1
Towards a Meta-Modelling Approach to Configurable
Middleware
Nelly Bencomo1, Gordon Blair1, Geoff Coulson1, and Thais Batista2
1 Comp. Dept., InfoLab21, Lancaster University, Lancaster, LA1 4WA, UK
{nelly, gordon, geoff}@comp.lancs.ac.uk
2 Comp. Scs. Dept., UFRN, 59072-970, Natal - RN, Brazil
thais@ufrnet.br
Abstract. In our research we are studying how to combine modelling, meta-
modelling, and reflection to systematically generate middleware configurations
that can be targeted at different application domains and deployment environ-
ments. Despite this generality our approach adopts a uniform set of concepts:
components, components frameworks, and reflection. Components and compo-
nent frameworks provide structure, and reflection provides dynamic
(re)configuration and extensibility for run-time evolution and adaptation. In this
paper we present meta-models that capture the generality inherent to our ap-
proach and form a basis for automatic generation of extensible “middleware
families” that can be instantiated differently depending on the application do-
main, QoS, deployment environment and degree of dynamic reconfigurability
required.
1. Introduction
Reflection has now emerged as an important technique in the support of more config-
urable and re-configurable middleware [1]. A number of experimental reflective mid-
dleware platforms have been developed and used in industry. In our research we
complement the use of reflection with the notions of components (language-
independent units of dynamic deployment), component frameworks (collections of
components that address a specific area of concern and accept additional plug-in
components) [9], and middleware families (abstract collections of component frame-
works that are tailored to specific application domains and deployment environ-
ments). In addition, middleware families employ reflection [7] to discover the current
structure and behaviour of the family instantiation, and to allow selected changes at
run-time for dynamically consistent evolution and adaptation. The end result is a
flexible middleware architecture that can be straightforwardly specialised to a wide
range of domains including multimedia, embedded systems [2], and mobile comput-
ing [5].
Challenging new requirements emerge when working with such architecture. Mid-
dleware developers are faced with a large number of variability decisions when plan-
ning configurations at various stages of the development cycle. These include deci-
sions in design, component development, integration, deployment and even at run-
time. These factors make it error-prone to manually guarantee that all these decisions

2
are consistent. In addition, such ad hoc approaches do not offer a formal foundation
for verification that the ultimately configured middleware will offer the required
functionality.
To address these issues, we are currently investigating the use of Model-Driven
Software Development (MDSD) techniques. MDSD is a new paradigm that encom-
passes domain analysis, meta-modelling and model-driven code generation. We be-
lieve that MDSD has great potential in systematically generating configurations of
middleware families. In our MDSD-based approach, we propose the capture of the
fundamental component-based programming concepts in a core set of meta-model
elements called a kernel. All middleware family members regardless of their domain
share this minimum set of concepts. On top of this, we propose a set of extension
meta-models which capture the extensibility characteristics of our underlying (con-
crete) component model and which can be plugged in as appropriate.
In the remainder of this paper we first, in section 2, introduce the main concepts of
our concrete component model. Then, in section 3, we discuss the MDSD-based
modelling of these concepts and show our current model-based realisation. Then in
section 4 we discuss the application of the meta-models and models in generating
middleware families. Finally, we present conclusions and discuss future work in sec-
tion 5.
2. A happy family: Lancaster’s reflective middleware
As mentioned, our notion of middleware families is based on three key concepts:
components, components frameworks, and reflection. Both the middleware platform
and the application are built from interconnected sets of components. The underlying
component model is based on OpenCOM[3], a general-purpose and language inde-
pendent component-based systems building technology. OpenCOM supports the
construction of dynamic systems that may require run-time reconfiguration. It is
straightforwardly deployable in a wide range of deployment environments ranging
from standard PCs, resource-poor PDAs, embedded systems with no OS support, and
high speed network processors. Components are complemented by the coarser-
grained notion of component frameworks (CFs) [9]. A CF is a set of components that
cooperate to address a required functionality or structure (e.g. service discovery and
advertising, security etc). CFs also accept additional ‘plug-in’ components that
change and extend behaviour. Many interpretations of the CF notion foresee only
design-time or build-time plugability. In our interpretation run-time plugability is also
included, and CFs actively police attempts to plug in new components according to
well-defined policies and constraints.

Figure 1. The OpenCOM main concepts

receptacle
binding
interface
component
runtime
API
capsule