Université de Franche-Comté

Interface graphique pour reconfiguration desystèmes à composants via politiques

d'adaptation

RAPPORT DE PROJET

Auteur :

Lemasson Nicolas

Picard Alexis

Responsables :

Weber Jean-François

Kouchnarenko Olga

Master 2 Informatique et Programmation - Janvier 2015

Université de Franche-Comté

Table des matières

Remerciements 2

Introduction 3

1 État de l'art 4

1.1 Systèmes composants . . . . . . . . . . . . . . . . . . . . . 4

1.2 Fractal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.3 Exemple du CyCab . . . . . . . . . . . . . . . . . . . . . . 4

2 Analyse et Conception 6

2.1 Analyse des fonctionnalités . . . . . . . . . . . . . . . . . 6

2.2 Modélisation les données . . . . . . . . . . . . . . . . . . . 6

2.3 Navigation . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.4 Outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3 Réalisation 10

3.1 Composition de l'interface . . . . . . . . . . . . . . . . . . 10

3.2 Gestion de projet . . . . . . . . . . . . . . . . . . . . . . . 12

3.3 Extraction de données . . . . . . . . . . . . . . . . . . . . 14

3.4 Exécution de commandes . . . . . . . . . . . . . . . . . . 15

3.5 A�chage des données . . . . . . . . . . . . . . . . . . . . 16

3.6 Événements . . . . . . . . . . . . . . . . . . . . . . . . . . 21

Conclusion 22

Références 23

Rapport de projetPage 1/25

1er février 2015

Université de Franche-Comté

Remerciements

Avant de commencer ce rapport, nous souhaitons remercier les personnesqui nous ont aidés à mener à bien nos objectifs pour notre projet tuteuré.

Nous remercions Jean-François Weber pour son aide, sa disponibilité etle site qu'il a mis en place pour nous guider.

Nous remercions Olga Kouchnarenko pour le suivi du projet et l'organi-sation de rendez-vous.

Rapport de projetPage 2/25

1er février 2015

Université de Franche-Comté

Introduction

Le sujet de notre projet était de réaliser une interface graphique pourrecon�guration de systèmes à composants via politiques d'adaptation. Nousavons analysé ce sujet, puis nous avons réalisé l'interface graphique en java.Nous allons donc présenter rapidement les systèmes à composants et les re-con�gurations de ceux-ci. Nous verrons ensuite les di�érentes fonctionnalitésde notre interface graphique, qui permettent de visualiser ces con�gurationsau cours du temps, de les analyser, ou encore d'interagir avec le système lorsd'une simulation par le biais d'événements qui lui sont envoyés.

Rapport de projetPage 3/25

1er février 2015

Université de Franche-Comté

1 État de l'art

1.1 Systèmes composants

Un composant est une unité de composition d'un système pour lequel onspéci�e des interfaces (ou port), fournies et requises. Les interfaces requisessont nécessaires au fonctionnement du composant, et lui permettent de four-nir un service par le biais de ses interfaces fournies. Au sein d'un systèmeà composants, chaque interface fournie peut être utilisée par un autre com-posant, à condition qu'il possède une interface requise du même type. Lescomposants ont donc la capacité de se connecter les uns aux autres via leursinterfaces, ce qui leur permet d'être réutilisable dans un autre système.

Il est possible de dé�nir des politiques de recon�guration, qui permettentde rendre le système modulable au cours de son exécution. Ces recon�gura-tions sont basées sur l'architecture (Composants, Interfaces, Liens), en fonc-tion du contexte de l'exécution (Attributs ou Événements). Par exemple ilest possible d'activer/désactiver un composant, ou encore de lier/délier deuxinterfaces de composants.

1.2 Fractal

Fractal est un méta-modèle de systèmes à composants qui peut être uti-lisé avec di�érents langages de programmation pour concevoir, mettre en÷uvre, déployer et recon�gurer di�érents systèmes à composants. Il autoriseles composants à être imbriqués dans d'autres composants qui sont dits com-posites. Il permet de faire une abstraction pour les connexions de composantsqui est appelé binding.

1.3 Exemple du CyCab

