Tolérance aux fautes sur CORBA par protocole à métaobjets et langages réflexifs

The goal of this dissertation is to design and implement a metaobject protocol adapted to fault-tolerance in Corba applications. No currently available metaobject protocol is satisfying in this context. We define a protocol that enables dynamic control of both the behaviour and internal state of Corba objects and of clients/servers and objects/metaobjects links. The implementation we propose is well adapted to a standard Corba platform thanks to the use of open languages and compile-time reflection: these tools allow the compilation process to be customized in order to obtain information that is necessary to fault-tolerance mechanisms. Another benefit of compile-time reflection is to enable, in a simple way, to enforce programming conventions thanks to the filtering of application source code. This protocol, well integrated with Corba, can also benefit from reflective properties of the underlying language runtime, such as the limited reflection provided by Java for object serialization. When the language runtime is not reflective, as for C++, compile-time reflection can be used to implement methods for saving or restoring the internal state of objects; both complete or partial state can be controlled by metaobjects. The various properties of this metaobject protocol are illustrated in an architecture proposal which allows fault-tolerance mechanisms to be integrated to the application in a flexible manner. This approach offers useful properties such as separation of concerns between the application and the non-functional mechanisms implemented as metaobjects, dynamicity of links between objects and metaobjects, composability and reuse of mechanisms and user transparency. Finally, this metaobject protocol is sufficiently generic to take advantage of any openness, in a reflective sense, of the platform's underlying software (operating system and middleware).L'objectif de cette thèse est la conception et l'implémentation d'un protocole à métaobjets adapté à la tolérance aux fautes d'objets Corba. En effet, il n'existe pas, à ce jour, de protocole à métaobjets satisfaisant dans ce contexte. Le protocole que nous définissons permet, d'une part, le contrôle du comportement et de l'état interne des objets Corba, et d'autre part, le contrôle des liens entre clients et serveur ainsi qu'entre objets et métaobjets, le tout de façon dynamique. L' implémentation proposée est adaptée à l'utilisation d'une plateforme Corba standard grâce à l'utilisation de langages ouverts et de réflexivité à la compilation : ces outils permettent de personnaliser le processus de compilation afin d'exhiber à l'exécution les informations nécessaires aux mécanismes de tolérance aux fautes. Un autre avantage de la réflexivité à la compilation est de permettre, de façon simple, d'assurer le respect de conventions de programmation grâce au filtrage du code source des applications. Ce protocole, bien intégré à Corba, tire également profit, lorsque c'est possible, des éléments réflexifs fournis par le support d'exécution du langage. C'est le cas avec Java, par exemple, qui permet la sérialisation des objets, grâce à ses aspects réflexifs limités. Lorsque le support du langage n'est pas réflexif, comme pour C++ par exemple, la réflexivité à la compilation permet également de mettre en ¿uvre des techniques de sauvegarde et de restauration de l'état des objets ; état complet et état partiels peuvent être contrôlés par les métaobjets. Les différentes propriétés de ce protocole à métaobjets sont illustrées par une proposition d'architecture Corba permettant d'intégrer à l'application des mécansimes de tolérance aux fautes de manière très flexible. Les propriétés de cette approche sont une bonne séparation entre l'application et les mécanismes non-fonctionnels implémentés dans les métaobjets, l'aspect dynamique du lien entre objets et métaobjets, la composabilité et la réutilisation des mécanismes ainsi que la transparence pour l'utilisateur. Enfin, ce protocole à métaobjets est suffisamment générique pour tirer parti de l' ouverture, au sens de la réflexivité, des logiciels de base (système d'exploitation et middleware) de la plateforme