Le Protocole de Reconguration de l'Architecture (PRA)

rn1 (x,”toto”) rn1 (x,”toto”) g= gn1= gn1 ^{(1,”toto”)} gn1’ ^{(1,”toto”)} rn1= rn1 ^{(x,”toto”)} rn2 1 1 rn1= ^{(x,”titi”)} (14) (15) (16) (17) ; gn1’ ^{(1,”toto”)} g= gn1 ^{(1,”toto”)} gn1= rn1 ^{(x,”toto”)} rn1= rn2 ^{(x,”titi”)} rn1= ; ; ; rn1 (x,”toto”) rn1 (x,”toto”) 1 rn2 (x,”titi”) r = rn2 (x,”titi”) 5 r = rn1 ^{; ; ;} (x,”toto”) r = rn1 ^{; ; ;} (x,”toto”) rn1 (x,”toto”) gn1= gn1 ^{(1,”toto”)} rn1= rn1 ^{(x,”toto”)} rn1= rn2 ^{(x,”titi”)} r = rn1 ^{; ; ;} (x,”toto”) rn1 (x,”toto”) rn2 (x,”titi”) 5 g= gn1’ (1,”toto”) 1 gn2’ (1,”titi”) gn3’ (1,”titi”) 5 5 (19)

Fig. 5.12  Un scénario pour les interactions impliquant le MTG et l'ATG

Nous présentons, dans la gure 5.12, un diagramme de séquence qui expose un scénario d'utilisation de l'API oerte par le moteur de transformation de graphes. Nous présentons, en parallèle, les diérents éléments construits grâce à l'API de programmation (étapes de (1) à (17)). D'un côté, nous construisons le graphe hôte g ainsi que les n÷uds et leurs labels et les arcs et leurs étiquettes qui le constituent (étapes de (1) à (6)). Et d'un autre côté nous construisons la règle de réécriture r et les n÷uds et les arcs qui constituent ses diérentes zones (étapes de (7) à (17)). Nous présentons ensuite le résultat obtenu après utilisation de l'API d'exécution en appliquant deux fois la règle r au graphe g (étapes (18) et (19)).

5.5 Le Protocole de Reconguration de l'Architecture (PRA)

Nous implémentons, au dessus du moteur de transformation de graphes, une brique logicielle permet-tant de dénir le protocole de reconguration de l'architecture (PRA) tel que nous l'avons spécié dans le chapitre 2.

Moteur de Transformation des Graphes ^rules

graphs ruleNodes

graphNodes InstantiatedRules

Protocole de Reconfiguration des Architectures mappingTable

Algorithme de Transformation de Graphes

API exécution API programmation

API

API programmation

API exécution propertiesLists

Fig. 5.13  Les trois couches implémentées

Nous considérons, par conséquent, un nouveau type correspondant aux événements de reconguration ainsi que les structures permettant de décrire les politiques d'instanciation. Ceci a pour objectif de répercuter les valeurs transportées par les événements de reconguration sur les diérents labels des n÷uds des règles de réécriture. La classe "instantiator" permet de spécier les variables concernées par les aectations. Nous distinguons, par conséquent, quatre tableaux regroupant ces variables selon leurs types. Pour chacune de ces variables, nous désignons la position de la valeur qui doit lui être aectée. Si nous prenons par exemple une instance I de cette classe telle que intV ariables = [x, y] et intV alues = [4, 3], cela caractérise une instanciation où nous aecterons la valeur du quatrième et du troisième paramètre entier transporté par l'événement respectivement aux variables x et y 90.

diagramme de classes 7 package toto {7/9}

instantiator string intVariables[ ] int intValues[ ] string stringVariables[ ] string stringValues[ ] string doubleVariables[ ] double doubleValues[ ] string boolVariables[ ] bool boolValues[ ]

void addIntInstantiation(int position, string var) void addStringInstantiation(int position, string var) void addDoubleInstantiation(int position, string var) void addBoolInstantiation(int position, string var)

mappingTable string eventTypes[ ] int ruleCombinations[ ] [ ] string operators[ ] int graphs[ ] instantiator* Inst[ ]

void addEventType(string type) int getEventTypeIndex(string type) void addRule(string eventType,int rule) void addGraph(string eventType, int graph) void addOperator(string eventType,string operator) void addIntInstantiation(string eventType,string intVar,int pos) void addStringInstantiation(string eventType,string stringVar,int pos) void addDoubleInstantiation(string eventType,string doubleVar,int

)

void addBoolInstantiation(string eventType,string boolVar,int pos)

Fig. 5.14  Règles d'instanciation et table de correspondance entre événements, règles et graphes Nous introduisons, aussi, une classe supplémentaire permettant de dénir la correspondance entre les événements de reconguration et les combinaisons des règles de reconguration. Pour chaque type

90e.g. si nous avons un événement e1(1,5,"titi",4,"toto",7), cela impliquerait l'aectation de la variable x par la valeur 7 et la variable y par la valeur 4.

d'événements, nous dénissons la combinaison de règles à appliquer (i.e. grâce aux deux attributs "rule-Combinations" et "operators") et sur quel graphe il faut l'appliquer. L'attribut "inst" permet d'instancier correctement, pour chaque type d'événement, les labels des règles appartenant aux combinaisons à appli-quer.