CyCab est un système à composants dé�nis en fractal, qui représente unrobot capable de se déplacer sans chau�eur. Dans l'exemple il possède deuxcomposants wi� et gps qui lui fournissent des informations sur sa position.Un de ces deux composants peut par exemple être amené à être désactivépar souci d'économie d'énergie. En e�et CyCab possède également un niveaude batterie, qui doit être pris en compte car ce robot doit être capable de serecharger automatiquement quand cela est nécessaire.

Le système (voir �gure ci-dessous) est sensible à deux types d'événements,internes et externes. Les événements externes sont envoyés par un gestion-naire d'événement, et les événements internes sont envoyés par le système àcomposant.

Rapport de projetPage 4/25

1er février 2015

1.3 Exemple du CyCab Université de Franche-Comté

Figure 1 � Système à composants

C'est en utilisant cet exemple que nous avons développé le projet. Nousavons utilisé les �chiers de logs produits par CyCab lors de son exécution,qui décrivent les di�érents états du système. Pour chaque état, nous avonsdes informations sur les di�érents composants et sur leurs interfaces, ainsique les valeurs des variables du système (comme le niveau de batterie). Nousavons également des informations sur les événements à cet état. La valeurd'un événement est dans B4. Ces �chiers de logs sont utilisés par l'interfacegraphique, a�n de récupérer les informations sur le système, pour pouvoir lesa�cher. Toutes applications générant le même format de logs peuvent êtregérées par l'interface graphique.

Rapport de projetPage 5/25

1er février 2015

Université de Franche-Comté

2 Analyse et Conception

2.1 Analyse des fonctionnalités

Avant de commencer la partie développement, nous avons commencé parlister toutes les fonctionnalités demandées dans ce projet grâce à une analysedu cahier des charges et aux explications lors des di�érentes réunions. Nousen sortons un diagramme de cas d'utilisation suivant :

Figure 2 � Diagramme de cas d'utilisation de l'interface

2.2 Modélisation les données

Les données extraites d'une l'implémentation d'un système à composantsdoivent être complètement indépendantes de celui-ci. Les con�gurations ex-traites doivent donc être recréées en mémoire à l'aide d'un ensemble de classesjava.

La classe principale est la classe Project. Elle contient la liste des di�é-rentes con�gurations du système au cours d'une simulation, et permet donc

Rapport de projetPage 6/25

1er février 2015

2.3 Navigation Université de Franche-Comté

de visualiser les changements au cours du temps. Une con�guration est com-posée de la liste des composants du système. Un composant est dé�ni parles valeurs de ses paramètres et par la dé�nition de ses interfaces requises eto�ertes. Une con�guration possède également une liste de liens (ou Binding),qui relie les interfaces des di�érents composants. Pour toutes les con�gura-tions, nous connaissons la valeur courante et précédente de chaque événe-ment.

La classe Project contient donc l'ensemble des données extraites. Voici lediagramme de classes de l'application.

Figure 3 � Diagramme de classe d'un projet

2.3 Navigation

La navigation dans une interface graphique est essentielle. Nous avonsdonc réalisé une interface simple d'utilisation et intuitive. Suivant l'état danslequel l'interface se situe, il n'est pas possible d'e�ectuer toutes les actionspossibles liées à celle-ci. En e�et s'il n'y a pas de projet ouvert, il n'est paspossible de charger des �chiers de logs ou de charger un �chier de build. Nousavons représenté une machine à état très simple :

Rapport de projetPage 7/25

1er février 2015

2.4 Outils Université de Franche-Comté

Figure 4 � Diagramme général d'état machine de l'interface

2.4 Outils

Design NetBeans

Le design NetBeans est un outil de construction d'interfaces graphiquespermettant de développer celles-ci sous Swing très simplement. Son fonc-tionnement est le suivant : les classes java peuvent être associées à un �chierform écrit xml et gérées par netbeans. Nous ne voyons pas ce �chier sous sonformat texte, mais graphiquement où les composants Swing sont dessinés àl'écran. Il est possible depuis cet éditeur d'intégrer des composants commedes panneaux, des boutons ou un menu, de les positionner, personnaliser,associer entre eux, dé�nir leurs actions (Listener) etc. Le �chier java est au-tomatiquement mis à jour en fonction du �chier xml, par la traduction de cedernier �chier en code java. Le code java écrit à la main dans la classe n'estpas e�acé.

Rapport de projetPage 8/25

1er février 2015

2.4 Outils Université de Franche-Comté

