Vous êtes sur la page 1sur 14

Créer un package

AMP pour Alfresco


 ECM

 ALFRESCO , AMP , EXTENSIONS , TUTORIEL


 LEAVE A COMMENT

 
Dans mon tutoriel sur les scripts Ant, j’avais évoqué les
packages AMP (Alfresco Module Package). Ils sont utilisés pour ajouter
des sets de fonctionnalités supplémentaires ou des fichiers pour
personnaliser l’outil (images, icônes, modèles de données, scripts, etc.).
Voyons comment transformer un projet en package AMP.

1. Le package AMP
Un package AMP est un dossier compressé qui possède une structure bien
précise :

/config correspond à /WEB-INF/classe. Il contient les fichiers de


configuration de vos extensions (web-client-config, modeles, -context.xml,
resources.properties, etc.)
/lib correspond à /WEB-INF/lib et contient tous les fichiers .jar dont vous
avez besoin.
/licences contient les éventuels fichiers de licence liés à des librairies
externes que vous pourriez utiliser.
/web est mappé à la racine de la webapp Alfresco,
soit /tomcat/webapps/alfresco/. Les noms des dossiers qu’il contient
parlent d’eux-même. Mais vous pouvez en ajoutez d’autres selon vos
besoins. La structure du package n’est pas figée.
Le fichier module.properties contient des informations sur votre module
comme son nom, son id, une description et éventuellement des contraintes
sur la version d’Alfresco à laquelle il peut s’appliquer. Nous y reviendrons
plus tard.
Le fichier file-mapping.properties est optionnel et vous permet de modifier
le mapping des dossiers de votre package AMP par rapport à la webapp
Alfresco. Si vous n’utilisez pas ce fichier, le mapping par défaut (décrit
précédemment) est utilisé.

2. Le projet Eclipse
Maintenant, voyons comment créer et structurer votre projet sous Eclipse. 
La structure est un peu différente du package amp mais un
script Ant permettra de facilement remodeler le projet pour générer un
package conforme en sortie.

Le dossier source contient les classes java. Le dossier build sera utilisé par


le script Ant pour compiler les classes et générer le jar. Nous retrouvons les
dossiers lib, web et config. Le dossier WEB-INF peut contenir votre
fichier web.xml si vous le modifiez ou bien le fichier faces-config-
custom.xml. Nous retrouvons également file-
mapping.properties et module.properties. Enfin il y a le
script Ant project-build.xml et son fichier de propriétés.
a. le fichier module.properties

# my module properties
module.id=myGreatModule
module.aliases=my-great-module, module-1
module.version=1.0
module.title=My Uber module for Alfresco
module.description=This module add great
new features to the alfresco web client
module.repo.version.min=2.0
module.repo.version.max=2.1
module.depends.alfresco.custom.module.myFi
rstModule=1.0-*
module.depends.alfresco.custom.module.mySe
condModule=*
Les propriétés marquée en bleu sont obligatoire ! Les deux lignes qui
suivent la description du module permettent de spécifier la version
d’Alfresco à laquelle peut s’appliquer votre module. Elles sont
optionnelles. Les deux lignes suivantes indiquent que votre module ne peut
être installé que si les deux modules cités sont déjà installés et avec une
contrainte sur leur version. Concrètement, doivent être installés au
préalable myFirstModule 1.0 minimum et mySecondModule toute version
acceptée…

b. le fichier module-context.xml
L’autre fichier important pour créer notre package amp est le
fichier module-context.xml. Ce fichier est un fichier de configuration
Spring standard et va permettre de charger les différents fichiers xml de
vos extensions au démarrage d’alfresco. Il se trouve dans le
dossier /config/alfresco/module/<module.id>/

Et sont contenu peut être comme ceci:


?

01<?xml version='1.0' encoding='UTF-8'?>


02<!DOCTYPE beans PUBLIC '-//SPRING//DTD BEAN//EN' 'http://www.springframework.o
03 
04<beans>
05     <import resource="context/bootstrap-context.xml" />
06     <import resource="context/custom-models-context.xml" />
07     <import resource="context/custom-actions-context.xml" />
08     <import resource="context/web-ui-config-context.xml" />
09     <import resource="context/resources-bundle-context.xml" />
10</beans>
Bien sûr, vous pouvez tout aussi bien déclarer vos beans directement dans
le fichier module-context.xml. Personnellement, je n’hésite pas à multiplier
les niveaux dans mon arborescence pour que tout soit bien structuré.

