NMaven dans la software-factory .NET

V. Etapes de la mise en oeuvre de NMaven▲

V-1. Pré-réquis▲

Nmaven est par définition un ensemble de plugin de l'outil Maven. Cela impose donc une installation préalable de ce dernier.

V-1-1. Installation du JDK Java▲

Vous pouvez trouver le JDK Java ici: http://java.sun.com/javase/downloads/index.jspJDK

V-1-2. Installation de Maven▲

Vous pouvez télécharger Maven à partir du site de ce projet sur apache à l'adresse: http://maven.apache.org/download.htmlMaven 2.0.9
NOTE: Nmaven ne marche qu'avec les versions 2.0.9 et ultérieure.

Vous aller donc télécharger une archive qui faudra décompresser à un endroit de votre disque (Exemple : G:\apache-maven-2.0.9). Le contenu de l'archive correspond au schéma ci-après.

La suite de l'installation consiste à mettre à jour les variables d'environnement de votre système comme suit:
Créer les variables M2_HOME, M2, M2_REPO qui pointe vers votre répertoire d'installation.

Figure 6 : variables M2_HOME, M2, M2_REPO

Ajouter à la variable PATH la valeur de M2. Ceci ce fait en ajoutant simplement à la fin de la valeur du PATH, la chaine " ;%M2% ".

Sélectionnez

JAVA_HOME = G:\Program Files\JAVA\jdk1.6.0_O1	// rep. d'installation JDK
M2_HOME = G:\apache-maven-2.0.9   		// Répertoire d'installation
M2 = %M2_HOME%\bin  		// Bin du répertoire d'installation
M2_REPO = D:\MAVEN-REPO  	// répertoire de votre repo Local
Path = "ancien_valeur";%M2%

V-2. Installation de NMaven et configuration du setting.xml▲

V-2-1. Télécharger le code▲

Le code source de Nmaven est disponible sur un serveur SVN à l'adresse: https://svn.apache.org/repos/asf/incubator/nmaven/trunkNMaven
Le rapatriement peut se faire avec un client SVN comme "TortoiseSVN".
Pour plus de détails se rendre sur le site de Nmaven: http://nmaven.codeplex.com/NMaven

V-2-2. Configuration du fichier setting.xml▲

Le fichier setting.xml se trouve dans le répertoire "conf" du lieu ou est installé Maven sur votre poste de travail (exemple : G:\apache-maven-2.0.9\conf). Ce fichier contient l'essentiel des configurations de base Maven : entre autre le lieu où se trouve le repository local, les repository proxy s'il y'en a, ainsi que les repository distants. Les configurations par défaut pointent sur le repository distant (Maven Central).
Pour un début nous allons simplement modifier le lieu où doit se trouver le repository local.

Sélectionnez

<localRepository>D:/maven-repo</localRepository>

V-2-3. Installation▲

Nmaven est un projet avec la structure Maven. Son installation correspond simplement à une installation des artéfacts dans votre repository local:

- Lancer la console de commande.
- Se rendre au niveau du répertoire où est rapatrié le code de Nmaven.
- Taper la commande "mvn install".

V-3. Gestion des ressources avec NMaven▲

NMaven dans sa version actuelle ne gère pas les ressources des projets. Koossery Technology a développé un plugin pour remédier à cela. Vous pouvez le télécharger sur le lien suivant: plugin NMaven pour la gestion des ressources dans le cycle de vieplugin NMaven pour la gestion des ressources dans le cycle de vie.
Les instructions d'installation se trouvent dans l'archive que vous aurez téléchargée.

La notion de ressource est un concept étendu dans le monde .NET. Il en existe à peu près quatre qui requièrent chacune une gestion spécifique lors de la phase de compilation. Le plugin développé redéfini certaines phases du cycle de vie en y insérant du code spécifique pour la gestion des ressources. Les phases redéfinies sont les suivantes:

generate-sources: génère le code source supplémentaire nécessité par l'application, ce qui est généralement accompli par des plug-ins appropriés.
compile: compile le code source du projet.
test-compile: compile les tests unitaires du projet.

Pour installer le plugin il suffit de télécharger le plugin, de lancer la fenêtre de commandes cmd, de vous placer dans le répertoire racine du plugin et d'exécuter la commande:

Sélectionnez

mvn install

Comment utiliser le plugin ?

Considérons un projet P contenant plusieurs modules m1, m2, m3, etc. Dans le pom parent on configure le plugin au niveau de la section pluginManagement c'est à dire :

Sélectionnez