Les librairies

Pour réaliser ce projet, nous avons utilisé plusieurs librairies qui nous ontaidés à rendre l'interface plus élaborée.

• La librairie XStream nous a permis de sérialiser les données d'un projeten �chier xml

• La librairie JFreeChart nous a permis de dessiner des graphiques

• La librairie GraphStream nous a permis de dessiner des automates decon�gurations

SVN

Un dépôt SVN nous a permis de travailler sans se court-circuiter. Nousavons décidé de mettre ce dépot en lecture publique à l'adresse suivante :https://subversion.assembla.com/svn/picky/

Rapport de projetPage 9/25

1er février 2015

Université de Franche-Comté

3 Réalisation

3.1 Composition de l'interface

L'interface a été créé dans un but précis : interagir avec l'utilisateur pourla visualisation et l'extraction de données de simulation.

Celle-ci est composée d'une fenêtre principale, une classe nommée Framehéritant de la classe JFrame. C'est par cette classe qu'une grande partiedes données passeront avant d'être a�chées, et que les actions utilisateursseront traitées. Au contraire, les données ne seront stockées que dans desclasses extérieures : la classe Project et ses sous classes vu précédemment.La classe Frame possède donc une instance de cette classe.

La fenêtre Frame est composée d'un ensemble de Component appartenantà la librairie Swing :

• Une barre de menu JMenu composée de JMenuItem pour lancer desactions

• Un barre d'outils composée de JButton pour accéder rapidement auxactions les plus importantes

• Des panneaux redimensionnables JSplitPanel pour faire de l'espaceentre les composants et se concentrer sur l'essentiel

• Des panneaux JPanel pour a�cher les données des dessins comme lesgraphiques et les con�gurations

• Un liste JList pour a�cher les di�érentes con�gurations

• Des zones de texte JTextPane ou JLabel pour écrire les informationscomme les sorties d'une simulation dans un terminal ou les commen-taires

• Une barre de progressionJProgressBar

Voici la disposition actuelle de l'interface pour une optimisation maxi-mum des surfaces :

Figure 5 � Disposition de l'interface

Rapport de projetPage 10/25

1er février 2015

3.1 Composition de l'interface Université de Franche-Comté

Terminal

Le terminal est composé par un JTextPane imbriqué dans un JScroll-

Pane, et représente un champ texte qui peut être dé�lé (scrollé) horizonta-lement et verticalement. Lors de l'exécution d'une commande, ou l'a�chaged'un message d'erreur, un texte sera a�ché dedans. Il présente toutefoisquelques spéci�cités :

lors de l'ajout d'un texte dans celui-ci, le texte sera automatiquementdé�lé au plus bas pour voir les dernières lignes comme un terminal classique.Pour réaliser ce dé�lement, on envoie le curseur au premier caractère de ladernière ligne.

Le texte a�ché est contenu dans un Document, ce qui permet de changerla couleur de police et de ne pas réécrire tout le texte après avoir ajouté unenouvelle ligne : on évite les scintillements. Le code couleur pour les messagesest vert pour une réussite, bleu pour une information, rouge pour une erreuret blanc pour le reste (le fond est noir).

Les informations importantes sont donc rapidement repérées par l'utili-sateur.

Barre de progression

L'interaction avec l'utilisateur étant très importante, il est nécessairede laisser des indices à celui-ci sur l'état de l'interface. Notamment, lorsdes périodes d'exécution longues d'un bout de programme, il est essentield'indiquer à l'utilisateur que l'interface n'est pas bloquée, mais en coursd'exécution. Nous avons donc créé une barre de progression indépendanteau thread d'exécution indiquant par exemple que l'interface travaille pourouvrir un projet, charge des logs ou exécute une commande.

Gestion des erreurs

Chaque action d'une interface est susceptible de générer une erreur, carles boutons de l'interface sont visibles et peuvent être activés en permanence.Nous avons fait le choix de laisser chaque bouton activable et de gérer aumaximum les cas d'erreurs en les spéci�ant à l'utilisateur via le terminal.Par exemple, il n'est pas possible de sauvegarder un projet qui n'a pas étécréé au préalable. Un message d'erreur Error, no open project s'a�che alorsen rouge dans le terminal.

Rapport de projetPage 11/25

1er février 2015

3.2 Gestion de projet Université de Franche-Comté

