Service-Oriented Computing - ICSOC 2005

We seek to elevate autonomic computing from infrastructure to process level. Different aspects of autonomic computing – self configuring, self healing, self optimizing and self aware are studied for Autonomic Web Processes (AWPs) with the help of a supply chain process scenario. Existing technologies and steps needed to shorten the gap from current process management systems to AWPs are studied in this paper. The behavior of AWPs is controlled by policies defined by users. Sympathetic and parasympathetic policies are introduced to model short and long term policies. A key advantage for elevating autonomic computing to a process level is that the trade-offs can be more evident because the process components map more readily to business functions.

We sketch the vision of a ubiquitous service bus that will be the base for hosting and accessing services everywhere. The utility model for using IT artifacts is implied. Applications on top of the service bus will be centered on business processes and will be adaptive in multiple dimensions. The ubiquitous service bus will change the way we think about information technology.

Grid computing is about allocating distributed collections of resources including computers, storage systems, networks and instruments to form a coherent system devoted to a “virtual organization” of users who share a common interest in solving a complex problem or building an efficient agile enterprise. Service oriented architectures have emerged as the standard way to build Grids. This paper provides a brief look at the Open Grid Service Architecture, a standard being proposed by the Global Grid Forum, which provides the foundational concepts of most Grid systems. Above this Grid foundation is a layer of application-oriented services that are managed by workflow tools and “science gateway” portals that provide users transparent access to the applications that use the resources of a Grid. In this paper we will also describe these Gateway framework services and discuss how they relate to and use Grid services.

The service oriented paradigm is, at its core, a model of distributed software components, built around the idea of multi-protocol interoperability and standardized component contracts. The Web Services Interoperability (WS-I) profiles provide standards for runtime interoperability, and the Web Services Description Language (WSDL) and WS-Policy define service contracts that support interoperability between developer tools. A major goal of Service Oriented Architectures (SOAs) is to enable an abstraction layer that integrates and bridges over platform and implementation technology differences, effectively providing a universal business software component and integration framework. Achieving a complete solution requires a portable component model and well-defined patterns for components types. This paper examines the main requirements for a SOA programming model and identifies its most relevant characteristics. In line with SOA’s goals, such model must allow a broad community of users (including non-programmers) to create service-oriented applications by

instantiating

, using,

assembling

and

customizing

different

component types

that match the user’s goals, skills, and conceptual framework. Moreover, these component types must be portable and interoperable between multiple different vendors’ runtimes.

The diffusion of service-oriented computing is today heavily influencing many software development and research activities. Despite this, service-oriented computing is a relatively new field, where many aspects still suffer from a lack of standardization. Also, the service-oriented approach is bringing together researchers from different communities or from organizations having developed their own solutions. This introduces the need for letting all these people communicate with each other using a common language and a common understanding of the technologies they are using or building.

This paper proposes a conceptual model that describes actors, activities and entities involved in a service-oriented scenario and the relationships between them. While being created for a European project, the model is easily adaptable to address the needs of any other service-oriented initiative.

Current composite web service development and management solutions, e.g. BPEL, do not cater for flexible and adaptive business collaborations due to their pre-defined and inflexible nature that precludes them accommodating business dynamics. In this paper we propose a rule driven approach for adaptive business collaboration development in which rules drive and govern the development process. We introduce the Business Collaboration Development Framework (BCDF), which provides enterprizes with the context to define their capabilities and business collaboration agreements. Subsequently, we explain how rules can drive and control the business collaboration development process to develop complete, correct and consistent business collaboration agreements that are conform the conditions under which parties wish to cooperate.

There have been significant efforts in providing semantic descriptions for Web services, including the approach as exemplified by OWL-S. Part of the semantic description in OWL-S is about the interaction process of the service concerned, and adopts a procedural programming style. We argue that this style of description for service interactions is not natural to publishing service behavior properties from the viewpoint of facilitating third-party service composition and analysis. In this paper, we introduce a declarative approach that better supports the specification and use of service interaction properties in the service description and composition process. This approach uses patterns to describe the interaction behavior of a service as a set of constraints. As such, it supports the incremental description of a service’s interaction behavior from the service developer’s perspective, and the easy understanding and analysis of the interaction properties from the service user’s perspective. We also introduce a framework and tool support for monitoring and checking the conformance of the service’s run-time interactions against its specified interaction properties, to test whether the service is used properly and whether the service fulfils its behavioral obligations.

