Active Services Architecture

views updated

Chapter 3
Active Services Architecture



As we make a comprehensive review of the development of the computing paradigm, software technology, and Internet applications, we find that there is always a clear trend in the process—namely to better meet user requirements. As a result of this trend, computing itself is getting closer to end users. The computing device, networks, paradigm and software are under the process of gradually changing from “computer-centered” to “human-oriented.”

The Internet has gone through the stages of computer device interconnection and Web interconnection, and is currently progressing in a direction that is much closer to end users. Correspondingly, software technologies are gradually changing to “software as a service,” and the role of software developers is changing to that of service providers to better satisfy user requirements. The Internet, thus motivated by applications, has seen widespread development with the aim of serving end users.

In terms of the depth of application, the Internet has changed from a simple information-sharing platform to a distributed computing platform. We do not only publish and share all sorts of information on the Internet but also deploy and access all sorts of applications on it, such as online shopping, online office, e-Commerce, e-Learning, online games, IP Phones, etc. Thus,

besides the demand for information customization, there is also a demand for programs (or services) customization to process specific information, because users need specific programs to process specific information.

In terms of the width of application, the Internet is expanding to the field of wireless and pervasive appliances, featuring increasingly diversified access methods and devices. Hence, the Internet applications and services need to adapt to more types of access methods (such as modem, wireless, cable modem, xDSL, dedicated line, etc.) and access devices (desktop devices, mobile devices, information appliances, etc.). Compared with traditional desktop devices, mobile devices and information appliances have limited local resources, such as power, memory, CPU performance, storage space, and display capability. Therefore, when accessing the Internet, people need to have flexibility in the selection of service functions and interfaces, according to the network environments under different access modes and the resources of different equipment, and even to execute completely new programs (or services), so as to satisfy specific information processing requirements.

These two aspects of development demand that we provide a large number of programs (or services) to process information and data in line with the application environment and changes in user requirements. Since personalized user requirements and application environments are diversified, it is impractical to satisfy all kinds of requirements by programs (or services) developed in advance. Thus, to make use of reusable components distributed on the Internet, and to rapidly generate new programs (or services) meeting requirements, which process information and data to support the personalized services, is exactly the function of Active Services in the Internet environment.

At present, Web Services can offer all kinds of application pre-defined services for end users or service requesters via the Internet. However, Web Services cannot actively adapt to diversified types of personalized requirements and changes. This means that researchers must search for new service paradigms.



Regarding adapting to changes in user requirements, Web Services are deficient in the following two aspects:

  1. From the realization perspective, existing services, which are based on fixed computation modules, are unable to make functional extensions.
  2. From the application perspective, existing services, which are based on static deployment methods, are unable to perceive changes in user requirements, thus making it impossible to provide user-oriented services on demand.

Active Services are a new computing paradigm that have been introduced to solve the above problems. The Active Services system may follow user requirements to search, discover, and mine corresponding programs (or services) on the Internet or LAN, and subsequently compose, compile, and execute them to meet user requirements. Besides, even for the same service, the Active Services system may customize it further in accordance with users' personalized requirements and features, so as to make Web Services dynamically adapt to users' requirements in the manner of “services on demand.”

On the Internet, services are all provided by the execution of the corresponding program modules. Active Services are no exception. As a result, when we mention services in the rest of this book, we imply the program modules that implement the services together.

The research on Active Services mainly consists of the following three parts:

  1. Basic models, architectures, specifications, and descriptions of Active Services. The biggest distinction between Active Services and Web Services is that Active Services are self-adaptive to user requirements, but Web Services are not. Web Services may be seen as a type of static Active Services, in which programmers have set up the static program in advance to supply the static services. Therefore, the models, architectures, and specifications of Active Services are introduced on the basis of extension of Web Services.
  2. Discovering and constructing programs and data that implement the services. Web Services rely on programs preset by programmers to supply the services. When users demand the services, the system activates the preset programs to supply users with the services. As some Active Services demanded by users are unpredictable, programmers cannot set up programs in advance for them. Therefore, the key point in the research on Active Services should be how to organize and discover existing programs, and affirm whether these programs supply the necessary functions for the Active Services.
  3. Service customization. Even if we find programs on the Internet satisfying user requirements, how do we organize these programs, link, compile and execute them in the users' software and hardware platforms? All the above-mentioned problems should be studied further. In fact, this is precisely the issue of service customization. Generally speaking, traditional programs cannot be found, organized, linked, compiled, and executed on different software and hardware platforms because users and systems are not able to simply find and perceive functions supplied with these programs. Besides, there are no standard interfaces linking these programs or connecting the programs and their running environments. The appearance of component technologies makes it possible to customize services. First, components afford users with interfaces at the function level, allowing them to ignore implementation details within components. Second, software developers have accumulated a large number of standardized reusable components within long-term research and development, which make it possible to customize the personalized services.

