ant-global.xml

<project name="ant-global">
    <!-- Set properties that can be used in all projects. -->
    <dirname property="zimbra.root.dir" file="${ant.file.ant-global}"/>

    <!-- Java -->
    <property name="javac.target" value="1.7"/>

    <!-- Ignore the classpath from the shell running ant.  This avoids dependency
      on the user's environment and suppresses the warning about includeAntRuntime. -->
    <property name="build.sysclasspath" value="ignore"/>

    <!-- Standard directory paths -->
    <property name="src.dir" location="src" />
    <property name="src.java.dir" location="src/java" />
    <property name="src.bin.dir" location="src/bin" />
    <property name="src.libexec.dir" location="src/libexec" />
    <property name="src.zimlet.dir" location="src/zimlet" />
    <property name="jars.dir" location="jars" />
    <property name="build.dir" location="build" />
    <property name="dist.dir" location="build/dist" />
    <property name="build.classes.dir" location="${build.dir}/classes" />
    <property name="build.instrumented.dir" location="${build.dir}/classes-inst" />
    <property name="build.coverage.dir" location="${build.dir}/coverage" />
    <property name="build.zimlet.dir" location="${build.dir}/zimlet" />
    <property name="test.dir" location="${build.dir}/test"/>
    <property name="itest.dir" location="${build.dir}/itest"/>
    <property name="test.src.dir" location="src/java-test"/>
    <property name="test.classes.dir" location="${build.dir}/test-classes"/>

    <path id="all.java.path">
        <pathelement location="${src.java.dir}" />
    </path>

    <!-- Standard install paths -->
    <property name="zimbra.home.dir" location="/opt/zimbra" />

    <!-- ZimbraCommon -->
    <property name="common.dir" location="${zimbra.root.dir}/ZimbraCommon"/>
    <property name="common.src.java.dir" location="${zimbra.root.dir}/ZimbraCommon/src/java"/>
    <property name="common.classes.dir" location="${common.dir}/build/classes"/>
    <property name="common.jarfile" location="${common.dir}/build/zimbracommon.jar"/>
    <property name="common.jars.dir" location="${common.dir}/jars"/>
    <property name="common.sourcejars.dir" location="${common.dir}/jars-src"/>
    <property name="common.internal.jars.dir" location="${common.dir}/jars-internal/jars"/>

    <!-- ZimbraNative -->
    <property name="native.dir" location="${zimbra.root.dir}/ZimbraNative" />
    <property name="native.classes.dir" location="${native.dir}/build/classes" />
    <property name="native.jarfile" location="${native.dir}/build/zimbra-native.jar" />

    <!-- ZimbraServer -->
    <property name="server.dir" location="${zimbra.root.dir}/ZimbraServer"/>
    <property name="server.classes.dir" location="${server.dir}/build/classes"/>
    <property name="server.test.classes.dir" location="${server.dir}/build/test-classes"/>
    <property name="server.jarfile" location="${server.dir}/build/zimbrastore.jar"/>
    <property name="server.jars.dir" location="${server.dir}/jars"/>
    <property name="server.conf.dir" location="${server.dir}/conf"/>

    <!-- ZimbraSoap -->
    <property name="soap.dir" location="${zimbra.root.dir}/ZimbraSoap"/>
    <property name="soap.classes.dir" location="${soap.dir}/build/classes"/>
    <property name="soap.jarfile" location="${soap.dir}/build/zimbrasoap.jar"/>

    <!-- ZimbraClient -->
    <property name="client.dir" location="${zimbra.root.dir}/ZimbraClient"/>
    <property name="client.classes.dir" location="${client.dir}/build/classes"/>
    <property name="client.jarfile" location="${client.dir}/build/zimbraclient.jar"/>

    <!-- ZimbraTagLib -->
    <property name="taglib.dir" location="${zimbra.root.dir}/ZimbraTagLib"/>
    <property name="taglib.classes.dir" location="${taglib.dir}/build/classes"/>
    <property name="taglib.jarfile" location="${taglib.dir}/build/zimbrataglib.jar"/>
    <property name="taglib.jars.dir" location="${taglib.dir}/jars"/>

    <!-- Emma -->
    <property name="emma.dir" value="/usr/share/java" />

    <path id="emma.lib" >
      <pathelement location="${emma.dir}/emma.jar" />
      <pathelement location="${emma.dir}/emma_ant.jar" />
    </path>

    <path id="emma.run.classpath" >
      <pathelement location="${build.classes.dir}" />
    </path>

    <!-- customizations -->
    <property name="aux.jars.dir" location="${server.dir}/build/auxjars"/>
    
    <!-- Platform -->
    <condition property="native.os" value="MacOSX">
        <os name="Mac OS X"/>
    </condition>
    <condition property="native.os" value="Linux">
        <os name="Linux"/>
    </condition>
    <condition property="native.so" value="jnilib">
        <os name="Mac OS X"/>
    </condition>
    <condition property="native.so" value="so">
        <not><os name="Mac OS X"/></not>
    </condition>
    <condition property="native.arch" value="">
        <os name="Mac OS X"/>
    </condition>
    <condition property="native.arch" value=".${os.arch}">
        <not>
            <os name="Mac OS X"/>
        </not>
    </condition>
    <condition property="is-windows">
        <os family="windows"/>
    </condition>
    <condition property="is-unix">
        <not><os family="windows"/></not>
    </condition>

    <!-- Build version -->
    <taskdef resource="net/sf/antcontrib/antlib.xml">
        <classpath>
            <pathelement location="${common.jars.dir}/ant-contrib-1.0b1.jar"/>
        </classpath>
    </taskdef>
    <tstamp/>

    <condition property="zimbra.buildinfo.platform" value="${native.os}">
        <not><isset property="${zimbra.buildinfo.platform}"/></not>
    </condition>
    <condition property="zimbra.buildinfo.version" value="9.0.0_BETA1_1111">
        <not><isset property="${zimbra.buildinfo.version}"/></not>
    </condition>

    <propertyregex property="zimbra.buildinfo.majorversion"
                   input="${zimbra.buildinfo.version}"
                   regexp="([0-9]+)\.([0-9]+)\.([0-9]+)"
                   select="\1"
                   casesensitive="false" />

    <propertyregex property="zimbra.buildinfo.minorversion"
                   input="${zimbra.buildinfo.version}"
                   regexp="([0-9]+)\.([0-9]+)\.([0-9]+)"
                   select="\2"
                   casesensitive="false" />

    <propertyregex property="zimbra.buildinfo.microversion"
                   input="${zimbra.buildinfo.version}"
                   regexp="([0-9]+)\.([0-9]+)\.([0-9]+)"
                   select="\3"
                   casesensitive="false" />

    <propertyregex property="zimbra.buildinfo.relclass"
                   input="${zimbra.buildinfo.version}"
                   regexp="([0-9]+)\.([0-9]+)\.([0-9]+)_([A-Z]+)"
                   select="\4"
                   casesensitive="false" />
    <propertyregex property="zimbra.buildinfo.relnum"
                   input="${zimbra.buildinfo.version}"
                   regexp="([0-9]+)\.([0-9]+)\.([0-9]+)_([A-Z]+)([0-9]+)(\.|_)?"
                   select="\5"
                   casesensitive="false" />

    <propertyregex property="zimbra.buildinfo.buildnum"
                   input="${zimbra.buildinfo.version}"
                   regexp="([0-9]+)\.([0-9]+)\.([0-9]+)_([A-Z0-9]+)(\.|_)?([0-9]+)?"
                   select="\6"
                   casesensitive="false" />

    <condition property="zimbra.buildinfo.relnum" value="0">
        <not><isset property="${zimbra.buildinfo.relnum}"/></not>
    </condition>

    <condition property="zimbra.buildinfo.type" value="">
        <not><isset property="${zimbra.buildinfo.type}"/></not>
    </condition>
    <condition property="zimbra.buildinfo.release" value="${user.name}">
        <not><isset property="${zimbra.buildinfo.release}"/></not>
    </condition>
    <condition property="zimbra.buildinfo.date" value="${DSTAMP}-${TSTAMP}">
        <not><isset property="${zimbra.buildinfo.date}"/></not>
    </condition>
    <condition property="zimbra.buildinfo.host" value="${zimbra.server.hostname}">
        <not><isset property="${zimbra.buildinfo.host}"/></not>
    </condition>
    <property name="zimbra.buildinfo.all"
              value="Version: ${zimbra.buildinfo.version}; Type: ${zimbra.buildinfo.type}; Release: ${zimbra.buildinfo.release}; Built: ${zimbra.buildinfo.date}; Host: ${zimbra.buildinfo.host}"/>

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

    <target name="compile" description="Compiles from src/java into build/classes.">
        <mkdir dir="${build.classes.dir}" />
        <javac destdir="${build.classes.dir}" debug="true" classpathref="class.path" target="${javac.target}">
            <src refid="all.java.path" />
        </javac>
    </target>

    <target name="test-compile" depends="compile">
        <mkdir dir="${test.classes.dir}"/>
        <javac srcdir="${test.src.dir}" destdir="${test.classes.dir}"
               debug="true" classpathref="class.path" target="${javac.target}"/>
        <copy todir="${test.classes.dir}">
            <fileset dir="${test.src.dir}" excludes="**/*.java"/>
        </copy>
    </target>

    <target name="test" depends="test-compile" description="Run unit tests">
        <property name="test.path" refid="class.path"/>
        <delete dir="${test.dir}" quiet="true"/>
        <mkdir dir="${test.dir}/output"/>
        <mkdir dir="${test.dir}/report"/>
        <copy file="${test.src.dir}/log4j-test.properties" tofile="${test.classes.dir}/log4j.properties" failonerror="false"/>
        <junit printsummary="on" showoutput="true" failureproperty="junit.failure" tempdir="${test.dir}">
            <classpath refid="class.path"/>
            <classpath path="${test.classes.dir}"/>
            <assertions><enable/></assertions>
            <formatter type="xml"/>
            <batchtest todir="${test.dir}/output">
                <fileset dir="${test.src.dir}">
                    <include name="**/*Test.java"/>
                    <exclude name="**/*ITest.java"/>
                    <exclude name="**/Abstract*Test.java"/>
                </fileset>
            </batchtest>
        </junit>
        <junitreport todir="${test.dir}/report">
            <fileset dir="${test.dir}/output"/>
            <report todir="${test.dir}/report"/>
        </junitreport>
        <echo>Test Report: ${test.dir}/report/index.html</echo>
        <fail if="junit.failure" message="Unit test failed"/>
    </target>

    <target name="test-hudson" depends="test-compile" description="Run hudson unit tests">
        <property name="test.path" refid="class.path"/>
        <delete dir="${test.dir}" quiet="true"/>
        <mkdir dir="${test.dir}/output"/>
        <mkdir dir="${test.dir}/report"/>
        <copy file="${test.src.dir}/log4j-test.properties" tofile="${test.classes.dir}/log4j.properties" failonerror="false"/>
        <junit printsummary="on" showoutput="true" failureproperty="junit.failure" tempdir="${test.dir}">
            <classpath refid="class.path"/>
            <classpath path="${test.classes.dir}"/>
            <assertions><enable/></assertions>
            <formatter type="xml"/>
            <batchtest todir="${test.dir}/output">
                <fileset dir="${test.src.dir}">
                    <include name="**/*Test.java"/>
                    <exclude name="**/*ITest.java"/>
                    <exclude name="**/Abstract*Test.java"/>
                </fileset>
            </batchtest>
        </junit>
        <junitreport todir="${test.dir}/report">
            <fileset dir="${test.dir}/output"/>
            <report todir="${test.dir}/report"/>
        </junitreport>
        <echo>Test Report: ${test.dir}/report/index.html</echo>
        <fail if="junit.failure" message="Unit test failed"/>
    </target>

    <!-- e.g. ant -Dtest.name=com.zimbra.cs.mailbox.ContactTest single-test -->
    <target name="single-test" depends="test-compile" description="Run single unit test">
        <fail message="test.name must be set - Need e.g. ant -Dtest.name=com.zimbra.cs.mailbox.ContactTest single-test"
              unless="test.name"/>
        <property name="single.test.dir" value="${test.dir}-${test.name}"/>
        <delete dir="${single.test.dir}" quiet="true"/>
        <mkdir dir="${single.test.dir}/output"/>
        <mkdir dir="${single.test.dir}/report"/>
        <copy file="${test.src.dir}/log4j-test.properties" tofile="${test.classes.dir}/log4j.properties" failonerror="false"/>
        <junit printsummary="on" showoutput="true" failureproperty="junit.failure" tempdir="${single.test.dir}">
            <classpath refid="class.path"/>
            <classpath path="${test.classes.dir}"/>
            <assertions><enable/></assertions>
            <formatter type="xml"/>
            <test name="${test.name}" todir="${single.test.dir}/output" />
        </junit>
        <junitreport todir="${single.test.dir}/report">
            <fileset dir="${single.test.dir}/output"/>
            <report todir="${single.test.dir}/report"/>
        </junitreport>
        <echo>Test Report: ${single.test.dir}/report/index.html</echo>
        <fail if="junit.failure" message="Single Unit test failed"/>
    </target>

    <target name="emma" description="Emma Instrumentation">

      <taskdef resource="emma_ant.properties" classpathref="emma.lib"/>
      <delete dir="${build.instrumented.dir}" quiet="true" />
      <mkdir dir="${build.instrumented.dir}" />
      <delete dir="${build.coverage.dir}" quiet="true"/>
      <mkdir dir="${build.coverage.dir}" />
      <emma>
        <instr instrpathref="emma.run.classpath"
               destdir="${build.instrumented.dir}"
               metadatafile="${build.coverage.dir}/metadata.emma"
               merge="true"
               />
      </emma>
    </target>

    <target name="test-coverage" depends="test-compile,emma" description="Run unit tests">
      <property name="test.path" refid="class.path"/>
      <delete dir="${test.dir}" quiet="true"/>
      <mkdir dir="${test.dir}/output"/>
      <mkdir dir="${test.dir}/report"/>
      <copy file="${test.src.dir}/log4j-test.properties" tofile="${test.classes.dir}/log4j.properties" failonerror="false"/>
      <taskdef resource="emma_ant.properties" classpathref="emma.lib"/>
      <junit fork="yes" printsummary="on" failureproperty="junit.failure" tempdir="${test.dir}">
        <classpath refid="emma.lib" />
        <classpath location="${build.instrumented.dir}" />
        <classpath refid="class.path"/>
        <classpath path="${test.classes.dir}"/>
        <jvmarg value="-Demma.coverage.out.file=${build.coverage.dir}/coverage.emma" /> 
        <jvmarg value="-Demma.coverage.out.merge=true" /> 
        <formatter type="xml"/>
        <batchtest todir="${test.dir}/output">
          <fileset dir="${test.src.dir}">
            <include name="**/*Test.java"/>
            <exclude name="**/*ITest.java"/>
            <exclude name="**/Abstract*Test.java"/>
	    <exclude name="**/RemoteMailboxContactOpsTest.java"/>
	    <exclude name="**/yc/**/*.java"/>
          </fileset>
        </batchtest>
      </junit>
      <junitreport todir="${test.dir}/report">
        <fileset dir="${test.dir}/output"/>
        <report todir="${test.dir}/report"/>
      </junitreport>
      <emma>
        <report sourcepath="${src.java.dir}">
          <fileset dir="${build.coverage.dir}">
            <include name="*.emma" />
          </fileset>
          <xml outfile="${build.coverage.dir}/coverage.xml" />
        </report>
      </emma>
      <echo>Test Report: ${test.dir}/report/index.html</echo> 
      <fail if="junit.failure" message="Unit test failed"/>
    </target>


    <target name="integration-test" depends="test-compile" description="Run integration tests">
        <property name="test.path" refid="class.path"/>
        <delete dir="${itest.dir}" quiet="true"/>
        <mkdir dir="${itest.dir}/output"/>
        <mkdir dir="${itest.dir}/report"/>
        <junit printsummary="on" failureproperty="junit.failure" tempdir="${itest.dir}">
            <classpath refid="class.path"/>
            <classpath path="${test.classes.dir}"/>
            <assertions><enable/></assertions>
            <formatter type="xml"/>
            <batchtest todir="${itest.dir}/output">
                <fileset dir="${test.src.dir}">
                    <include name="**/*ITest.java"/>
                </fileset>
            </batchtest>
        </junit>
        <junitreport todir="${itest.dir}/report">
            <fileset dir="${itest.dir}/output"/>
            <report todir="${itest.dir}/report"/>
        </junitreport>
        <echo>Test Report: ${itest.dir}/report/index.html</echo>
        <fail if="junit.failure" message="Integration test failed"/>
    </target>

    <target name="generate-jar-version" description="Creates the Version class that prints the version of the jarfile.  This class is the Main-Class in the jarfile's manifest.">
        <fail unless="build.dir" />
        <fail unless="build.classes.dir" />

        <if>
            <not><available file="${build.dir}/buildinfo/com/zimbra/buildinfo/Version.java"/></not>
            <then>
                <mkdir dir="${build.dir}/buildinfo/com/zimbra/buildinfo"/>
                <echo file="${build.dir}/buildinfo/com/zimbra/buildinfo/Version.java">
                    package com.zimbra.buildinfo;

                    public class Version {

                    public static void main(String[] args) {
                        Package p = Version.class.getPackage();
                        System.out.println("Implementation-Title: " + p.getImplementationTitle() +
                            "\nImplementation-Version: " + p.getImplementationVersion() +
                            "\nImplementation-Vendor: " + p.getImplementationVendor() + "\n");
                        }
                    }
                </echo>
            </then>
        </if>
        <javac destdir="${build.classes.dir}" debug="true" target="${javac.target}" srcdir="${build.dir}/buildinfo" />
    </target>

    <target name="zimbra-jar" depends="generate-jar-version" description="Builds a standard jar file that prints its version info when executed.  Optionally sets the Zimbra-Extension-Class attribute in the manifest if the zimbra.extension.class property is set.">
        <fail unless="jar.file"/>
        <fail unless="implementation.title"/>

        <if>
            <isset property="zimbra.extension.class"/>
            <then>
	        <jar destfile="${build.dir}/${jar.file}" basedir="${build.classes.dir}">
	            <manifest>
	                <attribute name="Main-Class" value="com.zimbra.buildinfo.Version" />
	                <attribute name="Implementation-Vendor" value="Zimbra Software, LLC"/>
	                <attribute name="Implementation-Title" value="${implementation.title}"/>
	                <attribute name="Implementation-Version" value="${zimbra.buildinfo.version}"/>
	                <attribute name="Specification-Vendor" value="Zimbra Software, LLC"/>
	                <attribute name="Specification-Title" value="Zimbra Collaboration Suite"/>
	                <attribute name="Specification-Version" value="${zimbra.buildinfo.majorversion}.${zimbra.buildinfo.minorversion}.${zimbra.buildinfo.microversion}"/>
	                <attribute name="Zimbra-Extension-Class" value="${zimbra.extension.class}"/>
	            </manifest>
	        </jar>
            </then>
            <else>
	        <jar destfile="${build.dir}/${jar.file}" basedir="${build.classes.dir}">
	            <manifest>
	                <attribute name="Main-Class" value="com.zimbra.buildinfo.Version" />
	                <attribute name="Implementation-Vendor" value="Zimbra Software, LLC"/>
	                <attribute name="Implementation-Title" value="${implementation.title}"/>
	                <attribute name="Implementation-Version" value="${zimbra.buildinfo.version}"/>
	                <attribute name="Specification-Vendor" value="Zimbra Software, LLC"/>
	                <attribute name="Specification-Title" value="Zimbra Collaboration Suite"/>
	                <attribute name="Specification-Version" value="${zimbra.buildinfo.majorversion}.${zimbra.buildinfo.minorversion}.${zimbra.buildinfo.microversion}"/>
	            </manifest>
	        </jar>
            </else>
        </if>
    </target>
    <target name="zmlocalconfig">
      <echo>Running localconfig with with argument: ${localconfig-args}</echo>
      <java classname="com.zimbra.cs.localconfig.LocalConfigCLI" fork="true" classpathref="class.path" failonerror="true">
        <arg line="${localconfig-args}"/>
      </java>
    </target>
</project>