Affichage des articles dont le libellé est maven. Afficher tous les articles
Affichage des articles dont le libellé est maven. Afficher tous les articles

lundi 21 février 2011

deploiement d'un fichier

Pour déployer un fichier sur archiva :

mvn deploy:deploy-file -Dfile=gwt-servlet.jar -DgroupId=com.google.gwt -DartifactId= -Dversion=1.3.0 -Dpackaging=jar -DrepositoryId=archiva.internal -Durl=http://archiva/repository/internal -DgeneratePom=true

Attention a bien fournir le proxy correct (https) et a fournir le user Id

 <proxies>
     <proxy>
      <id>optional</id>
      <active>true</active>
      <protocol>http https</protocol>
      <host>proxy.mdp</host>
      <port>3128</port>
      <nonProxyHosts>vmjirarh01|archiva</nonProxyHosts>
    </proxy>
  </proxies>


 <server>
      <id>archiva.internal</id>
      <username>upload</username>
      <password>ftj0bs-09</password>
    </server>
    <server>
      <id>archiva.snapshots</id>
      <username>upload</username>
      <password>ftj0bs-09</password>
    </server>

jeudi 10 juin 2010

Intégration continue avec Hudson et Maven

Environnement


Avant de donner la recette pour la mise en oeuvre de hudson, nous
allons donner quelques définitions. En effet, certains termes
utilisé dans ce document ont un sens variable suivant le
contexte.

Précisons d'abord les rôles des différents
environnements :

  • Environnement d'Intégration : sert à
    valider manuellement que le le comportement du produit est
    identique sur les environnements de développement et sur la
    plateforme cible. L'environnement d'intégration doit être
    un clone des plateformes de production.

  • Environnement Intégration continue : sert à
    valider automatiquement que le le comportement du produit est
    identique sur les environnements de développement et sur la
    plateforme cible. L'environnement d'intégration doit être
    un clone des plateformes de production.

  • Environnement de Validation :
    sert à vérifier
    que le produit est conforme aux spécifications.


Jeu de test :
Ensemble de données nécessaires au passage d'un test

Test unitaire : Théoriquement
il s'agit d'un test vérifiant une exigence, mais dans ce
document, nous l'utiliserons dans son acception consacrée
test
Junit
.

Bénéfices de l'intégration
continue


Dans les configurations de développement JAVA« standard »,
le codage s'effectue sur Windows et l'intégration s'effectue
sur LINUX/UNIX, il est donc fréquent d'avoir des surprises au
moment de passer sur l'environnement cible, les environnements
d'intégration permettent anticiper les problèmes
techniques.
L'intégrateur identifie les dysfonctionnements et les
corrige. Malheureusement, dans la plupart des configurations projet,
personne n'étant affecté exclusivement à
l'intégration et les soucis d'intégration tendent à
être reléguées aux dernières tâches.

Au delà de l'effet de mode, le principal bienfait de
l'intégration continue sera d'améliorer la visibilité
de ces problématiques.
L’intégration continue valide automatiquement le
produit sur la plateforme cible.


  • Permet de détecter au plus tôt les problèmes
    de dépendance aux environnements : File System, Encoding,
    Case-sensitive, performances etc.
  • Permet de lisser le stress dans l'équipe (plus de
    pression dans les phases précoces, moins au moment de la
    livraison)

  • Il donne une aperçu de la qualité du produit au
    chef de projet et donne confiance au moment de la livraison
    .

Impacts structurants de l'intégration
continue


Contraintes de codage


L'ensemble des projets sur le référentiel de source
doit être compilable à tout moment.

Pour l'intégration continue, le développeur est
contraint d'écrire des tests unitaires.

Test unitaires

Dans un monde systématique, chaque exigence devrait être
vérifiée par un test unitaire, inversement, chaque test
unitaire devrait se mettre en relation avec une seule exigence.
Cependant, dans le monde réel, un test unitaire pourra être
associé à plusieurs exigences, une exigence pourra
n'être pas couverte... etc. In fine le développeur
arbitrera (mais avec un minimum d'expérience, cela se passe
bien. )
A chaque TU est associé un jeu de tests, mais aucune
hypothèse de données préalable ne peut être
faite. Que l'on parte d'une base totalement vidangée ou pleine
de donnée, le résultat du test unitaire doit être
le même. D'autre part, le séquence des TU ne doit pas
non plus conditionner le résultat.

Ressources



  • L’intégration
    requiert un serveur dédié pour hudson
  • Il faut une base de données
    par utilisateur

    (Elle peux se situer sur la machine de
    développement ou sur un serveur mutualisé)

