move configuration files into a conf directory (which will be copied onto the filesys...
[java-idp.git] / custom / extension-build.xml
1 <!-- 
2   This file is imported in to the main Shibboleth build.xml file and 
3   contains all targets used for building IdP and SP extensions.  These
4   targets are not designed to be called by anything other than the main
5   Shibboleth build file.
6   
7   Chad La Joie
8   July 25, 2005
9 -->
10 <project name="Shibboleth-Extensions" default="ext-invoke" basedir=".">
11
12     <!-- Classpath for compiling an extension -->
13     <path id="ext-compile-path">
14         <!-- Shibboleth Libraries -->
15         <path refid="build.path" />
16
17         <!-- Extension's libraries -->
18         <fileset dir="${ext.lib}">
19             <include name="**/*.jar" />
20         </fileset>
21
22         <!-- Extension classes -->
23         <pathelement location="${ext.classes}" />
24     </path>
25     
26     <!-- Classpath for testing an extension -->
27     <path id="ext-test-path">
28         <!-- Extension Compilation Path -->
29         <path refid="ext-compile-path" />
30         
31         <!-- Extension test classes -->
32         <pathelement location="${ext.test.classes}" />
33     </path>
34
35     <!-- Loops through all the extension directories and executes a particular operation on them -->
36     <target name="ext-invoke" description="Invoke operation extensions">
37         <for keepgoing="true" param="module-path">
38             <dirset dir="${exts.dir}">
39                 <include name="*" />
40                 <exclude name="lib" />
41                 <exclude name="web" />
42             </dirset>
43             <sequential>
44                 <antcall target="${ext.build.function}">
45                     <param name="ext.root" value="@{module-path}" />
46                 </antcall>
47             </sequential>
48         </for>
49     </target>
50
51     <!-- Builds a single extension -->
52     <target name="ext-build" depends="ext-build-init" description="Builds the extension">
53         <echo message="--- Starting to build module ${ext.name} in ${ext.root}" />
54
55         <!-- Compile the source -->
56         <antcall target="ext-compile" />
57
58         <!-- Generate Javadocs -->
59         <antcall target="ext-gen-docs" />
60
61         <!-- Copy over non-source files -->
62         <antcall target="ext-copy-src-conf" />
63
64         <!-- Run unit tests if we're supposed to -->
65         <antcall target="ext-test" />
66
67         <!-- Put the libraries where the IdP and SP packaging can pick them up -->
68         <antcall target="ext-copy-libs" />
69
70         <!-- Put the webpages where the IdP and SP packaging can pick them up -->
71         <antcall target="ext-copy-webpages" />
72
73         <echo message="--- Extension ${ext.name} built" />
74     </target>
75
76     <target name="ext-load-properties" description="Loads property files needed by build process">
77         <!-- Load extension specific properties. -->
78         <if>
79             <not>
80                 <available file="${ext.root}/build.properties" />
81             </not>
82             <then>
83                 <fail message="No build.properties file found for extension in ${ext.root}; this file is required." />
84             </then>
85         </if>
86         <property file="${ext.root}/build.properties" />
87
88         <!-- Load default properties -->
89         <property file="${exts.dir}/extension-build.properties" />
90
91         <fail unless="ext.name" message="The extension ${ext.root} does not contain the required (ext.name) property in its build.properties file." />
92     </target>
93
94     <!-- Initialize everything we need. -->
95     <!-- The properties loaded here are scoped to this particular extension build -->
96     <target name="ext-build-init" depends="ext-load-properties" description="Sets up everything to prepare for the build">
97
98         <!-- Create needed directories -->
99         <mkdir dir="${ext.dist}" />
100         <mkdir dir="${ext.build}" />
101         <mkdir dir="${ext.classes}" />
102         <mkdir dir="${ext.test.classes}" />
103         <mkdir dir="${ext.docs}" />
104     </target>
105
106     <!-- Compiles the extension -->
107     <target name="ext-compile" description="Compiles an extension">
108         <!-- Compile any source that might be out there -->
109         <if>
110             <available file="${ext.src}" />
111             <then>
112                 <echo message="Compiling extension source" />
113                 <javac srcdir="${ext.src}"
114                        destdir="${ext.classes}"
115                        classpathref="ext-compile-path"
116                        includes="**/*.java"
117                        debug="on"
118                        source="1.4"
119                        deprecation="true"/>
120             </then>
121         </if>
122     </target>
123
124     <!-- Copies files from etc directory to dist directory to be bundled with extension jar -->
125     <target name="ext-copy-src-conf" description="Copys non-source files to place where they will be added to jar">
126         <!-- Copy any extra stuff that needs to be on the classpath -->
127         <if>
128             <available file="${ext.src.conf}" />
129             <then>
130                 <echo message="Detected files in the extensions 'src-conf' directory, ensuring they are bundled with the extension's jar." />
131                 <copy todir="${ext.classes}">
132                     <fileset dir="${ext.src.conf}">
133                         <include name="**" />
134                     </fileset>
135                 </copy>
136             </then>
137         </if>
138     </target>
139
140     <!-- Move third party libraries to be picked up by the war -->
141     <target name="ext-copy-libs" description="Moves third party libraries to be picked up by the war">
142         <if>
143             <available file="${ext.lib}" />
144             <then>
145                 <copy todir="${exts.dir}/lib">
146                     <fileset dir="${ext.lib}" includes="*.jar" />
147                 </copy>
148             </then>
149         </if>
150     </target>
151
152     <!-- Move web resources to be picked up by the war -->
153     <target name="ext-copy-webpages" description="Moves web resources to be picked up by the war">
154         <if>
155             <available file="${ext.webpages}" />
156             <then>
157                 <copy todir="${exts.dir}/web">
158                     <fileset dir="${ext.webpages}" />
159                 </copy>
160             </then>
161         </if>
162     </target>
163
164
165     <!-- Run any unit tests for the extension -->
166     <target name="ext-test" description="Runs extension unit test">
167         <if>
168             <equals arg1="${test.ext}" arg2="true" />
169             <then>
170                 <if>
171                     <available file="${ext.test.src}" />
172                     <then>
173                         <echo message="Compiling extension test source" />
174                         <javac srcdir="${ext.test.src}"
175                                destdir="${ext.test.classes}"
176                                classpathref="ext-compile-path"
177                                includes="**/*.java"
178                                debug="on"
179                                source="1.4"
180                                deprecation="true"/>
181                         
182                         <!-- Copy any conf files over so that they end up on the classpathh -->
183                         <copy todir="${ext.test.classes}">
184                                                         <fileset dir="${ext.test.src}">
185                                 <include name="**" />
186                                                             <exclude name="**/*.java"/>
187                             </fileset>
188                         </copy>
189
190                         <echo message="Running tests cases for extension ${ext.name}" />
191                         <junit printsummary="no" fork="yes" haltonerror="true" haltonfailure="true" dir="${ext.root}">
192                             <jvmarg value="-Djava.endorsed.dirs=${endorsed}" />
193                             <classpath refid="ext-test-path"/>
194                             <formatter type="plain" />
195                             <batchtest todir="${ext.root}">
196                                 <fileset dir="${ext.test.classes}">
197                                     <include name="**/*Test.class"/>
198                                 </fileset>
199                             </batchtest>
200                         </junit>
201                     </then>
202                 </if>
203             </then>
204         </if>
205     </target>
206
207     <!-- Generates the Javadocs for the extension -->
208     <target name="ext-gen-docs" description="Generates Javadocs for extension">
209         <if>
210             <equals arg1="${gen.ext.docs}" arg2="true" />
211             <then>
212                 <if>
213                     <available file="${ext.src}" />
214                     <then>
215                         <echo message="Generating javadocs for extension ${ext.name}" />
216                         <javadoc sourcepath="${ext.src}" destdir="${ext.docs}" packagenames="*" author="true" version="true" windowtitle="${ext.name} Shibboleth Extension Java API" doctitle="${ext.name} Shibboleth Extension Java API" failonerror="false">
217                             <classpath refid="build.path" />
218                             <link href="http://java.sun.com/j2se/1.5.0/docs/api/" />
219                         </javadoc>
220                     </then>
221                 </if>
222             </then>
223         </if>
224     </target>
225
226     <!-- Jars up the extension -->
227     <!-- 
228         Required parameters
229             exts.dir - the root directory of the extensions (contains all the individual extension directories)
230             ext.filesystem.home - the path on the filesystem that the extension will be installed
231                 expected subdirectories are 'bin, 'etc', and 'lib'
232             ext.home.token - the token, in config files, to replace with the path to the IdP/SP home
233     -->
234     <target name="ext-package" depends="ext-load-properties" description="Packages up the extension">
235         <if>
236             <available file="${ext.classes}" />
237             <then>
238                 <replace dir="${ext.classes}" token="${ext.home.token}" value="${ext.filesystem.home}" excludes="*.class" />
239                 <replace dir="${ext.classes}" token="$EXTENSION_NAME$" value="${ext.name}" excludes="*.class" />
240                 <jar jarfile="${ext.dist}/${ext.name}.jar" basedir="${ext.classes}" update="false" />
241                 <copy file="${ext.dist}/${ext.name}.jar" todir="${exts.dir}/lib" />
242                 <delete dir="${ext.classes}" />
243             </then>
244         </if>
245     </target>
246
247     <!-- Install extension files (configuration, scripts, etc) on to the filesystem -->
248     <!--
249         Required Paramter
250             ext.filesystem.home - the path on the filesystem that the extension will be installed
251                 expected subdirectories are 'bin, 'etc', and 'lib'
252             ext.home.token - the token that represents the extensions installation point within
253                 the various configuration files (those in the extensions 'etc' and 'src-conf' directories)
254     -->
255     <target name="ext-install-filesystem" depends="ext-build-init" description="Installs extension files on to the filesystem">
256         <echo message="Installing extension ${ext.name} to ${ext.filesystem.home}" />
257
258         <!-- Copy anything in the etc directory to the extension's installation point etc directory -->
259         <if>
260             <available file="${ext.etc}" />
261             <then>
262                 <if>
263                     <available file="${ext.filesystem.home}/etc/${ext.name}" />
264                     <then>
265                         <echo>--------------------------------------------------------------------------------------</echo>
266                         <echo>---</echo>
267                         <echo>---   NOTE:  Existing Shibboleth extension module configuration at ${line.separator}---   ${ext.filesystem.home}/etc/${ext.name} will not be overwritten.</echo>
268                         <echo>---</echo>
269                         <echo>--------------------------------------------------------------------------------------</echo>
270                     </then>
271                     <else>
272                         <mkdir dir="${ext.filesystem.home}/etc/${ext.name}" />
273                         <copy todir="${ext.filesystem.home}/etc/${ext.name}">
274                             <fileset dir="${ext.etc}">
275                                 <include name="**" />
276                             </fileset>
277                         </copy>
278                         <replace dir="${ext.filesystem.home}/etc/${ext.name}" token="${ext.home.token}" value="${ext.filesystem.home}" />
279                         <replace dir="${ext.filesystem.home}/etc/${ext.name}" token="$EXTENSION_NAME$" value="${ext.name}" />
280                     </else>
281                 </if>
282             </then>
283         </if>
284
285         <!-- Copy anything in the bin directory to the extension's installation point bin directory -->
286         <if>
287             <available file="${ext.bin}" />
288             <then>
289                 <copy todir="${ext.filesystem.home}/bin">
290                     <fileset dir="${ext.bin}">
291                         <include name="**" />
292                     </fileset>
293                 </copy>
294                 <replace dir="${ext.filesystem.home}/bin" token="${ext.home.token}" value="${ext.filesystem.home}" />
295                 <replace dir="${ext.filesystem.home}/bin" token="$EXTENSION_NAME$" value="${ext.name}" />
296                 <chmod dir="${ext.filesystem.home}/bin" perm="ug+rx" includes="**/*" />
297             </then>
298         </if>
299
300         <!-- Copy anything in the lib directory to the extension's installation point lib directory -->
301         <if>
302             <available file="${ext.lib}" />
303             <then>
304                 <copy todir="${ext.filesystem.home}/lib">
305                     <fileset dir="${ext.lib}">
306                         <include name="*" />
307                     </fileset>
308                 </copy>
309             </then>
310         </if>
311
312         <!-- Copy the extension jar to the extension's installation point lib directory -->
313         <if>
314             <available file="${ext.dist}/${ext.name}.jar" />
315             <then>
316                 <copy file="${ext.dist}/${ext.name}.jar" todir="${ext.filesystem.home}/lib" />
317             </then>
318         </if>
319     </target>
320
321     <!-- Cleans up classes files -->
322     <target name="ext-clean-build" depends="ext-load-properties" description="Cleans up any build created resources">
323         <delete dir="${ext.build}" failonerror="false" />
324     </target>
325
326     <!-- Cleans up java docs -->
327     <target name="ext-clean-javadocs" depends="ext-load-properties" description="Deletes generated javadocs">
328         <delete dir="${ext.docs}" failonerror="false" />
329     </target>
330
331     <!-- Cleans up distribution files -->
332     <target name="ext-clean-dist" depends="ext-load-properties" description="Deletes distribution generated files">
333         <delete dir="${ext.dist}" failonerror="false" />
334     </target>
335 </project>