Modèle à composants. Daniel Hagimont. IRIT/ENSEEIHT 2 rue Charles Camichel - BP TOULOUSE CEDEX 7. Remerciements

Transcription

1 Modèle à composants Daniel Hagimont IRIT/ENSEEIHT 2 rue Charles Camichel - BP TOULOUSE CEDEX 7 Daniel.Hagimont@enseeiht.fr Remerciements Eric Bruneton Sacha Krakowiak 1

2 Des objets aux composants Notion de composant logiciel Nécessité perçue très tôt [McIlroy 1968] mais conception et réalisation n'ont pas suivi Les objets : première approche pour la décomposition Encapsulation (séparation interface-réalisation) Mécanismes de réutilisation (héritage, délégation) Limitation des objets Pas d'expression explicite des ressources requises par un objet (autres objets, services fournis par l'environnement) Pas de vue globale de l'architecture d'une application Pas de possibilité d'expression de besoins non-fonctionnels (par ex. persistance, transactions, etc.) Peu d'outils pour le déploiement et l'administration 2

3 Modèles et infrastructures Pour mettre en œuvre des composants, il faut Un modèle de composants, qui définit les entités et leur mode d'interaction et de composition Une infrastructure à composants, qui met en œuvre le modèle et permet de construire, déployer, administrer et exécuter des applications conformes au modèle Situation actuelle Les infrastructures industrielles (EJB, CCM,.Net, OSGi) sont limitées Des modèles issus de la recherche ont été proposés (Fractal, CCM, ) ainsi que des infrastructures prototypes Plus récemment : SCA (Service Component Architecture)... 3

4 Que doit fournir un modèle de composants? Encapsulation Interface = seule voie d'accès, séparation interface-réalisation Possibilité de définir des interface multiples Composabilité Dépendances explicites (expression des ressources fournies et requises) Composition hiérarchique (un assemblage de composants est un composant) Capacité de description globale Si possible exprimée formellement (langage de description) Réutilisation et évolution Modèles génériques de composants (types de composants) Adaptation (interfaces de contrôle) Reconfiguration 4

5 Que doit fournir une infrastructure à composants? Couverture du cycle de vie Non limitée aux phases de développement et d'exécution Administration Déploiement : installation et activation des composants Surveillance : collecte et intégration de données, tenue à jour de la configuration Contrôle : réaction aux événements critiques (alarme, surcharge, détection d'erreur) Service communs Propriétés non-fonctionnelles (persistance, transactions, QoS) 5

6 Paradigmes de la composition Eléments de la composition Composant. Unité de composition et de déploiement, qui remplit une fonction spécifique et peut être assemblé avec d'autres composants. Il porte une description des interfaces requises et fournies. Connecteur. Elément permettant d'assembler des composants en utilisant leurs interfaces fournies et requises. Remplit 2 fonctions : liaison et communication. Configuration : un assemblage de composants (peut, selon les modèles, être lui-même un composant). NB1: la notion de composant est préservée à l'exécution pour faciliter l'adaptation dynamique NB2 : la différence entre composant et connecteur est une différence de fonction, non de nature : un connecteur est lui-même un composant 6

7 Exemples de schémas de composition Liaison simple Client serveur Une autre vue : le connecteur comme composant Client serveur Une autre vue : le connecteur comme composant composite Client talon session talon serveur 7

8 Exemples de schémas de composition subscriber subscriber Publish-subscribe connector subscriber Publisher and subscriber 8

9 Décrire la composition Une description formelle Donner un support aux notions d'architecture logicielle Composants, interfaces, connecteurs, configuration Permettre un traitement formel Vérification, preuves (contrôle de types) Permettre d'automatiser (ou assister) des opérations globales (mettant en jeu des configurations) Déploiement Reconfiguration Servir d'aide à la documentation (description globale, visualisation) Notion d'adl (Architecture Description Language) 9

10 Eléments d'un ADL Description des composants Définition des interfaces (requises, fournies) Types (synchrone, asynchrone, ) Signatures, contrats, annotations Description des configurations Association interfaces fournies-requises Directe (invisible, réalisée par édition de liens) Via un connecteur : description Composition hiérarchique (si le modèle l'autorise) Interfaces importées/exportées Interface graphique (visualisation, action) Aspects dynamiques (reconfiguration) 10