Aide

Une aide a été intégrée à l'application a�n de faciliter l'utilisation decelle-ci par un nouvel utilisateur. L'aide est un ensemble de pages HTMLextérieures à l'application a�ché dans une nouvelle fenêtre. Ces pages HTMLsont regroupées dans un dossier nommé documentation, à la racine du projet.Les pages a�chées dans un JEditorPane composent un tableau JTablePane

d'une JFrame. On peut visualiser du HTML en java dans un panel avec lecode suivant :

//Un JEditorPane de type HTML est cree, avec une chaine de caracteresstrHTML constituant la page

JEditorPane pane = new JEditorPane("text/html", strHTML)//Un ScrollPane permet de faire de�ler le texte verticalementScrollPane sc = new JScrollPane(pane);sc.setHorizontalScrollBarPolicy(JScrollPane.

HORIZONTAL_SCROLLBAR_NEVER);//ajout de la page a la tabletab.add(sc,BorderLayout.CENTER);

L'intérêt de cette méthode :

• Pouvoir éditer la documentation sans les sources

• La documentation n'est pas composée que de texte et peut être jolie.

• La documentation est exportable et visualisable en dehors de l'appli-cation avec un navigateur

Nous avons intégré un bouton permettant de recharger les pages HTMLdans l'application pour visualiser les modi�cations faites sur celle-ci.

3.2 Gestion de projet

Une simulation doit pouvoir être analysée, mais également et surtoutpouvoir être rejouée. Les données sauvegardées dans un projet doivent doncpouvoir être indépendantes des données générées par les logs. Nous avonsdonc créé une gestion de projet, ainsi que les fonctions de création, d'ouver-ture et de sauvegarde d'un projet.

La classe Project comporte toutes les informations nécessaires pour re-jouer une simulation comme nous l'avons vu précédemment. Pour gérer unprojet, il est donc su�sant de manipuler seulement cette classe.

Rapport de projetPage 12/25

1er février 2015

3.2 Gestion de projet Université de Franche-Comté

Sauvegarde

Pour sauvegarder un projet, une instance de la classe Project en mémoiredoit donc être sauvegardée en dur sous forme de �chier : ce procédé s'appellela sérialisation. La solution que nous avons utilisée est la sérialisation en�chier XML. Nous avons utilisé une bibliothèque, nommée XStream, pourfaire la sérialisation de l'instance de la classe Project. Le code pour créer le�chier XML est le suivant :

//XMLFile de type File est le �chier XML.FileOutputStream fOS = new FileOutputStream(XMLFile);BufferedOutputStream bOS = new BufferedOutputStream(fOS);DataOutputStream dOS = new DataOutputStream(bOS);XStream xstream = new XStream(new DomDriver());//ecriture : project represente une instance de la classe Projectoutput.writeBytes(xstream.toXML(project));

Le �chier XMLFile est le �chier où sera sauvegardé le projet. Une fois quia été saisie, il ne sera plus redemandé. Toutefois, une exportation de projetque nous avons implémenté permet de redé�nir ce �chier, et donc d'exporterle projet.

Au niveau de taille d'un �chier XML, une simulation avec l'exemple Cy-Cab sur 417 con�gurations représente un �chier XML de 5 Mo : c'est doncconvenable.

Ouverture

L'ouverture d'un projet consiste en la réformation d'une classe Project

sauvegardé en XML dans la mémoire : c'est l'opération inverse de la sau-vegarde. Ce procédé s'appelle la désérialisation, et va permettre de recréerl'instance de la classe Project. On utilise encore la librairie XStream :

//Information de chargement dans la barre de progressionprogressBar.setIndeterminate(true);XStream xstream = new XStream(new DomDriver());//deserialisation en objet et cast en Projectproject = (Project) xstream.fromXML(file);//a�chage des informations sur le projet ouvertmajProject();progressBar.setIndeterminate(false);

Rapport de projetPage 13/25

1er février 2015

3.3 Extraction de données Université de Franche-Comté

Création

La création d'un nouveau projet permet la création d'une nouvelle ins-tance vide de la classe Project. Les informations suivantes sont toutefois àcompléter lors de la création :

• Un nom de projet

• Un �chier ant et/ou un �chier maven

• Le dossier où sont générés les logs