Contrainte de conception



  • Il faut utiliser maven pour
    l'assemblage
  • Les test unitaires doivent être
    écrit avec Junit

Au quotidien



  • Il faut vraiment s’impliquer
    dans la supervision des builds et être vigilant tout au long
    du développement du produit : codage, intégration,
    validation
  • L'équipe doit s'organiser
    dans ce but, c'est-à-dire qu'il faut un responsable
    Intégration Continue (le même que le responsable GCONF)


Mise en oeuvre




  • Installer un serveur hudson
  • Planifier les tâches à des horaires où la
    machine n'est pas trop chargée

De The French Hack

De The French Hack

De The French Hack

vendredi 3 juillet 2009

Configurer maven à travers un proxy

Voici le fichier de configuration pour passer à travers un proxy
<settings>
<localRepository>d:/repo-maven</localRepository>
<proxies>
<proxy>
<active>true</active>
<protocol>http</protocol>
<host>proxy.mycorp.com</host>
<port>8080</port>
<nonProxyHosts>www.google.com|*.somewhere.com</nonProxyHosts>
</proxy>
</proxies>
</settings>

vendredi 12 juin 2009

Appfuse pour le développement rapide d'application JAVA

Appfuse aide au développement rapide des applications web java à l'aide de technologies open source.

A l'aide de maven vous pouvez simplement initiez un projet de par la commande mvn archetype:generate et selectionner :



  • appfuse-basic-jsf

  • appfuse-basic-spring

  • appfuse-basic-struts

  • appfuse-basic-tapestry

  • appfuse-core

  • appfuse-modular-jsf

  • appfuse-modular-spring

  • appfuse-modular-struts

  • appfuse-modular-tapestry


Les avantages :
Le développement est accéléré par une gestion des utilisateurs et des rôles déjà implémentée. Elle nécessite peu d'adaptation pour se conformer des cas d'utilisations réels d'une application de gestion.
Les controlleurs de base sont assez souples pour se conformer à toutes les navigations rencontrées dans les application de gestion.
Les DAO et manager Générique accélère notablement le cas basique d'édition d'un fomulaire.
L'adaptation graphique est peu couteuse.

Les inconvénients :
Les prototypes proposés par maven sont assez mauvais :
Le développement avec l'IDE eclipse est difficile à initialiser pour fonctionner avec WTP.
Le pom est pollué par tout un tas de fonctions qui ne sont pas nécessaires quand l'objectif est la rapidité. L'enrichissement progressif aurait été préférable.
Le mécanisme de properties est lourd et ne fonctionne bien qu'avec maven, voir lourdingue et freine la rapidité de développement.
Le prototype maven utilisant la dépendance de war est très peu lisible et n'apporte pas grand chose.

En réalité, le travail avec appfuse pour une petite application commence par les suppression des fonctions ne concernant pas directement la productivité : checkstyle, PMD, aspect etc.

La documentation est encore légère et manque d'exemples complets.

Conclusion :

Appfuse n'est pas encore un RAD, il n'est pas révolutionnaire non plus. Le vrai problème de appfuse est la manière dont il est exploité avec maven. Cependant, il peu constituer la première inspiration pour créer un framework maison. Les archétypes maven peuvent difficilement être considérés comme un framework RAD.

A mon sens, les archetypes fournis souffrent d'une conception trop théorique. Ces handicaps sont particulièrement gênants lorsqu'il s'agit d'être rapidement productif. Néamoins, après quelques adaptations, ces prototypes peuvent remplir leurs objectifs de rapidité.

mercredi 8 octobre 2008

Créer la metrologie à l'aide de maven

Le pluggin javancss de paven permet de calculer les métriques pour un projet. Notamment, cela permet de voir quel ration de code a été commenté.