Web Services are entailing a major shift of perspective in software engineering: software is used and not owned, and operation happens on machines that are out of the user control. This means that the user cannot decide the strategy to migrate to a new version of a service, as it happens with COTS. Therefore, a key issue is to provide users with means to build confidence that a service i) delivers over the time the desired function and ii) at the same time it is able to meet Quality of Service requirements.

This paper proposes the use of test cases as a form of contract between the provider and the users of a service, and describes an approach and a tool to allow users running a test suite against a service, to discover if functional or non-functional expectations are maintained over the time. The approach has been evaluated by applying it to two case studies.

Web services promise to allow businesses to adapt rapidly to changes in the business environment, and the needs of different customers. The rapid introduction of new web services into a dynamic business environment can lead to undesirable interactions that negatively impact service quality and user satisfaction. In previous work, we have shown how to model such interactions between web services as feature interactions, and reason about undesirable side-effects of web service composition. In this paper we present the results of subsequent research on a classification of feature interactions among web services. Such a classification is beneficial as we can then search for ways of detecting and resolving each class of feature interaction in a generic manner. To illustrate the interactions we use a fictitious e-commerce scenario.

Existing service matching techniques such as keyword-based and ontology-based, do not guarantee the correctness of the matching results (i.e. do not guarantee fulfilling user goals). This paper deals with this problem by capturing the high-level functional aspects (namely goals, contexts, and expected external behaviors) for both web services and users in a machine-processable format, then matching these aspects using the proposed functional substitutability matching scheme (FSMS). Based on FSMS, this paper describes a direct matching technique in which a user request is examined against one service description at a time, such that web services match users’ requests when they have substitutable goals, contexts and expected external behaviors. The substitutability semantics between the elements of application domains are captured via the proposed substitutability graphs, which are used during the matching process to mediate between users’ requests and web services’ descriptions. Simulation results show that the proposed matching approach succeeds in retrieving only the correct answers, while keyword-based and ontology-based retrieval techniques could not eliminate the appearance of false negatives and false positives.

One of the promises of the service-oriented architecture (SOA) is that complex services can be composed using individual services. Individual services can be selected and integrated either statically or dynamically based on the service functionalities and performance constraints. For many distributed applications, the runtime performance (e.g. end-to-end delay, cost, reliability and availability) of complex services are very important. In our earlier work, we have studied the service selection problem for complex services with only one QoS constraint. This paper extends the service selection problem to multiple QoS constraints. The problem can be modelled in two ways: the combinatorial model and the graph model. The combinatorial model defines the problem as the multi-dimension multi-choice 0-1 knapsack problem (MMKP). The graph model defines the problem as the multi-constraint optimal path (MCOP) problem. We propose algorithms for both models and study their performances by test cases. We also compare the pros & cons between the two models.

With the growing adoption of service-oriented computing, locating services becomes increasingly commonplace. Accordingly, a large number of systems for service discovery have been developed. Although all these systems perform the same function, they do it in lots of different ways. Finding commonalities of and differences between these systems can be hard due to the lack of criteria to compare and classify various discovery schemes.

This paper identifies the processes of registration and look-up as a distinguishing feature of the various discovery systems. It describes the possible types of processes, shows how they are distributed across the lifecycles of the involved entities and classifies existing service discovery systems according to these criteria. Some hints are given on how the process-based view can help guide the selection of a particular discovery style for a problem at hand.

In this paper, we describe SPiDeR, a peer-to-peer (P2P) based framework that supports a variety of Web service discovery operations. SPiDeR organizes the service providers into a structured P2P overlay and allows them to advertise and lookup services in a completely decentralized and dynamic manner. It supports three different kinds of search operations: For advertising and locating services, service providers can use keywords extracted from service descriptions (

keyword-based search

), categories from a global ontology (

ontology-based search

), and/or paths from the service automaton (

behavior-based search

). The users can also rate the quality of the services they use. The ratings are accumulated within the system so that users can query for the quality ratings of the discovered services. Finally, we present the performance of SPiDeR in terms of routing using a simulator.

In the context of web service procurement (WSP), temporal– awareness refers to managing service demands and offers which are subject to validity periods, i.e. their evaluation depends not only on quality of service (QoS) values but also on time. For example, the QoS of some web services can be considered critical in working hours (9:00 to 17:00 from Monday to Friday) and irrelevant at any other moment. Until now, the expressiveness of such temporal–aware specifications has been quite limited. As far as we know, most proposals have considered validity periods to be composed of a single temporal interval. Other proposals, which could allow more expressive time–dependent specifications, have not performed a detailed study about all the underlying complexities of such approach, in spite of the fact that dealing with complex expressions on temporality is not a trivial task at all. As a matter of fact, it requires a special design of the so–called

