thesis proposal

A NEW APPROACH TO AUTOMATIC WEB SERVICES COMPOSION

by

Luong Viet Phong

A thesis proposal submitted in partial fulfillment of the requirements for the degree of Master of Engineering.

Examination Committee: Prof. Vilas Wuwongse (Chairman)

Nationality: Vietnam Previous Degree: Bachelor of Information Technology

Ho Chi Minh University of Technology Ho Chi Minh city, Vietnam

Asian Institute of TechnologySchool of Advanced Technology

ThailandAugust 2005

i

TABLE OF CONTENTS

1 INTRODUCTION.................................................................11.1 Background.................................................................11.2 Problem Statement.....................................................11.3 Objectives...................................................................21.4 Scope..........................................................................2

2 LITERATURE REVIEW.........................................................32.1 Industrial efforts..........................................................32.2 Academic efforts.........................................................4

2.2.1 Semantic Web Service Language.........................52.2.2 Automatic Web Service Composition....................82.2.3 Current problems................................................10

3 METHODOLOGY...............................................................124 REFERENCE.....................................................................15

ii

1 INTRODUCTION

1.1 BackgroundWeb Service is one of the most interesting technologies in recent years. Web

Service is a software application identified by a URI, whose interfaces and binding are capable of being defined, described and discovered by XML artifacts and supports direct interactions with other software applications using XML based messages via Internet-based protocols [1]. Informally, Web Service is a software component that can be accessed through the Internet. It is language independent and platform independent. For example, a software component written on .Net framework can call or communicate with a Web Service written in Java language and deployed on Linux platform. This may provide the flexibility for the developers and increase the collaboration among the service providers. Due to these properties, Web Service has appealed to software community. Within the development of Web Service, service oriented architecture has been developed rapidly and been used in wide ranges of information technology applications. The applications are built by assembling appropriated services. Thus the description, discovery, matching, composition and execution of Web services are key actions when building services and service-oriented applications.

Exploiting Web Service has many benefits. Thus the amount of Web services is increasing rapidly. Many companies and organizations have just implemented their core business and outsourced other application services over the Internet. More enterprises have collaborated with others to offer valued-added integrated services by combining existing Web services. In addition, the user requirements and the changing of business environment are more complicated. A single Web services may not satisfy the user need. Thus many pre existing Web services may have to be composed to create novel functionalities. Moreover, the composite Web services can increase re-using and extension of Web services in development. Therefore, Web service composition is a potential area. It has been one of major streams in researches about Web Service.

1.2 Problem StatementIn general, Web service composition is the ability of one business to provide value-

added services through composition of basic Web services, possibly offered by different companies. Because of its potential, there are many researches about it in both industry and academic environment. The first effort is in industrial world. Numerous Web Service composition languages are created by many giants in software industry, such as IBM, Microsoft, BEA, etc. These enterprises are trying to propose their languages as the standard for composing Web Services. On the other hand, the academic researches have concentrated on Semantic Web Service. Semantic Web Service Language and Automatic Web Service Composition are two important streams in these researches. The first stream focuses on creating an expressive and powerful language to add more semantic into the description of Web Service. The second stream tries to automate the composite processes as much as possible. The majority of researches conducted have fallen into realm of workflow composition or AI planning [2]. In some aspects, workflow composition can be similar to AI planning. The work items can be considered as the steps in the plans. The flow among work items can be considered as the combination or the order of steps in the plan. Consequently, the workflow composition may be a particular case of the AI planning. The main AI planning techniques that have been used are situation calculus, theorem proving, ruled based, hierarchical task network (HTN). However, these techniques have problems when applying to Automatic Web Service Composition. For instance, there are

1

mismatches between the semantic service description languages and AI planners. The planners use the closed world assumption. In contrast, the semantic description languages have opened world semantic. Thus the planners cannot understand all the semantic in the service descriptions. In addition, the AI planners have limited reasoning capabilities. Furthermore, there are many other problems such as search space, non-deterministic behaviors of the services, incomplete information, etc.

1.3 ObjectivesThe objective of this proposal is to propose a new approach to automatic Web

Service composition. The approach is based on document generation using equivalent document transformation rules. WSML will be used to express Web Service, user request, constraints and preference. All transformation rules are described by XET language. The final results are service composition descriptions. These descriptions are documents in terms of BPEL4WS.

In addition to the new approach, a new framework which is used to implement the proposed approach is also introduced. The framework will have the following features:

Encoding the user request, constraints and preference into expressive language Combining user information with service descriptions, business model and domain

ontology as inputs for transformation engine. Applying the proposed method to generate the service composition description

documents.To evaluate the effectiveness and efficiency of the new approach and new

framework, the will be compared with some current AI planning solutions for automatic Web Services composition, such as rule-based, and theorem proving.

1.4 ScopeThere are many research topics in Web Service composition, especially automatic

Web Service. For example, service discovery, service matching, composite service evaluation, composite service invocation are related fields. However, the thesis focuses on the automatic composition process with the given set of Web Services. The new approach is proposed to generate the composition description automatically.

In addition, there are two assumptions in the composition processes. The first one is the processes do not have to communicate with the information providing Web Services to obtain information. The second assumption is the composition processes take place at the executable business process level.

The following contents of the proposal are organized into two sections. Section II will review some work in automatic Web Service composition and discuss the existing problems. Section III consists of three parts. Firstly, part one describes general idea of the new method and how the current obstacles can be improved. Secondly, the proposed framework is introduced and discussed. Finally, part three discusses about the intended technologies that will be used in the new method.

2

2 LITERATURE REVIEW

The Web Service composition has the interest from both industrial world and academic environment. The software enterprises have tried to create the Web Service Composition Language that can be executed by their application servers or middle wares. On the other hand, the academic researchers concentrate on Semantic Web Service. The two main streams are Semantic Web Service Language and Automatic Web Service Composition.

2.1 Industrial effortsIn industry, orchestration and choreography are two terms for describing

collaboration of Web services. Orchestration describes how web services can interact with each other at the message level, including the business logic and execution order of the interactions. Choreography tracks the sequence of messages that may involve multiple parties and multiple sources, including customers, suppliers and partners. Orchestration differs from choreography in it describes the message flow among services controlled by single service. Choreography is at a higher level of collaboration and more collaborative in nature. In addition, Web services may be considered as processes. There are two types of processes when considering about Web services, executable process and abstract process. Executable process models the behaviour of participants in a specific business interaction, essentially modelling a private workflow. It is similar to orchestration. In the other hand, abstract process specifies the public message exchange between parties. It is similar to choreography.

The industrial efforts focus on developing the Web service composition language. When the composition script written in Web service composition language is generated, the application servers or middleware, such as Microsoft Biz Talk Server or IBM WebSphere, can execute the script to perform the desired tasks. The application servers play a role as mediators in collaboration among Web services. However, there are many proposals of standard in industrial efforts. Every player tries to develop and recommend its language as standard. BPEL4WS, BPML, WSCI and WS-CDL are having most interest and advantages than other languages.

BPEL4WS stands for Business Process Execution Language for Web Services. It is developed by IBM, Microsoft and BEA. It was merged from XLANG of Microsoft and WSFL of IBM. BPEL4WS was on top of WSDL. It models the behaviour of Web service in a business process interaction. The language has control logic to coordinate Web service. In addition, it supports the long transaction. The first working draft of this language was released in April 2004 by OASIS BPEL TC [21].

The second interested language is BPML (Business Process Management Language). It is also developed by Sun, SAP, Intalio, and BEA. BPML is the meta-language for describing business process. It comprises basic activities such as sending, receiving, and invoking services. This language also provides structured activities such as conditional choices, sequential and parallel activities, joins, and looping. However there is no further development on BPML since its last release in November 2002 [21].

The third interested language is WSCI, developed by Sun, SAP, Intalio and BEA. WSCI is abbreviated from Web Service Chorography Interface. It describes the messages between web services that participate in a collaborative exchange. The language supports message correlation, sequencing rules, exception handling, transactions, and dynamic collaboration. However, it does not address the definition of executable business processes. WSCI was submitted to W3C in August 2002. Thereafter, Web Service Choreography

3

Working group, established by W3C, develop a new language based on WSCI specification, WS-CDL. WS-CDL is an XML specification for long-lived and peer-to-peer collaboration among Web Services participants. This language is purely for abstract business process specification. The first working draft of WS-CDL was released in April 2004.

In comparison, BPEL4WS is suitable to model executable process and abstract process. In contrast, WS-CDL is just suitable to model abstract process and BPML is suitable to model executable process. Although BPEL4WS has some advantages in support Web Services composition such as modeling the execution control, spawn off process and synchronization, and event handling, BPEL4WS may equal to WS-CDL combining with BPML informally [21], [3]. In addition, BPEL4WS and WS-CDL are developed by two major standard organizations, OASIS and W3C respectively. However, BPEL4WS has gained widest support from the industry. Most major software vendors have BPEL4WS supported in their products, such as IBM, Microsoft, etc. [21].