c. le script Ant

Maintenant que votre projet est bien structuré et que vous disposez de tous
les fichiers nécessaire à la création du package amp, vous pouvez vous
attaquer au script Ant ! Voici un exemple de script :
?

0<?xml version="1.0"?>

0<project name="Alfresco extensions sample" default="package-amp" basedir=".">

0    <property name="project.dir" value="."/>
3    <property file="${project.dir}/project-build.properties"/>
0    <property file="${project.dir}/module.properties"/>
4    <property name="project.name" value="org.alfresco.custom.extensions"/>

5    <property name="build.dir" value="${project.dir}/build"/>
0    <property name="config.dir" value="${project.dir}/config"/>
6    <property name="jar.file" value="${build.dir}/lib/${project.name}.jar"/>
0    <property name="amp.file" value="${build.dir}/dist/${module.id}.amp"/>

0    <target name="mkdirs">
8        <mkdir dir="${build.dir}/dist" />
0        <mkdir dir="${build.dir}/lib" />
9        <mkdir dir="${build.dir}/classes" />
1    </target>

1    <path id="class.path">
1        <dirset dir="${build.dir}" />
1        <fileset dir="${project.dir}/lib" includes="**/*.jar" />
2        <fileset dir="${alfresco.sdk.dir}/server" includes="**/*.jar" />
1    </path>

1    <target name="clean">
4        <delete dir="${build.dir}" />
1    </target>

1    <target name="compile" depends="mkdirs">
6        <javac classpathref="class.path" debug="${debug}" srcdir="${project.di
1            destdir="${build.dir}/classes" target="1.5" encoding="UTF-8"/>
7        <copy todir="${build.dir}/classes">
1            <fileset dir="${project.dir}/source" defaultexcludes="false">
8                <exclude name="**/*.java"/>
1                <exclude name="**/.svn/**"/>
9                <exclude name="**/CVS/**"/>
2            </fileset>
0        </copy>
2    </target>

2    <target name="package-jar" depends="compile">
2        <jar destfile="${jar.file}" encoding="UTF-8">
2            <fileset dir="${build.dir}/classes"  defaultexcludes="false" />
3        </jar>
2    </target>

2    <target name="package-amp" depends="package-jar" description="Package the
5        <zip destfile="${amp.file}" encoding="UTF-8">
2            <fileset dir="${project.dir}/build" includes="lib/*.jar" />
6            <fileset dir="${project.dir}" includes="config/**/*.*" excludes="*
2            <fileset dir="${project.dir}">
7                <include name="module.properties"/>
2                <include name="file-mapping.properties" />
8                <include name="WEB-INF/**/*" />
2                <include name="lib/**/*" />
9                <exclude name="project-build.properties"/>
3                <exclude name="project-build.xml"/>
0            </fileset>
3            <zipfileset dir="web" prefix="web"/>
1        </zip>
3    </target>

3    <target name="install-amp" depends="package-amp" description="Uses the Alf
3        <java dir="." fork="true" classname="org.alfresco.repo.module.tool.Mod
3            <classpath refid="classpath.server"/>
4            <arg line="install ${amp.file} ${alfresco.war.path} -force -verbos
3        </java>
5    </target>

6    <target name="deploy-amp" depends="install-amp" description="Unzips the AM
3           <unzip src="${alfresco.war.path}" dest="${alfresco.web.dir}" />
7    </target>
3</project>
8
3
9
4
0
4
1
4
2
4
3
4
4
4
5
4
6
4
7
4
8
4
9
5
0
5
1
5
2
5
3
5
4
5
5
5
6
5
7
5
8
5
9
6
0
6
1
6
2
6
3
6
4
6
5
6
6
6
7
6
8
6
9
7
0
7
1
7
2
7
3
7
4
7
5
ainsi que le contenu du fichier file-mapping.properties, utilisé ici pour
mapper les dossiers web et WEB-INF :
# Custom AMP to WAR location mappings
#
# The following property can be used to
include the standard set of mappings.
# The contents of this file will override any
defaults. The default is
# ‘true’, i.e. the default mappings will be
augmented or modified by values in
# this file.
#
include.default=true
#
# Custom mappings. If ‘include.default’ is
false, then this is the complete set.
#
/WEB-INF=/WEB-INF
/web=/
Voilà :) Vous avez à peu près tout ce qu’il vous faut pour créer vos
packages amp. Une fois généré, il vous suffit de le placer dans le
dossier /amp ou /amp-share puis exécuter le script apply_amps.bat pour
l’injecter dans le war alfresco. Pour comprendre le fonctionnement des
packages amp, j’ai utilisé les resources suivantes :
AMP Files – wiki Alfresco
Developing an Alfresco Module – wiki Alfresco
Howto – Create a new Alfresco Module – A Geek’s perspective
tutoriel] utilisation
d’un script Ant pour
packager une
extension
 ECM

 ALFRESCO , ANT , ECLIPSE


 1 COMMENT