Dans la gure 5.15, nous donnons un diagramme de classes qui implique la caractérisation et l'exécu-tion du protocole de recongural'exécu-tion des architectures (PRA). Nous remontons, à ce niveau, les API de programmation et d'exécution dénies au niveau du MTA. Nous récupérons, ainsi, les méthodes permet-tant de construire les graphes hôtes et les règles de réécriture.

diagramme de classes 8 package toto {8/9} Event string Type int intParams[ ] string stringParams[ ] double doubleParameters[ ] bool boolParameters[ ] void addIntParam(int p) void addStringParam(string p) void addDoubleParam(double p) void addBoolParam(bool p) int getIntParam(int pos) string getStringParam(int pos) double getDoubleParam(int pos) bool getBoolParam(int pos)

mappingTable voir diagramme 7 vois diagramme 7 MTG voir diagramme 6 voir diagramme 6 PRA mappingTable* MT property* propertiesLists[ ][ ] API Programmation Méthodes héritées de MTG +

void createMappingTable(string eventType)

void addRuleToMappingTable(string eventType,int rule) void addOperator(string eventType,string op)

void addIntInstantiation(string eventType,string intVar,int pos) void addStringInstantiation(string eventType,string stringVar,int pos) void addDoubleInstantiation(string eventType,string doubleVar,int pos) void addBoolInstantiation(string eventType,string boolVar,int pos) int addPositiveProperty(int rule, int graph)

int addNegativeProperty(int rule, int graph) API Execution

int ** EventHandling(Event* e) bool verifyProperty(int p, int graph) bool verifyAllGraphProperties(int graph) bool verifyAllProperties( )

property

int* rule int* graph bool positive

Fig. 5.15  Le protocole de reconguration

Nous enrichissons, par la suite, l'API de programmation par des méthodes permettant de construire la correspondance entre événements, combinaisons de règles et graphes, et des méthodes qui dénissent les liens entre les paramètres transportés par les événements et les labels des règles. Cette API permet d'actualiser, pendant l'exécution, le protocole de reconguration. Par exemple, nous pouvons prendre

en compte, sans avoir à arrêter l'application ni à la recompiler, un nouvel événement, et dénir les combinaisons de reconguration qui lui correspondent. Cette API permet aussi de modier, pendant l'exécution, les actions de reconguration relatives à un événement donné.

L'API d'exécution concernera principalement, en plus de celle héritée de la couche inférieure, deux méthodes. La première méthode (i.e. "eventHandling") correspond au traitement des événements en instanciant correctement les règles de réécriture et en appliquant la combinaison correspondante sur le graphe désigné par la table de correspondance. La deuxième méthode concerne la vérication des propriétés architecturales en testant l'applicabilité des règles (positives et négatives correspondantes). Nous disposons de trois options permettant 1) ou bien de cibler une propriétés particulière, ou 2) de vérier la validité de l'ensemble des propriétés dénies pour un graphe, ou 3) de vérier la validité de toutes les propriétés dénies pour tous les graphes du système.

PRA Utilisateur Requettes (1)--(17) (18') r'=createRule( ) (19') rn3=createRuleNode( ) (20) addIntRuleNodeAttribut(rn3,"y",-1) (21) rn3'=addRuleNode(r',"R",rn3) (22) createMappingTable("event1") (28) createMappingTable("event2") (23) addRuleToMappingTable("event1",r) (24) addOperator("event1",";") (25) addRuleToMappingTable("event1",r' ) (26) addIntInstantiation("event1","y",1) (29) addRuleToMappingTable("event2",r' ) (30) addIntInstantiation("event2","y",2)) (27) HandleEvent(event1(911)) (31) HandleEvent(event2(911,25)) (32) HandleEvent(event2(31)) g= ^gn1’ (1,”toto”) 1 (16) gn1’ (1,”toto”) 1 gn2’ (1,”titi”) 5 g= (27) gn3’ (911) gn1’ (1,”toto”) 1 gn2’ (1,”titi”) 5 g= (31) gn3’ (911) _{gn4’ (25)} gn1’ (1,”toto”) 1 gn2’ (1,”titi”) 5 g= (32) gn3’ (911) gn4’ (25) gn5’ (1,”titi”) gn6’ (31)

Fig. 5.16  Le protocole de reconguration

La gure 5.16 présente, sous forme de diagramme de séquence, un scénario d'utilisation de la brique logicielle correspondant à la programmation et à l'exécution du PRA. En considérant les étapes (1) à (17) présentées dans la gure, nous complétons le processus de dénition du protocole de reconguration par les étapes (18') jusqu'à (26). Les requêtes de (22) à (26) permettent de dénir le type d'événements "event1 ". À cet événement correspondra la combinaison "r; r′". Ces requêtes dénissent aussi une règle d'instanciation qui implique que la variable y sera aectée par le premier paramètre entier que

trans-porte l'événement (requête (26)). Les requêtes de (28) à (30) permettent de considérer un nouveau type d'événement "event2 ". À cet événement, correspond la combinaison constituée de l'unique règle r′. La règle d'instanciation spéciée implique que la variable y est aectée par le second paramètre entier de l'événement.