11 Organisation logique d'un composant Interface externe du contrôleur Interface fournie contenu Interface requise Interface interne contrôleur du contrôleur La séparation entre contrôleur et contenu est motivée par la séparation des préoccupations : isoler la partie purement fonctionnelle (propre à l'application) 11

12 Fonctions d'un contrôleur Gestion du cycle de vie Création, destruction Activation, passivation Gestion des composants inclus Si le modèle comporte des composants composites Liaison Connexion avec d'autres composants Réflexion Introspection des interface, composants Met en œuvre l'inversion de contrôle Hollywood : Ne nous appelez pas, c'est nous qui vous appellerons Contrôleur Contenu 12

13 Le modèle à composants Fractal Fractal Modèle général, peu de restrictions Fondé sur une base mathématique rigoureuse Plusieurs implémentations Très utilisé dans la recherche Source Auteurs Eric Bruneton (France Telecom R&D) Jean-Bernard Stefani (INRIA) 13

14 Plan Introduction Premier aperçu Définition du modèle Déploiement des composants Langage de description d'architecture Reconfiguration dynamique Conclusion 14

15 Aperçu : l'exemple Comanche Serveur HTTP minimal Écoute sur un ServerSocket Pour chaque connexion: Lance un nouveau thread Lit l'url Envoie le fichier demandé Ou un message d'erreur public class Server implements Runnable { private Socket s; public Server (Socket s) { this.s = s; } public static void main (String[] args) throws IOException { ServerSocket s = new ServerSocket(8080); while (true) { new Thread(new Server(s.accept())).start(); } } public void run () { try { InputStreamReader in = new InputStreamReader(s.getInputStream()); PrintStream out = new PrintStream(s.getOutputStream()); String rq = new LineNumberReader(in).readLine(); System.out.println(rq); if (rq.startswith("get ")) { File f = new File(rq.substring(5, rq.indexof(' ', 4))); if (f.exists() &&!f.isdirectory()) { InputStream is = new FileInputStream(f); byte[] data = new byte[is.available()]; is.read(data); is.close(); out.print("http/ OK\n\n"); out.write(data); } else { out.print("http/ Not Found\n\n"); out.print("<html>document not found.</html>"); } } out.close(); s.close(); } catch (IOException _) { } } } 15

16 Conception : trouver les composants Composants statiques Durée de vie Celle de l'application Correspondent aux «services» Composants dynamiques Durée de vie plus courte Correspondent aux «données» Définition des composants Trouver Les services [ les structures de données ] Un service = un composant public class Server implements Runnable { private Socket s; public Server (Socket s) { this.s = s; } public static void main (String[] args) throws IOException { ServerSocket s = new ServerSocket(8080); while (true) { new Thread(new Server(s.accept())).start(); } } public void run () { try { InputStreamReader in = new InputStreamReader(s.getInputStream()); PrintStream out = new PrintStream(s.getOutputStream()); String rq = new LineNumberReader(in).readLine(); System.out.println(rq); if (rq.startswith("get ")) { File f = new File(rq.substring(5, rq.indexof(' ', 4))); if (f.exists() &&!f.isdirectory()) { InputStream is = new FileInputStream(f); byte[] data = new byte[is.available()]; is.read(data); is.close(); out.print("http/ OK\n\n"); out.write(data); } else { out.print("http/ Not Found\n\n"); out.print("<html>document not found.</html>"); } } out.close(); s.close(); } catch (IOException _) { } } } 16

17 Conception : trouver les composants Receiver Scheduler Analyzer Logger FileHandler ErrorHandler public class Server implements Runnable { private Socket s; public Server (Socket s) { this.s = s; } public static void main (String[] args) throws IOException { ServerSocket s = new ServerSocket(8080); while (true) { new Thread(new Server(s.accept())).start(); } } public void run () { try { InputStreamReader in = new InputStreamReader(s.getInputStream()); PrintStream out = new PrintStream(s.getOutputStream()); String rq = new LineNumberReader(in).readLine(); System.out.println(rq); if (rq.startswith("get ")) { File f = new File(rq.substring(5, rq.indexof(' ', 4))); if (f.exists() &&!f.isdirectory()) { InputStream is = new FileInputStream(f); byte[] data = new byte[is.available()]; is.read(data); is.close(); out.print("http/ OK\n\n"); out.write(data); } else { out.print("http/ Not Found\n\n"); out.print("<html>document not found.</html>"); } } out.close(); s.close(); } catch (IOException _) { } } } 17

