The JOpera project brings together ideas of different research areas: distributed systems, visual languages, software composition, workflow management and autonomic computing.
First of all, we propose the application of visual languages to service composition. In order to connect basic services of various kinds into a larger distributed system, their interactions along the time dimension are deﬁned with the JOpera Visual Composition Language. As opposed to the textual or XML-based syntax of existing approaches, our language features a very simple graphical notation. This visual syntax is used to declare the data flow and control ﬂow graphs linking the various service invocations. This way, it becomes possible to rapidly build distributed applications out of a set of reusable services by literally drawing the interactions between them. To achieve this, usability features such as automatic, incremental graph layout and visual scalability features such as multiple views have been driving the design of JOpera’s visual service composition environment. To provide support for realistic application scenarios, we have also included recursion, iteration, streaming, dynamic late binding and reﬂection constructs with minimal changes to the syntax of the visual language.
A process graphically defines the flow between the different components of a service oriented architecture.
Underneath the visual syntax, our approach to modeling service composition is based on the concept of process. In this project we borrow the notion of workflow process so that it can be extended to model service oriented architectures. The structure of a process deﬁnes the partial order of invocation of its services, the data exchanges between them and the necessary failure handling behavior.
In this context, an important aspect of this project follows the simple idea that a composition language should be orthogonal with respect to the types of components that are employed. More precisely, in our approach, composition is deﬁned at the level of service interfaces. Therefore, a process is completely independent from the mechanisms and protocols used to access the implementation of its services. In other words, we introduce a composition language which is not limited to describing how components of a speciﬁc type (e.g., Web services) should be composed.
Heterogeneity cannot be solved by assuming that all components of a distributed system are all of the same Web services kind (or even that they all speak XML)
Instead, in our open component meta-model, we generalize the notion of service by abstracting common features among a large set of different component types. This abstraction has several important implications. By supporting a large and open set of types of services, the composition language is simpliﬁed because many constructs (e.g., modeling synchronous or asynchronous service invocation) can be shifted from the composition language to the component meta-model. Also, the service composer is free to choose the most appropriate mechanism to access the functionality of an existing service. Thus, the runtime overhead of a service invocation can be minimized as it becomes possible to choose the most effcient access mechanism.
This optimization regarding the service access mechanism would not make much of a difference regarding the overall system’s performance if the execution of the visual language would incur in a high overhead, as typically process-based languages are executed by an interpreter. On the contrary, in this project we explore the idea of compiling the visual speciﬁcation of a process into executable Java bytecode. One of the challenges of doing so is that the resulting code should still support the concurrent, persistent and scalable execution of multiple process instances.
JOpera uses advanced model-driven architecture (MDA) techniques to compile process models to Java bytecode while supporting interactive monitoring and debugging at the source level.
The choice of applying compilation to the execution of processes brings the following beneﬁts. In addition to the potential for providing better performance through the optimization of the generated code, compiling processes also helps to simplify the design of the corresponding runtime system. As opposed to having a full-blown process interpreter, it is enough to design and build a ﬂexible container of compiled processes.
Following this approach, JOpera provides a highly flexible architecture for a process support system. Flexibility is an important aspect of our design which, according to our experimental results, does not contradict the goal of building an efficient system. First, ﬂexibility enables JOpera to support heterogeneous types of services. To do so, Eclipse plug-ins are used to map the invocation of a service to the corresponding protocol in the most effcient manner. Second, the ﬂexible architecture of JOpera’s kernel can be deployed in a variety of conﬁgurations. This way, costly features such as reliable process execution can be added only if they are truly needed. Likewise, the system shows good scalability when deployed in a cluster-based conﬁguration, as large workloads are shared among multiple cluster nodes.
JOpera uses autonomic computing techniques to automatically configure its distributed process execution engine based on its workload.
Thanks to a wise choice of architectural abstractions, the code generated by the compiler is kept independent of the actual conﬁguration of the kernel into which it is loaded. Third, ﬂexibility is also a fundamental property for an autonomic system, where the optimal conﬁguration of the distributed process execution engine is determined automatically at runtime.