procurement tasks

(consistency and conformance checking, and optimal selection). In this paper, we present a constraint–based approach to temporal–aware WSP. Using constraints allows a great deal of expressiveness, so that not only demands and offers can be assigned validity periods but also their conditions can be assigned (possibly multiple) validity temporal subintervals. Apart from revising the semantics of procurement tasks, which we previously presented in the first edition of the ICSOC conferences, we also introduce the notion of the

covering set of a demand

, a topic which is closely related to temporality.

Web service coordination and composition have become a central topic for the development of Internet-based distributed computing. A wide variety of different standards have been defined to deal with the composition of Web services (usually represented as workflows) and the execution of coordination protocols. On the other hand, some relevant research proposals have already pointed to the use of the same formalism for both aspects, being Petri nets one of the adopted formalisms. In this work we present a case study showing how the adoption of the

Nets-within-Nets

paradigm helps in the modelling of complex coordination protocols and workflows. We first propose a Petri net model for a Web service peer able to run any workflow and to dynamically interpret the coordination required protocols. The execution of these protocols allows the peer to integrate functionalities offered by external peers. The

Linda

communication model has been used to support the integration among peers.

Service-oriented modeling and analysis is a promising approach to manage

context-aware

cooperation among organizations belonging to the same value chain. Following this approach, a value chain is modeled as a composition of services provided by different partners and coordinated in a way that their interactions can be reorganized according to changes in the environment. However, so far, most of the research work in this area has been focused on the design of architectures handling service discovery, compatibility and orchestration. Little attention has been given to the specification and verification of context-aware composition of services during the requirement engineering process. The goal of this paper is to fill this gap through a methodological approach based on the strict coupling between a social and a process model. The methodology is discussed through a simple example.

Service aggregation is one of the main issues in the emerging area of service-oriented computing. The aim of this paper is to contribute to the long-term objective of lifting service aggregation from manual hand-crafting to a semi-automated engineered process. We present a methodology which, given a set of service contracts, tries to construct an aggregation of such services. Service contracts include a description of the service behaviour (expressed by a YAWL workflow), as well as an (ontology-annotated) signature. The core aggregation process basically performs a control-flow and an (ontology-aware) data-flow analysis of a set of YAWL workflows to build the contract of an aggregated service.

Choreography and orchestration languages deal with business processes design and specification. Referring to Web Services technology, the most credited proposals are WS-CDL about choreography and WS-BPEL about orchestration. A closer look to such a kind of languages highlights two distinct approaches for system representation and management. Choreography describes the system in a top view manner whereas orchestration focuses on single peers description. In this paper we define a notion of conformance between choreography and orchestration which allows to state when an orchestrated system is conformant to a given choreography. Choreography and orchestration are formalized by using two process algebras and conformance takes the form of a bisimulation-like relation.

In the area of network monitoring a lot of tools are already available to measure a variety of metrics. However, these tools are often limited to a single administrative domain so that no established methodology for the monitoring of network connections spanning over multiple domains currently exists. In addition, these tools only monitor the network from a technical point of view without providing meaningful network performance indicators for different user groups. These indicators should be derived from the measured basic metrics.

In this paper a Service Oriented Architecture is presented which is able to perform multi-domain measurements without being limited to specific kinds of metrics. A Service Oriented Architecture has been chosen as it allows for increased flexibility and scalability in comparison to traditional software engineering techniques. The resulting measurement framework will be applied for measurements in the European Research Network (GÉANT) and connected National Research and Education Networks in Europe as well as in the United States.

Service-centric systems exist in a very dynamic environment. This requires these systems to adapt at runtime in order to keep fulfilling their QoS. In order to create self-adaptive service systems, developers should not only design the service architecture, but also need to design the self-adaptability aspects in a structured way. A key aspect in creating these self-adaptive service systems is modeling runtime variability properties. In this paper, we propose DySOA (Dynamic Service-Oriented Architecture), an architecture that extends service-centric applications to make them self-adaptive. DySOA allows developers to explicitly model elements that deal with QoS evaluation and variable composition configurations. Having the DySOA elements explicit enables separation of concerns, making them adaptable at runtime and reusable in next versions. We demonstrate the use of DySOA with an example.

