Christophe Bidan

A dynamic reconfiguration service for CORBA

Providing software qualities such as availability, adaptability and maintainability to long-running distributed applications forms a major challenge for the configuration management of a software system. Modifications of a systems structure are expected to happen on-the-fly, to cause minimum execution disruption and to be effected in a way that preserves a consistent state of the participating entities. This paper presents a novel algorithm for performing consistent dynamic reconfiguration of CORBA applications, where consistency refers to RPC integrity. The novelty of the algorithm is that it passivates the links affected by the reconfiguration, which causes the node activities that use them to block but does not result in blocking the entire node. The consequent execution disruption is minimal, a fact that is practically verified by a performance evaluation done in a number of different reconfiguration scenarios.

Achieving middleware customization in a configuration-based development environment: experience with the Aster prototype

Middleware configurations provide a means to make accessible a wide range of applications on a (possibly large) distributed heterogeneous platform. However, as new application areas appear, middleware configurations will have to evolve to accommodate those new applications needs. This paper discusses the implementation of the Aster development environment that realizes automatic configuration of middleware which are customized to the applications needs from the standpoint of provided non-functional properties (e.g., fault-tolerance, security). The environment relies on two main tools. The first tool retrieves the software constituting the middleware that meets application requirements, by means of software specification matching. The second tool implements the interfacing of the applications software components with the customized middleware. Interfacing is discussed in the framework of the CORBA environment, hence addressing construction of customized middleware on top of an ORB, possibly using common object services specified by the OMG.

Aster: a framework for sound customization of distributed runtime systems

This paper introduces the Aster distributed configuration-based-programming system that is aimed at easing the development of emerging distributed applications having quality of service requirements. Our approach is based on high-level customization: given the specification of application requirements using the Aster interconnection language, a distributed runtime system, customized for meeting these requirements is built. So as to make the customization process sound, we propose a formal method that allows one to reason about specification matching of a customized distributed runtime system with the applications requirements.

An Improved Reference Flow Control Model for Policy-Based Intrusion Detection

In this paper, we describe a novel approach to policy-based intrusion detection. The model we propose checks legality of information flows between objects in the system, according to an existing security policy specification. These flows are generated by executed system operations. Illegal flows, i.e., not authorized by the security policy, are signaled and considered as intrusion symptoms. This model is able to detect a large class of attacks, referred to as ”attacks by delegation” in this paper. Since the approach focuses really on attack effects instead of attack scenarii, unknown attacks by delegation can be detected.

Security Benefits from Software Architecture

In todays field of distributed software architectures there is a need for environments allowing the easy development of applications consisting of heterogeneous software modules and having various Quality of Service requirements (e.g., timeliness, availability or security). System customization using middleware-services is a promising solution to deal with the coexistence of multiple applications with different Quality of Service requirements. From the security point of view, the goal for system customization is to permit the interoperation among applications having different, possibly inconsistent security constraints. This paper demonstrates how the software architecture paradigm is beneficial for addressing security issues in distributed systems through system customization. The software architecture paradigm. allows the application developer to abstractly specify security-related requirements. Then, our framework takes in charge the system customization to meet these requirements. The practical use of our approach is also addressed by discussing its integration in a configuration-based distributed programming environment.

Characterizing coordination architectures according to their non-functional execution properties

A number of existing distributed processing environments (DPEs) are eligible to serve as a coordination architecture. In order to ease the construction of distributed applications while exploiting existing DPEs, the developer should be provided with notations that allow him to characterize the coordination architecture that is the best suited to his application. Existing DPEs can be distinguished according to at least two criteria: the coordination protocols (e.g. RPC, pipe-filter tuple space) they support; and the non-functional execution properties (e.g. availability, security, responsiveness) they provide. This leads us to propose a twofold formal description of coordination architectures that characterizes the coordination protocols and non-functional execution properties that are expected from the underlying DPE, hence allowing to reason about the adequacy of a DPE for supporting a given coordination architecture.

Aster: a CORBA-based software interconnection system supporting distributed system customization

The paper introduces the Aster distributed composition-based programming system that is aimed at easing the development of distributed runtime systems, customized to the application needs, in a CORBA-based environment. Our approach is based on high-level customization: given the specification of application requirements using the Aster composition language, a distributed runtime system, customized for meeting these requirements is built. Furthermore, the fact that the Aster system is based on the CORBA standard for distributed computing enhances the potential of re-use of both application-level and system-level software.

Towards Specifying QoS-Enabling Software Architectures

The term QoS has been originally used in the context of network communication resources and then in the context of system resources needed for multimedia applications. It now stands for specific resource management as required by applications and relating to non-functional execution properties implemented by the processing environment (e.g. availability, security, responsiveness).

Customized remote execution of Web agents

Agent based solutions are promising for ameliorating Web services, since they promote the modular construction of Web servers, relieve the network from transferring useless data, support user mobility, etc. However existing Web servers do not favor the hosting of agents. We propose a description of agent behaviors in terms of its requirements regarding resource utilization (e.g. memory and disk space), functional services (e.g. system calls), and quality of services (e.g. degree of replication, and access control). These requirements, when formally expressed, can be used in an automated decision process which employs software specification matching techniques. On the acceptance of an agent, the host can use the agents requirements to construct an environment customized to its execution. We discuss the benefits of this approach, and how it can be used to promote existing agent based solutions in the Web framework.

A programming system for the development of TINA services

Programming environments for the development of distributed applications are called to face issues such as the configuration of the interconnection system, the coordination of heterogeneous application constituents, etc. Aster is a configuration-based system which deals with those issues and allows the programmer to guide the customization of the runtime environment so as to meet the application needs. In this paper we show that our system conforms with TINA’s computing architecture and we demonstrate its capabilities on formal reasoning about functional and nonfunctional application requirements. An example of trading both within the same runtime environment and between heterogeneous ones is given. In this example we demonstrate the automatic customization capabilities of Aster and we illustrate a unified way for dealing with the issues of software heterogeneity, software reuse, and interoperability.