TP 2 - Sujet Fractal/Julia - Le système de composants Fractal

TP 2 - Sujet
Fractal/Julia - Le système de composants Fractal
et son implémentation Java de référence Julia.
Loïc LAGANE
Contents
1
2
3
4
Introduction
2
Présentation
2
Installation et pré-requis
4
2.1 Le système de composants Fractal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Composant Fractal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3 Julia : l'implémentation de référence Java de Fractal . . . . . . . . . . . . . . . . . . . .
3.1 L'API Fractal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 Julia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3 Les autres librairies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Premier exemple
4.1
4.2
4.3
4.4
4.5
Introduction . . . . . . .
Mise en place . . . . . .
Description des sources .
Manipulation . . . . . .
Résultats . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2
2
3
4
4
4
5
. 5
. 5
. 8
. 10
. 10
5
Exercice
10
6
Conclusion
11
1
1
Introduction
Les composants permettent la construction de logiciels à partir de l'assemblage d'entités logicielles
réutilisables. Le but est d'obtenir des entités logicielles composables, déployables et congurables tout
en conservant la performance et la légèreté des applications. Il existe de nombreux modèles basés sur
les composants tels que COM, EJB, CCM, .NET (destinés à des domaines d'applications spéciques).
Le système de composants Fractal est quant à lui plus universel.
2
Présentation
2.1
Le système de composants Fractal
Le système de composants Fractal est un modèle de composants extensible permettant de construire,
déployer et administrer des systèmes logiciels complexes. Il a été déni par l'INRIA et France Telecom R&D. Ce système de composants dénit donc un framework pour la construction d'applications
à partir de composants en permettant de créer des compositions hiérarchiques (dénir des types de
composants, créer des instances à partir de ces types, les congurer et les connecter entre elles).
Une application est donc représentée par un composant racine. Ce composant racine est déni par
l'assemblage de sous-composants, pouvant être eux aussi dénis par un assemblage de sous-composants,
jusqu'à atteindre un niveau de composants primitif.
Les compositions sont soit fonctionnelles (connexion de composants par l'intermédiaire de leur interfaces respectives), soit structurelles (création de nouveaux composants, dénis à partir de composants
existants).
Il existe une spécication de ce modèle de composants ainsi que de nombreuses implémentations en différents langages (Java, C, C++, SmallTalk, langages .NET). A ce modèle de composants est ajouté un
langage de description d'architecture, Fractal ADL, basé sur une syntaxe XML extensible (la DTD peut
être étendue avec de nouvelles balises an de spécier des propriétés supplémentaires aux composants).
Le langage Fractal ADL permet de réaliser la composition de composants de manière déclarative, il
est possible de dénir des composants et de composer des instances de ces derniers.
Les principales caractéristiques de ce modèle de composants sont :
• les composants composites (composants contenant des sous-composants),
• les composants partagés (sous-composants de plusieurs composites),
• la capacité d'introspection,
• les capacités de conguration et reconguration.
Le modèle Fractal est extensible. Il permet la personnalisation des capacités de contrôle des composants de l'application. Les fonctionnalités décrivant les capacités des composants sont décrites au
sein d'entités nommées contrôleurs.
2.2
Composant Fractal
Un composant Fractal est une entité d'exécution dénie par une ou plusieurs interfaces.
Deux catégories d'interfaces sont présentes :
• les interfaces décrivant les services fournis par le composant, appelées interfaces serveurs,
2
• les interfaces décrivant les services requis par le composant, appelées interfaces clientes.
De plus, un composant Fractal est déni en deux parties :
• une partie possédant des interfaces fonctionnelles (décrivant le contenu applicatif du composant)
et des interfaces de contrôle (pour l'introspection et la conguration), appelée membrane,
• l'autre constituée d'un ensemble ni de sous-composants, appelée contenu.
Les interfaces de la membrane d'un composant peuvent être internes (accessibles par ses sous-composants)
ou externes (accessibles depuis l'extérieur du composant).
Exemple de composant Fractal (source : http://fractal.objectweb.org).
Sur l'exemple, les interfaces clientes et serveurs sont respectivement de couleur verte et de couleur
rouge. Les interfaces de contrôles C, LC, BC et CC représentent respectivement le contrôleur pour
l'introspection, le contrôleur de cycle de vie (LifeCycleController, gestion des phases comportementales
du composant - démarrer ou arrêter l'exécution d'un composant par exemple), le contrôleur de liaisons
(BindingController, gestion des liaisons primitives entre deux interfaces de composants), et le contrôleur
de contenu (ContentController, gestion des sous-composants d'un composant composite). L'interface
de contrôle ServiceAttributes permet quant à elle d'accéder aux attributs du composant. De plus,
des contrôleurs spéciques peuvent être implémentés pour étendre ou spécialiser les capacités d'un
composant.
2.3
Julia : l'implémentation de référence Java de Fractal
Julia est l'implémentation de référence du modèle de composants Fractal pour des applications Java.
Il s'agit d'un canevas logiciel open source LGPL (consortium ObjectWeb) pour programmer les membranes de composants Fractal. Le principal but de conception de Julia est d'implémenter un framework
pour simplier le développement d'applications Fractal à travers la génération de classes de support.
Un ensemble de contrôleurs est fourni, ainsi que des mécanismes d'optimisation pour la conguration
des composants (en allant de la conguration entièrement statique et donc performante à la reconguration dynamique et moins performante). Il s'agit donc d'optimiser les performances des méthodes
de l'API Fractal. Cette implémentation peut être utilisée sur n'importe quelle JVM et/ou JDK.
3
Une application Fractal est donc conçue à partir d'un ensemble de classes qui implémentent la logique
applicative des composants, une ou plusieurs classes de coordination et une classe primaire, nommée
bootstrap (pour le démarrage de l'application).
Les classes de support sont nécessaires aux classes Java qui implémentent le code métier pour se conformer aux spécications du système de composants Fractal. Les classes de coordination, quant à elle,
interagissent avec l'API Fractal pour la création des types de composants, la création et la conguration des instances de composants an de construire l'application.
Avec Julia, un composant Fractal est donc déni à partir de plusieurs objets Java :
• les objets implémentant le contenu du composant, qui sont soit des sous-composants (si le com-
posant est un composite), soit des objets Java (si il s'agit d'un composant primitif),
• les objets implémentant les contrôles du composant,
• les objets référençant les interfaces du composant (lui permettant de posséder des références vers
d'autres composants).
Ces objets sont dénis grâce à des fabriques de composants (factory en Anglais). Les instances de
composants sont donc créées à partir de ces fabriques. Une fabrique fournit une méthode de création
qui retourne une nouvelle instance du composant à chaque invocation. Cette instance de composant
peut être activée ou désactivée si le contrôleur implémente l'interface LifeCycleController.
3
Installation et pré-requis
Dans le cadre de ce TP, nous utiliserons l'environnement de développement Eclipse. La page d'accueil
du projet Fractal se trouve à l'adresse suivante : http://fractal.objectweb.org/
3.1
L'API Fractal
L'API Fractal est disponible à l'adresse suivante :
http://forge.objectweb.org/project/showles.php?group_id=22&release_id=912
Nous utiliserons la version 2.0.1 dans le cadre de ce TP.
3.2
Julia
Julia, l'implémentation Java du modèle de composants Fractal, est disponible à l'adresse suivante :
http://forge.objectweb.org/project/showles.php?group_id=22&release_id=1848
Nous utiliserons la version 2.5 de Julia.
3.3
Les autres librairies
Les autres librairies requises sont contenues dans le répertoire nommé externals, fourni avec Julia.
Il s'agit des chiers asm-2.0.jar et ow_monolog.jar.
ASM est un framework permettant de générer ou modier dynamiquement des classes au moment du
chargement en manipulant le bytecode Java (avant que les classes ne soient chargées dans la machine
virtuelle Java).
Monolog fournit un système d'achage d'information de debug et de log à l'exécution.
Vous trouverez plus des informations complémentaires aux adresses suivantes : http://asm.objectweb.org
et http://monolog.objectweb.org.
4
4
Premier exemple
4.1
Introduction
Nous allons tester le système de composants Fractal grâce à son implémentation en Java nommée Julia.
Ce premier exemple est un programme de type Hello World.
4.2
Mise en place
Créez un nouveau projet Java dans l'environnement de développement Eclipse, nous le nommerons
Julia Helloworld par exemple.
• Importez dans le projet les sources du programme, fournies avec le sujet ci-présent, dans ce
nouveau projet.
• Importez ensuite dans votre projet les sources de l'API Fractal, disponibles dans l'archive fractal-
2.0.1.zip. Pour cela demandez à importer dans le projet Eclispe un système de chiers. Parcourez
l'arborescence jusqu'au répertoire nommé src, puis sélectionnez le répertoire appelé org.
5
• Puis importez les sources de Julia dans votre projet, disponibles dans l'archive julia-2.5.zip et
procédez la même façon que pour l'API Fractal. Importez un système de chiers dans le projet
Eclipse situé dans le répertoire src de l'archive.
6
• Importez également l'archive asm-2.0.jar, requise par Julia et disponible dans le répertoire ex-
ternals de l'archive julia-2.5.zip. Pour cela demandez à importez un chier archive.
7
• Récupérez ensuite les chiers de conguration Julia, disponibles dans le répertoire nommé etc
fourni avec le sujet. Copiez ce répertoire etc dans le répertoire principal de votre projet. Il s'agit
de chiers de conguration, utilisant une syntaxe de type LISP et contenant un ensemble de
dénitions utilisées par les fabriques sous forme d'alias :
(nomAlias1 dénitionAlias1)
(nomAlias2 dénitionAlias2)
....
(nomAliasN dénitionAliasN)
4.3
Description des sources
Les interfaces à implémenter sont :
• l'interface Main (Main.java),
• l'interface Service (Service.java) décrivant le(s) service(s) fournis.
L'interface ServiceAttributes (ServiceAttributes.java) décrit les méthodes permettant d'accéder aux
attributs du composant.
8
La classe ClientImpl (ClientImpl.java), implémentant le composant client, doit implémenter l'interface
Main pour pouvoir lancer une requête ainsi que l'interface BindingController an de pouvoir eectuer
les liaisons entre composants.
La classe ServerImpl (ServerImpl.java), implémentant le composant serveur, doit implémenter l'interface
Service et également l'interface ServiceAttributes.
La classe principale HelloWorld (HelloWorld.java) représente le programme principal de l'application.
L'application est implémentée selon la procédure qui suit :
• On récupère tout d'abord le contexte initial et on crée le bootstrap.
Component boot = Fractal.getBootstrapComponent();
• On récupère la fabrique (ou factory) TypeFactory du bootstrap pour la création des autres com-
posants.
TypeFactory tf = Fractal.getTypeFactory(boot);
• On crée ensuite les type de composants de l'application grâce à une fabrique , à partir d'une
liste d'interfaces. On peut créer un type rType qui sera utilisé pour le composant racine de
l'application. Les interfaces sont nommées, la vue externe peut contenir plusieurs instances
d'une même interface.
ComponentType rType = tf.createFcType(new InterfaceType[] {
tf.createFcItfType("m", "Main", false, false, false)
});
• On récupère la fabrique GenericFactory du bootstrap pour l'instanciation des composants.
GenericFactory cf = Fractal.getGenericFactory(boot);
• L'instanciation d'un composant se fait donc grâce à cette fabrique, à partir d'un des types de
composants dénis précédemment. On peut donc instancier par exemple le composant racine de
l'application comme étant un composant composite de type rType.
rComp = cf.newFcInstance(rType, "composite", null);
• L'assemblage des composants que l'on vient d'instancier se fait soit en imbriquant des sous-
composants au sein de composants composites, soit en créant une liaison entre deux composants.
Pour réaliser cela, on fait appel respectivement aux méthodes addFcSubComponent de l'interface
de contenu du composant (ContentController) et bindFc de l'interface de liaison du composant
(BindingController).
Fractal.getContentController(rComp).addFcSubComponent(cComp);
Fractal.getBindingController(rComp).bindFc("m", cComp.getFcInterface("m"));
• On active ensuite le composant racine de l'application, ce qui lancera également tous les com-
posants de l'application de façon automatique grâce à la méthode startFc du controleur de cycle
de vie du composant racine (LifeCycleController).
Fractal.getLifeCycleController(rComp).startFc();
• Enn, on appelle la méthode main en passant par l'interface fonctionnelle 'm' de notre composant
racine. Notons que la méthode getFcInterface retourne un type Object qui doit être casté par le
9
type de l'interface décrivant la méthode du service que l'on va appeler.
((Main)rComp.getFcInterface("m")).main(null);
Liens entre les composants de l'exemple HelloWorld (source : http://fractal.objectweb.org).
4.4
Manipulation
Rendez-vous dans le répertoire du projet, grâce à une console puis lancez la commande suivante :
java -cp . -Dfractal.provider=org.objectweb.fractal.julia.Julia
-Djulia.loader=org.objectweb.fractal.julia.loader.DynamicLoader
-Djulia.cong=etc/julia1.cfg,etc/julia2.cfg HelloWorld
Les options -Dxxx correspondent aux paramètres passés à la JVM pour pouvoir utiliser Julia.
4.5
Résultats
La commande précédente permet donc d'acher un petit message du serveur.
Dans notre cas, l'achage s'eectue deux fois puisqu'on a aecter la valeur 2 à l'attribut count du
serveur.
-> hello world
-> hello world
5
Exercice
On désire acher, en plus de l'achage hello world déjà présent :
* bonjour
* bonjour
* bonjour
An de réaliser cela, il faut procéder en plusieurs étapes :
1. Créez une seconde implémentation client que l'on appellera ClientImpl2 par exemple.
10
2. Ajoutez au composant racine de l'application un sous-composant client et un sous-composant
serveur. Pour cela, créez deux nouveaux composants c2Comp (ClientImpl2 ) et s2Comp (ServImpl ).
Dénissez les attributs header et count du composant s2Comp de manière à réaliser cet achage.
N'oubliez pas d'ajouter une interface fonctionnelle (que l'on appellera m2 par exemple) à la liste
des interfaces du composant racine rComp.
3. Dénissez les liaisons entre les composants racine rComp, le nouveau sous-composant c2Comp
et le nouveau sous-composant s2Comp.
4. Enn, réalisez un appel à la méthode adéquate pour l'achage.
6
Conclusion
Le système de composants Fractal est un modèle hiérarchique (il est possible d'inclure des composants au sein d'autres composants composites - d'où le nom Fractal), réexif (avec des capacités
d'introspection et d'intercession) et ouvert (possibilité de personnaliser les services des composants
par l'intermédiaire des contrôleurs). Alors que certains modèles de composants sont très liés à leur
domaine d'application, Fractal est quant à lui plus générique et plus exible.
De plus il n'impose pas de technologie particulière, il est indépendant des langages et plate-formes.
Plusieurs implémentations existent : Think (C), Julia, ProActive et AOKell (Java), FracTalk (SmallTalk)
et FracNet (.NET).
Il est donc possible de dénir des classes de composants, des fabriques, de recongurer dynamiquement les instances, d'eectuer de la composition hiérarchique et d'utiliser les propriétés d'instropection.
Il possède un langage de description d'architecture (Fractal ADL) qui permet de réaliser la composition
de manière déclarative (dénir des composants et composer des instances de ces derniers).
Il n'impose pas un nombre xe d'interface de contrôle, elles sont découvertes à l'exécution.
Un composant Fractal est une entité logicielle possédant des interfaces fournies (dites serveurs) et des
interfaces requises (dites clientes). De plus il est déni en deux parties, une membrane (possédant
des interfaces fonctionnelles et des interfaces de contrôle) et un contenu (constitué d'un ensemble de
sous-composants).
Les liaisons permettent de dénir des chemins de communication entre interfaces clientes et serveurs.
Julia est l'implémentation Java de référence du modèle de composants Fractal et vise à simplier le
développement d'applications Fractal. Le développement des contrôleurs se fait à l'aide de classes de
support. Des mécanismes d'optimisations sont mis en place de manière à adapter l'utilisation mémoire
et le temps d'exécution de l'application.
Un certains nombre d'outils sont également présents. On peut citer Fractal GUI (concevoir graphiquement une architecture et générer des squelettes de code), ou encore Fractal RMI (construire des assemblages de composants distribués). Il existe également Fractal AOP, qui est une extension du modèle
Fractal pour la programmation par aspect.
Par contre, le modèle Fractal ne dénit pas la manière de conditionner un composant an d'eectuer
un paquetage, comme les chiers jar (pour les composants) ou ear (pour les applications) des EJB.
11