build.xml

<?xml version="1.0" encoding="utf-8"?>
<project name="toplevel" default="build-default" basedir="."  xmlns:ivy="antlib:org.apache.ivy.ant">
<!--
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
# Copyright (C) 2005 - 2013 Open Microscopy Environment:
#   - Glencoe Software, Inc.
#   - University of Dundee
# Use is subject to license terms supplied in LICENSE.txt
#
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Written by:  Josh Moore, josh at glencoesoftware.com
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Rewrite of the OMERO build system to allow for building
individual components. Use "ant -p" to see the individual
build-* targets.

-->
    <description>
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Top-level OMERO build.

Eclipse
-------
To get started using Eclipse, execute "ant build-dev" and import the top-level
.project file. Eclipse projects also exist for each individual java component.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    </description>

    <property name="import.dir" value="${basedir}/components/antlib/resources"/>
    <import file="${import.dir}/global.xml"/>

    <target name="init" depends="check-ivy,check-scons,check-ice">
    </target>

    <target name="check-git">
      <available file=".git" type="dir" property="git.exists"/>
    </target>

    <target name="check-ivy" unless="ivy.done">
        <!-- Prevent future invocations and PermGen errors-->
        <property name="ivy.done" value="done"/>
        <!-- Touch the local configuration file which is no longer mandatory -->
        <if><not><available file="${basedir}/etc/local.properties"/></not>
        <then>
            <touch file="${basedir}/etc/local.properties"/>
        </then></if>
        <installIvy/>
        <ivy:buildlist reference="all.buildpath" settingsRef="ivy.toplevel">
            <fileset dir="${omero.home}/components" includes="*/build.xml" excludes="**/tools/**, **/tests/**"/>
        </ivy:buildlist>
        <ivy:buildlist reference="all-tools.buildpath" settingsRef="ivy.toplevel">
            <fileset dir="${omero.home}/components/tools" includes="*/build.xml"/>
        </ivy:buildlist>
        <ivy:buildlist reference="all-tests.buildpath" settingsRef="ivy.toplevel">
            <fileset dir="${omero.home}/components/tests" includes="*/build.xml"/>
        </ivy:buildlist>
        <!-- Single file paths defined in antlib/resources/directories.xml -->
    </target>

    <target name="clean" description="Calls 'clean' on all components" depends="check-ivy">
        <!-- Calling check-scons here rather than above, so that dependency graph later will re-install
        if a user does "ant clean some-target" -->
        <antcall target="check-scons" inheritRefs="true" inheritAll="true"/>
        <iterate buildpathref="all.buildpath"   target="clean"/>
        <iterate buildpathref="tools.buildpath" target="clean"/>
        <delete dir="${dist.dir}"/>
        <delete dir="${lib.dir}/cache"/>
        <delete includeemptydirs="true">
            <fileset dir="${lib.dir}/repository" includes="omero/**,omero-tools/**"/>
        </delete>
        <delete dir="${target.dir}" quiet="true"/>
        <delete dir="${omero.home}/test-output" quiet="true"/>
        <delete includeemptydirs="true" quiet="true">
            <fileset dir="${omero.home}/examples" includes="config.log,**/*.o,**/*.class,**/*.exe"/>
        </delete>
        <ant antfile="build.xml" dir="docs/sphinx-api" target="clean" inheritAll="false"/>
    </target>

    <target name="clean-ivy-cache" description="Cleans the Ivy cache" 
        depends="check-ivy">
        <ivy:cleancache settingsRef="ivy.${ant.project.name}"/>
    </target>

    <macrodef name="setup-py-install">

        <attribute name="tarball"/>
        <attribute name="dir"/>

        <sequential>
        <mkdir dir="${target.dir}"/>
        <mkdir dir="${target.dir}/lib/python/site-packages"/>
        <untar compression="gzip" src="${lib.dir}/repository/@{tarball}" dest="${target.dir}"/>
        <exec executable="python" dir="${target.dir}/@{dir}" failonerror="true">
            <env key="PYTHONPATH" value="${env.PYTHONPATH}:${target.dir}/lib/python/site-packages"/>
            <arg value="setup.py"/>
            <arg value="install"/>
            <arg value="--prefix=${target.dir}"/>
         </exec>
         </sequential>
    </macrodef>

    <target name="check-scons" description="Checks for scons and sets executable or installs">
        <available property="scons.py" value="${target.dir}/scons/scons.py" filepath="${target.dir}/scons" file="scons.py" />
        <antcall target="build-scons" inheritAll="true" inheritRefs="true"/>
    </target>

    <target name="build-scons" description="Installs the scons build tool" unless="scons.py">
        <unzip src="${lib.dir}/repository/scons-local-2.1.0.zip" dest="target/scons"/>
    </target>

    <target name="check-ice" description="Checks Ice versioning">
        <!-- Checking the slice2* version before continuing. See #1185 -->
        <exec outputproperty="executable.ice.version" executable="${ice.slice2java}">
            <arg value="--version"/>
        </exec>
        <if>
            <not>
                <or>
                    <matches pattern="^${ice.compatibility}" string="${executable.ice.version}"/>
                    <matches pattern="^${ice.compatibility}" string="auto"/>
                </or>
            </not>
            <then><fail>WRONG ICE VERSION!

                slice2java (${ice.slice2java}) version = ${executable.ice.version}
                Expected version = ${ice.compatibility}

                If you would like to configure which Ice to use, set
                ice.compatibility=ice_version in etc/local.properties
                or on the command-line, e.g.:

                  ./build.py -Dice.compatibility=3.6

            </fail></then>
        </if>
    </target>

    <target name="build-default" description="Default build calls build" depends="build"/>
    <target name="build" description="Build all components" depends="init">
        <iterate buildpathref="all.buildpath" target="dist"/>
        <iterate buildpathref="all-tools.buildpath" target="tools-dist"/>
        <iterate buildpathref="tools.buildpath" target="dist"/>
        <iterate buildpathref="tests.buildpath" target="dist"/>
        <iterate buildpathref="all-tests.buildpath" target="tests-dist"/>
        <antcall target="build-dist" inheritRefs="true" inheritAll="true"/>
    </target>

    <target name="build-all" description="Build all components" depends="build">
    </target>

    <target name="build-dev" description="build-default, then test-compile and build-eclipse"
        depends="clean,init,build-default,test-compile,build-eclipse"/>

    <target name="build-all-dev" description="build, then test-compile and build-eclipse"
        depends="clean,init,build,test-compile,build-eclipse"/>

    <target name="build-blitz" description="Alias for 'build-server'" depends="build-server"/>

    <target name="build-server" description="Build blitz and copy to dist/blitz" depends="init">
        <!-- Must also build python since it provides our command lines -->
        <iterate buildpathref="OmeroPy.buildpath" target="tools-dist"/>
        <iterate buildpathref="OmeroFs.buildpath" target="tools-dist"/>
        <iterate buildpathref="tools.buildpath" target="dist"/>
        <!-- Parts of build-dist -->
        <antcall target="copy-licenses" inheritRefs="true" inheritAll="true"/>
        <antcall target="copy-history" inheritRefs="true" inheritAll="true"/>
        <antcall target="copy-etc" inheritRefs="true" inheritAll="true"/>
        <antcall target="copy-sql" inheritRefs="true" inheritAll="true"/>
        <antcall target="copy-server" inheritRefs="true" inheritAll="true"/>
        <antcall target="update-version" inheritRefs="true" inheritAll="true"/>
    </target>

    <target name="build-java" description="Build Java bindings to the OMERO server" depends="init">
        <iterate buildpathref="OmeroJava.buildpath" target="tools-dist"/>
        <iterate buildpathref="tools.buildpath" target="dist"/>
    </target>

    <target name="build-py" description="Build Python bindings to the OMERO server" depends="init">
        <iterate buildpathref="OmeroPy.buildpath" target="tools-dist"/>
        <iterate buildpathref="tools.buildpath" target="dist"/>
    </target>

    <target name="build-web" description="Build OmeroWeb and copy to dist. May require 'build-py'" depends="init">
        <iterate buildpathref="OmeroWeb.buildpath" target="tools-dist"/>
        <iterate buildpathref="tools.buildpath" target="dist"/>
        <!-- Parts of build-dist -->
        <antcall target="copy-etc" inheritRefs="true" inheritAll="true"/>
        <antcall target="copy-web-requirements" inheritRefs="true" inheritAll="true"/>
        <antcall target="update-version" inheritRefs="true" inheritAll="true"/>
    </target>

    <target name="eclipse" depends="init">
        <tryEclipse settingsRef="ivy.toplevel" filter="true"/>
    </target>

    <target name="build-eclipse" description="Creates all source directories needed by eclipse in case default build is failing." depends="init">
        <iterate buildpathref="all.buildpath" target="eclipse"/>
        <iterate buildpathref="OmeroJava.buildpath" target="eclipse"/>
        <tryEclipse settingsRef="ivy.toplevel" filter="true"/>
    </target>

    <macrodef name="launchSuite">
        <attribute name="suite"/>
        <attribute name="excludes" default="**/tools/build.xml,**/tests/build.xml"/>
        <sequential>
        <ivy:settings id="ivy.@{suite}"  file="${etc.dir}/ivysettings.xml"/>
        <ivy:buildlist reference="@{suite}.buildpath" settingsRef="ivy.@{suite}" ivyfilepath="test.xml">
            <fileset dir="${omero.home}/components" includes="*/build.xml" excludes="@{excludes}"/>
            <fileset dir="${omero.home}/components/tools" includes="*/build.xml"/>
            <fileset dir="${omero.home}/components/tests" includes="*/build.xml"/>
        </ivy:buildlist>
        <iterate buildpathref="@{suite}.buildpath" target="@{suite}"/>
        </sequential>
    </macrodef>

    <target name="test-compile" description="Compile all tests" depends="init">
        <launchSuite suite="test-compile"/>
    </target>

    <target name="test-compile-all" description="Compile all tests" depends="test-compile">
    </target>

    <target name="test-unit" description="Run all unit tests" depends="init">
        <launchSuite suite="test"/>
    </target>

    <target name="test-unit-all" description="Run all unit tests" depends="test-unit">
    </target>

    <target name="test-integration" description="Run all integration tests" depends="init">
        <launchSuite suite="integration"/>
    </target>

    <target name="test-integration-all" description="Run all integration tests" depends="test-integration">
    </target>

    <target name="test-server" description="Run all non-tools/ tests" depends="init">
        <launchSuite suite="integration" excludes="**/tools/build.xml,**/tools/**/build.xml"/>
    </target>

    <target name="test-fs" description="Run all FS related unit and integration tests" depends="init">
        <ant antfile="${tools.comp}/OmeroJava/build.xml" dir="${tools.comp}/OmeroJava" target="test-suite" inheritall="false">
            <property name="test.dir" value="${tools.comp}/OmeroJava/test"/>
            <property name="unit.suite" value="fs.testng.xml"/>
        </ant>
        <ant antfile="${tools.comp}/OmeroPy/build.xml" dir="${tools.comp}/OmeroPy" target="python-integration" inheritall="false">
            <property name="suite_file" value="${tools.comp}/OmeroPy/test/integration/fs_suite.py"/>
        </ant>
    </target>

    <target name="test-report" description="Joins test results into a single report">
        <mkdir dir="${target.dir}/reports"/>
        <junitreport todir="${target.dir}/reports">
            <fileset dir="${basedir}/components">
                <include name="*/target/reports/xml/*.xml"/>
            </fileset>
            <fileset dir="${basedir}/components/tools/">
                <include name="*/target/reports/xml/*.xml"/>
            </fileset>
            <report format="frames" todir="${target.dir}/reports/html"/>
        </junitreport>
    </target>

    <target name="test-dist" description="Copy test files into dist for further testing" depends="test-compile">
        <ivy:resolve file="test.xml" type="jar,bundle" conf="test" settingsRef="ivy.toplevel" log="quiet"/>
        <ivy:retrieve conf="test" pattern="${dist.dir}/lib/client/[artifact].[ext]" sync="false" log="quiet" settingsRef="ivy.toplevel"/>
    </target>

    <target name="examples-java" description="Build and run OmeroJava examples">
        <scons_py dir="${basedir}/examples">
            <arg value="run_java=1"/>
        </scons_py>
    </target>

    <target name="examples-py" description="Build and run OmeroPy examples">
        <scons_py dir="${basedir}/examples" pythonpath="${env.PYTHONPATH}"><!-- omit OmeroPy/src -->
            <arg value="run_py=1"/>
            <arg value="no_java=1"/>
        </scons_py>
    </target>

    <target name="release-all" description="Produce all binary release artifacts (unsigned)"
        depends="release-clients,release-zip,release-docs">
   </target>

    <target name="release-zip" description="Zip the dist directory into ${product.name}-${omero.version}.zip">
        <zip destfile="${omero.home}/target/${product.name}-${omero.version}.zip">
            <zipfileset dir="${dist.dir}" prefix="${product.name}-${omero.version}"
                excludes="bin/omero"/>
            <zipfileset dir="${dist.dir}" prefix="${product.name}-${omero.version}"
                includes="bin/omero"
                filemode="755"/>
        </zip>
    </target>

    <target name="release-src-embed" description="Package the release source tree (non-git)"
            depends="check-git" unless="git.exists">
         <fail message="Releasing is only possible from a git repository"/>
    </target>

    <target name="release-src-git" description="Package the git source tree (git)"
            depends="check-git" if="git.exists">
        <mkdir dir="${target.dir}"/>
        <exec executable="python" failonerror="true">
            <arg value="${omero.home}/components/antlib/scripts/source-archive.py"/>
            <arg value="openmicroscopy"/>
            <arg value="${omero.shortversion}"/>
            <arg value="${omero.plainversion}"/>
            <arg value="${omero.vcs.shortrevision}"/>
            <arg value="${omero.vcs.revision}"/>
            <arg value="${omero.vcs.date}"/>
            <arg value="${omero.vcs.date_unix}"/>
            <arg value="${target.dir}"/>
        </exec>

    </target>

    <target name="release-src" description="Package the git source tree into openmicroscopy-${omero.plainversion}.zip"
            depends="release-src-embed,release-src-git"/>

    <target name="release-clients" description="Zip the Python and Java zips">
        <zip destfile="${omero.home}/target/OMERO.py-${omero.version}.zip">
            <zipfileset dir="${dist.dir}" prefix="OMERO.py-${omero.version}"
                includes="bin/**,etc/**,lib/python/**,lib/fallback/**,sql/**,share/web/**" excludes="bin/omero"/>
            <zipfileset dir="${dist.dir}" prefix="OMERO.py-${omero.version}"
                includes="bin/omero" filemode="755"/>
        </zip>
        <zip destfile="${omero.home}/target/OMERO.java-${omero.version}.zip">
            <zipfileset dir="${dist.dir}/lib/client"    prefix="OMERO.java-${omero.version}/libs" includes="**/*.jar"/>
        </zip>

	<copy todir="target">
            <fileset dir="components/tools/OmeroPy/dist" includes="*.egg"/>
            <fileset dir="components/tools/OmeroFS/dist" includes="*.egg"/>
        </copy>
    </target>

    <target name="release-tar" description="Tar the dist directory into ${product-name}-${omero.version}.tar.bz2">
        <tar destfile="${product.name}-${omero.version}.tar.bz2" compression="bzip2">
            <zipfileset dir="${dist.dir}" prefix="${product.name}-${omero.version}"
                excludes="bin/omero"/>
            <zipfileset dir="${dist.dir}" prefix="${product.name}-${omero.version}"
                includes="bin/omero"
                filemode="755"/>
        </tar>
    </target>

    <target name="release-headers" description="Generates headers.xml for all components" depends="init">
       <iterate buildpathref="all.buildpath"   target="headers"/>
       <iterate buildpathref="tools.buildpath" target="headers"/>
       <iterate buildpathref="tests.buildpath" target="headers"/>
       <taskdef resource="checkstyletask.properties" classpathref="omero.classpath"/>
        <checkstyle config="${omero.home}/docs/styles/checkstyle-header.xml" failOnViolation="true">
            <fileset dir="${basedir}" includes="*,docs/**/*,etc/**/*,sql/**/*"/>
            <formatter type="xml" toFile="${target.dir}/headers.xml"/>
        </checkstyle>
    </target>

    <target name="release-findbugs" description="Generates findbugs.xml and checkstyle.xml for all components" depends="init">
       <iterate buildpathref="all.buildpath"   target="findbugs"/>
       <iterate buildpathref="tools.buildpath" target="findbugs"/>
    </target>

    <target name="release-docs" depends="release-sphinx-api" description="Generate Docs for all components under dist/docs/api">
        <zip destfile="${omero.home}/target/OMERO.apidoc-${omero.version}.zip">
            <zipfileset dir="${dist.dir}/docs" prefix="OMERO.apidoc-${omero.version}"/>
        </zip>
    </target>

    <target name="release-sphinx-api" depends="build-py,build-web"
        description="The OMERO.py Sphinx API Documentation">
        <mkdir dir="${dist.dir}/docs/api/python"/>

        <ant antfile="build.xml" dir="docs/sphinx-api" target="clean" inheritAll="false"/>
        <ant antfile="build.xml" dir="docs/sphinx-api" target="html" inheritAll="false">
            <property name="omero.shortversion" value="${omero.version}"/>
        </ant>

        <copy todir="${dist.dir}/docs/api/python">
            <fileset dir="docs/sphinx-api/_build/html"/>
        </copy>
    </target>

    <target name="release-training" description="Produces a zip with the examples/Training files">
        <zip destfile="${omero.home}/target/OMERO.training-${omero.version}.zip">
            <zipfileset dir="${omero.home}/examples/Training" prefix="OMERO.training-${omero.version}" includes="**" excludes="markup.py"/>
            <zipfileset dir="${omero.home}" prefix="OMERO.training-${omero.version}" includes="LICENSE.txt"/>
        </zip>
    </target>

    <!--
    Top-level helpers (shared helpers are in components/antlib/resources)
    =====================================================================
    -->
    <target name="build-dist" depends="init,copy-licenses,copy-history,copy-etc,copy-sql,copy-server,copy-client,copy-web-requirements,update-version,create-workdirs, copy-luts"
        description="Copy all components to dist/; called at the end of build-* targets"/>

    <target name="copy-licenses" depends="init">
        <copy file="${omero.home}/LICENSE.txt" todir="${dist.dir}/"/>
        <mkdir dir="${dist.dir}/share"/>
        <copy todir="${dist.dir}/share">
            <fileset dir="${omero.home}/lib/" includes="licenses/**"/>
        </copy>
    </target>

    <target name="copy-history" depends="init">
            <copy file="${omero.home}/history.rst" todir="${dist.dir}/"/>
    </target>

    <target name="copy-etc" depends="init">
            <copy todir="${dist.dir}/etc">
                <fileset dir="${omero.home}/etc">
                    <exclude name="local.properties*"/>
                    <exclude name="ivysettings.xml"/>
                </fileset>
            </copy>
            <copy file="${omero.home}/components/tests/ui/resources/robot.template" todir="${dist.dir}/etc/templates"/>

            <replace dir="${dist.dir}/etc" token="@ICE_LIB_VERSION@" value="${versions.ice_lib}"/>
    </target>

    <target name="copy-web-requirements" depends="init">
        <mkdir dir="${dist.dir}/share/web"/>
        <copy todir="${dist.dir}/share/web">
            <fileset dir="components/tools/OmeroWeb">
                <include name="requirements*.txt"/>
            </fileset>
        </copy>
    </target>

    <target name="copy-sql" depends="init">
            <copy todir="${dist.dir}">
                <fileset dir="${omero.home}">
                    <include name="sql/**"/>
                </fileset>
            </copy>
    </target>

    <target name="copy-client" depends="init">
        <mkdir dir="${dist.dir}/lib/client"/>
        <!-- sync="true" deletes any other files like services.jar or extensions.jar which may be under lib -->
        <ivy:resolve file="ivy.xml" type="jar,egg,bundle,zip" conf="client" settingsRef="ivy.toplevel" log="quiet"/>
        <ivy:retrieve conf="client" pattern="${dist.dir}/lib/client/[artifact].[ext]" sync="false" log="quiet" settingsRef="ivy.toplevel"/>
    </target>

    <target name="copy-server" depends="init">
        <mkdir dir="${dist.dir}/lib/server"/>
        <!-- sync="true" deletes any other files like services.jar or extensions.jar which may be under lib -->
        <ivy:resolve file="ivy.xml" type="jar,egg,bundle,zip" conf="server" settingsRef="ivy.toplevel" log="quiet"/>
        <ivy:retrieve conf="server" pattern="${dist.dir}/lib/server/[artifact].[ext]" sync="false" log="quiet" settingsRef="ivy.toplevel"/>
    </target>

    <target name="create-workdirs" depends="init">
        <mkdir dir="${dist.dir}/etc/grid"/>
        <mkdir dir="${dist.dir}/var"/>
    </target>

    <target name="copy-luts" depends="init">
        <mkdir dir="${dist.dir}/lib/scripts/luts"/>
        <copy todir="${dist.dir}/lib/scripts/luts">
            <fileset dir="luts"/>
        </copy>
    </target>

    <macrodef name="jar_update_if">
        <attribute name="destfile"/>
        <element name="filesets" implicit="yes"/>
        <sequential>
            <if>
                <available file="@{destfile}"/>
                <then>
                    <jar update="true" destfile="@{destfile}">
                        <filesets/>
                    </jar>
                </then>
            </if>
        </sequential>
    </macrodef>

    <target name="update-version">
        <loadproperties srcFile="${dist.dir}/etc/omero.properties">
            <filterchain>
                <headfilter skip="20" lines="-1"/>
                <prefixlines prefix="dist.check."/>
            </filterchain>
        </loadproperties>

        <if><not><equals arg1="${dist.check.omero.version}" arg2="${omero.version}"/></not>
        <then>
            <!-- Setting version -->
            <copy todir="${dist.dir}/etc" overwrite="true">
                <fileset dir="${omero.home}/etc" includes="omero.properties"/>
            </copy>
            <echo file="${dist.dir}/etc/omero.properties" append="true">
omero.version=${omero.version}
            </echo>

        </then>
        </if>
    </target>
    <macrodef name="ice-admin">
        <element name="args" implicit="yes"/>
        <sequential>
            <exec executable="python" dir="${dist.dir}" failonerror="true">
                <arg value="bin/omero"/>
                <arg value="admin"/>
                <arg value="ice"/>
                <args/>
            </exec>
        </sequential>
    </macrodef>

    <target name="print-mem">
        <echo>
            *.maxmem.* settings
            -------------------
            javac.maxmem=${javac.maxmem}
            javadoc.maxmem=${javadoc.maxmem}
            javac.maxmem.default=${javac.maxmem.default}
            javadoc.maxmem.default=${javadoc.maxmem.default}
        </echo>
    </target>
</project>