18 Conception : définir l'architecture Structure hiérarchique : Correspond aux niveaux d'abstraction Dépendances : Liaisons entre les composants Receiver Analyzer Logger Frontend Scheduler File Handler Comanche Backend Dispatcher Handler Error Handler 18

19 Conception : définir les interfaces Interfaces entre composants : Doivent être définis avec attention Pour être le plus stable possible ne doivent concerner que les aspects fonctionnels Pour Comanche public interface Logger { void log (String msg); } public interface Scheduler { void schedule (Runnable task); } public interface RequestHandler { void handlerequest (Request r) throws IOException; } public class Request { Socket s; Reader in; PrintStream out; String url; } Passage en paramètre de la requête 19

20 Implémentation : composants Composants sans dépendances : Implémentés comme en Java standard public class BasicLogger implements Logger { public void log (String msg) { System.out.println(msg); } } public class SequentialScheduler implements Scheduler { public synchronized void schedule (Runnable task) { task.run(); } } public class MultiThreadScheduler implements Scheduler { public void schedule (Runnable task) { new Thread(task).start(); } } 20

21 Implémentation : composants Composants avec dépendances : Première solution : ne permet pas la configuration statique public class RequestReceiver implements Runnable { } private Scheduler s = new MultiThreadScheduler(); private RequestHandler rh = new RequestAnalyzer(); // rest of the code not shown Deuxième solution: ne permet pas la reconfiguration dynamique public class RequestReceiver implements Runnable { } private Scheduler s; private RequestHandler rh; public RequestReceiver (Scheduler s, RequestHandler rh) { this.s = s; this.rh = rh; } // rest of the code not shown 21