The intrinsic flexibility and dynamism of service-centric applications preclude their pre-release validation and demand for suitable probes to monitor their behavior at run-time. Probes must be suitably activated and deactivated according to the context in which the application is executed, but also according to the confidence we get on its quality. The paper supports the idea that significant data may come from very different sources and probes must be able to accommodate all of them.

The paper presents: (1) an approach to specify monitoring directives, called monitoring rules, and weave them dynamically into the process they belong to; (2) a proxy-based solution to support the dynamic selection and execution of monitoring rules at run-time; (3) a user-oriented language to integrate data acquisition and analysis into monitoring rules.

Service Level Agreements (SLAs) are a vital instrument in service-oriented architectures to reserve service capacity at a defined service quality level. Provisioning systems enable service managers to automatically configure resources such as servers, storage, and routers based on a configuration specification. Hence, agreement provisioning is a vital step in managing the life-cycle of agreement-driven services. Deriving detailed resource quantities from arbitrary SLA specifications is a difficult task and requires detailed models of algorithmic behavior of service implementations and capacity of a – potentially heterogeneous – resource environment, which are typically not available today. However, if we look at, e.g., data centers today, system administrators often know the quality-of-service properties of known system configurations and modifications thereof and can write the corresponding provisioning specifications. This paper proposes an approach that leverages the knowledge of existing data center configurations, defines templates of provisioning specifications, and rules on how to fill these templates based on a SLA specification. The approach is agnostic to the specific SLA language and provisioning specification format used, if based on XML.

Existing Grid schedulers focus on allocating resources to jobs as per the resource requirements expressed by end-users. This demands detailed knowledge of application behavior for different resource configurations on the part of end-users. Additionally, this model incurs significant delay in terms of the provisioning overhead for each request. In contrast, for interactive workloads, services are commonly pre-configured by an application server according to long-term steady-state requirements. In this paper, we propose a framework for bridging the gap between these two extremes. We target application services beyond simple interactive workloads, such as a parallel numeric application. In our approach, end users are shielded from lower-level resource configuration details and deal only with service metrics like average response time, expressed as SLAs. These SLAs are then translated into concrete resource allocation decisions. Since demand for a service fluctuates over time, static pre-configurations may not maximize utility of the common pool of resources. Our approach involves dynamic re-provisioning to achieve maximum utility, while accounting for overheads incurred during re-provisioning. We find that it is not always beneficial to re-provision resources according to perceived benefits and propose a model for calculating the optimal amount of re-provisioning for a particular scenario.

Due to the complexities of increasing prevalence of ubiquitous computing, it poses a large number of challenges for middleware and component technologies. We believe that service-oriented component adaptation provides a principled means to achieve the flexibility and scalability required. The focus of this paper regards an adaptive component management service in the ScudWare middleware architecture for smart vehicle space. The contribution of our work is twofold. First, an adaptive component management service framework, including a resource abstract framework, is put forward to implement adaptive mechanism. Second, a component hook proxy is proposed in detail for adaptation. In addition, this service is validated by a series of experimental results.

We present a semantic caching scheme suitable for caching responses from Web services on the SOAP protocol level. Existing semantic caching schemes for database systems or Web sources cannot be applied directly because there is no semantic knowledge available about the requests to and responses from Web services. Web services are typically described using WSDL (Web Service Description Language) documents. For semantic caching we developed an XML-based declarative language to annotate WSDL documents with information about the caching-relevant semantics of requests and responses. Using this information, our semantic cache answers requests based on the responses of similar previously executed requests. Performance experiments—based on the scenarios of TPC-W and TPC-W Version 2—conducted using our prototype implementation demonstrate the effectiveness of the proposed semantic caching scheme.

The convergence of the Semantic Web and Grid technologies has resulted in the Semantic Grid. The great effort devoted in by the Semantic Web community to achieve the semantic markup of Web services (what we call Semantic Web Services) has yielded many markup technologies and initiatives, from which the Semantic Grid technology should benefit as, in recent years, it has become Web service-oriented. Keeping this fact in mind, our first premise in this work is to reuse the ODESWS Framework for the Knowledge-based markup of Grid services. Initially ODESWS was developed to enable users to annotate, design, discover and compose Semantic Web Services at the Knowledge Level. But at present, if we want to reuse it for annotating Grid services, we should carry out a detailed study of the characteristics of Web services and Grid services and thus, we will learn where they differ and why. Only when this analysis is performed should we know how to extend our theoretical framework for describing Grid services. Finally, we present the ODESGS Framework, which is the result of having applied the extensions identified to the aforementioned Semantic Web Services description framework.