In this chapter, we mainly discuss the basic models and architectures of Active Services. We will talk about the issues concerning the discovery of programs and data for the implementation of the services and service customization in later chapters.


Active Services are established on the basis of Web service technical specifications. They search and mine component resources on the Internet, and realize user-oriented rapid service construction and computing on-demand in an open, dynamic, and automatically adaptive framework.

On the basis of Web Services, we introduce the mechanism for the discovery, customization, loading and application of Active Services, and derive corresponding Active Service Models by introducing Active Service brokers into the existing Web Service Models, as shown in Figure 3.1.

The Active Service Model includes four roles and six basic operations. The four roles namely are the requestor, the provider, the registry, and the broker. The six operations are publishing, finding, binding, calling, mining, and submitting. In the Active Service Model, the requestor, the provider, and the registry play the same role as they do in the Web Service Model. Since the requestor, the provider, the registry, publishing, finding, and binding of services have been explained in detail in Chapter 2, only the Active Service Broker and three relevant operations are explained here.

When receiving computation requests from end-users, the Active Service Broker will perform the following three operations:

  • Calling. The Active Service system always try to meet users' requests via existing Web Services. First it tries to find suitable services by means of active discovery modules, and, if available, the Broker, like a Service Requestor, will call related Web Services via an existing service calling mechanism.
  • Mining. If the active discovery modules fail to find the suitable Web Service, the Broker will call the program mining procedure, mine and look for available service resources to meet users' requests by analyzing the existing service resources, and thus produce new suitable services to satisfy users' computing requirements.
  • Submitting. After new services are formed, the composing scheme is stored by the Active Service Broker; meanwhile the new combined service is submitted and published via the Web publishing mechanism for reuse.


Active Services need to extend Web Service specifications. We have extended Web service specifications constituted mainly of SOAP/WSDL/UDDI, and added an active service layer and service description extension layer, which primarily handle with service active finding, customization, and loading. So a new protocol specification framework is formed, as shown in Figure 3.2.

In Figure 3.2, the network layer protocol, message transfer layer protocol, service description layer protocol, and services publication and discovery

