Noel De Palma

Autonomic Management of Clustered Applications

Distributed software environments are increasingly complex and difficult to manage, as they integrate various legacy software with proprietary management interfaces. Moreover, the fact that management tasks are performed by humans leads to many configuration errors and low reactivity. This paper presents Jade, a middleware for self-management of distributed software environments. The main principle is to wrap legacy software pieces in components in order to provide a uniform management interface, thus allowing the implementation of management applications. Management applications are used to deploy distributed applications and to autonomously reconfigure them as required

Self-Configuration of Distributed Applications in the Cloud

In the field of cloud computing, current solutions dedicated to PaaS (Platform as a Service), i.e. the environments that deal with the different stages of the application life-cycle, remain business domain specific and are only partially automated. This limitation is due to the lack of an architectural model for describing a distributed application in terms of its software stacks (operating system, middleware, application), their instantiation as virtual machines, and their configuration interdependencies. This article puts forward (i) a component-based application model for defining any kind of distributed applications composed of a set of interconnected virtual machines, (ii) an automated line for deploying such a distributed application in the cloud, which includes a decentralized protocol for self-configuring the virtual application machines, (iii) a first performance evaluation demonstrating the viability of the solution.

Self-protection for distributed component-based applications

The complexity of todays distributed computing environments is such that the presence of bugs and security holes is statistically unavoidable. A very promising approach to this issue is to implement a self-protected system, similarly to a natural immune system which has the ability to detect the intrusion of foreign elements and react while it is still in progress. This paper describes an approach relying on component-based software engineering to ease the protection of distributed systems. The knowledge of the application architecture is used to detect foreign activities and to trigger counter measures. We focus on a mean to recognize known and unknown attacks independently from legacy software and avoiding false positives. Hence, the scope of the detected attacks is, for the moment, limited to the detection of illegal communications. We describe how this approach can be applied to provide self-protection for clustered J2ee applications with a very low overhead.

Dynamic configuration of multimedia applications

Streaming multimedia applications, such as video on demand or conferencing are increasingly deployed in heterogeneous and mobile environments including Workstations, PDAs, mobile phones, etc. These applications are very resource demanding and in general, they need to be dynamically adapted when executed on low capability terminals. The proxy-based content adaptation approach is well suited to transparently adapt in real time multimedia data on intermediate nodes without modifying the application. In this paper, we report on experiments on dynamic configuration of such proxies by using a configuration language called APSL (Adaptation Proxy Specification Language). We developed a configurable proxy allowing adaptation of existing videoconferencing applications, and evaluated the performance benefits of the proxy approach using a DirectShow/COM-based framework.

Specification and Verification of a Dynamic Reconfiguration Protocol for Agent-Based Applications

Dynamic reconfiguration increases the availability of distributed applications by allowing them to evolve at run-time. This paper deals with the formal specification and model-checking verification of a dynamic reconfiguration protocol used in industrial agent-based applications. Starting from a reference implementation in Java, we produced a specification of the protocol using the Formal Description Technique Lotos. We also specified a set of temporal logic formulas characterizing the correct behaviour of each protocol primitive. Finally, we studied various finite state configurations of the protocol, on which we verified these requirements using the Cadp protocol engineering tool set.

Modular coordination of multiple autonomic managers

Complex computing systems are increasingly self-adaptive, with an autonomic computing approach for their administration. Real systems require the co-existence of multiple autonomic management loops, each complex to design. However their uncoordinated co-existence leads to performance degradation and possibly to inconsistency. There is a need for methodological supports facilitating the coordination of multiple autonomic managers. In this paper we propose a method focusing on the discrete control of the interactions of managers. We follow a component-based approach and explore modular discrete control, allowing to break down the combinatorial complexity inherent to the state-space exploration technique. This improves scalability of the approach and allows constructing a hierarchical control. It also allows re-using complex managers in different contexts without modifying their control specifications. We build a component-based coordination of managers, with introspection, adaptivity and reconfiguration. We validate our method on a multiple-loop multi-tier system.

Verification of a self-configuration protocol for distributed applications in the cloud

Distributed applications in the cloud are composed of a set of virtual machines running a set of interconnected software components. In this context, the task of automatically configuring distributed applications is a very difficult issue. In this paper, we focus on such a self-configuration protocol, which is able to configure a whole distributed application without requiring any centralized server. The high degree of parallelism involved in this protocol makes its design complicated and error-prone. In order to check that this protocol works as expected, we specify it in Lotos NT and verify it using the Cadp toolbox. The use of these formal techniques and tools helped to detect a bug in the protocol, and served as a workbench to experiment with several possible communication models.

Automated Configuration of Legacy Applications in the Cloud

Current solutions for managing distributed applications in the cloud, typically covered by PaaS (Platform as a Service) offers, remain domain specific and are only partially automated. In this context, the task consisting in automatically configuring distributed applications is still a difficult issue. In this paper, we present an application architectural model and a self-configuration protocol that automates the deployment of legacy distributed applications. Our protocol is decentralized and loosely coupled to avoid the need of a global synchronization between virtual machines (VMs) during the configuration stage. An evaluation reports the performances of the protocol when applied to deploy enterprise web applications on a private cloud platform.

DVFS Aware CPU Credit Enforcement in a Virtualized System

Nowadays, virtualization is present in almost all computing infrastructures. Thanks to VM migration and server consolidation, virtualization helps reducing power consumption in distributed environments. On another side, Dynamic Voltage and Frequency Scaling (DVFS) allows servers to dynamically modify the processor frequency (according to the CPU load) in order to achieve less energy consumption. We observed that these two techniques have several incompatibilities. For instance, if two virtual machines VM1 and VM2 are running on the same physical host (with their respective allocated credits), VM1 being overloaded and VM2 being underloaded, the host may be globally underloaded leading to a reduction of the processor frequency, which would penalize VM1 even if VM1’s owner booked a given CPU capacity. In this paper, we analyze the compatibility of available VM schedulers with DVFS management in virtualized environments, we identify key issues and finally propose a DVFS aware VM scheduler which addresses these issues. We implemented and evaluated our prototype in the Xen virtualized environment.

Component-Based Autonomic Managers for Coordination Control

The increasing complexity of computing systems has motivated the automation of their administration functions in the form of autonomic managers. The state of the art is that many autonomic managers have been designed to address specific concerns, but the problem remains of coordinating them for a proper and effective global administration. In this paper, we define controllable autonomic managers encapsulated into components, and we approach coordination as their synchronization and logical control. We show that the component-based approach supports building such systems with introspection, adaptivity and reconfiguration. We investigate the use of reactive models and discrete control techniques, and build a hierarchical controller, enforcing coherency properties on the autonomic managers at runtime. One specificity and novelty of our approach is that discrete controller synthesis performs the automatic generation of the control logic, from the specification of an objective, and automata-based descriptions of possible behaviors. Experimental validation is given by a case-study where we coordinate two self-optimization autonomic managers and self-repair in a replicated web-server system.