<pluginManagement>
      <plugins>
        <plugin>
          <groupId>com.koossery.maven.dotnet.plugins</groupId>
          <artifactId>maven-koossery-plugin</artifactId>
          <extensions>true</extensions>
          <configuration>
            <resources>
              <resource>
                <directory>${project.basedir}/src/main/resources/resource</directory>
                <includes>
                  <include>**/**.xml</include>
                </includes>
                <namespace>src.main.resources.resource</namespace>
                <type>resource</type>
              </resource>
              <resource>
                <directory>${project.basedir}/src/main/csharp</directory>
                <includes>
                  <include>**/**.resx</include>
                </includes>
                <namespace>src.main.csharp</namespace>
                <type>resource</type>
              </resource>
              <resource>
                <directory>${project.basedir}/src/main/resources/linkresource</directory>
                <includes>
                  <include>**/**.xml</include>
                  <include>**/**.config</include>
                </includes>
                <namespace>src.main.resources.linkresource</namespace>
                <type>linkresource</type>
              </resource>
              <resource>
                <directory>${project.basedir}/src/main/resources/win32Icon</directory>
                <includes>
                  <include>Icon1.ico</include>
                </includes>
                <namespace>src.main.resources.win32Icon</namespace>
                <type>win32Icon</type>
              </resource>
            </resources>
          </configuration>
        </plugin>
        <plugin>
          <groupId>org.apache.maven.dotnet.plugins</groupId>
          <artifactId>maven-dotnet-test-plugin</artifactId>
          <extensions>true</extensions>
          <configuration>
            <resources>
              <resource>
                <directory>${project.basedir}/src/main/resources/linkresource</directory>
                <includes>
                  <include>**/**.xml</include>
                  <include>**/**.config</include>
                </includes>
                <namespace>src.main.resources.linkresource</namespace>
                <type>linkresource</type>
              </resource>
            </resources>
          </configuration>
        </plugin>
      </plugins>
    </pluginManagement>

Dans la configuration ci-dessus toutes les ressources du projet doivent être explicitement définies dans la sous-section configuration du plugin utilisé. Pour chaque ressource on renseigne son type, le répertoire où la trouver, les fichiers à inclure via leur extension; on peut aussi explicitement indiquer les fichiers ressources à exclure.

Dans les pom des modules on signale juste le plugin sachant qu'il va alors hériter des configurations faites au niveau du pom parent.

Sélectionnez