specifications are the same as they are in Web Service protocol specifications. We give a brief account of the features below:

  1. Network layer protocol. Network layer ensures the communication between two service binding ends. Active Services select different network protocols to load, call, and execute certain services according to different application environments, and this kind of selection is transparent to the service user. Network layer protocol mainly includes HTTP, FTP, POP3, etc. For example, when two binding ends are connected via the Internet, the network layer protocol is a commonly deployed protocol on the Internet, such as HTTP. For Web Services used in Intranet, other requirements, such as safety, usability, performance, and reliability, may be considered to choose other network layer protocols, such as POP3, etc.
  2. Message transfer layer protocol. Message transfer layer protocol mainly implements the binding and calling among services. As in Web Services, Active Service implements the calling and communication among services by a message sending and receiving mechanism above the network layer. SOAP is the generally applied specification at the message transfer layer.
  3. Service description protocol. Active Service descriptions are also based on WSDL. As stated before, WSDL consists of six elements: Type, Message, Port Type, Binding, Port and Service. With the information, service callers may get to know the called service positions, interface definitions, data types, message structures, and transfer protocols, and subsequently call related services.
  4. Services publication and discovery layer. The layer protocol supports service registration and publishing. UDDI is still the main protocol within the layer. As stated in Chapter 2, UDDI defines five major message types, which are Business Entity, Business Service, Binding Template, tModel and Publisher Assertion. The five message structures are the core of UDDI, with which UDDI realize Web Service registration, publishing, and finding.
    Meanwhile, UDDI protocol specifications define an excellent extension mechanism, which may be extended through technical specifications. The service publishing layer specifications of Active Services are based on UDDI. They use the extension mechanism to add up message contents that can be recorded by UDDI, so UDDI can register special messages described in Active Services. In this way, we can fully describe and publish all information of Active Services.
    On the basis of specifications of the above layers, the Active Service Model extends existing Web Service protocol specifications, i.e., service description extension layer and Active Service layer.
  5. Services Extension Description Language. WSDL only describes service interface definitions and interface implementation information, and supplies concrete methods for the service calling. But, for the other messages required in Active Services, such as service functions and function semantics messages, WSDL does not supply description methods. We need other description methods. Therefore, we introduce the service description extension layer, i.e., Service Extension Description Language (SEDL).
    SEDL includes the following contents:
    • Performance. Mainly describes nonfunctional performance indexes of services QoS, such as the continuous time needed to fulfill services, the expenses to employ services, the service levels, and the security.
    • Function semantic. Mainly describes semantics of functions supplied by the service, which make it easy for computers to understand, utilize, and process the service. In order to support semantic description, we need to first provide the application domain information. Then, on the basis of the knowledge base of related application domains, we describe unified domain knowledge, so as to supply a semantic base for the understanding and interaction of different services in the system. Second, we provide function classification information of the services, which indicates in detail the function classifications related to the service. Function descriptions are required to make it easier to find the service. We use domain dictionaries and keywords to describe this part.
    • Service context. Mainly describes relations between this service and other services. It explains the appointed context dependence relation required by the service while running or composing. In other words, it shows other services related to running the service, for example, what services are needed to supply interfaces for this service, and what services may employ its results. The record of successful composing cases further supports service finding and composing.
    WSDL service description together with SEDL service description builds up the complete active service description, as shown in Figure 3.3. Of this, WSDL defines service interacting structures and interfaces, and SEDL defines service application environment.
  6. Active Service layer. The Active Services layer implements the active services broker's functions in the active service model as shown in Figure 3.1. It comprises two subsections: service finding and service customization. The service finding part is based on the service registry protocol. It uses the service registry protocol to find the most matching one in all registered services, according to user service requirements.
    The service customization part is responsible for analyzing user requirements and generating a proper service composing procedure. Then, it establishes service requirements for each subfunction and composes services retrieved from the service finding part. In the end the composed results are submitted to users in the mode of service.
    We will elaborate on the two parts in the following chapters.


The implementation process of Active Service consists of three phases, i.e., the phase of service requirement definition, the phase of service discovery and customization, and the phase of service execution and publishing, as shown in detail in Figure 3.4.

In the phase of service requirement definition, when a user inputs a certain task, we first actively discover a suitable service on the Internet via the Service Discovery Module. If successful, we directly execute the service to fulfill the task. Otherwise, we call the Requirement Analysis Module to analyze the computation task and finally generate schemes of service composing.

In the phase of service discovery and customization, the Service Discovery Module will be used again to actively discover service in the composing schemes, analyze the combination and negotiation relations of the discovered service, and dynamically improve the service composing scheme. In this process, service discovery, analysis, and negotiation are repeated. With the user's participation, the composing schemes are modified and optimized dynamically. The overall process is a spirally ascending course, and it continues until a perfect one is achieved. This scheme document is in fact a definition of service composing.

In the phase of service execution and publishing, when service composing is achieved successfully, the user gets a complete composing scheme, in which the execution order, conditions, and mode have all been clearly defined. This scheme, together with the related sub-services, will be submitted to the

execution environment of Active Service to be checked for correctness and suitability. If suitable, it will be submitted to the user, registered, and published for reuse. Otherwise, the user's feedback is needed for more modification.

