| dc.description.abstract | Service-oriented computing is a popular technology that facilitates the development
of large-scale distributed systems. However, the modular composition and flexible
coordination of such applications still remains challenging for the following reasons: 1)
the services are provided as loosely coupled black boxes that only expose their interfaces
to the environment; 2) interacting services are not usually known in advance: web
services are dynamically chosen to fulfil certain roles and are often replaced by services
with a similar functionality; 3) the nature of the service-based application is decentralised.
Loose coupling of web services is often lost when it comes to the construction of an
application from services. The reason is that the object-oriented paradigm, which is
widely used in the implementation of web services, does not provide a mechanism for
service interface self-tuning. As a result, it negatively impacts upon the interoperability
of web services.
In this dissertation we present a formal method for automatic service configuration in
the presence of subtyping, polymorphism, and flow inheritance. This is a challenging
problem. On the one hand, the interface description language must be flexible enough to
maintain service compatibility in various contexts without any modification to the service
itself. On the other hand, the composition of interfaces in a distributed environment must
be provably consistent.
Our method is based on constraint satisfaction and Boolean satisfiability. First, we
define a language for specifying service interfaces in a generic form, which is compatible
with a variety of contexts. The language provides support for parametric polymorphism,
Boolean variables, which are used to control dependencies between any elements of
interface collections, and flow inheritance using extensible records and variants. We
implemented the method as a constraint satisfaction solver.
In addition to this, we present a protocol for interface configuration. It specifies a
sequence of steps that leads to the generation of context-specific service libraries from
generic services. Furthermore, we developed a toolchain that performs a complete
interface configuration for services written in C++. We integrated support for flexible
interface objects (i.e. objects that can be transferred in the application along with their
structural description). Although the protocol relies solely on interfaces and does not
take behaviour concerns into account, it is capable of finding discrepancies between
input and output interfaces for simple stateful services, which only perform message
synchronisation. Two running examples (a three buyers use-case and an image processing
application) are used along the way to illustrate our approach.
Our results seem to be useful for service providers that run their services in the
cloud. The reason is twofold. Firstly, interfaces and the code behind them can be
generic as long as they are sufficiently configurable. No communication between service
designers is necessary in order to ensure consistency in the design. Instead, the interface
correspondence in the application is ensured by the constraint satisfaction algorithm,
which we have already designed. Secondly, the configuration and compilation of every
service are separated from the rest of the application. This prevents source code leaks in
proprietary software which is running in the cloud. | en_US |