Figure 1: Web service composition languages comparison [3].

Consequently, the giants in software industry try to create the Web Service Composition Language and propose their languages as the standard. These languages aim to describe the composition descriptions with logic constructs, such as condition, and loops, and the extended features, such as exception handling or transaction management. However, the efforts may focus on the execution phase of the composition process. The composition descriptions are generated manually. It needs human interactions during the design phase of the composition process.

2.2 Academic effortsThere are two main streams in academic researches about Web Service

Composition, Semantic Web Service Language and automatic Web Service composition.

4

2.2.1 Semantic Web Service LanguageThe first stream tries to add semantic to the descriptions of Web Services by

creating the expressive and powerful language. Current Web Services are based on the core technologies such as SOAP, WSDL, and UDDI. These technologies have limited semantic to advance tasks on the Web Service, such as discovery, matching or composition. The Web Services are described by WSDL currently. WSDL just describes the syntactical interface of a Web service and XML based message streams are used to communicate with Web services. However, this information is not enough to reason and perform advanced task on services. For example, to describe the service providing the add function, the service description may describe inputs and outputs in the following form: Int x Int Int. It means that the service need two integer number as inputs and it will produce and integer number as output. This description may be similar to the multiply function. Thus it is difficult to distinguish the differences between two services when comparing, selecting or performing some tasks automatically by software agents. In order to provide more semantic to service description, precondition and effect of service should be added. Preconditions are conditions required for service execution. Effects are conditions or states that hold after service execution. For instance, in course registration service, the preconditions may be that one course has some prerequisite courses and the students have to pass these prerequisite courses to register the new course. The effects of this service may be the state that students have registered the course. As a result, the current WSDL may lack of the semantic in describing the Web service. The services have to be described in the machine-readable form to carry out tasks automatically. Therefore, many researchers develop methods to describe the semantic and pragmatic aspects of Web services. Adding more semantic to Web service description will increase the reasoning capabilities and automatic composition of Web service. The majority of researches concentrate on creating the language that can have more expressive power and reasoning mechanism in service description.

The first interested language in semantic web service currently is OWL – S (formerly DAML – S). OWL – S define the ontology for services. The most important goal for OWL – S is to establish a framework within which service descriptions are made and shared. OWL – S is expected to enable following activities: automatic Web service discovery, automatic Web service invocation, automatic Web service composition and interoperation. The class Service is at the top ontology of services. It has properties, such as presents, describedBy, and supports. The classes ServiceProfile, ServiceModel, and ServiceGrounding are the respective ranges of those properties. Firstly, the property presents describe what the service does and what the service require of the users, or other agents, and provide for them. Secondly, the property describedBy provides information about how service works. This describes what happens when the service is carried out. Finally, the property support specifies how the service works or how to access the service, such as the communication protocols, port numbers, etc. [4].

However, OWL-S has some limitations. The first one is the unclear meaning of the description elements. This may lead to the misinterpretation and incompatible models. The second limitation is the lack of expressiveness of the specification languages. OWL-DL is used to express ontology of service concepts in OWL-S. But OWL-DL has to trade off expressiveness for decidability. Thus the semantic of some aspects in OWL-S process ontology cannot be defined in OWL-DL. In addition, using other specification languages, such as SWRL, DRS, and KIF, also has some shortcomings. For instance, the combination with SWRL or DRS may lead to inherent undecidability. The KIF syntax is also not integrated in OWL-S. Therefore, there are two efforts which try to develop standardized

5

ways of conceptualizing and organizing the semantic information about services and develop a language for the declarative specification of this semantic information.

The first effort is Semantic Web Service Ontology and Semantic Web Service Language. This is done by Semantic Web Service Committee of Semantic Web Service Initiative. The Semantic Web Services Ontology (SWSO) represents a conceptual model for Web Service description and a formal characterization of that model. This characterization is given in first order logic. It is called FLOWS, First Order Logic Ontology for Web Services. In addition, the axioms from FLOWS have been systematically translated into SWSL-Rules language with an avoidable weakening of some axioms. The resulting ontology, which relies on logic programming semantic, is called ROWS, Rules Ontology for Web Services [24].