In this paper, we present a framework for implicit service calls in data centric Peer to Peer Active XML language. Active XML is a language devoted to the management of distributed data by embedding Web service calls into XML document. The aim of implicit calls is to allow dynamic data sources discovey through dynamic services discovery and composition. Implicit service calls are based on the use of ontologies for describing the domain and functionality of services to call and an Active XML engine for calls evaluation. The evaluation process deals mainly with dynamic service composition. It consists in matching OWL-S descriptions contained in a query with service descriptions in a peer-to-peer network. Such a network is structured in such a way that peers with similar functionalities are grouped together and each peer makes itself acquainted with matching relationships between its inputs/outputs and those of other peers.

The tuplespace system is a popular cooperative communication paradigm in service-oriented computing. Tuple matching in existing tuplespace systems is either type-based or object-based. It requires that both tuple writers and readers adhere to the same approach of information organization (i.e., same terminologies or class hierarchy). Further, it examines the value of the tuple contents only. As such, these tuplespace systems are inadequate for supporting communication among services in heterogeneous and dynamic environments, because services are forced to adopt the same approach to organizing the information exchanged. In order to overcome these limitations and constraints, we propose a semantic tuplespace system. Our system uses ontologies to understand the semantics of tuple contents, and correlates tuples using relational operators as part of tuple matching. Therefore, by engineering ontologies, our system allows different services to exchange information in their native formats. We argue that a semantic tuplespace system like ours enables flexible and on-demand communication among services.

Security and trust relationships between services significantly govern their willingness to collaborate and participate in a workflow. Existing workflow tools do not consider such relationships as an integral part of their planning logic: rather, they approach security as a run-time issue. We present a workflow management framework that fully integrates trust and security into the workflow planning logic. It considers not only trust relationships between the workflow requestor and individual services, but also trust relationships among the services themselves. It allows each service owner to define an upper layer of collaboration policies (rules that specify the terms under which participation in a workflow is allowed) and integrates them into the planning logic. Services that are unfit for collaboration due to security violations are replaced at the planning stage. This approach increases the services owners’ control over the workflow path, their willingness for collaboration, and avoids run-time security failures.

Most web services need to be contracted through service level agreements that typically specify a certain quality of service (QoS) in return for a certain price.

We propose a new form of service level agreement where the price is determined by the QoS actually delivered. We show that such agreements make it optimal for the service provider to deliver the service at the promised quality. To allow efficient monitoring of the actual QoS, we introduce a reputation mechanism. A scoring rule makes it optimal for the users of a service to correctly report the QoS they observed.

Thus, we obtain a practical scheme for service-level agreements that makes it uninteresting for providers to deviate from their best effort.

Composite web services can be orchestrated in a decentralized manner by breaking down the original service specification into a set of partitions and executing them on a distributed infrastructure. The infrastructure consists of multiple service engines communicating with each other over asynchronous messaging. Decentralized orchestration yields performance benefits by exploiting concurrency and reducing the data on the network. Further, decentralized orchestration may be necessary to orchestrate certain composite web services due to privacy and data flow constraints. However, decentralized orchestration also results in additional complexity due to absence of a centralized global state, and overlapping or different life cycles of the various partitions. This makes handling of faults arising from composite service partitions or from the failure of component web services, a challenging task.

In this paper we propose a mechanism for handling faults in decentralized orchestration of composite web services. The mechanism includes a strategy for placement of fault handlers and compensation handlers, and schemes for fault propagation and fault recovery. The mechanism is designed to maintain the semantics of the original specification while ensuring minimal overheads.

Non-functional properties of services and service compositions are of paramount importance for the success of web services. The negotiation of non-functional properties between web service provider and consumer can be agreed a priori by specifying an agreement. WS-Agreement is a recently proposed and emerging protocol for the specification of agreements in the context of web services. Though, WS-Agreement only specifies the XML syntax and the intended meaning of each tag, which naturally leads to posing the question of “What’s in an Agreement?” We answer this question by providing a formal definition of an agreement and analyzing the possible evolution of agreements and their terms. From our analysis we identify ways in which to make an agreement more robust and long lived by proposing two extensions to the specification and supporting environment.