22 Implémentation : composants Composants avec dépendances : public class RequestReceiver implements Runnable, BindingController { private Scheduler s; private RequestHandler rh; public String[] listfc () { return new String[] { "s", "rh" }; } public Object lookupfc (String n) { if (n.equals("s")) { return s; } else if (n.equals("rh")) { return rh; } else return null; } public void bindfc (String n, Object v) { if (n.equals("s")) { s = (Scheduler)v; } else if (n.equals("rh")) { rh = (RequestHandler)v; } } public void unbindfc (String n) { if (n.equals("s")) { s = null; } else if (n.equals("rh")) { rh = null; } } // 22

23 Configuration : par programme Avantages : Méthode la plus directe Aucun outils requis Inconvénients : Propices aux erreurs Ne montre pas l'architecture public class Server { public static void main (String[] args) { RequestReceiver rr = new RequestReceiver(); RequestAnalyzer ra = new RequestAnalyzer(); RequestDispatcher rd = new RequestDispatcher(); FileRequestHandler frh = new FileRequestHandler(); ErrorRequestHandler erh = new ErrorRequestHandler(); Scheduler s = new MultiThreadScheduler(); Logger l = new BasicLogger(); rr.bindfc("rh", ra); rr.bindfc("s", s); ra.bindfc("rh", rd); ra.bindfc("l", l); rd.bindfc("h0", frh); rd.bindfc("h1", erh); rr.run(); } } 23

24 Configuration : avec un ADL Avantages : Bonne séparation des aspects architecture et déploiement Vérifications statiques possibles Liaisons invalides, Liaisons manquantes, Inconvénients : L'architecture n'est pas très visible <definition name="handlertype"> <interface name="rh" role="server" </definition> signature="comanche.requesthandler"/> <definition name="filehandler" extends="handlertype"> <content class="comanche.filerequesthandler"/> </definition> <definition name="comanche" extends="runnabletype"> <component name="fe" definition="frontend"/> <component name="be" definition="backend"/> <binding client="this.r" server="fe.r"/> <binding client="fe.rh" server="be.rh"/> </definition> 24

25 Configuration : avec un outil graphique Outils graphique pour éditer des fichiers ADL La représentation en graphe montre clairement l'architecture 25

26 Reconfiguration Statique : stopper l'application, changer l'adl, redémarrer Pas toujours possible, par exemple pour raisons de disponibilité Dynamique : reconfigurer l'application pendant son exécution Pose des problèmes de cohérence Outil de base pour aider à les résoudre : gestion du cycle de vie Exemple : Remplacer le composant FileHandler dynamiquement : RequestHandler rh = new FileAndDirRequestHandler(); rd.unbindfc("h0"); rd.bindfc("h0", rh); Le RequestDispatcher (composant englobant) doit être suspendu pendant l'opération 26

27 Cycle de vie Interface LifeCycleController : 1ère solution public class RequestDispatcher implements RequestHandler, BindingController, LifeCycleController { private boolean started; private int counter; public String getfcstate () { return started? STARTED : STOPPED; } public synchronized void startfc () { started = true; notifyall(); } public synchronized void stopfc () { while (counter > 0) { wait(); } started = false; } public void handlerequest (Request r) throws IOException { synchronized (this) { while (!started) { wait(); } ++counter; } try { // original code } finally { synchronized (this) { --counter; if (counter == 0) { notify(); } } } } // rest of the class unchanged 27

28 Reconfiguration: cycle de vie Interface LifeCycleController : autres solutions Implémenter l'interface dans une (sous) classe séparée Meilleure séparation des aspects Composants déployables avec ou sans gestion du cycle de vie Générer cette classe ou cette sous classe automatiquement Génération de code statique ou dynamique Dans le contrôleur LifeCycleController BindingController RequestHandler 28

29 Reconfiguration : autres APIs Avant de stopper ou de reconfigurer un composant, il faut obtenir sa référence D'où les interfaces d'introspection (et de reconfiguration) suivantes : public interface Component { Object[] getfcinterfaces (); Object getfcinterface (String itfname); Type getfctype (); } public interface ContentController { Object[] getfcinternalinterfaces (); Object getfcinternainterface(string itfname); Component[] getfcsubcomponents (); void addfcsubcomponent (Component c); void removefcsubcomponent(component c); } Une interface Fractal implante à la fois l'interface Interface et l'interface métier, ce qui explique le type Object. 29

30 30 Quelques choix de déploiement BC BC BC BC LC BC LC LC LC LC BC LC LC BC C LC BC C LC C LC C LC C LC BC C LC C LC BC C LC CC BC C LC CC BC C LC CC BC C LC CC BC C C BC C C C BC C C BC C CC BC C CC BC C CC BC C CC

31 Quelques choix de déploiement C CC BC LC C BC LC C BC LC C LC C LC C LC C BC LC C LC 31

32 En résumé Les composants Encapsulent du code fonctionnel Possèdent des interfaces (requises et fournies) Possèdent un ensemble de contrôleurs Les contrôleurs Fournissent une API de gestion des composants (non fonctionnelles) L'ADL est un langage de description des composants des assemblages de composants 32

33 Plan Introduction Premier aperçu Définition du modèle Déploiement des composants avec l'api Langage de description d'architecture Reconfiguration dynamique Conclusion 33

34 Modèle : fondations Composant Fractal : Entité à l'exécution Par exemple, en Java, des objets et non pas des classes ou des.jar De n'importe quel type Service, ressource, donnée, activité, processus, protocole, liaison, Sans cible ni granularité particulière Application, intergiciel (middleware), système d exploitation 34

35 Modèle : structure externe De l extérieur, un composant Fractal : Est une boite noire, Avec des points d accès appelés interfaces (externes) Chaque interface à un nom (unique dans le composant) Une signature (ensemble d opérations i.e. méthodes en Java) Un rôle (client, serveur ou contrôle) component, Component interfaces de contrôle interfaces serveur -ou fournies -reçoivent des appels -à gauche par convention s, I t, J u, I v, I w, K interfaces clientes -ou requises -émettent des appels -à droite par convention 35

36 Modèle : structure externe Composant de base : Aucune interface de contrôle => pas d'introspection Équivalent à un objet au sens des langages orienté objets Premier niveau de contrôle : introspection Introspection des composants : Interface Component Donne accès à la liste des interfaces d'un composant Introspection des interfaces : Interface Interface Donne accès au nom d'une interface Donne accès à l'interface Component du composant Autres niveaux de contrôle : BindingController, LyfeCycleController, ContentController... 36

37 Modèle : structure interne composant composite A l intérieur, un composant : À un contrôleur et un contenu Contenu Composants primitifs Composants composites Composants partagés Le contrôleur peut (entre autres) : contenu contrôleur composant primitif Fournir des fonctions d introspection et de reconfiguration Intercepter les appels d opération entrants et sortants Pour les aspects non fonctionnels (cycle de vie, transactions, sécurité, ) Modifier le comportement de ses sous contrôleurs 37

38 Modèle : structure interne Liaisons Liaison primitive Lie une interface cliente à une interface serveur Dans le même espace d adressage Liaison multiple Lie une interface cliente À un nombre arbitraire d interface serveur Liaison composite Est formée d'un ensemble de composants de liaisons Liaisons normales, d import et d export 38

39 Modèle : structure interne Interfaces internes Interfaces du contrôleur Visibles seulement des sous composants Interfaces complémentaires Deux interfaces internes et externes De même nom et même signature, mais de rôle opposés interfaces complémentaires liaison d'export Exporte une interface d'un sous composant à l'extérieur du composant englobant liaison d'import Importe une interface externe à l'intérieur d'un composant composite 39

40 Modèle : typage Type de composant ensemble de types d interface non modifiable à l exécution c, J Type d interface nom signature contingence obligatoire, optionnelle cardinalité singleton, collection s, I c : interface de type singleton c1, J c2, J c3, J c : interface de type collection 40

41 Modèle : API Le modèle se définit principalement au travers de ses API de contrôle 41

42 Modèle : API d'introspection Interface de contrôle pour la découverte d'interfaces Les interfaces ont un nom (valide dans le composant qui possède l'interface) Les interfaces sont typées (interface fonctionnelle et Interface Fractal) public interface Component { Object[] getfcinterfaces (); Object getfcinterface (String itfname) throws NoSuchInterfaceException; Type getfctype (); } public interface Interface { String getfcitfname (); Type getfcitftype (); Component getfcitfowner (); boolean isfcinternalitf (); } public interface Type { boolean isfcsubtypeof (Type type); } 42

43 Modèle : API de gestion des liaisons Interface de gestion des liaisons entre interfaces de composants Les interfaces liées doivent être dans le même composant composite englobant Les liaisons complexes peuvent impliquer des composants de liaison interface BindingController { String[] listfc (); Object lookupfc (string clientitfname) throws NoSuchInterfaceException; void bindfc (String clientitfname, Object serveritf) throws NoSuchInterfaceException, IllegalBindingException, IllegalLifeCycleException; void unbindfc (String clientitfname) throws NoSuchInterfaceException, IllegalBindingException, IllegalLifeCycleException; } 43

44 Modèle : API de gestion du contenu Interface de gestion de la structure hiérarchique des composants Gestion des liaisons entre sous et super composants interface ContentController { Object[] getfcinternalinterfaces (); Object getfcinternalinterface (String itfname) throws NoSuchInterfaceException; Component[] getfcsubcomponents (); void addfcsubcomponent (Component c) throws IllegalContentException, IllegalLifeCycleException; void removefcsubcomponent (Component c) throws IllegalContentException, IllegalLifeCycleException; } interface SuperController { Component[] getfcsupercomponents (); } 44

45 Modèle : API de gestion d'attributs Les attributs sont des propriétés configurables des composants interface AttributeController { } interface MyAttributeController extends AttributeController { int getmyattributex (); void setmyattributex (int newattributex); } 45

46 Modèle : API de gestion du cycle de vie Permet d'arrêter / démarrer des composants Gère 2 états STARTED et STOPPED Peut s'appuyer sur l'arrêt/démarrage de threads ou de sous composants interface LifeCycleController { string getfcstate (); void startfc () throws IllegalLifeCycleException; void stopfc () throws IllegalLifeCycleException; } 46

47 Plan Introduction Premier aperçu Définition du modèle Déploiement des composants avec l'api Langage de description d'architecture Reconfiguration dynamique Conclusion 47

48 Déploiement : avec l API Component boot = Fractal.getBootstrapComponent(); class Fractal static getbootstrapcomponent interface Component Object[] getfcinterfaces Object getfcinterface getfctype interface Interface Component getfcitfowner getfcitfname m rcomp m ccomp s s scomp getfcitftype isfcinternalitf 48

49 Déploiement : avec l API TypeFactory tf = Fractal.getTypeFactory(boot); interface Component Interface[] getfcinterfaces Interface getfcinterface getfctype TypeFactory createfcinterfacetype createfctype On devrait écrire (TypeFactory)boot.getFcInterface("type-factory"); 49

50 Déploiement : avec l API ComponentType rtype = tf.createfctype(new InterfaceType[] { tf.createfcitftype("m", "pkg.main", false, false, false)}); TypeFactory createfcinterfacetype createfctype ComponentType extends Type getfcinterfacetypes getfcinterfacetype InterfaceType extends Type getfcitfname getfcitfsignature isfcclientitf isfcoptionalitf isfccollectionitf m m ccomp s s scomp rcomp 50

51 Déploiement : avec l API ComponentType ctype = tf.createfctype(new InterfaceType[] { tf.createfcitftype("m", "pkg.main", false, false, false), tf.createfcitftype("s", "pkg.service", true, false, false)}); ComponentType stype = tf.createfctype(new InterfaceType[] { tf.createfcitftype("s", "pkg.service", false, false, false), tf.createfcitftype("attribute-controller","pkg.serviceattributes", )}); nom signature isclient isoptional iscollection m m ccomp s s scomp rcomp 51

52 Déploiement : avec l API GenericFactory gf = Fractal.getGenericFactory(boot); GenericFactory newfcinstance 52

53 Déploiement : avec l API Component rcomp = gf.newfcinstance(rtype, "composite", null); LifeCycleController, BindingController, ContentController contenu m rcomp 53

54 Déploiement : avec l API Component ccomp = gf.newfcinstance(ctype, "primitive", "pkg.clientimpl"); LifeCycleController, BindingController m m ccomp s rcomp 54

55 Déploiement : avec l API Component scomp = gf.newfcinstance(stype, "parametricprimitive", "pkg.serverimpl"); si attributs m m ccomp s s scomp rcomp 55

56 Déploiement : avec l API Fractal.getContentController(rComp).addFcSubComponent(cComp); ContentController getfcinternalinterfaces getfcinternalinterface getfcsubcomponents addfcsubcomponent removefcsubcomponent m m ccomp s s scomp rcomp 56

57 Déploiement : avec l API Fractal.getContentController(rComp).addFcSubComponent(sComp); m m ccomp s s scomp rcomp 57

58 Déploiement : avec l API Fractal.getBindingController(rComp).bindFc( "m", ccomp.getfcinterface("m")); BindingController listfc lookupfc bindfc unbindfc m m ccomp s s scomp rcomp 58

59 Déploiement : avec l API Fractal.getBindingController(cComp).bindFc( "s", scomp.getfcinterface("s")); m m ccomp s s scomp rcomp 59

60 Déploiement : avec l API Fractal.getLifeCycleController(rComp).startFc(); ((pkg.main)rcomp.getfcinterface("m")).main(null); LifeCycleController getfcstate startfc stopfc m m ccomp s s scomp rcomp 60

61 Plan Introduction Premier aperçu Définition du modèle Déploiement des composants avec l'api Langage de description d'architecture Reconfiguration dynamique Conclusion 61

62 Déploiement : Fractal ADL Définition des types de composants <definition name="roottype"> <interface name="m" role="server" signature="pkg.main" contingency="mandatory" cardinality="singleton"/> </definition> <definition name="clienttype"> <interface name="m" role="server" signature="pkg.main"/> <interface name="s" role="client" signature="pkg.service"/> </definition> optionnel 62

63 Déploiement : Fractal ADL Héritage entre définitions <definition name="clienttype" extends="roottype"> <interface name="s" role="client" signature="pkg.service"/> </definition> Est équivalent à : <definition name="clienttype"> <interface name="m" role="server" signature="pkg.main" contingency="mandatory" cardinality="singleton"/> <interface name="s" role="client" signature="pkg.service"/> </definition> 63

64 Déploiement : Fractal ADL Héritage entre définitions (suite) <definition name="extendedclienttype" extends="clienttype"> <interface name="s" role="client" signature="pkg.extendedservice"/> </definition> Est équivalent à : <definition name="extendedclienttype"> <interface name="m" role="server" signature="pkg.main" contingency="mandatory" cardinality="singleton"/> <interface name="s" role="client" signature="pkg.extendedservice"/> </definition> 64

65 Déploiement : Fractal ADL Définition des composants primitifs <definition name="basicclient" extends="clienttype"> <content class="pkg.clientimpl"/> </definition> <definition name="basicserver" extends="servertype"> <content class="pkg.serverimpl"/> <attributes signature="pkg.serviceattributes"> <attribute name="header" value="-> "/> <attribute name="count" value="1"/> </attributes> </definition> 65

66 Déploiement : Fractal ADL Définition des composants composites <definition name="basicclientserver" extends="roottype"> <component name="client" definition="basicclient"/> <component name="server" definition="basicserver"/> <binding client="this.m" server="client.m"/> <binding client="client.s" server="server.s"/> </definition> m m client s s server BasicClientServer 66

67 Déploiement : Fractal ADL Définition des composants composites (suite) <definition name="abstractclientserver" extends="roottype"> <component name="client" definition="clienttype"/> <!-- pas d'implémentation --> <component name="server" definition="servertype"/> <!-- pas d'implémentation --> <binding client="this.m" server="client.m"/> <binding client="client.s" server="server.s"/> </definition> <definition name="basicclientserver" extends="abstractclientserver"> <component name="client" definition="basicclient"/> <component name="server" definition="basicserver"/> </definition> 67

68 Déploiement : Fractal ADL Création d'un composant avec l'adl (en Java) en ligne de commande java org.objectweb.fractal.adl.launcher template par programme Factory f = FactoryFactory.getFactory(FRACTAL_BACKEND); Component c = (Component)f.newComponent("template", null); les définitions doivent être dans le CLASSPATH 68

69 Composants primitifs : utilisation d'annotation : une interface public interface Service { : un composant Fournit les interfaces qu'il public class ServerA implements Service { : une interface fournie importée signature=java.lang.runnable.class, cardinality=cardinality.singleton, contingency=contingeny.mandatory)} public class Client implements Runnable { } 69

70 Composants primitifs : utilisation d'annotation une propriété configurable d'un composant Génère un controller CompAttibuteController (pour un composant private String message : une interface = "service", cardinality = Cardinality.COLLECTION) private Map<String,Service> services = new : une méthode à exécuter lors d'un private void init() {... } 70

71 Plan Introduction Premier aperçu Définition du modèle Déploiement des composants Langage de description d'architecture Reconfiguration dynamique Conclusion 71

72 Reconfiguration dynamique ContentController rcompcc = Fractal.getContentController(rComp); Component ccomp = rcompcc.getfcsubcomponents()[0]; Component scomp = rcompcc.getfcsubcomponents()[1]; Fractal.getLifeCycleController(rComp).stopFc(); Fractal.getBindingController(cComp).unbindFc("s"); m m ccomp s s scomp rcomp 72

73 Reconfiguration dynamique rcompcc.removefcsubcomponent(scomp); m m ccomp s rcomp 73

74 Reconfiguration dynamique scomp = gf.newfcinstance(stype, "primitive", "pkg.newserverimpl"); rcompcc.addfcsubcomponent(scomp); m m ccomp s s scomp rcomp 74

75 Reconfiguration dynamique Fractal.getBindingController(cComp). bindfc("s", scomp.getfcinterface("s")); Fractal.getLifeCycleController(rComp).startFc(); m m ccomp s s scomp rcomp 75

76 Bilan de Fractal Principes architecturaux pour l ingénierie des systèmes Construction par composition de briques logicielles : les composants Vision homogène de la topologie des systèmes logiciels applications, intergiciel, systèmes d exploitation Gestion uniforme des ressources, des activités et des domaines de contrôle Couverture du cycle de vie complet : - développement, déploiement, supervision Réalisation d un support d exécution pour composants : Fractal Julia Le modèle peut être mis en oeuvre dans de nombreux environnements (Think, Plasma...) des tutoriaux en ligne... 76