The active discovery and customization of services are two important mechanisms for the implementation of Active Service. We will discuss them in detail.


  1. Services resource classification. We divide the service program resources on the Internet into two types:
    1. Resources distributed in Web servers—they generally provide a function explanation in the format of natural language and serve users through standard interfaces defined in advance.
    2. Program resources registered in various special resource warehouses on the Internet—they primarily have complete function explanations, and are classified according to classification specifications of their resource warehouses.
    The two types of service resources are the objects to be discovered in Active Services. However, it is very hard to discover resources of the first type, as its publishing mode does not follow unified description specifications. As for the second type of service resources, since description specifications are diversified among different resource warehouses, it is fairly hard to discover service resources belonging to various resource warehouses. Therefore, we use the “push” and “pull” method in the agent technology to make active discovery of required service resources. Here, the “push” mode refers to search and obtain related services by agents in advance and organizes them into a service library so that the discovery technique will act more effectively. The “pull” mode refers to utilize various service search techniques to discover services published on the service library.
  2. Function relations of service. Service active finding technology relies mostly on service expression methods. Service expression methods include descriptions of services and organization modes of services in the directory library. In order to describe function relations of services, we introduce the concept of service functional semantics Ontology and consider it as an organization mode of the service directory library.
    The relations among services include combination, inheriting, inclusion, equation (replacement), calling, etc. The combination relations may be further divided into sequence, branching, synchronization and recursion, etc. No matter what the combination, inheriting, inclusion, equation, or calling, there exist different semantic relations among related services.
    To realize active discovery of services, we should first organize the semantic relations among existing services to establish a service relations network with layer structures, which is the service functional semantics Ontology. Second, we need to analyze user service requirements into sub-functions, so as to search and find out existing services related to or matching the requirements. We also use the service functional semantics Ontology to define the relations among the subfunctions.
    The service functional semantics Ontology makes it easier to discover and manage the related services and resources. For example:
    • When we want to use one service to replace another (for instance, when the network connection of a service breaks down, if we want to replace it with a service having identical functions), we may use the service equation (replacement) relations defined in the service functional semantics Ontology and instantly obtain required services.
    • When we obtain an expected service using other service search technologies, we may search for the composing semantics network related to the service, so as to retrieve other services and application models having fixed relations with the service, which subsequently supply a basis for service composing.
    • Each successful service composing will form corresponding composing semantics for storage. With the increase in size of the component library, it may also be used by users as a knowledge library of discomposing tasks with cases.
    • The service functional semantics Ontology may work as an important basis for agents to traverse all the service resources. By developing the service browse graphic navigation software on the basis of the service functional semantics Ontology, we may provide users with visualized service active finding tools.
  3. Process of service description and subfunction division. In many cases, there aren't service or computing resources to match exactly the users' requirements. Obviously, we will fail if we directly go to search for such exact computing resources. But, if we divide the requested services into a number of smaller ones, i.e., decompose the services into subfunctions, we are very likely to obtain these discomposed subservice functions. For instance, there might not be any computing resources for car automatic driving services. But if we divide car automatic driving service into GPS localization service, city geographical information service, and driving control service, we might search for and obtain computing resources for these services. Besides, if necessary, we may further go on to divide the subservice functions.
    The process of service active finding is also a course of gradually dividing and searching for subfunctions. To divide services into subfunctions, we must first make a formalized description of user service requirements. Besides, in order to customize service, we need to analyze the functional semantics of services and pick up the functional semantics of subfunction connection, such as keywords and subfunction connecting sequences.
  4. Process of service active finding. Naturally, it is impossible to accurately locate user requested services only on the basis of the service functional semantics Ontology. The complete active finding process must be combined with other self-describing search methods.
    In the Active Services model, a complete description of services consists of both WSDL and SEDL descriptions. Of this, WSDL defines service interaction interfaces and structures to support inter-calling and inter-operation among services. SEDL defines some essential information for Active Service application environments, including service functions and functional semantics. On the basis of such description information, we may have various search methods for the active finding search process, such as application domain-based searches, functional description-based searches, and developer-based searches.


Active customization of services refers to the process by which, according to user service requests, the system discovers and mines service resources approaching or matching user service requests from the Internet or LAN, assembles or disposes them, and provides them to the users within the required time.

After users put in service requests through the human–machine interface, they will directly implement the Web Services if the system contains Web Services satisfying user requested functions, which is a process that traditional Web Service Models supply to users with Web Services. If the system does not have Web Services satisfying user requested functions, it will need the Active Service customization process.

The Active Service customization process covers the following procedures:

  1. According to the service subfunction discomposing sequence and functional semantics Ontology obtained in the service active finding, validate and test computing resources corresponding to each discovered service subfunction, and verify the consistency of the functions supplied with computing resources with requested service subfunctions.
  2. Assemble and link validated and tested computing resources according to the subfunction sequence table derived in the service active finding.
  3. Validate and test the consistency of composed and linked computing resources. If the validation and test results show that the composed and linked computing resources supply consistent services with user requests, publish the computing resources and services.