We discuss our experiences in building a real-world, mission-critical enterprise business application on a service-oriented architecture for a leading consumer lending company. The application is composed of a set of services (such as

Credit Report Service, Document Management Service, External Vendor Service, Customer Management Service

, and

Lending Lifecycle Service

) that communicate among themselves mainly through asynchronous messages and some synchronous messages with XML payloads. We motivate the choice of SOA by discussing its tangible benefits in the context of our application. We discuss our experiences at every stage of the software development life cycle that can be uniquely attributed to the service oriented architecture, list several challenges, and provide an insight into how we addressed them in real-life. Some of the hard design and development challenges we faced were related to modeling workflow interactions between services, managing change analysis, and contract specification. In addition, SOA architecture and asynchronous messaging introduces fresh challenges in the area of integration testing (e.g. how do we test a system whose interface points are asynchronous messages) and in testing the robustness of the system (e.g. how do we deal with out of order messages, duplicate messages, message loss?). To address these challenges, we built a tool called

SOA Workbench

. We also discuss the techniques we adopted to address scenario-based validation that go beyond traditional document-centric validation based on XML Schema. Monitoring and error recovery, two key aspects of any mission-critical system, pose special challenges in a distributed SOA-based, asynchronous messaging setting. To address these, we built a tool called

SIMON

. We discuss how SIMON helps error detection and recovery in a production environment. We conclude by listing several opportunities for further work for people in both academia and industry.

Service-Oriented Design has driven the development of telecommunication infrastructure and applications, in particular the so-called Intelligent Network (IN) Services, since the early 90s. A service-oriented, feature-based architecture, a corresponding standardization of basic services and applications in real standards, and adequate programming environments enabled flexibilization of services, and dramatically reduced the time to market. Today the current trend toward triple-play services, which blend voice, video, and data on broadband wireline and wireless services builds on this successful experience when reaching for new technological and operational challenges. In this paper, we review our 10 years of experience in service engineering for telecommunication systems from the point of view of Service-Oriented Design then and now.

New generation network services must be deployed and managed according to the customers’ specific requirements. In this context, service providers must devise a way to design network services with near zero development time and high degrees of customization and evolution. Customization is necessary to fit the service according to the customers’ requirements, while evolution is necessary to adapt the service as soon as these requirements change. In addition, customers are demanding the ability to manage the service in order to keep the usage, configuration, and evolution under their control. This paper presents an approach based on service oriented architecture (SOA) for developing network services able to fulfill the requirements of rapid deployment, customization, and customer-side manageability. The approach considers the network service as a set of interacting elements implemented as Web Services. The service logic is expressed in terms of Web Services orchestration. Two services for the management of connections in optical networks are presented as a case study.

Dynamo advocates that pre-deployment validation and testing are intrinsically inadequate for tackling the ephemeral and rapidly changing context in which service oriented applications are deployed. Validation must be shifted to run-time and continuous monitoring must be introduced. We propose a simple architecture that, through specific and simple annotations, allows for the automatic creation of instrumented WS-BPEL processes. These processes interact with a special-purpose proxy that enacts the monitoring activities and permits us to dynamically set the level of monitoring through use of a web-based interface.

The Business Process Execution Language for Web Service, known as BPEL4WS, more recently as WS-BPEL (or BPEL for short) [1], is a process definition language geared towards Service-Oriented Computing (SOC) and layered on top of the Web services technology stack. In BPEL, the logic of the interactions between a given service and its environment is described as a composition of communication actions. These communication actions are interrelated by control-flow dependencies expressed through constructs close to those found in workflow definition languages. In particular, BPEL incorporates two sophisticated branching and synchronisation constructs, namely “control links” and “join conditions”, which can be found in a class of workflow models known as

synchronising workflows

formalised in terms of Petri nets in [3].

OpenWS-Transaction is an open source middleware that enables Web services to participate in a distributed transaction as prescribed by the WS-Coordination and WS-Transaction set of specifications. Central to the framework are the Coordinator and Participant entities, which can be integrated into existing services by introducing minimal changes to application code. OpenWS-Transaction allows transaction members to recover their original state in case of operational failure by leveraging techniques in logical logging and recovery at the application level. Depending on transaction style, system recovery may involve restoring key application variables and replaying uncommitted database activity. Transactions are assumed to be defined in the context of a BPEL process, although other orchestration alternatives can be used.