mvn javancss:report
NCSS est le nombre d'instructions, ces dernières sont spécifié par une norme, grossièrement cela correspond au nombre de ';' et de '{'

2766 est le nombre d'instruction du projet

Programm NCSS : le nombre d'instruction total
NCSS average : le nombre d'instruction moyen par classes
CCN : la complexité cyclomatique
Javadocs average : Le nombre de ligen de commentaire par classe.

Program NCSSNCSS averageCCN averageJavadocs average
2,766.003.862.020.46










jeudi 28 août 2008

Ganymede et maven

Pour utiliser Ganymede et maven, il est nécessaire d'utiliser la version 1.5 ou 2.0 de wtp :

mvn -Dwtpversion=1.5 eclipse:eclipse

Ou bien il est possible de le préciser dans le fichier settings.properties
<profile>
<id>dev</id>
<properties>
<wtpversion>2.0</wtpversion>
</properties>
</profile>

mardi 24 juin 2008

Problème de mémoire avec maven

%MAVEN_JAVA_EXE% %MAVEN_OPTS%  -Xmx1024m -classpath
%CLASSWORLDS_JAR% "-Dclassworlds.conf=%M2_HOME%\bin\m2.conf"
"-Dmaven.home=%M2_HOME%" org.codehaus.classworlds.Launcher
%MAVEN_CMD_LINE_ARGS%



The system is out of resources.
Consult the following stack trace for details.
java.lang.OutOfMemoryError: Java heap space
at com.sun.tools.javac.code.Scope$ImportScope.makeEntry(Scope.java:385)
at com.sun.tools.javac.code.Scope.enter(Scope.java:196)
at com.sun.tools.javac.code.Scope.enter(Scope.java:183)
at com.sun.tools.javac.comp.MemberEnter.importAll(MemberEnter.java:132)
at com.sun.tools.javac.comp.MemberEnter.visitTopLevel(MemberEnter.java:509)
at com.sun.tools.javac.tree.JCTree$JCCompilationUnit.accept(JCTree.java:446)
at com.sun.tools.javac.comp.MemberEnter.memberEnter(MemberEnter.java:387)
at com.sun.tools.javac.comp.MemberEnter.complete(MemberEnter.java:819)
at com.sun.tools.javac.code.Symbol.complete(Symbol.java:386)
at com.sun.tools.javac.code.Symbol$ClassSymbol.complete(Symbol.java:758)
at com.sun.tools.javac.comp.Enter.complete(Enter.java:451)
at com.sun.tools.javac.comp.Enter.main(Enter.java:429)
at com.sun.tools.javac.main.JavaCompiler.enterTrees(JavaCompiler.java:819)
at com.sun.tools.javac.main.JavaCompiler.compile(JavaCompiler.java:727)
at com.sun.tools.javac.main.Main.compile(Main.java:353)
at com.sun.tools.javac.main.Main.compile(Main.java:279)
at com.sun.tools.javac.main.Main.compile(Main.java:270)
at com.sun.tools.javac.Main.compile(Main.java:87)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at org.codehaus.plexus.compiler.javac.JavacCompiler.compileInProcess(JavacCompiler.java:420)
at org.codehaus.plexus.compiler.javac.JavacCompiler.compile(JavacCompiler.java:141)
at org.apache.maven.plugin.AbstractCompilerMojo.execute(AbstractCompilerMojo.java:493)
at org.apache.maven.plugin.CompilerMojo.execute(CompilerMojo.java:114)
at org.apache.maven.plugin.DefaultPluginManager.executeMojo(DefaultPluginManager.java:447)
at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeGoals(DefaultLifecycleExecutor.java:539)
at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeGoalWithLifecycle(DefaultLifecycleExecutor.java:480)
at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeGoal(DefaultLifecycleExecutor.java:459)
at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeGoalAndHandleFailures(DefaultLifecycleExecutor.java:311)
at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeTaskSegments(DefaultLifecycleExecutor.java:278)


Les tests unitaires lancés avec maven provoquent des erreurs de mémoire, il est possible de changer le fork afin d'instancier une JVM par test. Par défaut le fork utilisé est once (un seul fork)

<project>
[...]
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<forkMode>pertest</forkMode>
<argLine>-enableassertions</argLine>
</configuration>
</plugin>
</plugins>
</build>
[...]
</project>

mardi 26 février 2008

Utilisation de cargo

Configuration du plugin en mode local et remote
Voici la ligne à insérer dans le pom.xml
<plugin>
<groupId>org.codehaus.cargo</groupId>
<artifactId>cargo-maven2-plugin</artifactId>
<configuration>
<configuration> (Indique ou sont déployés les war)
<type>existing</type> (Le type par defaut est standalone, c'est à dire que les repertoire de deploiement est créé s'il n'existe pas)
<home>/opt/tomcat/</home> (Nécessaire dans le cas d'un existing)
</configuration>
<container>
<containerId>tomcat5x</containerId>
<home>/opt/tomcat/</home> (Home indique ou trouver le container (le moteur))
</container>
</configuration>
</plugin>


Pour pouvoir déployer sous un chemin spécifique, indépendamment des version, il faut créer le fichier META-INF/context.xml et affecter le nom d'application que l'on souhaite.

<Context path="/gestion" />

vendredi 1 février 2008

Deployer avec les sources à l'aide de maven

Cette commande effectue le javadoc et la mise à disposition des sources.
mvn -DperformRelease=true deploy

jeudi 4 octobre 2007

Bonne pratique pour gérer les environnement multiple dans maven

A chaque fois qu'un fichier représente un élément de configuration :

- fichier de propriétés
- fichier de configuration des log
- fichier de configuration hibernate
etc.

Il doit être aisément modifiable, c'est à dire qu'il ne doit pas se trouver dans un jar mais se trouvé dans un fichier facilement modifiable. Dans une application Web on placera le fichier de log4j.properties, hibernate.cfg.xml dans le répertoire classes. Ainsi, ces répertoire sont facilement modifiable par un intervenant qui ne connait a priori rien au fonctionnement de l'application.

Quand une application Web utilise un librairie, il ne faut donc pas qu'elle contienne de ressource susceptible d'interférer avec sa propre configuration. Concrètement, il faut éviter de mettre les fichier de configuration dans les partie

src/main des application et les mettre dans le repertoire test.

Il arrive parfois que la configuration soit une tache complexe et qu'il ne s'agisse pas de modifier quelques lignes mais de nombreuse modifications auquels cas il est plus approprié d'effectuer une copie pure et simple des fichiers de configuration et de garder ceux-ci dans le référentiel de sources.

Pour ce genre de problématique, maven a un mécanisme permettant de constituer un package et sa configuration à partir d'un ensemble de fichiers groupé dans un répertoire. Le mécanisme utilisé s'appelle profil. L'utilisation d'un profil conditionne le comportement de maven, il est selectionné par maven en tapant la commande -P

Supposons qu'on ai 4 environnements :

- Développement
- Test
- Recette
- Production

Pour créer un package, on spécifie le profil utilisé. Par exemple mvn -Ptest

Pour gérer ces différents environnements, on créé autant de profils dans le fichier settings.xml qui se trouve dans $HOME/.m2

<settings>
[...]
<profiles>
<profile>
<id>dev</id>
<properties>
<mode>dev</mode>
</properties>
</profile>
<profile>
<id>recette</id>
<properties>
<mode>recette</mode>
</properties>
</profile>
<profile>
<id>test</id>
<properties>
<mode>test</mode>
</properties>
</profile>
<profile>
<id>prod</id>
<properties>
<mode>prod</mode>
</properties>
</profile>
</profiles>
<activeProfiles>
<activeProfile>dev</activeProfile>
</activeProfiles>
[...]
</settings>


Ainsi, chaque fois que l'on tape mvn -Pprod on utilise le profil de production. La configuration des plugin et un ensemble de propriétés d'éxécution sont définies à ce moment. Dans cet exemple on ne configure que les propriétés, ainsi la propriété mode est définie à dev quand on est dans l'environnement de développement.

activeProfile permet de déterminer le profil par défaut (dev)

Pour avoir des ressources différenciées, on peut se servir du filtering maven. Le filtering effectue des substitution lors des copies de ressources. Toutefois, il est plus commode lorsque les modifications sont importantes et portent sur des fichiers en entier d'avoir recours à des répertoires différentiés.
Ainsi on a la structure de répertoire suivante :

- main/resources/resources qui contient les resources communes

et

- main/resources/dev
- main/resources/test
- main/resources/recette
- main/resources/prod

qui contiennent les ressources spécifiques à des environnements.

On modifie le descripteur de projet en modifiantle pom.xml


   <build>
[...]
<resources>
<resource>
<directory>src/main/resources</directory>
</resource>
<resource>
<directory>src/main/${mode}</directory>
</resource>
</resources>
[...]
<build>

jeudi 27 septembre 2007

Utilisation des filters dans maven

Les filter de maven permettent de copier des resources en modifiant le contenu défini comme étant filtré. Ils sont utiles pour fonctionner dans différent environnement. Notamment dans les fichier de propriétés qui définissent des propriétés pour passer les test unitaires.

Supposons qu'il soit nécessaire de configurer un chemin d'un fichier de log différemment suivant que l'on travaille sur un station LINUX ou sur son poste de développement Windows.

Ce fichier est défini dans un fichier de src/main/resources/log-aida.properties

son contenu est :

aida.logFile=${fileLog}


Il faut définir dans le fichier pom.xml que ces resources sont filtrées

<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
</resource>
</resources>
[...]
</build>



Dans le fichier ~/.m2/settings on défini cette propriété

   <profiles>
<profile>
<id>unix</id>
<properties>
<filelog>/tmp/log.prout</filelog>
</properties>
</profile>
</profiles>
<activeprofiles>
<activeprofile>unix</activeprofile>
</activeprofiles>


Dès lors quand on tape mvn resources:resources le fichier src/main/resources/log-aida.properties est copié vers target/classes/log-aida.properties et son contenu est

aida.logFile=/tmp/log.prout