Alfresco est une application modulaire, ce qui signifie qu’on peut lui


ajouter des extensions sans avoir besoin de recompiler tout le code source.
Lorsque vous développez une extension avec Eclipse, vous pouvez utiliser
des scripts Ant pour ajouter vos modifications dans Alfresco.
Plusieurs solutions sont envisageables :
 Intégrer vos modifications dans une archive war alfresco et
déployer cette archive dans tomcat.
 Packager vos fichiers puis les déployer directement sur un war
alfresco éclaté.
 Générer un package AMP qui sera installé au prochain lancement
d’Alfresco
Lorsqu’il s’agit de déployer des modifications pour faire des tests rapides,
il est sans doute préférable d’utiliser la seconde méthode. Les packages
amp et l’intégration dans une archive war sont plutôt utilisés lorsque
l’extension est terminée. Ils évitent d’avoir à déployer une archive de
l’extension après l’installation d’Alfresco. C’est un gain de temps et de
simplicité d’utilisation.
Nous allons donc étudier un script ant standard utilisé pour déployer une
extension sur un war alfresco explosé. Son but va être de compiler les
classes java s’il y en a, de générer les archives jar puis de les copier, ainsi
que tous les fichiers de configuration et les fichiers jsp/css/images
nécessaires dans le répertoire de l’application web Alfresco, à savoir par
défaut C:\Alfresco\tomcat\webapps\alfresco.
Tout d’abord, regardons à quoi peut ressembler l’arborescence d’un projet
d’extension pour Alfresco:

 source : Il contient vos classes java. vous en aurez besoin si vous


voulez ajouter de nouvelles actions (copier/coller un document, le
taguer, ajouter des commentaires, modifier ses paramètres, etc.)
 build : Ce dossier accueille le jar contenant vos classes et
l’archive zip de tout votre projet.
 config : Ici se trouvent tous vos fichiers de configuration custom
(web client, modèle, propriétés, etc.)
 web : les fichiers de personnalisation du client web.
Pour utiliser un script Ant, ajoutez un fichier xml ant à votre projet et
appelez le build.xml. Ajoutez également un fichier build.properties. Ce
fichier va contenir quelques chemins absolus utilisés dans le build.xml.
Copiez le code suivant à l’intérieur :
?

1alfresco.sdk.dir=C:/alfresco-env/sdk/lib
2alfresco.web.dir=C:/Alfresco/tomcat/webapps/metalawyerweb
3alfresco.shared.extension.dir=C:/Alfresco/tomcat/shared/classes/alfresco/extension
Bien sûr, pensez à modifier les chemins par rapport à votre environnement.
Le dossier shared est inclus dans le classpath d’Alfresco et vous permet de
séparer vos fichiers de configuration personnalisés du reste des fichiers
d’Alfresco. Ils sont ainsi plus faciles à retrouver. Vous pouvez aussi les
placer dans le dossier de l’application web,  /Alfresco/WEB-
INF/classes/alfresco/extensions.
Regardons maintenant le contenu du fichier build.xml. On commence par
déclarer le projet, les différentes variables du script (les dossiers et sous-
dossiers du projet) et quelques target simples :
?

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


02<project name="My Custom Alfresco Extension project" default="setup" basedir=".">
03    <property file="build.properties" />
04 
05    <property name="project.dir" value="." />
06    <property name="build.dir" value="${project.dir}/build" />
07    <property name="bin.dir" value="${project.dir}/bin" />
08    <property name="project.name" value="my-custom-alfresco-extension" />
    <property name="package.file.zip" value="${build.dir}/${project.name}.zip" />
09
    <property name="package.file.jar" value="${build.dir}/${project.name}.jar" />
10
    <property name="project.file.zip" value="${build.dir}/${project.name}-project.zip" />