Web services are rapidly emerging as the reference paradigm for the interaction and coordination of distributed business processes. In several research papers we have shown how advanced automated planning techniques can be exploited to automatically compose web services, and to synthesize monitoring components that control their execution. In this demo we show how these techniques have been implemented in the ASTRO toolset (

http://www.astroproject.org

), a set of tools that extend existing platforms for web service design and execution with automated composition and execution monitoring functionalities.

Web processes are next generation workflows on the web, created using Web services. In this paper we demonstrate the METEOR-S Configuration and Execution Environment (MCEE) system. It will illustrate the capabilities of the system to a) Discover partners b) Optimize partner selection using constraint analysis, c) Perform interaction protocol and data mediation. A graphical execution monitor to monitor the various phases of execution will be used to demonstrate various aspects of the system.

Implementing web services that participate in long-running, multi-lateral conversations is diffcult because traditional programming languages are poor at manipulating XML data and handling concurrent and interrelated interactions. We have designed a programming language to deliberately address these problems. In this paper we describe how to use this language to consume a popular web service, and discuss the compiler, including the kinds of semantic checks it performs, and the runtime environment.

We present

semantic management of Web Services

as a paradigm that is located between the two extremes of current Web Services standards descriptions and tools, which we abbreviate by

WS*

, and Semantic Web Services. On the one hand, WS* does not have an integrated formal model incurring high costs for managing Web Services in a declarative, but mostly manual fashion. On the other hand, the latter aims at the formal modelling of Web Services such that

full automation

of Web Service discovery, composition, invocation, etc., becomes possible — thereby incurring unbearably high costs for modelling. Based on a set of use cases, we identify who benefits from what kind of semantic modelling of Web Services, when and for what purposes. We present how an ontology is used in an implemented prototype.

In [3] we started studying an advanced form of service composition where available services were modeled as deterministic finite transition systems, describing the possible conversations they can have with clients, and where the client request was itself expressed as a (virtual) service making use of the same alphabet of actions. In [4] we extended our studies by considering the case in which the client request was loosen by allowing don’t care nondeterminism in expressing the required target service. In the present paper we complete such a line of investigation, by considering the case in which the available services are only partially controllable and must be modeled as nondeterministic finite transition systems, possibly because of our lack of information on their exact behavior. Notably such services display a “devilish” form of nondeterminism, since we want to model the inability of the orchestrator to actually choose between different executions of the same action. We investigate how to automatically perform the synthesis of the composition under these circumstances.

Web services technology standards enable description, publication, discovery of and binding to services distributed towards the Internet. However, current standards do not address the service selection issue : how did a consumer select the service that matches its functional (e.g. operations’ semantics) and non-functional (e.g. price, reputation, response time) properties ? Most projects advocate automatic selection mechanism, advising adaptation or modification of the web-services model and its entities (UDDI, WSDL, Client, Provider). These proposals also do not take advantage of distributed-systems’ state of the art, mainly with respect to the collection and the dissemination of services’ QoS. This paper presents an extension of the initial model that permits automatic service selection, late binding and collection of metrics that characterize the quality of service. The extension consists on a web-service access infrastructure, made of web service proxies and a peer to peer network of QoS metrics repository (the proposal does not impose modification on UDDI registries or services). The proxies interact with common UDDI registries to find suitable services for selection and to publish descriptions. They collect QoS metrics and store them on a p2p network.

The flexibility and reusability of Web Service flows (WS-flows) are limited especially by the fact that portType and operation names are hard-coded in the process definition. In this paper we argue that through parameterization and substitution WS-flows flexibility can be improved, while reusability is enhanced. We introduce a meta-model extension to enable run time evaluation of parameter values and thus discard the need to predict any possible partner service types during process modeling. The extension enables also run time changes in portType values. We show how the approach can be mapped to BPEL. We discuss prototypical implementation for the extended functionality and present conclusions and ideas for future work.

Business performance management (BPM) is a new approach for an enterprise to improve their capabilities for sensing and responding to business situations. In a diverse and fast-changing business environment, an enterprise needs to adapt itself to any unexpected changes. For BPM, such changes imply changes of the models and services that support BPM. This paper discusses an implementation of BPM with the focus on dynamically adapting its services. We will present the motivation, concept and architecture of the dynamic change mechanisms. First we define a set of configurations as a policy, and also define its consistency through an application context. Then we propose an architectural overview including a policy management service as an implementation of consistency management.