Ces informations permettent de situer où doivent être exécutées les com-mandes, et où doivent être récupérés les logs lors du parsage à chaud. Deplus, si un �chier ant est spéci�é, les commandes �ltrées dans celui-ci appa-raissent dans un JComboBox pour être lancées plus rapidement. Notons quela création d'un projet ne le sauvegarde pas automatiquement.

3.3 Extraction de données

Les données récoltées d'une simulation proviennent uniquement des �-chiers logs générés par celle-ci nommés ap_'date'. La date représente le mo-ment où ils ont été créés, et donc le début de la simulation. Il existe deuxtypes d'extractions des données de ce �chier : l'une à chaud lors de l'exécu-tion de la simulation qui se fait état par état, l'autre à froid après simulationet qui récupère toutes les données.

Lors de l'extraction à froid, l'utilisateur doit spéci�er le �chier log. Enrevanche pour celle à chaud, un problème survient : puisque l'exécution n'apas encore été lancée, et que le �chier log n'est pas encore créé, commentspéci�er à l'application quel �chier log prendre au début de l'exécution sansintervention utilisateur ? Pour répondre à cette question, nous avons placéune boucle dans un thread qui va lire en permanence les nom des �chiersappartenant au dossier où sont les logs (saisi au début d'un projet). Puisqueces �chiers comportent la date de leur création, on peut en comparant avecla date courante voir si ces �chiers sont récents ou non. On va donc parcourirla boucle jusqu'à trouver un �chier dont la di�érence entre la date couranteet sa date est inférieure à un certain temps : nous avons �xé ce temps à uneseconde.

Notre fonction d'analyse syntaxique parseState prend en entrée unechaîne de caractères et renvoie une con�guration complète. Une con�gu-ration dans les logs commence par le mot-clé Begin of State et �nit parEnd of State, il est alors facile de découper les logs en plusieurs parties quireprésentent chacune une état :

Dans le cas de l'extraction à chaud il faut lire les lignes une par une etles ajouter dans une chaîne de caractères jusqu'à obtenir une ligne contenant

Rapport de projetPage 14/25

1er février 2015

3.4 Exécution de commandes Université de Franche-Comté

le mot-clé End of State. La lecture est faite dans un thread contenant uneboucle qui ne s'arrêtera que lorsque la simulation sera stoppée. Une fois avoirrécupéré en texte un état, on envoie celui-ci dans la fonctions parseState dansun nouveau thread a�n de ne pas bloquer la lecture, puis on ajoute l'état deretour à la liste des con�gurations courantes.

Dans le cas de l'extraction à froid, il su�t simplement de découper toutle texte du �chier log en parties représentant un état et de parser ensuitechaque partie.

La fonction de parsage parseState découpe la chaîne de caractères prise enentrée en une suite de tokens. Les tokens représentent les mots indépendantsd'une chaîne de caractères, séparés par des espaces. On créer cette suite detokens grâce à la classe StringTokenizer :

StringTokenizer st = new StringTokenizer(replace)

Les logs du �chier à parser sont disposés en ligne. Chaque ligne commencegénéralement par un mot-clé. Par exemple la ligne qui décrit les noms descomposants présents commence par le mot-clé Components. Ainsi nous avonscréé un switch dans une boucle pour parser chaque ligne qui commence parle mot-clé voulu. Pour passer au token suivant, on utilise la fonction :

st.nextToken()

Il faut donc lire les tokens jusqu'à obtenir un saut de ligne pour sortir d'uncas du switch et passer au cas suivant. Les données lues juste avant, tels lenoms des composants seront sauvegardés une par une dans un nouvel étatcrée au début de la fonction. A la �n de la fonction, on peut donc retournerle nouvel état qui sera ajouté.

3.4 Exécution de commandes

L'application gère l'exécution de commandes, via l'invité de commandesinclut ou par les commandes prédé�nies dans la barre d'outils. L'exécutiond'une commande se fait dans un thread pour ne pas bloquer l'interface, etlance un processus extérieur à l'application qui exécute la commande grâce àla classe Runtime. On peut alors récupérer dans une boucle la sortie output :

//Execution (directory = repertoire ou est execute la commande)Process process = runtime.exec("ant run", null, new File(directory))//Flux de lectureBufferedReader reader = new BufferedReader(new InputStreamReader

(process.getInputStream()));