<sourceDirectory>.</sourceDirectory>
    <testSourceDirectory>./src/test/csharp</testSourceDirectory>

    <resources>
      <resource>
        <directory>src/test/resources</directory>
        <includes>
          <include>**/**.xml</include>
        </includes>
      </resource>
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/**.*</include>
        </includes>
      </resource>
    </resources>
    <plugins>
      <plugin>
        <groupId>com.koossery.maven.dotnet.plugins</groupId>
        <artifactId>maven-koossery-plugin</artifactId>
        <extensions>true</extensions>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.dotnet.plugins</groupId>
        <artifactId>maven-dotnet-test-plugin</artifactId>
        <extensions>true</extensions>
      </plugin>      
    </plugins>

V-4. Configuration NMaven - Visual Studio▲

Pour des besoins de convivialité pour les développements, il est nécessaire d'avoir l'essentiel des outils de développement dans son IDE. Koossery Technology est entrain de développer un Addin Visual Studio pour réaliser l'essentiel des taches NMaven à partir de notre IDE VStd.
Cet Addin sera mis à disposition prochainement.

V-5. Installation et configuration d'un repository interne à l'aide de Nexus ▲

La documentation de référence de Nexus se trouve à l'adresse: http://www.sonatype.com/books/nexus-book/reference/.Repo Interne Nexus

V-5-1. Téléchargement de Nexus Open Source▲

Nexus existe en deux versions:

- Nexus Open Source: http://nexus.sonatype.org/using/download.htmlNexus Open Source
- Nexus Profesionnal: http://www.sonatype.com/products/downloadsNexus Professional

V-5-2. Installation d'un repository interne Nexus▲

- Décompresser l'archive téléchargée dans un répertoire de votre choix.
- Se rendre dans le répertoire "xxx\yyy\nexus-webapp-1.0.1\bin\jsw\windows-x86-32"
- Lancer le fichier "installNexus.bat"
- Puis lancer (si nexus n'est pas encore lancé) le fichier "StartNexus.bat"

V-5-3. Configuration du repository interne Nexus▲

Vérifier par la suite si l'installation s'est bien passée en se connectant à cette application via l'explorateur Web avec l'adresse: "http://localhost:8080/nexus" ou plus précisement "http://nom_du_serveur:port/nexus".

La suite porte alors sur les configurations des repository distants où le serveur Nexus ira faire les recherches d'artefacts s'il ne les trouve pas à son niveau.

Les configurations par défaut de Nexus sont dans l'ensemble suffisantes pour une utilisation basique (simple repository proxy). Cependant pour d'autres configurations (comme la création d'un repository pour les artéfacts que vous aurez vous-même produits), lire http://www.sonatype.com/books/nexus-book/reference/config.htmlNexus Reference Book.

Il faut noter que Nexus se comporte comme une agrégation de Repository c'est-à-dire qu'au niveau de Nexus on peut définir plusieurs repository en fonction des besoins. Par exemple onpourrait configurer unrepository pour les snapshots, un pour les releases,etc.

Nexus propose par la suite la notion de "Repository Groups". Il s'agit d'une sorte de porte d'entrée unique pour réaliser les recherches sur un ensemble de repository; c'est-à-dire qu'au lieu de définir plusieurs repository dans mon fichier settings, je vais plutôt pointer vers le " repository group " et ensuite aller définir sur Nexus ce "repository groups" qui contiendra tous les repository que je suis supposé utiliser.

Dans la figure ci-dessous vous avez la définition d'un "repository groups" (Public Repositories) qui regroupe par défaut l'ensemble des repository public que les projets utilisent par défaut.

Figure 10 : exemple de repository group avec Nexus

V-5-4. Configurer NMaven pour utilisation de Nexus▲

La configuration de NMaven pour une utilisation de Nexus se fait au niveau du fichier "settings.xml". Voici un exemple de configuration du fichier settings.xml

Sélectionnez

<settings>
  <localRepository>D:/maven-repo</localRepository> 
  
  <servers>
    <server>
      <id>releases</id>
      <username>koossery</username>
      <password>#tochange00</password>
    </server>	
   </servers>
   <pluginGroups>
	  <pluginGroup>org.apache.maven.dotnet.koossery.plugins</pluginGroup>
   </pluginGroups>

  <mirrors>
    <mirror>
      <!--This is used to direct the public snapshots repo in the --> 
	  <!--profile below over to a different nexus group -->
      <id>nexus-public-snapshots</id>
      <mirrorOf>*snapshots*</mirrorOf>
      <url>http://192.168.100.30:8081/nexus/content/groups/public-snapshots</url>
    </mirror>
    <mirror>
      <!--This sends everything else to /public -->
      <id>nexus</id>	  
      <mirrorOf>!*snapshots*</mirrorOf>     
	  <url>http://192.168.100.30:8081/nexus/content/groups/public</url>
    </mirror>
  </mirrors>
  
  <profiles>
    <profile>
      <id>development</id>
      <repositories>
        <repository>
          <id>central</id>
          <url>http://central</url>
          <releases><enabled>true</enabled></releases>
          <snapshots><enabled>true</enabled></snapshots>
        </repository>
      </repositories>
     <pluginRepositories>
        <pluginRepository>
          <id>central</id>
          <url>http://central</url>
          <releases><enabled>true</enabled></releases>
          <snapshots><enabled>false</enabled></snapshots>
        </pluginRepository>
      </pluginRepositories>
    </profile>
    <profile> 
      <!--this profile will allow snapshots to be searched when activated-->
     <id>public-snapshots</id>
      <repositories>
        <repository>
          <id>public-snapshots</id>
          <url>http://public-snapshots</url>
          <releases><enabled>false</enabled></releases>
          <snapshots><enabled>true</enabled></snapshots>
        </repository>
      </repositories>
     <pluginRepositories>
        <pluginRepository>
          <id>public-snapshots</id>
          <url>http://public-snapshots</url>
          <releases><enabled>false</enabled></releases>
          <snapshots><enabled>true</enabled></snapshots>
        </pluginRepository>
      </pluginRepositories>
    </profile>
  </profiles>
  <activeProfiles>
	<activeProfile>public-snapshots</activeProfile>
    <activeProfile>development</activeProfile>	
  </activeProfiles> 
</settings>

Dans cet exemple nous avons principalement 4 sections qui nous intéressent:

- Servers: dans cette section on définit le compte et mot de passe pour accéder à un repository précis de Nexus. Dans cet exemple nous avons défini un compte (koossery) et un mot de passe (#tochange00) pour le repository dont l'id est "releases".

- Mirrors: dans cette section on définit les miroirs. Ils permettent de donner l'url (élément Url) vers laquelle maven ira chercher un artéfact en fonction de son nom (expression régulière définie au niveau de mirrorOf). Notez ici que les adresses sont ceux du "repository group" pour la plupart des cas.

- Profile : C'est ici qu'on définit les profils avec pour chaque profil l'ensemble des repositories dans lesquels maven ira chercher les artefacts. Il y'a utilisation implicite des miroirs pour déterminer les adresses des repositories.

- ActiveProfiles : c'est ici qu'on décide quels profils sont actifs et lesquels ne le sont pas.