Lasagne is used for the construction of customizable middleware and distributed services

Problem Description

In aspect-oriented software development (AOSD) research, it has been recognized that a slice of behavior affecting a set of collaborating objects is a better unit of reuse than a single object. Different techniques and language extensions have been proposed to express such slices in programming languages.

The aim of this project is to investigate how AOSD methods can be used for the customization of distributed systems, middleware platforms and on-line services. We particularly focus on solving the problem of the need for context-sensitive customization of such systems. The need for context-sensitive customization can be described as:
clients of an on-line service must be able to customize this service for use in their own contexts (without affecting the service behavior that is delivered to other clients of that service).
It is important to understand that due to the Internet success, an on-line service is at the same time used by hundreds or even thousands of simultaneously requesting client systems, where each client system may have different - possibly conflicting - preferences about how the service must be customized to their needs. So multiple client-specific views must simultaneously be taken into account during the customization process of such a system.

In order to get a grip at this problem, we present the customization process of a core system as a dynamic and selective integration of extensions to the core system on per client request basis. According to the AOSD approach, each extension implements a reusable slice of behavior. However in order to make AOSD feasible for context-sensitive customization of on-line services, AOSD techniques must be improved in the following ways:

• Aspects must be composed at run-time in order to become usable for customization of on-line services.
• A notion of context-sensitive selection of aspects is needed (some existing AOSD programming languages (a.o Aspect/J) recently support this, but it's not clear how this will work for distributed applications)

The Approach Taken

We have developed an architecture for run-time and context-sensitive combination of aspects. Note that we are not focussing on new high-level programming concepts nor pointcut definitions that improve existing aspect-oriented programming languages. Our sole intention is to develop a run-time aspect weaving mechanism that can be integrated on top of existing object-oriented and aspect-oriented programming languages and middleware platforms

Our approach is based on a non-invasive, aspect-oriented, per-instance, per-collaboration component extension mechanism; the idea behind this mechanism is changing the behavior of the system without changing the code of core components, but instead encapsulating them within wrappers. In turn, wrappers can be encapsulated in other wrappers if needed.

Non-invasive extension mechanism. Wrappers support separation of concerns, since code for implementing a concern can be completely encapsulated in a wrapper. As was described above, subsequent composition of concerns is supported by conjunctive encapsulation of such wrappers.

Aspect-oriented extension mechanism. According to the AOSD approach, wrappers are grouped into extensions that encapsulate a slice of reusable behavior. An extension may update multiple components at the same time, where each wrapper of that extension is decorated around another component.

Per-instance extension mechanism. Since wrappers operate at the instance-level, run-time composition of extensions becomes feasible.

Per-collaboration extension mechanism. Selection of extensions happens per client request. Since a client request triggers a collaboration that executes over the entire core system, special attention is paid on maintaining consistency: Once an extension is selected for a client request, this decision must be coordinated all over the core system such that all wrappers of that extension are applied.

The Underlying Framework

Context-sensitive customization builds upon propagation of the calling and deployment context within the core system. Context is reified by contextual properties which stem from the clients or configurator/deployer of that system. Example contextual properties are client-specific preferences, method call history, message arguments, etc.

The underlying programming language or middleware platform must implement a method dispatch mechanism that supports a run-time combination of wrappers on a per collaboration basis, while taking the contextual properties into account. First, by means of programmable interceptors contextual properties can be defined and attached to specific collaborations. Second, another kind of interceptors inspect the values of these contextual properties to decide which extensions should be executed for each ongoing collaboration. More specifically, the latter kind of interceptors supports some kind of predicate dispatching over the context. They can specify that an extension should be executed when a programmer-defined expression over the contextual properties is true. Third, the run-time wrapper combination mechanism knows from this decision which extensions must be composed with the core system. Furthermore, this decision is propagated with the collaboration's message flow to enable consistent, system-wide dispatching to all the wrappers of a selected extension. As such, a modular predicate dispatch mechanism is achieved that allows for dispatching to aspect-oriented extensions in a consistent manner.

Interceptors at the server-side allow the system configurator to detect and override invalid customizations that were requested by clients.

Important Contributions

• A non-invasive approach to achieving dynamic software extension using wrappers
  • The approach is not intrusive with respect to the core code of the system.
  • It provides a good level of flexibility.
• Addresses the object schizophrenia problem that is inherent in wrapper-based approaches
• The distinction between "wrappers" (devoted to extend the basic services provided by a component and to add new services), "extensions" (layer of wrappers that collaborate, e.g., at the client and server side, to provide an extended or new service), and "interceptors" that for each service call decide what extensions have to be applied, enables separation of concerns and results in a clean design of such customization mechanism.

Selected Publications

Eddy Truyen, Dynamic and Context-Sensitive Composition in Distributed Systems, PhD thesis, K.U.Leuven, Belgium, November 2004 (pdf).

B. N. Joergensen and E Truyen, "Evolution of collective object behavior in presence of simultaneous client-specific views", International Conference on Object-Oriented Information Systems", Springer, 2003. (pdf)

E. Truyen and W. Joosen, "An Object Model With Feature-Based Dispatch for Context-Sensitive Behavior in Distributed Systems", Technical Report, Department of Computer Science, CW 527, 2008 (pdf)

E. Truyen, W. Joosen, P. Verbaeten, and B. N. Joergensen, "A metadata-driven approach that combines family polymorphism, delegation and flexible composition semantics", draft - available on request

E. Truyen, W. Joosen, P. Verbaeten, "Consistency Management in the presence of Simultaneous Client-Specific Views", accepted for International Conference on Software Maintenance (ICSM'2002), Montreal, Canada (pdf), (ps.gz) [IEEE copyright]

Eddy Truyen, Bart Vanhaute, Wouter Joosen, Pierre Verbaeten, Bo Noerregaard Joergensen, "Dynamic and Selective Combination of Extensions in Component-based Applications", in Proceedings of the 23rd International Conference on Software Engineering (ICSE'2001), May 2001, Toronto, Canada. (ppt) (pdf) (abstract) [IEEE copyright]

Eddy Truyen, Bo N. Joergensen, Wouter Joosen, "Customization of Object Request Brokers through Dynamic Reconfiguration", in Proceedings of Tools Europe 2000, June 2000, Mont-St-Michel, France (PDF) (postscript) (abstract) [IEEE copyright]

Bo Noerregaard Joergensen, Eddy Truyen, Frank Matthijs, Wouter Joosen. Customization of Object Request Brokers by Application Specific Policies. in Proceedings of the Middleware'2000 conference, April 2000, New York, USA. (PDF)(ps) (abstract) [Springer copyright]

Eddy Truyen, Bart Vanhaute, Wouter Joosen, Pierre Verbaeten, Bo N. Joergensen, "Customization of On-line Services With Simultaneous Client-specific Views", accepted for ICSE'2001 and ECOOP'2001 workshops on Advanced Separation of Concerns. (pdf)

Eddy Truyen, Bart Vanhaute, Wouter Joosen, Pierre Verbaeten, Bo Noerregaard Joergensen, "A Dynamic Customization Model for Distributed Component-Based Applications, accepted for International Workshop on Dynamic and Distributed Multiservice Architectures (DDMA 2001). (pdf), (extended version)

Downloads

Lasagne is an abstract model in the sense that it can be implemented on top of various platforms:

• Lasagne/J: Lasagne/J is a Java extension that supports the Lasagne semantics and offers higher-level object-oriented language constructs that make it easier to 'program' the Lasagne run-time.

• Correlate: There is also a programming framework (click here to download) developed on top of the concurrent object-oriented language Correlate. Correlate classes are compiled to normal Java classes, so Correlate runs on any JVM platform. Finally, Correlate has a meta-level architecture that makes it easier to build distributed applications and to build customized middleware platforms for these applications. This meta-level architecture was as well the tool for implementing the Lasagne semantics on top of Correlate.