More precisely, FLOWS is an axiomatized ontology of service concepts, which provides the conceptual framework for describing and reasoning about services. The goal of FLOWS is to enable reasoning about the semantics underlying Web services, and how they interact with each other and with the real world. The FLOWS model provides infrastructure for representing messages between services. FLOWS also provides constructs for modeling the internal processing of Web services. FLOWS has many intuitions and improvement from OWL-S. Following the high-level structure of OWL-S, FLOWS has three major components: Service Descriptors, Process Model, and Grounding. In the formal ontology, these three elements are associated with services by representing a formal service as a conceptual object, and using relations to associate specific artifacts with the service. A primary difference between FLOWS and OWL-S is the expressive power of the underlying language. FLOWS is based on first-order logic, which means that it can express considerably more than can be expressed using OWL-DL. A second difference is that FLOWS strives to explicitly model more aspects of Web services than OWL-S. FLOWS is able to model process models using a variety of different paradigms and model data flow between services [25].

Semantic Web Service Language (SWSL) is a logic-based language for specifying formal characterizations of Web service concepts and descriptions of individual services. It includes two sublanguages: SWSL-FOL, a full first-order logic language, which is used to specify the service ontology (SWSO), and SWSL-Rules, a rule-based sublanguage, which can be used both as a specification and an implementation language. As a language, SWSL is domain-independent and does not include any constructs specific to services.

More specifically, SWSL is a general-purpose logical language, with certain features to make it usable with the basic languages and infrastructure of the Web. These features include URIs, integration of XML built-in types, and XML-compatible namespace and import mechanisms. SWSL includes two layers of expressiveness: SWSL-FOL and SWSL-Rules. SWSL-FOL is a first-order logic, extended with features from HiLog and the frame syntax of F-logic. SWSL-Rules is a full-featured logic programming (LP) language, which includes a novel combination of features from Courteous logic programs, HiLog, and F-logic [26].

The second effort is Web Service Modeling Ontology and Web Service Modeling Language. It is under the development of DERI. WSMO provides an overall framework for Semantic Web Service in order to support automated Web Service discovery, composition, and execution. WSMO has two major design principles [22].

Principle of maximal de-coupling: all WSMO components are specified autonomously, independent of connection or interoperability with other components.

6

Principle of strong mediation: the connection and interplay between different components are managed by mediators which can resolve possible occurring heterogeneities.WSMO has four major components: Ontologies, Goals, Web Services, and

Mediators. Ontologies define terminology and formal semantic for describing the other

elements in WSMO. They provide concepts and relationships among the set of concepts which are defined and agreed upon by communities of users. An ontology consists of non-functional properties, imported ontologies, and the definition of concepts, relations, axioms, functions, and instance of the ontology.

Goals describe user requests that are resolved by executing a Web Service. The requests are expressed as logical expression in WSMO on basis of domain ontologies. They contains non-functional properties, imported ontologies, mediators used, post conditions and effects.

Web Services component provides the semantic description of Web Services, including their functional and non-functional properties, as well as other aspects relevant for interoperating with them.

Mediators are connectors that resolve the heterogeneity problems in order to enable interoperation between heterogeneous parties.

Figure 2: The core components of WSMO [22], [23].Web Service Modeling Language (WSML) is a language framework for Semantic

Web Service, based on conceptual model of WSMO. WSML has different variants which are based on different formalisms, namely Description Logic, First Order Logic, and Logic Programming [23].

WSML-Core: this language is defined by the intersection of Description Logic and Horn Logic. It has the least expressive power in the WSML family. Thus it has the most preferable computational characteristic. The main features of the language are the support for modeling classes, attributes, binary relations and instances. It also supports class hierarchies and relation hierarchies. This language is fully compliant with a subset of OWL.

WSML-DL: this is an extension of WSML-Core, which captures the Description Logic SHOIN(D). It can be seen as an alternative syntax for OWL-DL, based on the WSMO conceptual model.

WSML-Flight: this is an extension of WSML-Core in the direction of Logic Programming. WSML-Flight has a rich set of modeling primitives for modeling different aspects of attributes, such as value constraints and integrity constraints. Furthermore, WSML-Flight incorporates a fully-fledged rule language, while still

7

allowing efficient decidable reasoning. To be more precise, WSML-Flight allows writing down any Datalog rule, extended with inequality and (locally) stratified negation. WSML-Flight is based on OWL-Flight.

WSML-Rules: it extends WSML−Flight to a fully-fledged Logic Programming language, including function symbols. WSML−Rule no longer restricts the use of variables in logical expressions.

