log4430 architecture logicielle et conception avanc e n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
LOG4430 : Architecture logicielle et conception avancée PowerPoint Presentation
Download Presentation
LOG4430 : Architecture logicielle et conception avancée

Loading in 2 Seconds...

play fullscreen
1 / 36

LOG4430 : Architecture logicielle et conception avancée - PowerPoint PPT Presentation


  • 67 Views
  • Uploaded on

LOG4430 : Architecture logicielle et conception avancée. Cadres de référence et plugiciels. Plan. Introduction Un exemple de plugiciel Eclipse Extensions OSGi Architecture Gestion du cycle de vie Service d’enregistrement Environnement d’exécution Gestion du cycle de vie

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'LOG4430 : Architecture logicielle et conception avancée' - titus


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
slide2
Plan
  • Introduction
  • Un exemple de plugiciel
      • Eclipse
      • Extensions
  • OSGi
      • Architecture
      • Gestion du cycle de vie
      • Service d’enregistrement
      • Environnement d’exécution
  • Gestion du cycle de vie
      • Gestion de besoin
      • Architecture
      • Implantation
      • Test
      • Suivi des problèmes
      • Gestion des versions
1 introduction
1. Introduction
  • Aujourd’hui (et demain), les programmes
    • Sont de plus en plus complexes
    • Doivent être livrés de plus en plus rapidement
    • Doivent fonctionner avec un minimum d’arrêt
1 introduction1
1. Introduction
  • Les programmes nécessitent donc
    • Une plateforme de programmation favorisant l’indépendance des composants
    • Un format de livraison « standardisé »
    • Une plateforme d’exécution permettant le remplacement à chaud
  • Les programmes doivent donc être formés de composants réutilisables et interchangeables en cours d’exécution(cf. « Cours 5 - Cadres de reference et plugiciels (JAOO06-OSGi_Tutorial).pdf », pages 7–11)
2 definition plugiciel
2. Definition: plugiciel
  • « Un [plugiciel] est un programme qui interagit avec un logiciel principal, appelé programme hôte, pour lui apporter de nouvelles fonctionnalités » [Wikipedia]
    • ils ne peuvent fonctionner seuls car ils sont uniquement destinés à apporter une fonctionnalité à un ou plusieurs logiciels ;
    • ils sont mis au point par des personnes n'ayant pas nécessairement de relation avec les auteurs du logiciel principal.
2 definition plugiciel1
2. Definition: plugiciel
  • L’ojectif derriere l’implementation des plugiciels est de permettre:
    • L’ajout des fonctionnalités sans avoir à tout reprogrammer
    • Permettre aux utilisateurs d'ajouter leurs propres fonctionnalités de manière indépendante
  • Cette indépendance inclut la possibilité pour le logiciel principal d'évoluer tout en restant compatible avec les plugiciels existants ; cette condition est cependant loin d'être toujours remplie.
2 chargement de plugiciel
2. Chargement de plugiciel
  • Dans les architectures statiques, la structure des plugiciel est définie avant le lancement du logiciel ( par exemple dans un fichier de configuration)
  • Dans les architectures dynamique c’est l’application qui va elle même recenser les plugiciels présents,
    • Très souvent par examen de fichiers présents dans un répertoire dédié aux plugiciels. Exemple Eclipse.
    • L’ajout et la suppression d’éléments dans le répertoire permet d’activer ou de désactiver les plugiciels correspondants.
    • Certaines applications permettent le démarrage et l’arrêt d’un plugiciel pendant son fonctionnement. On parle alors de configuration à chaud ou hot-plug
    • Toutefois, ce type d’architecture devient vite complexe du fait des dépendances qui peuvent exister entre les plugiciels.
un exemple de plugiciel1
Un exemple de plugiciel
  • Extensions
    • Points d’extension
      • point d'ancrage dans plugins
      • le “provide” des composants
      • ressemble à la déclaration d'une interface, le plugiciel informe qu’il est ouvert à l’ajout de nouvelles fonctionnalités d’une certaine façon
      • mais description en XML précisant la grammaire que les meta-data des extensions doivent suivre
    • Extension
      • greffon attaché à un point d'extension (déclaration de la nouvelle fonctionnalité d’extension)
      • le “require” des composants
      • ressemble à une liaison entre une interface et une implémentation (description XML suivant la grammaire spécifiée par le point d’extension)
un exemple de plugiciel2
Un exemple de plugiciel
  • Extensions
    • Registre des extensions (Extension Registry)
      • Match des points d’extensions aux extensions
      • Les plugiciel interrogent cette base pour connaître les extensions qui leurs sont proposées.
    • Chargement à la demande

http://www-master.ufr-info-p6.jussieu.fr/2006/Ajouts/Master_esj_2006_2007/IMG/pdf/Eclipse-plugins-slides.pdf

un exemple de plugiciel3
Un exemple de plugiciel
  • Extensions

