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.
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.
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