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