WSML-Full: this language unifies all WSML variants under a common First-Order umbrella with non-monotonic extensions which allow capturing non-monotonic negation of WSML-Rule. The syntax for WSML-Full is in fact as the basic syntax for WSMO.

2.2.2 Automatic Web Service CompositionThe second research stream is automatic Web Service composition. In this stream,

the majority of researches propose to apply the AI planning techniques to automate composition process. The general planning problems can be described by the five-tupple (S, S0, G, A, Г) [2].

S: set of possible states of the world S0: the initial states, S0 ⊂ S G: goal states, G ⊂ S A: set of actions Г: translation relation which specify the world will change from the state S 1 to the

state S2 after executing the action A, (Г ⊆ S x A x S)The plan is the sequence of actions that can change the world from the initial state

S0 to the goal states G. The description of the planning problems shows that the AI planning is suitable to solve the automatic Web Service composition problems. A Web Service can be considered as an action. Г may be used to describe the preconditions and effects of a Web Service. G is the desired goal or the requests of the users. S0 is the initial conditions of the users. Thus the composition description is the generated plan that archives the desired goals.

There are many AI planning techniques are applied into automatic Web Service composition. The main four of them are situation calculus, theorem proving, hierarchical task network, and rule based.

First, the situation calculus planning was proposed by Sheila McIlraith and Tran Cao Son [5]. This solution implemented in Golog programming language built on top of situation calculus. In situation calculus, the do(a, s) function is defined as the map a situation s and action a to a new situation. A situation calculus theory D comprises domain-independent foundational axioms of the situation calculus, Σ; accessibility axioms for K (special fluent knowledge to deal with sensing actions), Kinit; successor state axioms, Dss; action precondition axioms, Dap; axioms describing the initial situation, DSo; unique names axioms for actions, Duna; domain closure axioms for actions, Dca. The problem that has to be solved is defined as following: “Given a domain theory D and a Golog program δ, find a sequence of execution a so that D╞ Do(δ, S0, do(a, S0)) ”. Do(δ, S0, do(a, S0)) has the meaning that the program δ will start at the situation S0 and legally terminate at do(a, S0) where do(a, S0) stands for do(an, do(an-1,…do(a1,do(a0,S0))))). The steps of automatic Web Service composition in situation calculus planning are following:

Creating the generic procedures Translating service description in DALM-S and requests into situation calculus Customizing the appropriated generic procedure

8

Generating and executing the a sequence of requests to Web Services to perform the desired tasksSecond, Jinghai Rao, Peep Küngas and Mihhail Matskin recommended using

theorem proving technique [6]. It is based on the Propositional Linear Logic (LL). LL is a refinement of the classical logic. It was claimed that LL was useful as a declarative language and inference system. This logic has the expressive power to describe functional and non-functional attributes of the Web Services. The intuition of adopting theorem proving in automatic Web Service Composition is described as following:

Translate service specification (DAML - S) into LL extralogical axioms Translate service request into the form of theorem to be proven Prove the specified theorem using the LL inference rules If the theorem is proven, extract the process model from the completed proof

generated by the LL theorem prover Otherwise, request should be re – formulated or existent service specification

should be modifiedThe third used technique is hierarchical task network (HTN) [7, 8]. The basic idea

is to create plan by task decomposition. The complex tasks are decomposed into smaller and smaller subtasks until the primitive tasks that can be executed directly are found. Thus this is suitable to Web Service composition. The desired Web Services, which is often complex, are decomposed until the primitive Web Services are found. The current implementation is SHOP2 (Simple Hierarchical Ordered Planner). SHOP2 is the domain independent HTN planning system. One difference between SHOP2 and most other HTN planning systems is that SHOP2 plans for tasks in the same order that they will later be executed. Planning for tasks in the order that those tasks will be performed makes it possible to know the current state of the world at each step in the planning process, which makes it possible for SHOP2’s precondition-evaluation mechanism to incorporate significant inference, reasoning power and the ability to call external programs. This makes SHOP2 ideal as a basis for integrating planning with external information sources. The following steps are implemented in SHOP2 to generate the composite plan.

Encoding OWL-S process models as SHOP2 domain Encoding OWL-S Web Services Composition Problem as SHOP2 Planning

Problem Generating plan by SHOP2 algorithm Converting the SHOP2 plan to OWL plan. The final result is the sequence of Web

Service calls, which are subsequently executed.Finally, Shankar R. Ponnekanti and Armando Fox implemented rule based planning

