La contribution principale de ce travail est le modèle ScriptCOM qui étend le modèle de composants COM afin de faciliter le développement d’applications à base de composant adaptable pendant leurs exécutions par une entité externe (composant ou application ou un humain) ou par le composant luis même. L‟idée principale « c’est qu’il n’est pas nécessaire de redéployer le composant pour le mettre à jour par une entité externe ».
Nous avons vu dans le troisième chapitre que l‟opération d‟adaptation doit répondre à plusieurs contraintes dont la plus importante est la garantie de la cohérence de l‟application qui est reliée avec le passage d‟état entre les composants. Ce dernier est
un très grand problème pour l‟adaptation dynamique. Pour le résoudre, nous avons choisi d‟utiliser les langages de scripts pour l‟implémentation des composants, car ils permettent une programmation incrémentale, c.à.d. la possibilité d‟exécuter et de développer simultanément les scripts qui représente dans notre contexte l‟implémentation des composants. Nous parlons donc de composants scriptés.
La section suivante présente l‟impact d‟utilisation des langages de script dans la programmation à base des composants et justifie donc notre choix de l‟utilisation de ces langages.
4.2.1 L’impacte d’utilisation des langages de script dans la programmation orienté composants
Les langages de script [BAR 00] offrent depuis longtemps la capacité de faire évoluer le programme d‟application en cours de l‟exécution. La concision et la simplicité d‟écriture des programmes développés rendent ces langages de script [OUS 98], [PER 00] attractifs aux yeux des développeurs débutants.
La propriété qui nous intéresse dans ce travail est que plusieurs de ces langages sont dynamiques et qu‟ils autorisent une programmation incrémentale au cours de l‟exécution du programme développé [SAV 03].
Nous pouvons développer et exécuter notre programme simultanément sans passer par le cycle traditionnel itératif développement-déploiement-exécution. Dans le contexte de l‟adaptation dynamique, la programmation incrémentale apportée par les langages de script présente un intérêt majeur : l‟état de l‟application en cours d‟exécution est relativement résistant aux changements et aux évolutions du code (fonctionnel ou non-fonctionnel) de l‟application [DON 09].
Elle soulage ainsi le concepteur de l‟utilisation de mécanismes souvent ad hoc pour le transfert d‟état et pour le redémarrage des composants dont le comportement (code fonctionnel) a été modifié [DON 09]. La programmation incrémentale offerte par les langages de script est intéressante à plusieurs égards pour l‟adaptation dynamique des composants.
Elle est particulièrement intéressante pour le développement des programmes utilisant un environnement fluctuant, et non connu à l‟avance [DON 09]. Grâce aux langages de scripts, les composants concernés dans l‟application peuvent ainsi évoluer fonctionnellement au fur et à mesure des évolutions du contexte sans requérir de redéploiement. En contrepartie, la programmation orientée composant offre aux langages de script l‟opportunité d‟être plus largement utilisés (en partie) dans le développement de très gros logiciels.
4.2.2 ScriptCOM : Principes et règles de base
Nous avons choisi d‟étendre le modèle COM à cause de l‟importance de ce dernier et sa grande utilisation (voir la section 2.1 du chapitre 2). La définition de ScriptCOM est basée sur les principes fondamentaux suivants:
Comme ScriptCOM est une extension du modèle de composant COM, il est basé sur les mêmes règles de ce dernier qui sont les suivantes :
Un composant est essentiellement une entité binaire pour laquelle sont définis plusieurs interfaces et un mode d’interaction. Ces deux éléments se résument en fait par un simple pointeur, offrant accès aux fonctions de l‟implantation du composant.
Une interface principale est nécessairement disponible pour un composant, qui s‟appelle IDispath, et qui est une dérivée de l‟interface IUnknown, c.à.d. qu‟elle implémente les méthodes : addref(), realise(), qui permettent de gérer le cycle de vie du composant, et la méthode QueryInterface() : qui permette à des clients de découvrir dynamiquement (au temps d’exécution) si une interface est soutenue par un composant. L‟Interface IDispath regroupe l’utilisation de toutes les opérations d’un composant sous une unique méthode : invoke().
Cette méthode permet l’utilisation systématique et dynamique d’un composant à partir d’un langage interprété comme javascript et PHP. L’utilisation de cette méthode permet, d’autre part, de faire du forward automatique d’opérations sur un composant : il n’est pas nécessaire de connaitre statiquement son interface pour l’utiliser.
En plus de ces principes de COM, nous avons introduit trois contrôleurs qui sont détaillés dans la section suivante, et qui permettent de rendre un composant COM adaptable durant son exécution par une entité externe ou par lui même.
La figure 4.1 représente la structure d‟un composant ScriptCOM.
Un composant ScriptCOM est donc constitué de deux parties, partie fonctionnelle, et une partie de contrôle (les trois contrôleurs). Notre proposition s‟intéresse à revisiter ces règles et notions dans le contexte de langage de script « Windows Script » pour permettre le support de l‟adaptation externe et l‟adaptation interne lors de l‟exécution.
L‟adaptation externe autorise l‟évolution et le changement des interfaces fournis, tandis que l‟adaptation interne autorise l‟évolution et le changement du comportement des méthodes ainsi que l‟ajout et le retrait des propriétés. Dans ce qui suit, nous allons expliquer les contrôleurs et leur fonctionnement.
4.2.3 Les contrôleurs
L‟adaptation externe et l‟adaptation interne sont pilotées au moyen de trois nouveaux contrôleurs exposés par les composants du modèle ScriptCOM. Ces contrôleurs sont le contrôleur d‟interface CI, le contrôleur de script CS, et le contrôleur de propriété CP.
L‟action des contrôleurs est réalisée au niveau de l‟instance du composant. Avec ces contrôleurs on peut effectuer toutes les adaptations nécessaires au composant par un autre composant ou une autre application ou par le composant lui même.
Le contrôleur d‟interface CI permet l‟ajout et le retrait des interfaces sur une instance du composant. La méthode getInterfaceNames() permet de retourner un tableau de chaine de caractères, où chaque élément représente un nom d‟une interface fourni par le composant ScriptCOM. La méthode getInterface() permet de retourner la définition de l‟interface (sous forme d‟une chaine de caractère) indiquée par le paramètre de cette méthode.
La méthode addInterface() permet d‟ajouter une nouvelle interface au composant La méthode setInterface() permet également de faire évoluer une interface existante par le remplacement de la définition de cette dernière par une autre définition contenant des nouvelle méthodes ou avec la suppression d‟une ou plusieurs autres méthodes si elles ne sont pas, et ne seront pas invoqués par d‟autres composants.
La méthode setInterface() retourne la valeur True si la mise à jour de l‟interface est réalisée avec succès et false dans le cas où l‟interface n‟existe pas.. En fin, La méthode removeInterface() permet de supprimer la définition de l‟interface qui a comme nom le nom donné comme paramètre, si elle n‟est pas utilisé et ne sera pas utilisé par un autre composant.
Interface Controleur-Interface {
String[] getInterfaceNames();
String[] getInterface (String name);
Boolean addInterface (String name, String[] interface);
Boolean setInterface (String name, String[] interface);
Boolean removeInterface(String name);
}
Le contrôleur de script CS permet d‟évoluer de manière incrémentale un script programmé dans un langage de script quelconque à condition que son interpréteur soit disponible dans l‟environnement d‟exécution.
Ces scripts ou ces fragments de script contiennent généralement la définition des fonctions correspondantes aux opérations des interfaces fournies. Le script peut contenir également des déclarations de variables ce qui permet d‟ajouter des variables d‟état. Pour la modification de l‟implantation complète du composant nous avons défini deux méthodes getScript() et setScript() qui permettent respectivement de retourner l‟implantation du composant et de la remplacer par une autre. Les deux méthodes addVarDec() et addFuncDef() permettent respectivement d‟ajouter au script une déclaration d‟une variable et une définition d‟une fonction. La méthode getMethode() permet de retourner la définition d‟une méthode indiqué par le paramètre name sous forme d‟une chaine de caractère.
La méthode setMethode() peut être invoquée successivement plusieurs fois pour compléter ou pour remplacer les définitions des opérations. La méthode removeMethode() permet de supprimer l‟implémentation d‟une méthode existe dans l‟implantation du composant si elle n‟est pas utilisé et ne sera pas utilisé par un autre composant. La méthode removeALL() supprime la définition des opérations, ainsi que les variables et leurs états.
Toutes les méthodes de l‟interface Controleur-Script permettent donc l‟adaptation de l‟implantation des composants ScriptCOM.
interface Controleur-Script {
String getScriptText();
void setScript(String newScript);
void addVarDec(String nomVar, String value);
void addFuncDef(String func_imp);
String getMethode(String name);
Boolean setMethode(String nameMethode,
String newCode);
Boolean removeMethode(String nameMethode);
Boolean removeALL ();
}
Le contrôleur de variable permet l‟ajout, la modification, et le retrait des propriétés dans l‟instance du composant. Ces propriétés sont manipulées sous la forme de variables dans le script. La méthode getProperties_Names() retourne une liste des noms des propriétés du composant en question. Ce contrôleur consulte et positionne aussi la valeur d‟une propriété grâce aux méthodes getPropertie(). On a aussi la possibilité d‟ajouter des nouvelles propriétés via la méthode addPropertie().
La méthode setValue() permet de modifier la valeur d‟une propriété. Notons que le changement de valeur d‟une propriété peut provoquer des erreurs de conversion de type si le langage de script ne supporte pas le type de la nouvelle valeur. On a aussi la possibilité de supprimer des propriétés via la méthode removePropertie().
interface Controlleur-Propriété {
String[] getProperties_Names(); String getPropertie(String name);
void addPropertie(String name, String value);
Boolean setValue(String name, String Value);
Boolean removePropertie(String name);
}
Les contrôleurs CS et CP permettent l‟adaptation interne du composant. Alors que le contrôleur d‟interface CI permet l‟adaptation externe du composant.
4.2.4 Les mécanismes de maintien de la cohérence des applications sujets à des adaptations dynamiques
Nous avons vu dans le troisième chapitre que la cohérence de l‟application peut être locale ou globale. Dans le premier cas, elle concerne un composant indépendamment des autres, par exemple, lorsqu‟un composant est altéré au moment où il modifie l‟une de ses ressources, il ne peut pas revenir dans un état cohérent.
La cohérence globale concerne l‟application dans sa globalité, par exemple, les messages transitant dans l‟application ne doivent pas être perdus. La possibilité de retour en arrière est une opération très importante pour préserver la cohérence des composants en particulier et la cohérence de l‟application en général.
Nous avons intégrer dans notre modèle ScriptCOM un mécanisme de retour en arrière. Ce dernier permet d‟annuler l‟adaptation et faire retourner l‟application à son état initial. Pour atteindre cet objectif, il faut vérifie en premier la correction (correctness) de l‟application. S‟il y a certaines erreurs qui sont trouvées le mécanisme va être déclenché.
On remarque donc, que la vérification de la correction de l‟application est une partie très importante et essentielle pour atteindre notre objectif. Pour cela, nous avons implémenté aussi un mécanisme de vérification de la correction de l‟application. Nous allons présenter dans la section 5.4 du chapitre 5 les principes et les implémentations de ces deux mécanismes. Ces deux mécanismes sont prédéfinis dans notre modèle ScriptCOM ce qui rend ce modèle très puisant et très intéressant que la plus part des modèle de composant qui existe dans le marché.
4.2.5 Notion de Type pour un composant ScriptCOM
Le type d‟un composant COM est associé à sa liste des interfaces fournies. Dans notre contexte, le contrôleur CI permet de faire évoluer (ajouter ou retirer) les interfaces d‟une instance de composant.
Le type d‟une instance de composant n‟a donc plus un caractère immuable comme le considèrent les implémentations de nombreux modèles de composants, comme Fractal et CCM. Le type d‟un composant est généralement considéré immuable tout au long de sa vie.
Un problème qui peut être posé dans notre proposition est que les erreurs peuvent être introduites dans l‟architecture lors de l‟usage des opérations des trois contrôleurs. Dans notre contexte, un composant a un type initial (interfaces), un comportement initial (un script) et une liste initiale de contrôleurs. Le type et le comportement de chaque instance peuvent muter indépendamment par l‟action des contrôleurs sur l‟instance du composant.
4.2.6 Type de réutilisation des composants ScriptCOM
Un composant ScriptCOM est une boîte Blanche parce que la source du composant est entièrement disponible et peut être étudiée, réutilisée, adaptée, ou modifiée.
Page suivante : 4.3 Exemple d’utilisation des composants ScriptCOM
Retour au menu : UTILISATION DES SCRIPTS POUR LE DEVELOPPEMENT DES COMPOSANTS COM ADAPTABLES