Voici rapidement les quelques nouveautés apportées par cette version :

=> Utilisation de Scrum comme processus de développement (c’est bien comme ça qu’on l’appèlle hein ?)
=> Premier support de la notion de plans : pensez les features d’Eclipse. Je tiens à préciser que j’avais abandonné DM Server 1 à cause de la notion de PAR, une sorte de regroupement de bundles dans un archive, ce qui va tout simplement à l’encontre de l’essence de l’OSGi. Avec les plans, un simple descripteur xml d’un ensemble de bundles, je crois qu’une ré-évaluation des choses s’impose
=> Premier support de la notion de cloning : j’ai pas encore approfondi ma lecture la dessus, je peux donc pas présenter ce que c’est.

Voici maintenant quelques liens clés :
=> Annonce
=> Téléchargement
=> Release notes
=> Doc : Getting Started, User Guide, Dev Guide

1. Vue d’ensemble

L’application que je vais utiliser comme exemple est simpliste : elle ne sert qu’à afficher une liste de personnes (peu importe comment cette liste est retrouvée) dans une page web.

Seulement, histoire de faire propre, je vais découper cette application en 4 bundles:

1. domain: C’est un bundle qui définit les objets métier (un seul dans notre cas: Person)
2. service-api: C’est un bundle qui définit les interfaces (contrats) de la couche métier
3. service-impl: C’est un bundle qui définit les implémentations des services mais aussi les exporte en tant que services OSGi qui seront consommés par le dernier bundle.
4. web-frontend: C’est un bundle qui définit le front-end web de l’application et qui consomme les services exposés par service-impl

N.B.: Je suppose tout au long de ce billet que le serveur S2AP ainsi que le tooling Eclipse correspondant est déjà en place comme je le montre ici.

2. Créer le bundle domain

Dans Eclipse, lancez le wizard « New Bundle Project » :

Saisissez un nom parlant pour ce bundle (djo.s2ap.demo.domain pour moi) et cliquez sur Next.
Là, et c’est une nouveauté dans le tooling S2AP pour Eclipse (sur une suggestion de ma part, merci à Christian Dupuis qui l’a implémenté), il est possible de choisir le type du bundle (None ou Web) :

Choissisez None et validez.
Créer un package dans le dossier src (j’utilise habituellement le nom du projet comme package de base), et créez une classe Person (forcément, mon type de données préféré )

package djo.s2ap.demo.domain; 

 

public class Person { 

  private String name; 

  private int age; 

 

  public Person(String name, int age) { 

    super(); 

    this.name = name; 

    this.age = age; 

  } 

 

  public String getName() { 

    return name; 

  } 

 

  public void setName(String name) { 

    this.name = name; 

  } 

 

  public int getAge() { 

    return age; 

  } 

 

  public void setAge(int age) { 

    this.age = age; 

  } 

 

}

Je vais me contenter de cette classe comme mon domaine.

Il faut ensuite exporter le package de cette classe pour qu’elle soit visible aux autres bundles.
Pour ce faire, localisez le fichier src/META-INF/MANIFEST.MF et double-cliquez la dessus, ce qui ouvre l’éditeur de manifest de STS (encore une fonctionnalité proposé par l’auteur de ce billet (moi) et implémentée par l’equipe STS (re-merci) !).
Dans l’éditeur multi-pages qui se lance, localisez la page « Runtime » et activer la.
A gauche, vous trouverez une liste présentant les packages exportés par le bundle en question. Cliquez sur le bouton « Add » et dans la fenêtre qui s’affiche, sélectionnez l’unique package présent (djo.s2ap.demo.domain).

Sinon, il est toujours possible de travailler directement sur le manifest en utilisant le contenu suivant:

Manifest-Version: 1.0 

Bundle-Version: 1.0.0 

Bundle-Name: Domain Bundle 

Bundle-ManifestVersion: 2 

Bundle-SymbolicName: djo.s2ap.demo.domain 

Export-Package: djo.s2ap.demo.domain

Voilà, le premier bundle est prêt.

3. Créer le bundle service-api

Comme énoncé plus haut, ce bundle va juste définir les contrats des services (sous forme d’interfaces). C’est LE pattern OSGi à mon avis, i.e. séparer l’interface de l’implémentation dans des bundles différents, histoire de pouvoir changer (mettre à jour, corriger des bugs, peaufiner, etc.) l’implémentation séparément de son interface mais aussi pour éviter que le consommateur d’un service ne dépende de son implémentation.

