build.xml

<project name="cacheonix" default="usage" xmlns:artifact="antlib:org.apache.maven.artifact.ant">

   <typedef resource="org/apache/maven/artifact/ant/antlib.xml" uri="antlib:org.apache.maven.artifact.ant"
            classpath="3rdparty/maven-ant-tasks-2.1.3/maven-ant-tasks-2.1.3.jar"/>

   <!-- Environment variables -->
   <property environment="env"/>
   <property file="core.properties"/>

   <!-- Version -->
   <property name="release.major" value="2"/>
   <property name="release.minor" value="4"/>

   <!-- Location of source files -->
   <property name="config.dir" value="conf"/>
   <property name="test.data.dir" value="test/data"/>
   <property name="pmd.home" value="3rdparty/pmd-4.0"/>

   <!-- Results -->
   <property name="test.classes.dir" value="temp/test/classes"/>

   <!-- Site deployment -->
   <property name="sdar.result" value="temp/deployment/result"/>
   <property name="sdar.staging" value="temp/deployment/staging"/>

   <!-- Working directories -->
   <property name="build.temp.dir" value="temp/build/temp"/>
   <property name="generated.dir" value="temp/generated"/>
   <property name="test.temp.dir" value="temp/test/temp"/>
   <property name="clover.dir" value="temp/clover"/>
   <property name="clover.db.dir" value="${clover.dir}/db"/>

   <!-- 3rd party -->
   <property name="asm.home" value="3rdparty/asm-3.1"/>
   <property name="junit.jar" value="3rdparty/junit3.8.2/junit.jar"/>
   <property name="mockito.jar" value="3rdparty/mockito-1.8.5/mockito-all-1.8.5.jar"/>
   <property name="mx4j-jmx.jar" value="3rdparty/mx4j-3.0.2/lib/mx4j-jmx.jar"/>
   <property name="mail.jar" value="3rdparty/mail/mail.jar"/>
   <property name="jms.jar" value="3rdparty/jms-1.1/jms.jar"/>
   <property name="clover.jar" value="3rdparty/clover1312/lib/clover.jar"/>
   <property name="cenquatasks.jar" value="3rdparty/clover1312/etc/cenquatasks.jar"/>
   <property name="ibatis.jar" value="3rdparty/ibatis-2.3.0.677/lib/ibatis-2.3.0.677.jar"/>
   <property name="hibernate.jar" value="3rdparty/hibernate-3.2/hibernate3.jar"/>
   <property name="gsbase.jar" value="3rdparty/gbase20/gsbase-2.0.jar"/>
   <property name="servlets.jar" value="3rdparty/servlets-2.3/servletapi-2.3.jar"/>
   <property name="commons-math.jar" value="3rdparty/commons-math-1.2/commons-math-1.2.jar"/>
   <property name="array-utils.jar" value="3rdparty/cacheonix-array-utils-1.0.3/cacheonix-array-utils-1.0.3.jar"/>
   <property name="mybatis.jar" value="3rdparty/mybatis-3.0.5/mybatis-3.0.5.jar"/>
   <property name="spring-modules-cache.jar"
             value="3rdparty/spring-modules-integration-proxy/spring-modules-cache.jar"/>
   <property name="spring.jar" value="3rdparty/spring-framework-2.5.1/dist/spring.jar"/>
   <property name="activation.jar" value="3rdparty/jaf-1.0.2/activation.jar"/>
   <property name="catalina-7.0.30.jar" value="3rdparty/apache-tomcat-7.0.30/lib/catalina.jar"/>
   <property name="findbugs.home" value="3rdparty/findbugs-2.0.3"/>
   <property name="checkstyle-all.jar" value="3rdparty/checkstyle-5.3/checkstyle-5.3-all.jar"/>
   <property name="primefaces.jar" value="3rdparty/primefaces-6.0/primefaces-6.0.jar"/>

   <!-- Maven snapshots and staging repository id and url -->
   <property name="ossrh-snapshots-repository-url" value="https://oss.sonatype.org/content/repositories/snapshots/"/>
   <property name="ossrh-staging-repository-url" value="https://oss.sonatype.org/service/local/staging/deploy/maven2/"/>

   <!-- Tasks -->
   <taskdef resource="com/cenqua/ant/antlib.xml" classpath="${cenquatasks.jar}"/>
   <taskdef name="if" classname="ise.antelope.tasks.IfTask" classpath="${antelope.jar}"/>
   <extendclasspath path="${clover.jar}"/>
   <taskdef resource="clovertasks" classpath="${clover.jar}"/>

   <taskdef name="findbugs" classname="edu.umd.cs.findbugs.anttask.FindBugsTask"
            classpath="${findbugs.home}/lib/findbugs-ant.jar"/>

   <!-- Defines source files -->
   <path id="src">
      <fileset dir="${src.dir}">
         <include name="**/*.java"/>
         <exclude name="org/cacheonix/impl/util/logging/jmx/*.**,
                     org/cacheonix/impl/util/logging/misc/*,
                     org/cacheonix/impl/util/logging/**/UnitTest*.java,
                     org/cacheonix/impl/util/logging/**/StressCategory.java,
                     org/cacheonix/impl/util/logging/**/doc-files/*,
                     org/cacheonix/impl/util/logging/net/JMS*.java,
                     org/cacheonix/impl/util/logging/or/jms/*.java"/>
      </fileset>
   </path>


   <!--
   Defines classpath to build cacheonix
   -->
   <path id="build.classpath">
      <pathelement path="${activation.jar}"/>
      <pathelement path="${array-utils.jar}"/>
      <pathelement path="${clover.jar}"/>
      <pathelement path="${hibernate.jar}"/>
      <pathelement path="${ibatis.jar}"/>
      <pathelement path="${jms.jar}"/>
      <pathelement path="${mail.jar}"/>
      <pathelement path="${mx4j-jmx.jar}"/>
      <pathelement path="${servlets.jar}"/>
      <pathelement path="${spring.jar}"/>
      <pathelement path="${spring-modules-cache.jar}"/>
      <pathelement path="${catalina-7.0.30.jar}"/>
      <pathelement path="${mybatis.jar}"/>
      <pathelement path="${primefaces.jar}"/>
   </path>


   <!--
   Defines classpath to build tests
   -->
   <path id="test.classpath">
      <path refid="build.classpath"/>
      <pathelement path="${classes.dir}"/>
      <pathelement path="${commons-math.jar}"/>
      <pathelement path="${gsbase.jar}"/>
      <pathelement path="${junit.jar}"/>
      <pathelement path="${mockito.jar}"/>
   </path>


   <!--
   Defines classpath to run tests
   -->
   <path id="junit.classpath">
      <path refid="test.classpath"/>
      <pathelement path="${test.classes.dir}/"/>
      <pathelement path="conf/jar"/>
      <pathelement path="test/conf"/>
      <pathelement path="test/data"/>
   </path>

   <!--
   Outputs usage information
   -->
   <target name="usage">
      <echo message="all              - builds all"/>
      <echo message="all.clean        - builds all cleanly"/>
      <echo message="test             - runs unit tests"/>
      <echo message="with.clover test - runs unit tests with clover instrumentation enabled"/>
   </target>


   <!--
   Prepares
   -->
   <target name="init">
      <mkdir dir="${dist.bin.staging.dir}"/>
      <mkdir dir="${test.classes.dir}"/>
      <mkdir dir="${build.temp.dir}"/>
      <mkdir dir="${test.temp.dir}"/>
      <mkdir dir="${test.log.dir}"/>
      <mkdir dir="${classes.dir}"/>
   </target>


   <!--
   Cleans everything
   -->
   <target name="clean">
      <delete dir="temp"/>
   </target>


   <!--
   Replaces version information with actual build values.
   -->
   <target name="version">

      <!-- Prepare version tokens -->
      <echo message="Set tokens"/>
      <if name="env.CACHEONIX_BUILD_NUMBER">
         <property name="release.build" value="${env.CACHEONIX_BUILD_NUMBER}"/>
         <property name="release.change" value="${env.CACHEONIX_CHANGE_LIST_NUMBER}"/>
         <property name="release.date" value="${env.CACHEONIX_BUILD_TIMESTAMP}"/>
         <if name="env.CACHEONIX_VERSION">
            <property name="release.patch" value="${env.CACHEONIX_VERSION}"/>
            <break/>
            <else>
               <property name="release.patch" value="SNAPSHOT"/>
            </else>
         </if>
         <break/>
         <else>
            <property name="release.build" value="0"/>
            <property name="release.change" value="0"/>
            <property name="release.patch" value="SNAPSHOT"/>
            <tstamp>
               <format property="release.date" pattern="yyyyMMddHHmmss" locale="en"/>
            </tstamp>
         </else>
      </if>

      <!-- Generate release version -->
      <if>
         <bool>
            <contains string="${release.patch}" substring="SNAPSHOT" casesensitive="false"/>
         </bool>
         <property name="release.version" value="${release.major}.${release.minor}-${release.patch}"/>
         <break/>
         <else>
            <property name="release.version" value="${release.major}.${release.minor}.${release.patch}"/>
         </else>
      </if>

      <!-- Generate version file -->
      <property name="release.suffix" value="-${release.build}"/>
      <echo message="  Release version : ${release.version}"/>
      <echo message="     Build number : ${release.build}"/>
      <echo message="      Change list : ${release.change}"/>
      <echo message="       Build date : ${release.date}"/>

      <echo message="Generate version file"/>
      <propertyfile file="temp/version.properties" comment="Release version">
         <entry key="release.major" value="${release.major}"/>
         <entry key="release.minor" value="${release.minor}"/>
         <entry key="release.patch" value="${release.patch}"/>
         <entry key="release.date" value="${release.date}"/>
         <entry key="release.change" value="${release.change}"/>
         <entry key="release.suffix" value="${release.suffix}"/>
         <entry key="release.version" value="${release.version}"/>
         <entry key="release.build" value="${release.build}"/>
      </propertyfile>

      <echo message="Generate version class"/>
      <mkdir dir="${generated.dir}/cacheonix"/>
      <copy file="src/org/cacheonix/Version.java" todir="${generated.dir}/cacheonix" overwrite="yes">
         <filterset>
            <filter token="release.patch.version" value="${release.patch}"/>
            <filter token="release.change" value="${release.change}"/>
            <filter token="release.build" value="${release.build}"/>
            <filter token="release.date" value="${release.date}"/>
         </filterset>
      </copy>
   </target>


   <!--
   Initializes build to run with clover instrumentation
   -->
   <target name="with.clover" depends="init">
      <property name="is.with.clover" value="true"/>
      <mkdir dir="${clover.db.dir}"/>
      <clover-setup initString="${clover.db.dir}/coverage.db" source="1.5">
         <files>
            <include name="**/*.java"/>
            <exclude name="org/cacheonix/impl/util/concurrent/**/*.java"/>
            <exclude name="org/cacheonix/impl/util/logging/**/*.java"/>
            <exclude name="org/cacheonix/impl/util/**/*.java"/>
         </files>
      </clover-setup>
   </target>


   <!--
   Compiles version
   -->
   <target name="javac.version" depends="init, version">
      <javac srcdir="${generated.dir}" destdir="${classes.dir}" includes="cacheonix/Version.java"
             fork="yes" debug="yes">
      </javac>
   </target>


   <!--
   Compiles product
   -->
   <target name="javac.core" depends="javac.version">
      <javac srcdir="${src.dir}" destdir="${classes.dir}" classpathref="build.classpath" excludes="org/cacheonix/impl/util/logging/jmx/*.**,
                  org/cacheonix/impl/util/logging/misc/*, org/cacheonix/impl/util/logging/**/UnitTest*.java,
                  org/cacheonix/impl/util/logging/**/StressCategory.java,
                  org/cacheonix/impl/util/logging/**/doc-files/*,
                  org/cacheonix/impl/util/logging/net/JMS*.java,
                  org/cacheonix/impl/util/logging/or/jms/*.java"
             fork="yes" debug="yes">
      </javac>
   </target>


   <!--
   Compiles tests
   -->
   <target name="javac.tests" depends="init, version">
      <!-- Disable clover for tests -->
      <clover-setup initString="${clover.db.dir}/coverage.db" enabled="no"/>
      <javac srcdir="${test.src.dir}" destdir="${test.classes.dir}" classpathref="test.classpath"
             fork="yes" debug="yes">
      </javac>
   </target>

   <!--
   Compiles everything
   -->
   <target name="javac"
           depends="javac.version, javac.core, javac.tests"/>


   <!-- Runs findbugs -->
   <target name="findbugs" depends="javac">
      <findbugs home="${findbugs.home}" output="html" reportLevel="medium" quietErrors="false"
                excludeFilter="quality/findbugs.xml" outputFile="${test.log.dir}/findbug-result.html"
                effort="max" jvmargs="-Xmx200m">
         <auxClasspath refid="build.classpath"/>
         <class location="${classes.dir}"/>
         <sourcePath path="${src.dir}"/>
      </findbugs>
   </target>


   <!-- Runs pmd -->
   <target name="pmd" depends="javac">
      <property name="pmd.html.report" value="${test.log.dir}/pmd_report.html"/>
      <property name="pmd.xml.report" value="${test.log.dir}/pmd_report.xml"/>
      <property name="cpd.text.report" value="${test.log.dir}/cpd_report.txt"/>
      <echo message="PMD HTML Report: ${pmd.html.report}"/>
      <echo message="PMD XML Report : ${pmd.xml.report}"/>
      <echo message="CPD Text Report: ${cpd.text.report}"/>
      <path id="pmd.classpath">
         <fileset dir="${pmd.home}/java14/lib" includes="**/*.jar"/>
         <path path="${pmd.home}/lib/jaxen-1.1.jar"/>
      </path>
      <taskdef name="pmd" classname="net.sourceforge.pmd.ant.PMDTask" classpathref="pmd.classpath"/>
      <pmd rulesetfiles="quality/pmd.xml" failOnRuleViolation="true">
         <fileset dir="${src.dir}" includes="**/*.java" excludes="
                     org/cacheonix/impl//util/concurrent/**/*.java,
                     org/cacheonix/impl//util/binding/**/*.java,
                     org/cacheonix/impl//util/logging/**/*.java,
                     org/cacheonix/impl//util/**/*.java,
                     org/cacheonix/impl//net/remoting/**/*.java,
                     org/cacheonix/impl//net/multicast/totem/**/*.java,
                     "/>
         <fileset dir="${test.src.dir}" includes="**/*.java"/>
         <formatter type="html" toFile="${pmd.html.report}"/>
         <formatter type="xml" toFile="${pmd.xml.report}"/>
         <formatter type="text" toConsole="true"/>
      </pmd>
      <taskdef name="cpd" classname="net.sourceforge.pmd.cpd.CPDTask" classpathref="pmd.classpath"/>
      <cpd minimumTokenCount="50" outputFile="${cpd.text.report}">
         <fileset dir="${src.dir}" includes="**/*.java"/>
      </cpd>
   </target>

   <!-- Runs checkstyle -->
   <target name="checkstyle" depends="javac">
      <taskdef resource="checkstyletask.properties" classpath="${checkstyle-all.jar}"/>
      <checkstyle config="quality/checkstyle.xml" failOnViolation="false">
         <fileset dir="src" includes="**/*.java"/>
         <formatter type="xml" toFile="${test.log.dir}/checkstyle_errors.xml"/>
      </checkstyle>

      <style in="${test.log.dir}/checkstyle_errors.xml" out="${test.log.dir}/checkstyle_report.html"
             style="quality/3rdparty/checkstyle-5.3/contrib/checkstyle-noframes-severity-sorted.xsl"/>
   </target>

   <target name="quality" depends="pmd, findbugs, checkstyle"/>

   <!-- Runs tests -->
   <target name="test.cacheonix" depends="javac">
      <junit fork="yes" printsummary="on" haltonfailure="${fail.fast}" haltonerror="${fail.fast}" showoutput="yes"
             errorproperty="test.errors" failureproperty="test.failures">
         <classpath refid="junit.classpath"/>
         <jvmarg value="-Xms1024m"/>
         <jvmarg value="-Xmx1024m"/>
         <jvmarg value="-Dcacheonix.client.request.timeout=120s"/>
         <jvmarg value="-Dcacheonix.home.alone.timeout=5000"/>
         <jvmarg value="-Dcacheonix.logging.level=debug"/>
         <jvmarg value="-Dcacheonix.multicast.ttl=0"/>
         <jvmarg value="-Djava.awt.headless=true"/>
         <jvmarg value="-Djava.io.tmpdir=${test.temp.dir}"/>
         <jvmarg value="-Djava.net.preferIPv4Stack=true"/>
         <jvmarg value="-Dtest.data.home=${test.data.dir}"/>
         <!-- Run only test defined by test.single property -->
         <batchtest todir="${test.log.dir}" if="test.single">
            <fileset dir="${test.classes.dir}">
               <include name="**/${test.single}*.class"/>
               <exclude name="**/*$*.class"/>
            </fileset>
         </batchtest>

         <!-- Run all standlalone tests as a batch -->
         <batchtest todir="${test.log.dir}" unless="test.single">
            <fileset dir="${test.classes.dir}">
               <include name="**/*Test.class"/>
               <exclude name="**/*$*.class"/>
               <exclude name="**/PerformanceTest*.class"/>
            </fileset>
         </batchtest>

         <formatter type="xml" if="env.CACHEONIX_BUILD_NAME"/>
         <formatter type="plain" usefile="false"/>
      </junit>
   </target>

   <target name="test" depends="all, test.cacheonix"/>

   <!--
   Generates clover report
   -->
   <target name="clover.report" depends="with.clover, test">
      <clover-report>
         <current outfile="${clover.dir}/html_report" title="Cacheonix Test Coverage">
            <format type="html"/>
         </current>
      </clover-report>
   </target>


   <!--
   Generates Javadoc
   -->
   <target name="javadoc.core" depends="javac">
      <mkdir dir="${dist.javadoc.dir}"/>
      <javadoc destdir="${dist.javadoc.dir}" sourcepath="${src.dir}" packagenames="org.cacheonix.*"
               windowtitle="Cacheonix ${release.version} API" package="true" author="true" version="true"
               noindex="true" use="true">
         <classpath refid="build.classpath"/>
         <tag name="noinspection" enabled="false"/>
         <doctitle><![CDATA[<h1>Cacheonix</h1>]]></doctitle>
         <bottom>
            <![CDATA[<a href="http://www.org.cacheonix.org/support.htm">Cacheonix Support</a> |
            <a href="http://wiki.org.cacheonix.org/display/CCHNX/Cacheonix+Knowledge+Base">Cacheonix Knowledgebase</a> |
            <i>Copyright &#169; 2006-2021 <a href="http://www.org.cacheonix.org">Cacheonix Systems</a>. All Rights Reserved.</i>]]></bottom>
      </javadoc>
   </target>

   <!--
   Builds all Javadoc
   -->
   <target name="javadoc" depends="javadoc.core"/>

   <!--
   Generates core Jar
   -->
   <target name="jar.core" depends="javac">
      <mkdir dir="${dist.lib.dir}"/>
      <jar basedir="${classes.dir}" destfile="${dist.cacheonix.jar}">
         <metainf dir="conf/jar/META-INF"/>
         <manifest>
            <attribute name="Main-Class" value="org.cacheonix.Version"/>
         </manifest>
         <zipfileset src="${array-utils.jar}"/>
      </jar>
   </target>


   <!--
   Zips Javadoc
   -->
   <target name="zip.javadoc" depends="javadoc.core">
      <mkdir dir="${dist.lib.dir}"/>
      <zip destfile="${dist.cacheonix-javadoc.zip}" basedir="${dist.javadoc.dir}"/>
   </target>


   <!--
   Creates Cacheonix libraries
   -->
   <target name="lib" depends="jar.core, zip.javadoc"/>

   <!--
   Builds bin directory
   -->
   <target name="bin">
      <mkdir dir="${dist.bin.dir}"/>
      <copy todir="${dist.bin.dir}">
         <fileset dir="bin"/>
      </copy>
   </target>


   <!--
   Copies Cacheonix license
   -->
   <target name="license">
      <mkdir dir="${dist.bin.staging.dir}"/>
      <copy file="LICENSE.txt" todir="${dist.bin.staging.dir}"/>
   </target>


   <!--
   Generates core source
   -->
   <target name="src.core">
      <mkdir dir="${dist.lib.dir}"/>
      <jar basedir="${src.dir}" destfile="${dist.cacheonix.src}"/>
   </target>


   <!--
   Builds source
   -->
   <target name="src" depends="src.core">
      <mkdir dir="${dist.src.staging.dir}"/>
      <copy todir="${dist.src.staging.dir}">
         <fileset dir=".">
            <exclude name="temp/**"/>
            <exclude name="internal/**"/>
            <exclude name="internal.*"/>
            <exclude name="deployment/**"/>
            <exclude name="deployment.*"/>
            <exclude name="quality/**"/>
            <exclude name="quality.*"/>
            <exclude name="examples/**"/>
            <exclude name="examples.*"/>
            <exclude name="**/*.iml"/>
            <exclude name="**/*.ipr"/>
            <exclude name="**/*.iws"/>
         </fileset>
      </copy>
   </target>


   <!--
   Builds examples
   -->
   <target name="examples">
      <mkdir dir="${dist.examples.dir}"/>
      <copy todir="${dist.examples.dir}">
         <fileset dir="examples"/>
      </copy>
   </target>


   <!-- Builds everything -->
   <target name="all" depends="javac, javadoc, license, lib, bin, src"/>


   <!-- Creates Cacheonix distribution -->
   <target name="dist" depends="all">

      <!-- Create binary -->
      <mkdir dir="${dist.result.dir}"/>

      <!-- Copy jar to dist result -->
      <copy file="${dist.cacheonix.jar}" todir="${dist.result.dir}"/>

      <!-- Copy Javadoc to dist result -->
      <copy todir="${dist.result.dir}">
         <fileset dir="${dist.doc.dir}"/>
      </copy>

      <!-- Zip binary distribution -->
      <property name="dist.bin.zip" value="cacheonix-binary-${release.version}.zip"/>
      <zip basedir="${dist.bin.staging.dir}" destfile="${dist.result.dir}/${dist.bin.zip}"/>

      <!-- Zip source distribution -->
      <property name="dist.src.zip" value="cacheonix-source-${release.version}.zip"/>
      <zip basedir="${dist.src.staging.dir}" destfile="${dist.result.dir}/${dist.src.zip}"/>
   </target>

   <!--
   Builds everything cleanly
   -->
   <target name="all.clean" depends="clean, all"/>

   <property name="pom.file" value="temp/pom.xml"/>

   <!-- There server id in the Maven settings.xml -->
   <property name="ossrh-server-id" value="ossrh"/>

   <!-- Installs Cacheonix to local repo -->
   <target name="maven.pom" depends="all">

      <!-- Define POM in memory -->
      <artifact:pom id="cacheonix-core-in-memory" groupId="org.cacheonix" artifactId="cacheonix-core"
                    version="${release.version}" name="Cacheonix Core" url="http://www.cacheoix.org"
                    description="Cacheonix is an open source distributed cache for Java that allows its users to scale Java applications in a cluster while preserving the simplicity of design and coding in a single Java VM.">
         <artifact:developer name="Slava Imeshev" email="simeshev@cacheonix.org" organization="Cacheonix"
                             organizationUrl="http://www.cacheonix.org"/>
         <artifact:license name="lgpl" url="http://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html"/>
         <artifact:scm connection="scm:git:git@github.com:cacheonix/cacheonix-core.git"
                       developerConnection="scm:git:git@github.com:cacheonix/cacheonix-core.git"
                       url="git@github.com:cacheonix/cacheonix-core.git"/>
      </artifact:pom>

      <!-- Write to disk -->
      <artifact:writepom pomrefid="cacheonix-core-in-memory" file="${pom.file}"/>

      <artifact:pom id="cacheonix-core-on-disk" file="${pom.file}"/>
   </target>


   <!-- Installs Cacheonix to local repo -->
   <target name="maven.install" depends="maven.pom">
      <artifact:install pomrefid="cacheonix-core-on-disk" file="${dist.cacheonix.jar}">
      </artifact:install>
   </target>


   <!-- Before this, update project version (both build.xml and pom.xml) from SNAPSHOT to RELEASE -->
   <target name="maven.stage" depends="maven.pom" description="Deploy release version to Maven staging repository">

      <!-- Verify that this is a release version -->
      <fail message="Snapshot build should not be deployed to the release repository: ${release.version}">
         <condition>
            <contains string="${release.version}" substring="SNAPSHOT" casesensitive="false"/>
         </condition>
      </fail>

      <!-- Sign and deploy the main artifact -->
      <artifact:mvn failonerror="true">
         <artifact:arg value="org.apache.maven.plugins:maven-gpg-plugin:1.5:sign-and-deploy-file"/>
         <artifact:arg value="-Durl=${ossrh-staging-repository-url}"/>
         <artifact:arg value="-DrepositoryId=${ossrh-server-id}"/>
         <artifact:arg value="-DpomFile=${pom.file}"/>
         <artifact:arg value="-Dfile=${dist.cacheonix.jar}"/>
         <artifact:arg value="-Pgpg"/>
      </artifact:mvn>

      <!-- Sign and deploy the sources artifact -->
      <artifact:mvn failonerror="true">
         <artifact:arg value="org.apache.maven.plugins:maven-gpg-plugin:1.5:sign-and-deploy-file"/>
         <artifact:arg value="-Durl=${ossrh-staging-repository-url}"/>
         <artifact:arg value="-DrepositoryId=${ossrh-server-id}"/>
         <artifact:arg value="-DpomFile=${pom.file}"/>
         <artifact:arg value="-Dfile=${dist.cacheonix.src}"/>
         <artifact:arg value="-Dclassifier=sources"/>
         <artifact:arg value="-Pgpg"/>
      </artifact:mvn>

      <!-- Sign and deploy the javadoc artifact -->
      <artifact:mvn failonerror="true">
         <artifact:arg value="org.apache.maven.plugins:maven-gpg-plugin:1.5:sign-and-deploy-file"/>
         <artifact:arg value="-Durl=${ossrh-staging-repository-url}"/>
         <artifact:arg value="-DrepositoryId=${ossrh-server-id}"/>
         <artifact:arg value="-DpomFile=${pom.file}"/>
         <artifact:arg value="-Dfile=${dist.cacheonix-javadoc.zip}"/>
         <artifact:arg value="-Dclassifier=javadoc"/>
         <artifact:arg value="-Pgpg"/>
      </artifact:mvn>
   </target>

   <!--
      Create Secure Downloads Archives (SDARs)
   -->
   <target name="sdar" depends="dist">

      <!-- Create source zip SDAR -->
      <createDownload releaseBuild="${release.build}" releaseVersion="${release.version}"
                      mediaFile="${dist.result.dir}/${dist.src.zip}"
                      descriptorTemplate="internal/deployment/cacheonix-single-file-download-descriptor.xml"
                      stagingDir="${sdar.staging}" resultDir="${sdar.result}"
                      downloadName="${dist.src.zip}"
                      groupName="Complete Cacheonix Distribution"
                      groupOrder="0"
                      mediaComment="(complete distribution, source .zip)"/>

      <!-- Create binary zip SDAR -->
      <createDownload releaseBuild="${release.build}" releaseVersion="${release.version}"
                      mediaFile="${dist.result.dir}/${dist.bin.zip}"
                      descriptorTemplate="internal/deployment/cacheonix-single-file-download-descriptor.xml"
                      stagingDir="${sdar.staging}" resultDir="${sdar.result}"
                      downloadName="${dist.bin.zip}"
                      groupName="Complete Cacheonix Distribution"
                      groupOrder="0"
                      mediaComment="(complete distribution, binary .zip)"/>


      <!-- Create jar-only SDAR -->
      <createDownload releaseBuild="${release.build}" releaseVersion="${release.version}"
                      mediaFile="${dist.result.dir}/cacheonix.jar"
                      descriptorTemplate="internal/deployment/cacheonix-single-file-download-descriptor.xml"
                      stagingDir="${sdar.staging}" resultDir="${sdar.result}"
                      downloadName="cacheonix.jar"
                      groupName="Cacheonix Jar only and Javadocs"
                      groupOrder="2"
                      mediaComment="(Cacheonix jar only)"/>

      <!-- Create javadocs-only SDAR -->
      <createDownload releaseBuild="${release.build}" releaseVersion="${release.version}"
                      mediaFile="${dist.javadoc.dir}"
                      descriptorTemplate="internal/deployment/cacheonix-html-directory-download-descriptor.xml"
                      stagingDir="${sdar.staging}" resultDir="${sdar.result}"
                      downloadName="cacheonix-javadocs"
                      groupName="Cacheonix Jar only and Javadocs"
                      groupOrder="2"
                      mediaComment="(Cacheonix Javadocs only)"/>
   </target>

   <!-- Deploys build to www.cacheonix.org -->
   <target name="deploy" depends="sdar">

      <property name="deploy.to.downloads" value="${env.DEPLOY_TO_DOWNLOADS}"/>
      <if name="deploy.to.downloads" value="Yes">

         <!-- Set up upload properties -->
         <property name="remote.staging.dir" value="/home/tomcat/downloads_staging"/>
         <property name="remote.destination.dir" value="/opt/sd/WEB-INF/content/downloads"/>
         <property name="remote.user.host" value="tomcat@downloads.cacheonix.org"/>

         <!-- Prepare paths -->
         <pathconvert targetos="unix" property="unix.result.distrib">
            <path location="${sdar.result}"/>
         </pathconvert>

         <!-- Create directories -->
         <echo message="Create directories"/>
         <exec failonerror="true" executable="ssh">
            <arg value="${remote.user.host}"/>
            <arg value="mkdir -p ${remote.staging.dir} ${remote.destination.dir}"/>
         </exec>

         <!-- Copy to the downloads website's staging -->
         <echo message="Copy to the downloads website staging"/>
         <echo message="unix.result.distrib: ${unix.result.distrib}"/>
         <echo message="Copy files"/>
         <exec failonerror="true" executable="sh">
            <arg value="-c"/>
            <arg value="scp -Crpqv ${unix.result.distrib}/* ${remote.user.host}:${remote.staging.dir}/"/>
         </exec>

         <!-- Clear destination -->
         <echo message="Clear destination"/>
         <echo message="Destination directory to clear: ${remote.destination.dir}"/>
         <exec failonerror="true" executable="ssh">
            <arg value="${remote.user.host}"/>
            <arg value="rm -rf ${remote.destination.dir}/*"/>
         </exec>

         <!-- Copy from staging to downloads -->
         <echo message="Copy from staging to destination"/>
         <exec failonerror="true" executable="ssh">
            <arg value="${remote.user.host}"/>
            <arg value="cp -rp ${remote.staging.dir}/* ${remote.destination.dir}/; chmod -R ag+r ${remote.destination.dir}"/>
         </exec>

         <!-- Cleanup staging -->
         <echo message="Cleanup staging"/>
         <exec failonerror="true" executable="ssh">
            <arg value="${remote.user.host}"/>
            <arg value="rm -rf ${remote.staging.dir}"/>
         </exec>
      </if>
   </target>


   <!-- A macro responsible for creading SDAR files -->
   <macrodef name="createDownload" description="Creates a Secure Downloads Archive">

      <!-- Attribute definitions -->
      <attribute name="resultDir"/>
      <attribute name="stagingDir"/>
      <attribute name="mediaFile"/>
      <attribute name="descriptorTemplate"/>
      <attribute name="downloadName"/>
      <attribute name="groupName"/>
      <attribute name="groupOrder"/>
      <attribute name="releaseVersion"/>
      <attribute name="releaseBuild"/>
      <attribute name="mediaComment"/>
      <attribute name="format" default="exploded"/>

      <sequential>

         <!-- Used to re-set properties sdar.file.name and sdar.file.size and set in this macrodef -->
         <taskdef name="unset" classname="ise.antelope.tasks.Unset" classpath="${antelope.jar}"/>

         <!-- Prepare directories -->
         <delete dir="@{stagingDir}"/>
         <mkdir dir="@{stagingDir}"/>
         <mkdir dir="@{stagingDir}/META-INF"/>
         <mkdir dir="@{resultDir}"/>

         <!-- Populate SDAR directory -->
         <unset name="sdar.file.size"/>
         <unset name="sdar.file.name"/>
         <basename file="@{mediaFile}" property="sdar.file.name"/>
         <if>
            <bool>
               <available file="@{mediaFile}" type="file"/>
            </bool>

            <!-- Calculate file length -->
            <length file="@{mediaFile}" property="sdar.file.size"/>

            <!-- Copy file -->
            <copy file="@{mediaFile}" todir="@{stagingDir}"/>
            <else>
               <if>
                  <bool>
                     <available file="@{mediaFile}" type="dir"/>
                  </bool>

                  <!-- Calculate directory length -->
                  <length property="sdar.file.size" mode="all">
                     <fileset dir="@{mediaFile}"/>
                  </length>

                  <!-- Copy directory -->
                  <mkdir dir="@{stagingDir}/${sdar.file.name}"/>
                  <copy todir="@{stagingDir}/${sdar.file.name}">
                     <fileset dir="@{mediaFile}"/>
                  </copy>
                  <else>
                     <fail message="Media file not found: @{mediaFile}"/>
                  </else>
               </if>
            </else>
         </if>

         <!-- Create SDAR descriptor -->
         <copy file="@{descriptorTemplate}" tofile="@{stagingDir}/META-INF/secure-download-descriptor.xml">
            <filterset begintoken="@" endtoken="@">
               <filter token="cacheonix.download.name" value="@{downloadName}"/>
               <filter token="cacheonix.download.display.name" value="@{downloadName}"/>
               <filter token="cacheonix.download.description"
                       value="Cacheonix @{releaseVersion}, build @{releaseBuild} @{mediaComment}."/>
               <filter token="cacheonix.download.group.name" value="@{groupName}"/>
               <filter token="cacheonix.download.group.order" value="@{groupOrder}"/>
               <filter token="cacheonix.download.file.name" value="${sdar.file.name}"/>
               <filter token="cacheonix.download.file.size" value="${sdar.file.size}"/>
            </filterset>
         </copy>

         <!-- Create SDAR -->
         <if>
            <bool>
               <equals arg1="@{format}" arg2="zip"/>
            </bool>

            <!-- Zip format -->
            <zip basedir="@{stagingDir}" destfile="@{resultDir}/@{downloadName}.sdar" update="true"/>

            <else>
               <if>
                  <bool>
                     <equals arg1="@{format}" arg2="exploded"/>
                  </bool>

                  <!-- Exploded format -->
                  <mkdir dir="@{resultDir}/@{downloadName}.sdar"/>
                  <copy todir="@{resultDir}/@{downloadName}.sdar">
                     <fileset dir="@{stagingDir}"/>
                  </copy>

                  <else>
                     <!-- Unknown format -->
                     <fail message="Unknown download format: @format"/>
                  </else>
               </if>
            </else>
         </if>
      </sequential>
   </macrodef>

</project>