11    <property name="source.dir" value="${project.dir}/source" />
12    <property name="config.dir" value="${project.dir}/config" />
13    <property name="web.dir" value="${source.dir}/web" />
14    <property name="extension.dir" value="/alfresco/extension" />
15 
16    <path id="classpath.server">
17        <fileset dir="${alfresco.sdk.dir}/server" includes="**/*.jar" />
18    </path>
19 
20    <path id="classpath.remote">
21        <fileset dir="${alfresco.sdk.dir}/remote" includes="**/*.jar" />
22    </path>
23 
24
25
26    <path id="classpath.local">
27        <fileset dir="${project.dir}/lib" includes="**/*.jar" />
28    </path>
29 
30    <path id="classpath.build">
31        <fileset dir="${build.dir}" includes="**/*.jar" />
32    </path>
 
33
    <target name="clean" description="Removes all generated files">
34
        <delete dir="${build.dir}" />
35        <delete dir="${bin.dir}" />
36    </target>
37 
38    <target name="setup" description="Creates the ${build.dir} and ${bin.dir} directories">
39        <mkdir dir="${build.dir}" />
40        <mkdir dir="${bin.dir}" />
41    </target>
42</project>
La target setup va créer les deux dossiers build et bin dans votre
workspace. On va ensuite compiler les classes java et les déplacer dans le
dossier bin avec le code suivant :
?

0
1
0
2
0
3
0
4
0
5
0
6
0
7<target name="compile" description="Compiles src to ${bin.dir}">
0    <mkdir dir="${bin.dir}" />
8    <javac srcdir="${project.dir}/source" destdir="${bin.dir}" source="1.6" target="1.6" deb
        <classpath refid="classpath.server"/>
0
        <classpath refid="classpath.remote"/>
9        <classpath refid="classpath.local"/>
1    </javac>
0    <!-- copy in non-compiled files like props if needed -->
1    <copy todir="${bin.dir}">
1        <fileset dir="${project.dir}/source" excludes="**/*.java"/>
1    </copy>
2</target>
Une fois celà fait, On va générer l’archive .jar contenant ces classes :
?

1
<target name="package-jar" depends="setup, compile"
2
    description="Jars up the compiled classes and ${web.dir}/META-INF into ${package.file.jar}"
3        <delete file="${package.file.jar}" />
4        <jar destfile="${package.file.jar}">
5            <fileset dir="${bin.dir}" includes="com/**" />
6            <fileset dir="${bin.dir}" includes="org/**" />
7            <zipfileset dir="${web.dir}/META-INF" excludes="*.zip" prefix="META-INF" />
8        </jar>
9</target>
Les lignes includes permettent de choisir les packages de votre code source
qui vont être ajoutés au jar. Remarquez que l’argument depends fait appel
aux target setup et compile, ce qui signifie que si vous exécutez la
target package-jar, ces deux tâches seront exécutée en premier et dans
l’ordre dans lequel elles sont indiquées !
On poursuit avec la tâche package-extension, qui va créer une archive zip
de l’extension avec tout son contenu, pré-formatée pour être décompressée
par dessus le dossier de l’application web alfresco :
?

1
<target name="package-extension" depends="setup, package-jar"
2
    description="Creates a zip called ${package.file.zip} which can be unzipped on top of an ex
3    <delete file="${package.file.zip}" />
4    <zip destfile="${package.file.zip}" update="true">
5        <zipfileset dir="${config.dir}${extension.dir}" prefix="WEB-INF/classes${extension.dir
6        <zipfileset file="${package.file.jar}" prefix="WEB-INF/lib" />
7        <zipfileset dir="${web.dir}" excludes="META-INF/**" />
8    </zip>
9</target>
Enfin, on termine avec la tâche deploy, qui va s’occuper de décompresser
pour vous l’archive de votre extension sur votre installation alfresco :
?

1<target name="deploy" depends="package-extension" description="Unzips the ${package.file.zip}


2    <unzip src="${package.file.zip}" dest="${alfresco.web.dir}" />
3</target>
Votre script ant est maintenant complet et prêt à être exécuté. Faites un clic
droit sur votre fichier build.xml et cliquez sur Run As… Vous pouvez
choisir les tâches à exécuter dans l’ordre, mais pensez aussi que la tâche
deploy appelle toutes les sous-tâches nécessaires à sa réalisation. Il vous
suffit de cocher cette tâche pour que tout soit fait dans l’ordre et que votre
extension soit déployée !
Pensez à consulter les fichiers build.xml des différents projets
du SDK pour découvrir d’autres options et comprendre leur
fonctionnement.
Post navigation

Vous aimerez peut-être aussi