Dans le cadre de cette application exemple, je vais me contenter d’un seul service exposant une seule fonctionnalité qui est de récupérer une liste de personnes.

Commencez par créer un autre bundle nommé « djo.s2ap.demo.service.api » dans mon cas (même procédure que pour le bundle domain, choisissez « None » comme personality).
Ce bundle aura besoin de voir la classe Person du bundle domain.
Or, justement, j’ai exporté le package contenant cette classe. Il ne reste plus qu’à importer ce package dans le bundle service.api.

Pour ce faire, localisez et double-cliquez sur le fichier « src/META-INF/MANIFEST.MF » du bundle service.api.
Dans l’éditeur multi-pages qui s’affiche, activez la page « Dependencies ».
Dans la liste à gauche (Import Package », cliquez sur Add, et localisez le package « djo.s2ap.demo.domain » contenant la classe Person (utilisez le filtre):

Sélectionnez ce package et validez.
Ainsi, la classe Person devient visible dans le second bundle.

Créez ensuite un package « djo.s2ap.demo.service.api » avec une interface IPersonRepository dont voici le code:

package djo.s2ap.demo.service.api; 

 

import java.util.List; 

 

import djo.s2ap.demo.domain.Person; 

 

public interface IPersonRepository { 

  List<Person> getPersonsList(); 

}

Pour finir, il faut exporter le package qui définit cette interface car l’implémentation de ce service aura besoin d’y accéder.
Donc, comme montré plus haut, exportez le package « djo.s2ap.demo.service.api » en utilisant soit l’editeur graphique du manifest ou en jouant directement sur le manifest.

4. to be continued

Faute d’espace et de temps, je vais m’arrêter là pour ce billet et je finirais la chose bientôt dans un autre billet.

Toujours faute de temps, mais aussi à cause du fait que j’ai abandonné S2DMS, j’arrive pas à finir le second volet
J’espère au moins pouvoir parler des raisons du pourquoi j’ai abandonné cette plateforme (1 raison plus précisément, la notion de PAR)

Pour rappel, SpringSource DM Server est une nouvelle génération de serveurs Java offrant OSGi comme modèle de programmation (qui utilise Spring Dynamic Modules en interne).

Quelques nouveautés:

• Renommage de SpringSource Application Platform à SpringSource DM Server
• Utilisation de Tomcat 6.0.18
• Quelques renommage de classes
• Bug fixes

La version finale est prévue dans 2 semaines.

A noter qu’il faut s’enregistrer dans leur programme Beta pour pouvoir télécharger SpringSource DM Server.

Le serveur et le client sont architecturés comme suit:

• Le serveur est un ensemble de bundles OSGi tournant sur S2AP (beta 8) composé comme suit:
  • un bundle définissant un PAO
  • un bundle définissant l’interface d’un DAO
  • un bundle définissant une implémentation du DAO utilisant Spring JDBC, MySQL et Apache DBCP
  • un bundle exposant ce DAO pour accès distant via Hessian/Spring
• Le client est une application à base d’Eclipse RCP (3.4) qui est constitué de :
  • un bundle définissant un PAO (exactement le même que celui deployé dans le serveur)
  • un bundle définissant l’interface d’un DAO (exactement le même que celui deployé dans le serveur)
  • un bundle qui importe le DAO distant (toujours via Hessian/Spring) et l’expose en tant que Service OSGi (via Spring DM)
  • un plug-in qui définit l’aplication RCP
  • un plug-in qui ddéfinit une perspective et une vue affichant la liste des PAOs récupérés par le DAO distant tournant sur le serveur.

Ca m’a pris 2 jours (plus précisément 2 demi-journées et 1 nuit blanche), et même si le résultat est juste un proof-of-concept, sa mise en place etait vraiment douleureuse.

Je compte donc faire partager cette expérience en montrant, captures, explications et sources à l’appui, comment réaliser celà, enfin, si ça intéresse quelqu’un

Par contre, j’hésite encore sur le format : soit une série de billets dans ce blog, ou encore un article en bonne et due forme. Toutefois, ça risque de prendre du temps quand même …

1.Préparation de l’environnement

1.1. Téléchargement et installation du serveur S2AP

Le serveur S2AP peut être téléchargé ici moyennant l’inscription dans le programme Beta de SpringSource (rien d’effrayant: juste un un petit formulaire à remplir, et hop).
Notez que la plateforme est divisée en deux paquetages (à cause d’histoires de licences):
– springsource-ap-1.0.0.beta2.zip
– springsource-ap-epl-1.0.0.beta2.zip

Téléchargez les deux paquetages, et à moins que vous ne soyez sur Gnome 2.22 (comme je le suis) qui offre une fonctionnalité de merge super-utile, l’installation va être un peu ennuyante:
– Extraire les deux archives (ils portent le même nom, donc, il faut les extraire dans des dossiers séparés)
– Déplacer tous les fichiers du second paquetage dans l’emplacement adéquat à l’intérieur du dossier d’extraction du premier paquetage.
– Voilà. Le User guide de S2AP indique qu’il faut renseigner une variable d’environnement PLATFORM_HOME mais je ne l’ai pas fait, et ça tourne sans problèmes …

Pour tester si tout s’est bien passé, allez au dossier d’installation puis au sous dossier bin et lancez startup.sh (ou .bat, selon votre plateforme). Vous devriez avoir dans la console un log similaire à celui-ci:

[2008-05-12 14:38:41.654] main                     <SPKB0001I> Platform starting. 

[2008-05-12 14:38:46.198] main             <SPKE0000I> Boot subsystems installed. 

[2008-05-12 14:38:47.441] main             <SPKE0001I> Base subsystems installed. 

[2008-05-12 14:38:50.554] platform-dm-14   <SPPM0000I> Installing profile 'web'. 

[2008-05-12 14:38:53.787] platform-dm-14   <SPPM0001I> Installed profile 'web'. 

[2008-05-12 14:38:54.222] platform-dm-1    <SPSC0001I> Starting ServletContainer on port 8080 and SSL port 8443. 

[2008-05-12 14:38:55.083] platform-dm-9    <SPPM0002I> Platform open for business with profile 'web'. 

[2008-05-12 14:38:56.329] fs-watcher      <SPSC1000I> Creating web application '/'. 

[2008-05-12 14:38:56.448] async-delivery-thread-1  <SPSC1001I> Starting web application '/'. 

[2008-05-12 14:38:56.872] fs-watcher               <SPDE0010I> Deployment of 'platform.admin.splash- 

1.0.0.beta2.war' version '0' completed. 

[2008-05-12 14:38:58.281] fs-watcher               <SPSC1000I> Creating web application '/admin'. 

[2008-05-12 14:38:58.579] async-delivery-thread-1  <SPSC1001I> Starting web application '/admin'. 

[2008-05-12 14:38:59.405] fs-watcher               <SPDE0010I> Deployment of 'platform.admin.web- 

1.0.0.beta2.war' version '0' completed.

Lancez ensuite le navigateur avec l’adress localhost:8080, et vous devriez avoir un belle page avec le logo SpringSource.

Arretez le serveur si c’est bon (Ctrl+C ou encore en lancant shutdown.sh (ou .bat)), sinon, essayez de ragarder dans le JIRA de S2AP ou encore dans le forum de S2AP (qui ne sont accessibles qu’après enregistrement dans ledit programme beta) s’il n’y a pas de problème similaires.

1.2. Mise en place du tooling eclipse

Le tooling eclipse relatif à S2AP consiste en:

• Spring IDE 2.0.5 beta:

  http://springide.org/updatesite-weekly

  Spring IDE 2.0.5 final: Ajoutez l’update site suivant dans eclipse:

  http://springide.org/updatesite

• SpringSource Tool Suite: Ajoutez l’update site suivant:

  http://static.springsource.com/projects/sts-ap/nightly/

Vérifiez ensuite que vous avez les wizards suivants dans New:

Il faut ensuite ajouter le serveur S2AP dans la liste des serveurs connus d’eclipse.
Pour ce faire, dans eclipse, allez dans Window, Preferences, Server, Installed Runtimes, et cliquez sur le bouton Add

Dans la fenêtre qui s’affiche, vous trouverez un section SpringSource ainsi qu’un type de serveur (adpater) SpringSource AP v1.0. Sélectionnez ce type et cliquez sur « Next »:

Dans la page suivante, localisez l’emplacement de S2AP et validez.

2. Développement d’applications pour S2AP

2.1. Création d’un bundle:

Dans eclipse, Sélectionnez File, New, Other. Dans la liste, localisez la section SpringSource AP et sélectionnez « Bundle Project » puis « Next » :

Saisissez un nom pour le projet et cliquez sur « Next »:

Dans la dernière page, veuillez juste à sélectionner le serveur qu’on vient de créer dans le drop down « Target Runtime » et validez.

Le projet généré ainsi contient d’office un dossier META-INF et un fichier manifest avec une configuration minimale:

2.2. Déploiement du bundle:

Pour déployer le bundle sur le serveur, il faut localiser le serveur S2AP (qu’on vient de créer) dans la vue Servers:

Dans son menu contexuel, choisissez « Add and Remove Projects », ce qui affiche une double liste:

qui permet de deployer ou de undeployer les bundles.

2.3. Contrôle du serveur:

Comme pour tous les autres serveurs sous eclipse, S2AP se contrôle comme d’habitude (via les boutons Start, Stop, etc.) de la vue Servers:

=> Annonce ici

Plus de détails dans des billets ultérieurs.

A noter qu’il faut s’enregistrer dans leur programme Beta pour pouvoir télécharger la chose.

SpringSource voulait initialement fournir une nouvelle méthode pour la configuration d’une application web, qui utilise le manifest au lieu de l’habituel web.xml.

Seulement, dans les premières versions (et même jusqu’à la plus récente), les paramètres de configuration étaient limités comparé à ceux offerts par web.xml, ce qui a fait que plusieurs frameworks webs ne pouvaient pas être utilisés dans un bundle web de S2AP.

Pour Wicket, ce qui manquait avant, c’était:

1. La possibilité de déclarer une servlet/filtre dans le manifest des bundles. Ce point a été adressé (quoi que partiellement) en donnant la possibilité de spécifer des servlets dans le manifest (mais pas les filtres, utilisés par Wicket depuis la version 1.3).
2. Mais surtout la possibilité de spécifier les init-params des servlets/filtres depuis le manifest.
3. enfin, les méta-données OSGi dans la distribution wicket.

S2AP beta 5 a donc résolu les deux premiers points en donnant la possibilité d’utiliser le bon vieux web.xml dans les bundles, ce qui nous permet donc de déclarer le filtre de Wicket, son mapping ainsi que l’init-param « applicationClassName« .

Le dernier point a lui été adressé par l’équipe de Wicket qui ont inclus ledits méta-données OSGi dans les manifest des jars de Wicket 1.4 (disponible actuellement en version « Milestone 2« ).

Bon, en réalité, il y’avaient quelques problèmes dans ces méta-données comme ici par exemple ou encore ici, mais l’équipe Wicket est suffisamment réactive et rapide pour que ces détails soient réglées en quelques jours.

remarque aussi que l’équipe de S2AP est en train d’OSGi’fier la distribution actuelle de Wicket (1.3.3) (suivi ici).

Voici maintenant comment créer un bundle Wicket-powered:

Serveur

Assurez vous que vous avez S2AP beta 5 qui soit installée sur votre disque (« /home/djo/Java/servers/springsource-ap-1.0.0.beta5/ » dans mon cas).

Installer les jars OSGi’fiés de Wicket

Téléchargez ensuite la distribtion Wicket 1.4 M2 (téléchargeable ici) et décompressez la. Copiez le fichier « wicket-1.4-m2.jar » du dossier lib vers le dossier « repository/bundles/usr » de S2AP (« /home/djo/Java/servers/springsource-ap-1.0.0.beta5/repository/bundles/usr » dans mon cas).

Installer les jars OSGi’fiés de SLF4J (enfin presque)

Il nous faut aussi Slf4j, donc, normalement, il faut se rendre dans le respository de SpringSource pour récupérer les jars OSGI’fiés de Slf4j et « Slf4j log4j binding » et les copier dans le dossier « repository/bundles/usr« , mais je vais montrer une autre façon beaucoup plus pratique pour le faire.

Installer le tooling eclipse

Dans eclipse, assurez vous que le tooling de SpringSource (ainsi que Spring IDE) est mis en place comme montré ici.

Installer les jars OSGi’fiés de SLF4J (pour de vrai)

Dans la vue Servers, double cliquez sur le serveur S2AP et dans la fenêtre qui s’affiche, activer l’onglet repository.
Cette vue (éditeur en fait) permet de rechercher et récupérer des jars depuis le repository S2, le tout depuis eclipse.
Effectuez une recherche sur slf4j, cochez SLF4J API et SLF4J LOG4J Binding et cliquez sur download => Et hop, ils seront ajoutés dans le repository de S2AP.

Le manifest

Créez un nouveau bundle (nommé « djo.s2ap.wicket » dans mon cas) et modifiez son manifest comme ceci:

Manifest-Version: 1.0 

Bundle-Version: 1.0.0 

Bundle-Name: Wick Bundle 

Bundle-ManifestVersion: 2 

Web-ContextPath: wicket 

Bundle-SymbolicName: djo.s2ap.wicket 

Platform-ModuleType: Web 

Import-Package:  

 org.apache.wicket, 

 org.apache.wicket.markup.html, 

 org.apache.wicket.markup.html.basic, 

 org.apache.wicket.model, 

 org.apache.wicket.protocol.http, 

 org.apache.wicket.behavior, 

 org.apache.wicket.ajax, 

 org.apache.wicket.util.time, 

 org.slf4j

Le fragment de web.xml

Créez ensuite un dossier WEB-INF dans le dossier src du bundle, et un fichier web.xml ladedans avec ce contenu:

<?xml version="1.0" encoding="UTF-8"?> 

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

  xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 

  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 

  id="WebApp_ID" version="2.5"> 

  <display-name>wicket</display-name> 

  <filter> 

    <filter-name>WicketApplication</filter-name> 

    <filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-class> 

    <init-param> 

      <param-name>applicationClassName</param-name> 

      <param-value>djo.s2ap.wicket.MyApp</param-value> 

    </init-param> 

  </filter> 

  <filter-mapping> 

    <filter-name>WicketApplication</filter-name> 

    <url-pattern>/*</url-pattern> 

  </filter-mapping> 

</web-app>

L’infrastructure Wicket

Créez un package « djo.s2ap.wicket ». dans ce package, on crée comme d’habitude pour Wicket une classe pour l’application, une classe et une page html pour la page d’accueil.

Classe de la page d’accueil

package djo.s2ap.wicket; 

 

import java.text.DateFormat; 

import java.text.SimpleDateFormat; 

import java.util.Date; 

 

import org.apache.wicket.ajax.AjaxSelfUpdatingTimerBehavior; 

import org.apache.wicket.markup.html.WebPage; 

import org.apache.wicket.markup.html.basic.Label; 

import org.apache.wicket.model.LoadableDetachableModel; 

import org.apache.wicket.util.time.Duration; 

 

public class MainPage extends WebPage<MainPage> { 

  private static final DateFormat df = new SimpleDateFormat("HH:mm:ss"); 

 

  public MainPage() { 

 

    final Label<String> currentTime = new Label<String>("time", 

        new LoadableDetachableModel<String>() { 

          @Override 

          protected String load() { 

            return df.format(new Date()); 

          } 

 

        }); 

    currentTime.add(new AjaxSelfUpdatingTimerBehavior(Duration.ONE_SECOND)); 

    add(currentTime); 

  } 

}

Page HTML de la page d’accueil (MainPage.html)

<?xml version="1.0" encoding="UTF-8" ?> 

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 

<html xmlns="http://www.w3.org/1999/xhtml"> 

<head> 

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> 

<title>Test</title> 

 

</head> 

<body> 

<span wicket:id="time">...</span> 

</body> 

</html>

Classe de l’application

package djo.s2ap.wicket; 

 

import org.apache.wicket.protocol.http.WebApplication; 

 

public class MyApp extends WebApplication { 

 

  @Override 

  public Class getHomePage() { 

    return MainPage.class; 

  } 

 

}

Déploiement et test

Et voilà : reste plus qu’à deployer et tester la chose.

En ce qui me concerne, j’arrive pas à lancer un bundle depuis eclipse, donc je procède manuellement en exportant le projet du bundle en jar (via le wizard standard d’eclipse). Il faut juste faire attention à utiliser le manifest du projet comme manifest du jar.

Je place ensuite le jar généré dans le dossier pickup de s2AP (/home/djo/Java/servers/springsource-ap-1.0.0.beta5/pickup) et je démarres le serveur (depuis eclipse ou via bin/startup.sh).
Tapez ensuite l’adresse suivante dans le navigateur:

http://localhost:8080/wicket/

et hop, j’ai une page qui affiche le temps courant en temps réel (enfin presque, rafraichissement ajax chaque seconde).

Sources

Le jar en question (ainsi que les sources) peuvent être téléchargées ici.

TODO

Dans un futur billet, je vais montrer comment utiliser Spring avec Wicket pour retrouver un service OSGi exporté par un autre bundle.