iPOJO-based Middleware Solutions for Self-Reconfiguration and Self-Optimization

Paolo Bellavista, Antonio Corradi, Damiano Fontana, Stefano MontiKSII Trans. Internet Inf. Syst 2011 · DOI · OpenReview

Abstract

Modern software systems operating in Ubiquitous Computing (UC) environments must adapt to dynamic resource availability and changing user requirements. This paper presents OTS-RTG (Off-The-Shelf Ready To Go), an iPOJO-based middleware that facilitates runtime self-reconfiguration. Unlike traditional frameworks that require specialized component design, OTS-RTG introduces an integration pattern using Façades and Wrappers to bring autonomic capabilities to legacy and off-the-shelf components. Evaluation in an Enterprise Service Bus (ESB) context shows that the system provides effective self-optimization with negligible performance overhead.

Introduction

Ubiquitous Computing environments are characterized by high volatility, including frequent network drops and fluctuating hardware resources. To maintain Quality of Service (QoS), software must be "autonomic"—capable of sensing environmental changes and adjusting its configuration accordingly.

Existing autonomic frameworks face two primary challenges. First, they often focus exclusively on functional business logic, ignoring critical non-functional features such as security, persistence, and transaction management. Second, they typically require components to be built specifically for the framework, creating a "legacy lock-in" that prevents the reuse of existing off-the-shelf software without expensive redesigns.

System Architecture and the MAPE-K Loop

OTS-RTG addresses these challenges by building upon iPOJO, a service-oriented component model for Java/OSGi. The middleware implements the standard MAPE-K (Monitor, Analyze, Plan, Execute, Knowledge) control loop to manage system state.

The OTS-RTG architecture implementing the MAPE-K loop over an iPOJO-based autonomic application.

As shown in Figure 1, the architecture consists of:

  • Monitor Layer (Sensors): Pluggable components that observe the application environment.
  • Control Component: Analyzes sensor data and plans reconfigurations based on XML-defined rules.
  • Reconfiguration Layer (Effectors): Executes changes by swapping or modifying components, managing lifecycles, and reconfiguring dependencies.

The Integration Pattern: Façades and Wrappers

The core innovation of OTS-RTG is its "integration pattern," which enables transparent reconfiguration of both functional and non-functional properties. This pattern relies on two primary constructs: Façades and Wrappers.

The integration pattern utilizing Façades and Wrappers to enable transparent dynamic dependency reconfiguration.

A Façade mimics the interface expected by a client, while a Wrapper acts as a mediator for the actual service provider. Because these are managed as first-class components within the OTS-RTG middleware, the system can swap underlying service providers or alter their properties (e.g., switching from a secure protocol to a high-speed one) without the client's knowledge. To minimize developer effort, the framework utilizes the ASM bytecode manipulation library to generate Façade code dynamically at runtime.

Conceptual Model: The "Creative Chef"

The authors conceptualize the middleware as a "creative chef." While a standard system might fail if a specific resource is missing, OTS-RTG adapts the configuration to what is currently available. This approach emphasizes that non-functional requirements are fundamental; sometimes, the best way to optimize a system is to relax a heavy non-functional constraint, such as a database transaction, during periods of peak demand.

Experimental Evaluation

The researchers evaluated OTS-RTG using an industrial Enterprise Service Bus (ESB) scenario. The testbed utilized Apache Camel to route messages between queues on a system stressed with a load of 1,000 messages per second.

Performance and Overhead

The "autonomic tax"—the overhead introduced by the middleware—was found to be minimal. Reconfiguration actions, such as swapping a component, exhibited latency comparable to standard object instantiation.

Self-Optimization Results

The system was tested on its ability to optimize performance by switching from a "Transactional" route (high reliability, low speed) to a "Non-Transactional" route (low reliability, high speed) during peak traffic:

  • Component Replacement: Swapping the route caused a minor 50ms spike in enqueuing time, followed by rapid recovery.
  • Component Augmentation: Instead of replacing the slow route, the middleware added a fast route to run in parallel. This reduced average enqueuing time to approximately 1ms, a massive improvement over static configurations.

Conclusion and Future Work

OTS-RTG demonstrates that autonomic capabilities can be integrated into legacy systems with low overhead and high transparency. However, the current implementation relies on static, human-defined XML rules for the "Plan" phase of the MAPE-K loop. Future research aims to replace these rigid rules with a more intelligent control component that utilizes session history and machine learning to infer optimal reconfiguration strategies based on historical environmental data.

Summary updated

Abstract

KSII Transactions on Internet and Information Systems
BibTeX
@article{bellavista2011ipojo,
  author = {Paolo Bellavista and Antonio Corradi and Damiano Fontana and Stefano Monti},
  title = {{iPOJO-based Middleware Solutions for Self-Reconfiguration and Self-Optimization}},
  journal = {KSII Trans. Internet Inf. Syst.},
  year = {2011},
  doi = {10.3837/tiis.2011.08.001},
}
Figure