Rapport de projetPage 15/25

1er février 2015

3.5 A�chage des données Université de Franche-Comté

String line;try {

while ((line = reader.readLine()) != null) {ecritureTerminal(line);

}}�nally {

//�n executionreader.close();process = null;

}

Le Process d'exécution peut également être interrompu par un boutonlorsque l'exécution est trop longue ou non �nie comme une simulation. Deplus nous avons implémenté la possibilité de lancer une �le de commandes :lors de la �n d'une commande, on détecte si une autre est dans la �le, etsi c'est le cas on l'exécute. On peut ajouter des commandes dans la �le àn'importe quel moment, et même personnaliser des suites de commandes àajouter en même temps comme ant clean, ant compile et ant run.

3.5 A�chage des données

Ensemble des con�gurations

Il existe deux types d'a�chage de l'ensemble des con�gurations.

Le premier est une simple liste construite à l'aide d'une JList, dont lemodèle, un DefaultListModel est composé de JLabel au nom des états. Nousavons donc ajouté un CellRenderer pour personnaliser chaque cellule de laliste : Les cellules dont l'état est favori ont une icône jaune, tandis que lesautres ont une icône grise. Les commentaires des états sont également a�chésdans les cellules. La sélection d'un état dans la liste lance l'a�chage de lacon�guration en question.

Le second est un a�chage sous forme d'arbre de con�gurations. Les con�-gurations se suivant toutes, cette vue ne présente pas d'intérêt particulier.En revanche elle ouvre des perspectives sur le sujet, par exemple le croise-ment entre plusieurs projets ou l'a�chage des recon�gurations candidates.L'arbre est dessiné grâce à la librairie GraphStream, en ajoutant des n÷udset des arêtes à un graph. Le réseau d'états qui composent l'automate créépar cette librairie agit comme un system multi-agent : les états se repoussententre eux jusqu'à obtenir une situation stable.

En e�ectuant des tests de performances sur l'exemple CyCab, nous avonspu a�cher des ensembles de 500 con�gurations sans problème de mémoireou d'a�chage.

Rapport de projetPage 16/25

1er février 2015

3.5 A�chage des données Université de Franche-Comté

A�chage d'une con�guration

L'a�chage d'une con�guration se fait dans un JPanel, auquel nous avonsredé�ni la méthode paintComponent. Aucune librairie en dehors de Swingn'a donc été utilisée.La méthode paintComponent prend comme unique paramètre un Graphics,et c'est donc à partir de celui-ci que nous avons dessiné l'ensemble de lacon�guration. Dans notre dessin, une con�guration est composée de :

• Composants parents et enfants

• Paramètre de chaque composant

• Interfaces de chaque composant

• Liens entre interfaces

Le JPanel représente pour nous une feuille de dessin dont la taille est de wen largeur et h en hauteur. Le principe utilisé pour représenter les objets surla feuille est basé sur la proportion des objets : On considère que la taille enlargeur et en hauteur de la feuille est toujours de 1. Ainsi, un composant de0.5 de largeur placé en position 0 sera représenté sur la moitié de la feuilleen largeur. Les dessins Swing étant basés eux sur un nombre de pixels, ilest nécessaire d'utiliser des formules de transformation : Une position en xsera transformé en pixel par largeur du panel * posX et en y par hauteur dupanel * posX. Les positions des objets sont donc également entre 0 et 1. Ilexiste un certain nombre d'avantages à utiliser cette méthode. Notammentle fait que les objets sont automatiquement redimensionnés suivant la taillede l'écran, et qu'il est facile de manipuler les tailles et positions entre 0 et 1.

Avant de commencer à dessiner, il est important de dé�nir la taille descomposants. En e�et les composants parents doivent être a�chés plus grandsque leurs enfants. La position des composants enfants doivent également êtresituée à l'intérieur de leurs parents. Une fonction récursive permet de dé�nircela :

Rapport de projetPage 17/25

1er février 2015

3.5 A�chage des données Université de Franche-Comté

public void initComposants(State s) {for (Component c : s.listeCompo) {

//pour les composants qui n ont pas de parentsif (c.parent == null) {

recInitTaille(c, 1);}

}}public recInitComposants(Component c, int profondeur) {

//de�nition taille et positionif (c.parent != null) {

c.size = c.parent.size/profondeurc.position = aleatoirePositionDansParent();

}//appel resursif sur les composants enfantsfor (Component cRec : c.listeFils)