in SWORLD, developer toolkit for Web Service composition [9]. This toolkit used its own way to describe the Web Service. Entity relationship model is employed to specify the services. Services are modelled by the preconditions and effects. For each service, a rule is defined that the effects are archived if the proconditions are true. The composite services are also specified by the initial states and final states. Then the composite plan is generated by the rule engine. However, the authors agured that the ruled based chaining in SWORLD can sometimes generate the uncertain results.

Consequently, the four methods mentioned above apply different techniques to automate the composite process. Each method has a new contribution to this research area. However, there are still many obstacles that need to be solved. These problems will be discussed in the next subsection.After doing survey on researches in Web Service Composition, Jinghai Rao and Xiaomeng Su have come up with a general framework for composing Web Service [2]. This framework may appear in the methods mentioned above and the others.

9

Figure 3: General Web Service composition framework [2].

In the framework, there are two participants, service requesters and service providers. Service providers offer and publish the services to the service repository. The service requesters are people who consume the service of the service providers. The translators translate between the external languages used by the participants and the internal languages that are compatible with the process generator. The process generator will generate the composition plan that composes the existing services in the service repository to satisfy the specific requests. If more than one plan is generated, the evaluator will evaluate all the plans. The most reasonable plan is proposed to be executed. Thereafter, the execution engine will perform the composition plan and return the results to the service requesters. The proposed framework can be the general framework for many composition methods in automatic Web Service composition. In comparison, the AI planning methods in automatic Web Service composition may adopt the framework similar to this framework. The process generator plays the role as the AI planner.

2.2.3 Current problemsAI planning is suitable for automating Web Service composition. However, there

are many problems when applying AI planning techniques to this area.First, the AI planners use the closed world assumption with negation as failure [10].

This means that a statement or a predicate can only have one value, truth or falsity. A statement can be assumed to be true on the basis of failure to prove it. For example, to prove a predicate P that is true in a knowledge base K, people often prove that the union between K and negation of P is inconsistent. In contrast, the advanced web service description languages have open world semantic. For instance, the statement that is not true in OWL – S can be not false. This difference creates a mismatch between the planners and the service description languages.

Second, the AI planners have limited reasoning capabilities. Most of planners employ their own languages to express the domain information, such as preconditions and effects of Web Services, desired goals, constraints, and user preference. But these logics have less expressiveness than current ontology languages, OWL and OWL – S. Therefore, Planning Domain Description Language (PDDL) was created to provide more expressive power when describing the planning problems and many planners have been changing their input forms to be compatible with PDDL. The service descriptions in OWL-S and other information in OWL will be translated into PDDL before being processed by the AI

10

planners. However, this language still has many disadvantages, such as closed world assumption, non-XML format, etc. Thus the semantic of problem descriptions may be lost during the translation.

Third, the information in Web Service world may be incomplete. The composition process sometimes has to inquire information from the outside environment. Thus the information providing services are necessary occasionally. On the other hand, the planners assume that they have all information about the world. It is also the gap when applying AI planning to the Web Service composition.

The fourth obstacle is the non-deterministic behaviors of the Web Service. The service may fail during the execution or it may produce the uncertain results. The service can also return the new object that is undefined in result.In addition, search space to find the plan is also the problem. For example, in the theorem proving method, since the amount of available services and the size of the ontology models are huge, it is necessary to reduce the search space during problem solving [6].

Finally, the last two problems that should be considered are about the complex services and business models. Most of planners deal with the primitive services. However, the complex services, which have been composed by planners, can be considered as the new primitive services. This increases the reuse of composed service and may decrease the planning time. Moreover, the business models that specify the relationships among multiple services should be participated in the planning processes. This may help to increase the precision of the generated plans.

In conclusion, AI planning is suitable approach to solve automatic Web Service composition. However, there are several disadvantages when applying AI planning to this research area. Thus the next section will describe general idea of the new method for automating Web Service composition and how the current obstacles can be improved. In addition, a new Web Service composition framework is proposed and discussed. The technology for new method is also introduced.

11

3 METHODOLOGY

Equivalent Transformation (ET) invented by Prof. Kiyoshi Akama of Hokkaido University is a new computational paradigm which is based on semantic preserving transformations. A given declarative description is transformed successively and equivalently into a simpler description until a description in which answers can be directly or easily obtained is reached. Based on Equivalent Transformation, the proposal proposes a new approach to automatic Web Service composition. The idea of new approach is to employ XML document transformation which is based on Equivalent Transformation to generate the composition plan of Web Services automatically.