Leveraging service oriented programming paradigm would significantly affect the way people build software systems. This paper contributes to the above goal proposing a lightweight formal framework capable of capturing the essential components of service-oriented programming paradigm.

The integration of business and operational processes is today of major importance in a wide range of industries. The challenge is to seamlessly integrate software applications supporting business activities and field devices belonging to the plant floor. It requires to build Internet-scale distributed systems in complex, heterogeneous environments characterized by stringent requirements regarding security and evolution in particular. In order to meet these requirements, distributed architectures based on the service-oriented paradigm have been proposed. This paper argues that the service-oriented development is too technology-driven. We propose a reusable MDE approach for service development in power distribution industry where the developer focuses on application logic. The approach is currently tested for a service-platform based on the OSGi technology.

Semantic Web services promise the addition of semantics annotations to Web services in a manner that enables automatic discovery, usage, and integration of services as part of every day processes. IBM’s unified activity management (UAM) implements activity-centric computing concepts by representing human work in terms of activities that relate to each other using semantic information from the various contexts in which the activities are used. In this paper we explore how, using common domain-specific ontologies, we can make use of the semantic annotations added to Web services and our UAM environment, to produce dynamic and richer Web applications widgets and services.

If we accept that service providers and service users all operate with autonomy in some form of market place, then a necessary prerequisite for service discovery and engagement is the description of the non-functional properties of a service. Price acts as one of the key nonfunctional properties used in choosing candidate services. Conventional services describe prices using several approaches (e.g. fixed price, price ranges, proportional pricing, dynamic price mechanisms). Furthermore, there are associated concepts such as price matching, price granularity, taxes and reward schemes that might need to be taken into consideration. This paper offers a discussion of the non-functional property of price. By incorporating some information about price, service descriptions will move away from the narrow distributed computing view of web services, enabling greater reasoning with respect to service descriptions.

Enterprise business services are often deployed over complex environments, managed by multiple service-management products. For instance, a business service may be configured as a three-tier environment with multiple services that run on different resource domains and span one or more tiers, and comprising service-management products such as workload managers, business resiliency managers, and resource arbiters. The objective policies of the enterprise business service, henceforth called Global Service Policies, determine the runtime policies used by the various management products. The lifecycle management of global service policies, including the deployment and enforcement stages, inherits the complexity of the enterprise IT environment. This paper proposes a novel framework for efficiently managing the deployment and enforcement lifecycle stages. The framework enables the complete automation of dissemination and translation of global policy for all service managers, for a low-cost, correct policy deployment. Also, the framework enables the runtime customization of resource arbitration components for using the actual business value models of the enterprise objectives global, for a high quality of policy enforcement. The proposed framework is prototyped and integrated with several IBM service-management products.

Probably one of the most difficult tasks in the development of a Service Oriented Architecture (SOA) is how to obtain well designed Web Services. Some Web Engineering methods provide support to introduce Web services in the software development process but do not give support to the systematic design and implementation of them. In this work, we present an extension of a Web Engineering method (called OOWS) to provide a methodological guide for designing Web Services. This allows identifying and designing the operations and arguments of Web Services following a modeldriven approach, taking the OOWS conceptual models as a source. To document our approach, we apply our ideas to the design of the Amazon Web Service and compare our proposal with the solution provided by Amazon.

Security issues are one of the major deterrents to Web Services adoption in mission critical applications and to the realization of the dynamic e- Business vision of Service Oriented Computing. Role Based Access Control (RBAC) is a common approach for authorization as it greatly simplifies complex authorization procedures in enterprise information systems. However, as most RBAC implementations rely on the manual setup of pre-defined user-ID and password combinations to identify the particular user, this makes it very hard to conduct dynamic e-Business as the service requestor and service provider must have prior knowledge of each other before the transaction. This paper proposes a new Web Services security architecture which unifies the authorization and authentication processes by extending current digital certificate technologies. It enables secure Web Service authorization decisions between parties even if previously unknown to each other and it also enhances the trustworthiness of service discovery.

The introduction of the Semantic Web techniques in Service-oriented Architectures enables explicit representation and reasoning about semantically rich descriptions of service operations. Those techniques hold promise for the automated discovery, selection, composition and binding of services. This paper describes an approach to derive formal specifications of Web Service compositions on the basis of the interpretation of informal user requests expressed in (controlled) Natural Language. Our approach leverages the semantic and ontological description of a portfolio of known service operations (called Semantic Service Catalog).