recInitNode(cRec, profondeur ∗ 6);}

Figure 6 � Fonction d'initialisation des tailles et positions des composants

Nous pouvons donc passer à l'implémentation de la méthode paintCom-

ponent. Cette méthode est appelée à chaque fois que le JPanel doit êtrerepeint.

• Inconsciemment lors du changement de taille du panel

• Volontairement lors d'un déplacement ou agrandissement d'un compo-sant etc

Cette fonction est donc traitée de la manière suivante :

Rapport de projetPage 18/25

1er février 2015

3.5 A�chage des données Université de Franche-Comté

@Override

public void paintComponent(Graphics g) {super.paintComponent(g);for(Component c : etat.listeCompo)

//traitement sur chaque composantfor (Binding b : etat.listeBinding)

//traitement des liens entre interfaces}

Figure 7 � Fonction de dessin des composants

Pour dessiner un composant, on utilise les fonctions intégrées au Graphic.Les fonctions permettent de dessiner des objets pleins ou vides tels que desrectangles, des ovales ou du texte. Par exemple pour représenter le cadre ducomposant, on dessine un rectangle aux positions et tailles du composant.On dessine ensuite le titre du composant, la liste des paramètres, son état(en marche ou non), la liste des interfaces fournies et des interfaces requisesetc. Si le composant est sélectionné, on dessine également ses angles pourpouvoir le redimensionner. On représente les liens entre interfaces par deslignes hachées.

L'utilisateur doit également pouvoir manipuler les composants, enles déplaçant ou en les redimensionnant. Nous avons utilisé les interfacesjava MouseListener, MouseMotionListener et MouseWheelListener pourmanipuler les événements de la souris. Nous allons illustrer l'exemple dudéplacement d'un composant :Le premier clic du glisser-déposer est récupéré dans la fonction mousePres-

sed. On regarde ensuite si la position du clic appartient à un composant. S'ilappartient à plusieurs composants, on sélectionne le composant qui n'a pasde �ls (composant à l'intérieur d'un parent). Dans la fonction mouseDragged

on va alors créer une boucle qui sera stoppée seulement quand la sourissera relâchée (récupération dans la fonction mouseReleased). Cette boucleva constamment repositionner le composant sélectionné et redessiner lacon�guration. La boucle sera placée dans un nouveau thread pour ne pasbloquer l'a�chage.

Nous avons également ajouté une zone de propriété où sont a�chés dansun onglet les événements de la con�guration courante, ainsi qu'un ongletpour laisser des commentaires et un bouton permettant d'exporter le pa-nel de con�guration sous forme d'image (jpg). Un dernier onglet permet devisualiser des graphiques.

Rapport de projetPage 19/25

1er février 2015

3.5 A�chage des données Université de Franche-Comté

Pour �nir sur cette partie, nous avons implémenté une fonction permet-tant d'appliquer la disposition de la con�guration courante aux autres con�-gurations. La disposition d'une con�guration représente la taille et la po-sition de tous les composants. On obtient donc des con�gurations qui seressemblent : il est donc plus facile de les analyser. De plus, nous avons ap-pliqué cette fonction lors de l'exécution à chaud : la con�guration avant lelancement de la simulation est enregistrée, et la première con�guration dela nouvelle simulation lui ressemblera. Ensuite, chaque nouvelle con�gura-tion ajoutée en cours d'exécution appliquera la disposition de sa précédente.On obtiendra donc des con�gurations ressemblantes, et l'utilisateur pourraégalement les modi�er en cours d'exécution.

Graphiques

Les graphiques, réalisés à l'aide de la librairie JFreeChart permettent devisualiser deux types de courbe :

• L'évolution des paramètres des composants en fonction du temps

• L'évolution des états des événements en fonction du temps

Une liste déroulante permet de choisir le paramètre ou l'événement voulu.Cette liste déroulante est mise à jour en fonction des données présentes dansl'ensemble des con�gurations. Ainsi si un paramètre est présent dans uneseule con�guration, il apparaîtra tout de même, mais la courbe représenta-tive ne sera composée que d'un unique point.Le graphique est également redessiné lors de l'exécution à chaud. On peutdonc suivre l'évolution d'un événement ou d'un paramètre en cours de simu-lation. Voici le graphique obtenu lors d'une simulation avec génération d'unévénement entry :

Figure 8 � Exemple de graphique représentant un événement

Rapport de projetPage 20/25

1er février 2015

3.6 Événements Université de Franche-Comté

Par un clic droit sur le graphique, un menu lié à la librairie s'a�che per-mettant de zoomer, de modi�er les options du graphique et de l'exporter. Lagénération d'un graphique comme celui-ci, ou un autre que propose la librai-rie JFreeChart est assez simple. En revanche la documentation est limitéecar payante.

3.6 Événements

Il est possible d'interagir avec une simulation en cours d'exécution.L'exemple de CyCab possède son propre gestionnaire d'événements, qui per-met d'envoyer facilement un événement, en créant un �chier qui porte le nomde cet événement. Les �chiers d'événement sont créés par défaut dans le sous-répertoire /tmp du répertoire contenant le �chier de build. Ainsi l'interfacepermet à l'utilisateur de sélectionner un événement et de le déclencher enappuyant sur un bouton. La liste des événements disponibles est représentéepar les événements déclarés dans les �chiers de politiques d'adaptation (�-chiers .eap) du système à composants. Tous les �chiers .eap présents dans lerépertoire contenant le �chier build.xml (ou sous-répertoire) seront analyséspour retrouver la liste des événements. Lorsque l'utilisateur aura déclenchéun événement, il sera capturé par la simulation en cours et la valeur de cetévénement deviendra vraie à l'état suivant (ou celui d'après). L'utilisateurpourra alors visualiser la courbe de la valeur des événements en fonction desdi�érents états du système dans le graphe des événements (Events Graph).Les valeurs des événements sont comprises dans B4 (true, p_true, false,p_false). Pour �nir, il est également possible de dé�nir à l'avance les événe-ments qui seront lancés dans une con�guration ultérieure. Par exemple onpeut prévoir avant la simulation que dans la con�guration 14, un événemententry sera lancé, et que dans la 16 un événement exit sera lancé également.Pour que ces deux événements soient pris en compte dans les con�gurations14 et 16, ils seront lancés respectivement, dans l'application, au début descon�gurations 13 et 15 car l'a�chage d'une con�guration se fait après sonexécution.