More precisely, the user requests or desired goals, constraints, preference and the given service descriptions are expressed by a powerful language, such as WSML. This information and the business process models will be combined into one XML formatted document that describes the domain problem to be solved. In addition, the ET rules, which have to satisfy the semantic preserved condition, are defined. Thereafter, a transformation mechanism will transform this XML document to generate the composition description documents in which the desired goals are archived. The final results are expressed in term of Web Service composition languages, such as BPEL4WS.

With this new approach, the problems of exploiting AI planning may be overcome. First, the domain problems are described in the powerful languages which have opened semantic. These languages can express fully the main semantic of problems. This may increase the precision of the solutions. Second, the computation and reasoning are done directly on the description languages. The input information does not have to translate into another forms such as PDDL. Thus the meaning of the descriptions will not be lost during the translation. The reasoning capabilites also increase because of doing reasoning on the expressiveness languages. Third, the transformation engine does not have to have complete information about the Web Service world during the transformation process. It can obtain information from the information providing services since that is necessary. The fourth obstacle can be solved by adding the exception handlers in form of ET rules. This may make the composition process more flexible and automatic. In addition, the solutions may be implied in the problem description. The transformation engine just transforms the problems until the solutions are reached. It does not have to search for the solutions. As a result, the search space problem can be overcome. Moreover, the business models can be participated as the service composition templates when creating the problem descriptions. It helps to increase the accuracy of the generated composition descriptions. Finally, due to employing the expressiveness and powerful languages to describe the domain problems such as desired goals, constraints, user preference, etc, the complex services that are already composed can be considered as primitive services in the transformation process. This increases the reuse of services and decreases the computation time.

In addition to the new approach to automatic Web Service composition, the proposal also proposes a new Web service composition framework in which the new approach will be implemented. This framework is based on the framework of Jinghai Rao and Xiaomeng Su [2], mentioned in section 2.2.2.

12

Figure 4: Web Service composition framework for BPEL4WS document generation approach

The framework has two participants, service providers and service requesters. The framework also has main component, transformation engine. The transformation engine takes service descriptions, business models, user requests, constraints and preference, which are expressed by an expressive language, as inputs. Thereafter, it transforms this information until the composition description documents are generated. The semantic will be preserved during the transformation process. The transformation engine can also do reasoning on the problem description if it is necessary. In addition, the framework consists of main repositories: service repository, business models repository, domain ontology, and ET rule repository. First, the service repository contains the descriptions of the primitive Web Services. The descriptions of complex Web Services, which are already composed, are also stored in this repository. Second, the business models repository stores the business models that are necessary for the problem domain in form of BPEL4WS templates. Third, domain ontology consists of the ontology about the problem domain. Finally, the ET rule repository stores all the equivalent transformation rules that the transformation engine uses to produce the solutions.

The intended technologies will be used to implement the framework‘s prototype are WSMO\WSML, BPEL, XET [11], and Java technology.

Firstly, WSMO has a clear separation among four major components: ontology, goals, Web Services and mediators. As a result, it is compatible to apply to the proposed framework. For example, ontology, goals, and Web Services can be used to express domain ontology, user request and constrains, and Web Service description respectively. In addition, WSML has strong expressiveness and formalization for semantic Web Service and semantic web. Thus WSMO\WSML is suitable to express information in repositories and user requests.

Secondly, BPEL has some advantages than other Web Service composition languages, such as modeling the execution control, spawn off process and synchronization, and event handling. It also has the widest acceptance in industry. Therefore, BPEL is employed to describe the final results of the framework.

Thirdly, the main rationale of the new approach is document generation using equivalent document transformation rules. As a result, XET is a suitable for expressing all the transformation rules.

13

Finally, because all the documents using in the framework are in XML format and Java has many components for XML processing, the transformation engine will be programmed in Java language. In addition, some necessary user interfaces will be implemented in Web based using Java technology.

The thesis will be done in two semesters. The following table depicts the detail work and time.

Work detail Estimated time9 10 11 12 1 2 3 4

Design the approach detailFormalize the approachDesign the framework componentsImplement the componentsTest, fix bugs and evaluationCollect documents and edit thesis report

In conclusion, equivalent document transformation is proposed to apply to automatic Web Service composition. It may be a new approach in this research area. A new framework for implementing this new approach is also proposed. In order to implement the framework’s prototype, the following main technologies will be employed, namely WSMO\WSML, BPEL, XET, and Java technology