Akkermans, H., and Baida, Z., et al. (2004). Value webs: using ontologies to bundle real-world services intelligent. Systems IEEE, 19(4), 57–66.

Benatallah, B., and Dumas, M., et al. (2002). Declarative composition and peer-to-peer provisioning of dynamic services. Proc. of the 18th International Conference on Data Engineering, pp. 297–308. San Jose: IEEE Computer Society.

Benatallah, B., Sheng, Q. Z., and Dumas, M. (2003). The Self-Serv environment for web services composition. IEEE Internet Computing, 7(1), 40–48.

Berger, M., and Bouzid, M., et al. (2003). An approach to agent-based service composition and its application to mobile business processes. IEEE Transactions on Mobile Computing, 2(3), 197–206.

Bianchi, G., and Campbell, A. T. (2000). A programmable MAC framework for utility-based adaptive quality of service support. IEEE Journal on Selected Areas in Communications, 18(2), 244–255.

Burstein, M. H., et al. (2002). DAML-S: Web service description for the semantic Web. In Horrocks (Ed.), Proc. of the International Semantic Web Conference (pp. 348–363). Sardinia: Springer-Verlag.

Chakraborty, D., et al. (2002). GSD: A novel group-based services discovery protocol for MANETS. Proc. of the 4th IEEE Conference on Mobile and Wireless Communications Networks (MWCN2002).

Daoud, F. (1999). Integrated open service node for active networks and services.IEEE Communications Magazine, 37(9), 139–146.

Huhns, M. N. (2002). Agents as web services. IEEE Internet Computing, 6(4), 93–95.

Ko, I. Y., and Neches, R. Composing web services for large-scale tasks. IEEE Internet Computing, 7(5), 52–59.

Lum, L., and Wai, Y. User-centric content negotiation for effective adaptation service in mobile computing. IEEE Transactions on Software Engineering, 29(12), 1100–1111.

Mennie, D., and Pagurek, B. (2001). A runtime composition service creation and deployment and its applications in internet security, E-commerce and software provisioning. Proc. of the 25th Annual International Computer Software and Applications Conference (COMPSAC 2001) (pp. 371–376). Chicago: IEEE Computer Society Press.

Musliner, D. J., and Oldman, R. P., et al. (1999). Self-adaptive software for hard real-time environments intelligent. IEEE Intelligent Systems, 14(4), 23–29.

Nagata, T., Nishio, N., and Tokuda, H. (2004). Design and implementation of adaptive service disconnect/reconnect support mechanism. Proc. of the 2004 International Symposium on Applications and the Internet (pp. 301–304). IEEE (IEEE Press).

Narayanan, S., and McIlraith, S. A. (2002). Simulation, verification and automated composition of Web Services. Proc. of the 11th International World Wide Web Conference WWW2002 (pp. 77–88). Honolulu: ACM.

Paolucci, M., and Sycara, K. (2003). Autonomous semantic web services. IEEE Internet Computing, 7(5), 34–41.

Parnes, P., Synnes, K., and Schefstrom, D. (2000). mStar: enabling collaborative applications on the Internet. IEEE Internet Computing, 4(5), 32–39.

Peer, J. (2002). Bringing together semantic web and web services. In Horrocks (Ed.), Proc. of the International Semantic Web Conference (pp. 279–291). Sardinia: Springer-Verlag.

Thakkar, S., and Knoblock, C. A., et al. (2002). Dynamically composing web services from on-line sources. Proc. of the 2002 AAAI Workshop on Intelligent Service Integration. AAAI Press.

Tosic, V., Mennie, D., and Pagurek, B. (2001). On dynamic service composition and its applicability to business software systems. Workshop on Object-Oriented Business Solutions (WOOBS2001).

Tosic, V., et al. (2001). On the management of compositions of web Services. Proc. of the OOPSLA 2001 Workshop on Object-Oriented Web Services.

Tsur, S. (2001). Are web services the next revolution in e-commerce. Proc. of the 27th International Conference on Very Large Data Bases (pp. 614–617). Morgan Kaufmann.

Vinoski, S. (2003). Integration with web services. IEEE Internet Computing, 7(6), 75–77.

Ye, Y. W. (2003). Programming with an intelligent agent. IEEE Intelligent Systems, 18(3), 43–47.