Rapport de projetPage 21/25

1er février 2015

3.6 Événements Université de Franche-Comté

Conclusion

Ce projet nous a beaucoup plu, et nous y avons passé du temps pour leréaliser.

La partie la plus di�cile de celui-ci a été sans doute l'analyse. En e�et,nous avons dû passer plusieurs semaines avant le développement à analyserl'implémentation de l'exemple CyCab et les données des logs, ainsi que lefonctionnement des systèmes à composants.

La réalisation de l'interface par la suite ne nous a pas posé de pro-blèmes bloquants. Nous avons consolidé grandement les connaissances quenous avions déjà en java, notamment sur la gestion des composants Swinget des threads d'exécution mais aussi nous avons découvert beaucoup denouveaux aspects du langage java. Pour conclure, nous avons perfectionnéau maximum l'interface a�n de rendre un projet fonctionnel, et agréable àutiliser.

Rapport de projetPage 22/25

1er février 2015

RÉFÉRENCES Université de Franche-Comté

Références

[NET] Rapport en latex. http://lataix-sebastien.developpez.com/

tutoriels/latex/memoire-de-fin-d-etude/

[NET] Librairie JFreeChart. http://www.jfree.org/jfreechart/

[NET] Librairie XStream. http://xstream.codehaus.org/

[NET] Librairie GraphStream. http://graphstream-project.org/

[NET] Design Netbeans. https://netbeans.org/community/magazine/

html/03/visualwebdev/

[NET] Dessin en java. http://duj.developpez.com/tutoriels/java/

dessin/intro/

Rapport de projetPage 23/25

1er février 2015

RÉFÉRENCES Université de Franche-Comté

Figure 9 � Exemple de con�guration sur une imprimante

Figure 10 � Une con�guration sous l'exemple cycab

Rapport de projetPage 24/25

1er février 2015

RÉFÉRENCES Université de Franche-Comté

Figure 11 � Vue générale sur l'interface

Rapport de projetPage 25/25

1er février 2015