14

4 REFERENCE

1. Heather Kreger (2001), Web Services Conceptual Architecture (WSCA 1.0), IBM Software Group.

2. Jinghai Rao and Xiaomeng Su (2004), A Survey of Automated Web Service Composition Methods

3. Chris Peltz(2003), Web Services Orchestration. A review of emerging technologies, tools and standards, Hewllett Packard White Paper, January 2003.

4. David Martin, Mark Burstein, Jerry Hobbs, Ora Lassila, Drew McDermott, Sheila McIlraith, et al, OWL-S: Semantic Markup for Web Services, DARPA Agent Markup Language web site: http://www.daml.org.

5. Sheila McIlraith and Tran Cao Son (2002), Adapting Golog for Composition of Semantic Web Services, In Proceedings of the Eighth International Conference on Knowledge Representation and Reasoning.

6. Jinghai Rao, Peep Küngas and Mihhail Matskin, Logic-based Web Services Composition: from Service Description to Process Model, In Proceedings of the 2004 International Conference on Web Services, San Diego, USA, July 2004.

7. Evren Sirin, Bijan Parsia, Dan Wu, James Hendler, and Dana Nau. HTN planning for web service composition using SHOP2. Journal of Web Semantics, 1(4):377-396, 2004.

8. Dan Wu, Bijan Parsia, Evren Sirin, James Hendler, and Dana Nau, Automating DAML-S Web Services Composition Using SHOP2, In Workshop on Planning for Web Services, Trento, Italy, June 2003.

9. S. R. Ponnekanti and A. Fox, SWORD: A developer toolkit for Web service composition, In Proceedings of the 11th World Wide Web Conference, Honolulu, HI, USA, 2002.

10. Evren Sirin and Bijan Parsia, Planning for semantic web services. In Semantic Web Services Workshop at 3rd International Semantic Web Conference (ISWC2004),2004.

11. Wattanapailin V. (2000). A Declarative Programming Language with XML, Master’s Thesis, Computer Science and Information Management Program, Asian Institute of Technology, Thailand.

12. Chutiporn Anutariya (2001), XML declarative description, Dissertation, Computer Science and Information Management Program, Asian Institute of Technology, Thailand

13. Joachim Peer, A PDDL Based Tool A PDDL Based Tool for Automatic Web Service Composition

14. Biplav Srivastava and Jana Koehler, Web Service Composition – Current Solutions and Open Problems

15. Sheng Huang, Xiaoling Wang, Aoying Zhou, Efficient Web Service Composition Based on Syntactical Matching

16. Nikola Milanovic and Miroslaw Malek, Current Solutions for Web Service Composition

17. D. Fensel and C. Bussler, Web service modeling framework 18. Joachim Peer, Towards Automatic Web Service Composition using AI Planning

Techniques 19. McIlraith, S. and Fadel, R., Planning with Complex Actions'. In Proceedings of the

Ninth International Workshop on Non-Monotonic Reasoning (NMR2002), pages 356-364, April, 2002

15

20. Chris Peltz(2003), Web Service Orchestration and Choreography, A look at WSCI and BPEL4WS, Hewllett Packard White Paper, July 2003.

21. Cheng Yushi, Lee Eng Wah, Dilip Kumar Limbu, Web Services Composition – An overview of standards. Synthesis 2004 Journal, Information Technology Standards Committee, An Industry Partnership Supported by SPRING Singapore & IDA, 2004.

22. Ioan Toma,Michael Stollberg, Jos de Bruijn, Axel Polleres, Rub´en Lara, Semantic Web Fred – Language Evaluation and Comparison, Draft 2, DERI August 2004.

23. Rub’en Lara, Axel Polleres, Holger Lausen, Dumitru Roman, Jos de Bruijn, and Dieter Fensel, A Conceptual Comparison between WSMO and OWL-S, Final Draft, DERI April 2005.

24. Steve Battle, Abraham Bernstein, Harold Boley, et, Semantic Web Services Framework (SWSF) Overview, version 1.0, the Semantic Web Services Language Committee of the Semantic Web Services Initiative, May 2005.

25. Steve Battle, Abraham Bernstein, Harold Boley, et, Semantic Web Service Ontology, version 1.0, May 2005.

26. Steve Battle, Abraham Bernstein, Harold Boley, et, Semantic Web Service Language, version 1.0, May 2005.

16