[http://www.eclipsezone.com/articles/extensions-vs-services/images/extensions.png]

un exemple de plugiciel4
Un exemple de plugiciel
  • Illustration:
    • fonctionnement du point d'extension qui permet d'ajouter des pages de préférences dans la fenêtre des préférences d'Eclipse
    • Le plugiciel 'org.eclipse.ui', fourni par le framework Eclipse, définit un point d'extension nommé 'org.eclipse.ui.preferencePages'.
    • Le fichier 'preferencePages.exsd' contient la grammaire associée à ce point d'extension, en voici un extrait :
illustration de points d extensions
Illustration de points d’extensions
  • <element name="page">   <complexType>      <attribute name="id" type="string" use="required" />      <attribute name="name" type="string" use="required" />      <attribute name="class" type="string" use="required">         <annotation>            <appInfo>               <meta.attribute kind="java"                      basedOn="org.eclipse.jface.preference.PreferencePage:                                             org.eclipse.ui.IWorkbenchPreferencePage"/>               </appInfo>            </annotation>         </attribute>      <attribute name="category" type="string"/>   </complexType></element>
illustration de points d extensions1
Illustration de points d’extensions
  • Cette grammaire définit un élément XML nommé 'page' qui possède quatre attributs : 'id', 'name', et 'class'.
    • Pour l'attribut 'class', l'interface à implémenter est indiquée ('org.eclipse.ui.IWorkbenchPreferencePage') et dans ce cas précis une superclasse est aussi proposée ('org.eclipse.jface.preference.PreferencePage').
    • Les attributs 'id', 'name' et 'class' sont obligatoires.
illustration de points d extensions2
Illustration de points d’extensions
  • Pour ajouter une page de préférences, un plugin doit donc définir, dans son fichier plugin.xml, une extension sur le point d'extension 'org.eclipse.ui.preferencePages‘, et une classe indiquée par “class”

<?xml version="1.0" encoding="UTF-8"?><?eclipse version="3.2"?><plugin>   <extensionpoint="org.eclipse.ui.preferencePages">         <page          id="com.eclipsetotale.tutorial.pagepreference.page1"          name="Tutorial développement de plugin"class="com.eclipsetotale.tutorial.pagepreference.TutorialPreferencePage"         />   </extension></plugin>

illustration de points d extensions3
Illustration de points d’extensions

package com.eclipsetotale.tutorial.pagepreference;import org.eclipse.jface.preference.PreferencePage;...

public class TutorialPreferencePage extends PreferencePage       implements IWorkbenchPreferencePage {       protected Control createContents(Composite parent) {            Composite composite = new Composite(parent, SWT.NONE);            Color jaune = parent.getDisplay().getSystemColor(SWT.COLOR_YELLOW);            composite.setBackground(jaune);            return composite;      }      public void init(IWorkbench workbench) {      }}

Cette sous-classe de 'org.eclipse.jface.preference.PreferencePage' a pour responsabilité la gestion du contenu spécifique à la page de préférences ajoutée.

3 osgi
3. OSGi
  • Considérons une classe java faisant partie d’une application et implémentant une fonctionnalité.
    • Cette classe doit donc faire partie des .jar de l’application.
    • En cas de bug dans cette classe, l’application complète doit être arrêtée afin que celui-ci soit corrigé même s’il n’affecte qu’une sous-fonctionnalité très rarement utilisée.
  • La technologie OSGi permet de développer les fonctionnalités de façon indépendantes et de les intégrées dans l’application sous forme de services.
  • Ces services peuvent être reliées dynamiquement à l’application
  • Un service particulier pouvant être arrêté et mis à jour sans que le reste de l’application ne soit affecté.
3 osgi1
3. OSGi
  • OSGi (Open Service Gateway Initiative) a été fondé par Ericson, IBM, Oracle et Sun
  • Modèle à composants complet et dynamique
    • Complémente la machine virtuelle Java
    • Réduit la complexité : encapsulation, interface de programmation
    • Réutilisation : composants depuis l’étagère
    • Déploiement simplifié : gestion du cycle de vie
    • Mises à jour dynamiques : voir ci-dessus
    • Adaptation : les services peuvent aller et venir
    • Transparence : composants indépendants

[http://aneeshkumarkb.blogspot.com/]

slide19
Architecture

Bundles = composants

Services = publication, recherche et connexion dynamique d’objets Java

Life Cycle = gestion du cycle de vie des objets (démarrage, arrêt, mises à jours, installation,…)

Module = fonctions basiques de gestion (classloading, import, export,…)

Security = gestion des aspects de sécurité

Execution Environment = plateforme d’exécution

OSGi

[http://www.osgi.org]

slide20
OSGi
  • La spécification de OSGi définit comment les bundles (composants) doivent être implémentés afin d’être intégrés à la plateforme OSGi. Elle se structure de la manière suivante:
    • Un ensemble de services qu’un conteneur OSGi doit implémenter (Exple de conteneur: Equinox d’Eclipse)
    • Un contrat entre le conteneur et les application
osgi exemple
OSGi: Exemple
  • Etape 1: Télécharger et sauvegarder un conteneur OSGi: Equinoxe par exemple dans C:/lab
  • Etape 2: Créer la classe HelloOSGI.java suivante:

package test.osgi.helloworld;import org.osgi.framework.BundleActivator;import org.osgi.framework.BundleContext;public class Activator implements BundleActivator {public void start(BundleContext context) throws Exception {System.out.println("Hello World");}public void stop(BundleContext context) throws Exception {System.out.println("Bye Bye");}}

Cette classe est comme une classe main usuelle, la méthode start() est le point de démarrage du bundle (composant)

osgi exemple1
OSGi: Exemple
  • Etape 3: Mettre à jour le path et compiler la classe

# Set classpath=%classpath%;org.eclipse.osgi_3.4.0.v20080605-1900.jar

# javac -d . HelloOSGi.java

  • Etape 4: Créer un fichier manifeste MANIFEST.MF contenant:
osgi exemple2
OSGi: Exemple
  • MANIFEST.MF

Manifest-Version: 1.0Bundle-ManifestVersion: 2Bundle-Name: HelloWorld OSGiBundle-SymbolicName: test.osgi.HelloWorldBundle-Version: 1.0.0Bundle-Activator: test.osgi.helloworld.HelloOSGIImport-Package: org.osgi.framework

osgi exemple3
OSGi: Exemple
  • Bundle-ManifestVersion: indique que le composant suit la spécification OSGi
  • Bundle-Name: défini le nom du composant
  • Bundle-SymbolicName: défini un nom de référencement pour le composant (ce nom sera utilisé par les autres composants)
  • Bundle-Version: spécifie la version du composant
  • Bundle-Activator: spécifie le nom de la classe listener à notifier des démarrages et arrêts du composant.
  • Import-Package: définit les packages importés.
osgi exemple4
OSGi: Exemple
  • Etape 5: Créer ensuite le fichier bundle-jar# jar -cvmf MANIFEST.MF HelloOSGi.jar -C test/*
  • Etape 6: Démarrer le conteneur OSGi:

#java -jar org.eclipse.osgi_3.4.0.v20080605-1900.jar -console

Le prompt osgi> s’affichera.

  • Etape 7: Installer le bundle

osgi> install file:/C:/lab/HelloOSGi.jar

osgi exemple5
OSGi: Exemple

Etape 8: Puis démarrer le bundle (composant)

osgi> start file:/C:/lab/HelloOSGi.jar

Vous verrez « Hello World » s’imprimer dans la console, votre composant est prêt! 

slide27
OSGi
  • Architecture (cf. « Cours 5 - Cadres de reference et plugiciels (JAOO06-OSGi_Tutorial).pdf », pages 12–21)
  • Eclipse implemantion d’OSGi
    • Equinox (cf. « Cours 5 - Cadres de reference et plugiciels (JAOO06-OSGi_Tutorial).pdf », pages 22–26)
slide28
OSGi
  • Services d’enregistrement (cf. « Cours 5 - Cadres de reference et plugiciels (JAOO06-OSGi_Tutorial).pdf », pages 48–50)

[http://www.eclipsezone.com/articles/extensions-vs-services/images/extensions.png]

slide29
OSGi
  • Services d’enregistrement

[http://www.eclipsezone.com/articles/extensions-vs-services/images/extensions.png]

slide30
OSGi
  • Services d’enregistrement

public void start(BundleContext context) {

this.context = context;

}

public String getCustomerName(long id) {

ServiceReference ref = context.getServiceReference(

ICustomerLookup.class.getName());

if(ref != null) {

ICustomerLookup lookup = (ICustomerLookup)

context.getService(ref);

if(lookup != null) {

Customer cust = lookup.findById(id);

context.ungetService(ref);

return cust.getName();

}

}

// Couldn't get name -- service not available

return null;

}

public void start(BundleContext context) {

// Create the service object

DbCustomerLookup lookup =

new DbCustomerLookup(

"jdbc:mysql:localhost/customers");

// Create the properties to register with the service

Dictionary properties = new Hashtable();

properties.put("dbname", "local");

// Register the service

context.registerService(

ICustomerLookup.class.getName(),

lookup, properties);

}

[http://www.eclipsezone.com/articles/extensions-vs-services/images/extensions.png]

slide32
OSGi
  • Collaborative model (cf. « Cours 5 - Cadres de reference et plugiciels (JAOO06-OSGi_Tutorial).pdf », pages 41–51)
  • Component model (cf. « Cours 5 - Cadres de reference et plugiciels (JAOO06-OSGi_Tutorial).pdf », pages 52–58)
  • Example(cf. « Cours 5 - Cadres de reference et plugiciels (JAOO06-OSGi_Tutorial).pdf », pages 27–40)
4 gestion du cycle de vie
4. Gestion du cycle de vie
  • Gestion de besoin
  • Architecture
  • Implantation
  • Test
  • Suivi des problèmes
  • Gestion des versions
gestion du cycle de vie
Gestion du cycle de vie
  • Problème de la traçabilité
    • Besoins – conception
    • Besoins – code
    • Besoins – tests
    • Besoins – bogues
    • Besoins – versions
    • Code – tests
    • Code – bogues
    • Code – versions