<!--
 -
 - Licensed to the Apache Software Foundation (ASF) under one
 - or more contributor license agreements.  See the NOTICE file
 - distributed with this work for additional information
 - regarding copyright ownership.  The ASF licenses this file
 - to you under the Apache License, Version 2.0 (the
 - "License"); you may not use this file except in compliance
 - with the License.  You may obtain a copy of the License at
 - 
 -   http://www.apache.org/licenses/LICENSE-2.0
 - 
 - Unless required by applicable law or agreed to in writing,
 - software distributed under the License is distributed on an
 - "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 - KIND, either express or implied.  See the License for the
 - specific language governing permissions and limitations
 - under the License.
 -
 -->
<project name="module" xmlns:artifact="antlib:org.apache.maven.artifact.ant">

  <import file="common.xml"/>

  <property file="${project.root}/build.deps"/>

  <path id="maven-ant-tasks.classpath" path="${project.root}/${maven-ant-tasks}" />
  <typedef resource="org/apache/maven/artifact/ant/antlib.xml"
           uri="antlib:org.apache.maven.artifact.ant"
           classpathref="maven-ant-tasks.classpath" />

  <map property="module" value="${basedir}" split="${path.separator}">
    <globmapper from="${project.root}${file.separator}*" to="*"/>
  </map>

  <map property="module.name" value="${module}">
    <filtermapper>
        <replacestring from="${file.separator}" to="-"/>
    </filtermapper>
  </map>
	
  <echo message="Running ant for module : ${module}" level="info"/>

  <property name="module.build"        location="${build.scratch}/${module}"/>
  <property name="module.classes"      location="${module.build}/classes"/>
  <property name="module.instrumented" location="${module.build}/classes-instrumented"/>
  <property name="module.precompiled"  location="${module.build}/src"/>
  <property name="module.api"          location="${build.api}/${module}/"/>
  <property name="module.test.api"     location="${build.test.api}/${module}"/>
  <property name="module.test.classes" location="${module.build}/test/classes"/>
  <property name="module.test.resources" location="src/test/resources"/>
  <property name="module.results"      location="${build.results}/${module}"/>
  <property name="module.failed"       location="${module.results}/FAILED"/>
  <property name="module.src"          location="src/main/java"/>
  <property name="module.test.src"     location="src/test/java"/>
  <property name="module.bin"          location="bin"/>
  <property name="module.etc"          location="etc"/>

  <property name="module.src.resources" location="src/main/resources"/>
  <property name="module.src.resources.metainf" location="${module.src.resources}/META-INF"/>
  <property name="module.resources.dir" location="resources/"/>
  <property name="module.metainf"      location="${module.build}/META-INF"/>

  <property name="module.namever"      value="${project.name}-${module.name}-${project.version}"/>
  <property name="module.namever.osgi" value="${project.name}-${module.name}_${project.version}.0.osgi"/>
  <property name="module.release.base" value="${basedir}/release"/>
  <property name="module.release"      value="${module.release.base}/${module.namever}"/>
  <property name="module.release.lib"  value="${module.release}/lib"/>
  <property name="module.release.zip"  location="${module.release.base}/${module.namever}.zip"/>
  <property name="module.release.tar"  location="${module.release.base}/${module.namever}.tar"/>
  <property name="module.release.tgz"  location="${module.release.base}/${module.namever}.tar.gz"/>
  <property name="module.release.bz2"  location="${module.release}/${module.namever}.tar.bz2"/>

  <property name="module.genpom.args"  value=""/>
  <property name="maven.remote.repo"     value="file://${module.release.base}/maven"/>

  <property name="broker.log.prefix" value="BROKER: "/> 
  <property name="broker.log.interleave" value="true"/>

  <property name="module.jar"          location="${build.lib}/${project.name}-${module.name}-${project.version}.jar"/>
  <property name="module.qpid.jar"     location="${module.release.lib}/qpid-all.jar"/>
  <basename property="qpid.jar.name"  file="${module.qpid.jar}"/>

  <property name="module.coverage"     location="${module.build}/coverage"/>
  <property name="cobertura.datafile"  location="${module.instrumented}/cobetura.ser"/>


  <available property="module.test.src.exists" file="${module.test.src}"/>
  <available property="module.etc.exists" file="${module.etc}"/>
  <available property="module.bin.exists" file="${module.bin}"/>
  <available property="module.src.resources.exists" file="${module.src.resources}"/>
  <available property="module.test.src.resources.exists" file="${module.test.resources}"/>
  <available property="module.src.resources.metainf.exists" file="${module.src.resources.metainf}"/>
  <available property="module.resources.dir.exists" file="${module.resources.dir}"/>

  <property name="module.source.jar"
            location="${build.lib}/${project.name}-${module.name}-${project.version}-sources.jar"/>

  <!-- module.depends and module.test.depends are supplied by the importing file -->
  <property name="module.depends"       value=""/>
  <property name="module.test.depends"  value=""/>
  <property name="module.test.excludes" value=""/>

   <!-- Add depenencies dependencies to path -->
   <map property="module.depends.libs" value="${module.depends}" join=" ">
       <chainedmapper>
           <filtermapper>
               <replacestring from="${file.separator}" to="-"/>
           </filtermapper>
           <propertymapper from="*" to="*.libs"/>
       </chainedmapper>
   </map>
    <condition property="module.depends.libs.includes" value="__EMPTY__" else="${module.depends.libs}">
      <equals trim="true" arg1="${module.depends.libs}" arg2=""/>
    </condition>


    <!-- Add depenencies test dependencies to path -->
    <map property="module.test.depends.libs" value="${module.test.depends}" join=" ">
        <chainedmapper>
            <filtermapper>
                <replacestring from="${file.separator}" to="-"/>
            </filtermapper>
            <propertymapper from="*" to="*.libs"/>
        </chainedmapper>
    </map>
    <condition property="module.test.depends.libs.includes" value="__EMPTY__" else="${module.test.depends.libs}">
      <equals trim="true" arg1="${module.test.depends.libs}" arg2=""/>
    </condition>


  <indirect name="module.libs"         variable="${module.name}.libs"/>
  <condition property="module.libs.includes" value="__EMPTY__" else="${module.libs}">
    <equals trim="true" arg1="${module.libs}" arg2=""/>
  </condition>
    
  <indirect name="module.test.libs"    variable="${module.name}.test.libs"/>
  <condition property="module.test.libs.includes" value="__EMPTY__" else="${module.test.libs}">
    <equals trim="true" arg1="${module.test.libs}" arg2=""/>
  </condition>

  <path id="module.libs">
    <fileset dir="${project.root}" includes="${module.libs.includes}"/>
    <fileset dir="${project.root}" includes="${module.depends.libs.includes}"/>
  </path>

  <path id="module.test.libs">
    <fileset dir="${project.root}" includes="${module.test.libs.includes}"/>
    <fileset dir="${project.root}" includes="${module.test.depends.libs.includes}"/>
  </path>

  <path id="module.src.path">
    <pathelement location="${module.src}"/>
    <pathelement location="${module.precompiled}"/>
  </path>
	
  <path id="module.test.src.path">
    <pathelement location="${module.test.src}"/>
  </path>

  <property name="module.test.jar"
            location="${build.lib}/${project.name}-${module.name}-tests-${project.version}.jar"/>

  <map property="module.depends.jars" value="${module.depends}" join=",">
    <globmapper from="*" to="${project.name}-*-${project.version}.jar"/>
    <filtermapper>
        <replacestring from="/" to="-"/>
    </filtermapper>
  </map>

  <map property="module.depends.jars.path" value="${module.depends}" join="${path.separator}">
    <filtermapper>
        <replacestring from="/" to="-"/>
    </filtermapper>

    <globmapper from="*" to="${build.lib}/${project.name}-*-${project.version}.jar"/>
  </map>

  <map property="module.test.depends.jars.path" value="${module.test.depends}" join="${path.separator}">
    <filtermapper>
        <replacestring from="/" to="-"/>
    </filtermapper>
    <globmapper from="*" to="${build.lib}/${project.name}-*-${project.version}.jar"/>
  </map>

  <!-- used for building the module -->
  <path id="module.class.path">
    <pathelement path="${module.depends.jars.path}"/>
    <path refid="module.libs"/>
  </path>

  <!-- used at runtime -->
  <path id="module.runtime.class.path">
    <pathelement location="${module.jar}"/>
    <pathelement path="${module.depends.jars.path}"/>
    <path refid="module.libs"/>
  </path>

  <!-- used to build the tests -->
  <path id="module.test.path">
    <path refid="module.runtime.class.path"/>
    <pathelement path="${module.test.depends.jars.path}"/>
    <path refid="module.test.libs"/>
  </path>

  <!-- used to run the tests -->
  <path id="module.test.runtime.path">
    <pathelement path="${module.test.jar}"/>
    <path refid="module.runtime.class.path"/>
    <pathelement path="${module.test.depends.jars.path}"/>
    <path refid="module.test.libs"/>
  </path>

  <property name="javac.deprecation" value="off"/>

  <target name="debug">
    <echo-prop name="basedir"/>
    <echo-prop name="project.root"/>
    <echo-prop name="module"/>
    <echo-prop name="module.libs"/>
    <echo-prop name="module.test.libs"/>
    <echo-prop name="module.name"/>
    <echo-prop name="module.jar"/>
    <echo-prop name="module.depends"/>

    <echo-prop name="module.test.depends"/>

    <echo-prop name="module.depends.libs"/>
    <echo-prop name="module.test.depends.libs"/>      

    <echo-prop name="module.depends.jars"/>
    <echo-prop name="module.depends.jars.path"/>
    <echo-prop name="module.test.depends.jars.path"/>

    <echo-path refid="module.src.path"/>
    <echo-path refid="module.class.path"/>
    <echo-path refid="module.runtime.class.path"/>
    <echo-path refid="module.test.path"/>
    <echo-path refid="module.test.runtime.path"/>
  </target>

  <target name="prepare">
    <mkdir dir="${build.bin}"/>
    <mkdir dir="${build.etc}"/>
    <mkdir dir="${build.lib}"/>
    <mkdir dir="${build.results}"/>
    <mkdir dir="${build.scratch.broker.plugins.lib}"/>
    <mkdir dir="${module.classes}"/>
    <mkdir dir="${module.precompiled}"/>
    <mkdir dir="${module.api}"/>
    <mkdir dir="${module.test.api}"/>
    <mkdir dir="${module.test.classes}"/>
    <mkdir dir="${module.results}"/>
  </target>

  <target name="pom" depends="prepare" if="module.genpom">
    <jython path="${mllib.dir}">
      <args>
        <arg line='"${project.root}/genpom"'/>
        <arg line='-s "${project.root}/lib/poms${path.separator}lib/poms"'/>
        <arg line='-o "${build.scratch}/qpid-${module.name}.pom"'/>
        <arg line="-u ${project.url}"/>
        <arg line="-g ${project.groupid}"/>
        <arg line="-v ${project.version.maven}${maven.version.suffix}"/>
        <arg line="-p qpid"/>
        <arg line='-m "${module.depends}"'/>
        <arg line="-a ${module.name}"/>
        <arg line="${module.genpom.args}"/>
        <arg line="${module.libs}"/>
      </args>
    </jython>
  </target>

  <target name="release-mvn" depends="build,pom" if="module.genpom" description="Install the artifacts into the local repository and prepare the release artifacts">
    <artifact:pom id="module.pom" file="${build.scratch}/qpid-${module.name}.pom"/>

    <artifact:install file="${module.jar}" pomRefId="module.pom" settingsFile="${maven.settings.xml}">
        <localRepository path="${maven.local.repo}"/>
    </artifact:install>

    <artifact:deploy file="${module.jar}" pomRefId="module.pom" uniqueVersion="${maven.unique.version}" settingsFile="${maven.settings.xml}">
      <attach file="${module.source.jar}" classifier="sources"/>
      <localRepository path="${maven.local.repo}"/>
      <remoteRepository url="${maven.remote.repo}"/>
    </artifact:deploy>
  </target>

  <target name="deploy-snapshot" depends="build,pom" if="module.genpom" description="deploy a snapshot build to nexus">
    <!-- In order to use this target you need to have predefined a username and password for the
    server with id ${maven.snapshots.repo.id} in your m2 settings file, e.g ~/.m2/settings.xml -->
    <artifact:pom id="module.pom" file="${build.scratch}/qpid-${module.name}.pom"/>

    <fail message="The pom version must include -SNAPSHOT. Version found was: ${module.pom.version}">
      <condition>
        <not>
          <contains substring="-SNAPSHOT" string="${module.pom.version}" />
        </not>
      </condition>
    </fail>

    <artifact:install file="${module.jar}" pomRefId="module.pom" settingsFile="${maven.settings.xml}">
        <localRepository path="${maven.local.repo}"/>
    </artifact:install>

    <artifact:deploy file="${module.jar}" pomRefId="module.pom">
      <localRepository path="${maven.local.repo}"/>
      <remoteRepository id="${maven.snapshots.repo.id}" url="${maven.snapshots.repo.url}"/>
    </artifact:deploy>
  </target>

  <target name="precompile"/>

  <target name="compile" depends="prepare,precompile" description="compile sources">

    <echo message="Targeting : ${java.target}" level="info"/>

    <javac source="${java.source}" target="${java.target}" 
           destdir="${module.classes}" debug="on" debuglevel="lines,vars,source" includeantruntime="false"
           deprecation="${javac.deprecation}">
      <compilerarg line="${javac.compiler.args}"/>
      <src refid="module.src.path"/>
      <classpath refid="module.class.path"/>
    </javac>

    <!-- copy any non java src files into the build tree, e.g. properties files -->
    <copy todir="${module.classes}" verbose="true">
      <fileset dir="${module.src}">
        <exclude name="**/*.java"/>
        <exclude name="**/package.html"/>
      </fileset>
    </copy>
  </target>

  <target name="precompile-tests" if="module.test.src.exists"/>

  <target name="copy-test-resources" if="module.test.src.resources.exists">
      <echo message="Copying test resources from ${module.test.resources} to ${module.test.classes}..."/>
      <copy todir="${module.test.classes}" failonerror="true">
        <fileset dir="${module.test.resources}"/>
      </copy>
  </target>

  <target name="compile-tests" depends="compile,precompile-tests" if="module.test.src.exists"
          description="compilte unit tests">
    <javac target="${java.target}" source="${java.source}"
           destdir="${module.test.classes}" debug="on"
           deprecation="${javac.deprecation}"
           srcdir="${module.test.src}"
           includeantruntime="false">
      <classpath refid="module.test.path"/>
    </javac>

    <!-- copy any non java src files into the build tree, e.g. properties files -->
    <copy todir="${module.test.classes}" verbose="true">
      <fileset dir="${module.test.src}">
        <exclude name="**/*.java"/>
        <exclude name="**/package.html"/>
      </fileset>
    </copy>
  </target>


  <property name="profile" value="java-mms.0-10"/>
  <property name="testprofile.file" value="${test.profiles}/${profile}.testprofile"/>
  
  <available file="${testprofile.file}" property="testprofile.file.present"/>
  <fail unless="testprofile.file.present" message="The requested test profile was not found: ${testprofile.file}"/>

  <property file="${testprofile.file}" prefix="preload"/>
  <property name="preload.include" value=""/>
  <property name="profiles" value="${preload.include} ${profile}"/>
  <map property="_profile_files" value="${profiles}" join=" ">
    <globmapper from="*" to="*.testprofile"/>
  </map>

  <concat destfile="${build.scratch}/test-${profile}.properties" force="yes" append="no" fixlastline="yes">
    <filelist dir="${test.profiles}" files="testprofile.defaults"/>
    <filelist dir="${test.profiles}" files="${_profile_files}"/>
  </concat>
  <property file="${build.scratch}/test-${profile}.properties"/>

  <map property="test.excludefiles" value="${test.excludes}">
    <globmapper from="*" to="${test.profiles}/*;"/>
  </map>

  <condition property="dontruntest" value="dontruntest" else="runtest">
         <contains substring="${module.name}" string="${exclude.modules}" />
  </condition>

  <!-- JVM args pass to forked Junit JVM -->
  <property name="jvm.args" value=""/>
  <!-- Following properties are used by the tests -->
  <property name="test.output" value="${module.results}"/>
  <property name="QPID_HOME" value="${qpid.home}"/>
  <property name="QPID_WORK" value="${qpid.work}"/>
  <property name="broker.existing.qpid.work" value=""/>

  <propertyset id="all.test.systemproperties">
    <propertyref prefix="test"/>
    <propertyref prefix="profile"/>
    <propertyref prefix="javax.net.ssl"/>
    <propertyref prefix="broker"/>
    <propertyref prefix="qpid"/>

    <propertyref name="amqj.logging.level"/>
    <propertyref name="amqj.server.logging.level"/>
    <propertyref name="amqj.protocol.logging.level"/>

    <propertyref name="log4j.debug"/>
    <propertyref name="log4j.configuration"/>
    <propertyref name="log4j.configuration.file"/>

    <propertyref name="root.logging.level"/>
    <propertyref name="java.naming.factory.initial"/>
    <propertyref name="java.naming.provider.url"/>
    <propertyref name="messagestore.class.name" />
    <propertyref name="max_prefetch"/>

    <propertyref name="QPID_HOME"/>
    <propertyref name="QPID_WORK"/>
    <propertyref name="example.plugin.target"/>
  </propertyset>

  <target name="test" depends="build,compile-tests" if="module.test.src.exists"
         unless="${dontruntest}" description="execute unit tests">

    <delete file="${module.failed}"/>

    <echo message="Using profile:${profile}" level="info"/>
    <junit fork="yes" forkmode="once" maxmemory="${test.mem}" reloading="no"
           haltonfailure="${haltonfailure}" haltonerror="${haltonerror}"
           failureproperty="test.failures" printsummary="on" timeout="6000000"
           dir="${project.root}" >

      <jvmarg line="${jvm.args}" />

      <syspropertyset refid="all.test.systemproperties"/>

      <formatter type="plain"/>
      <formatter type="xml"/>

      <classpath refid="module.test.runtime.path"/>

      <batchtest todir="${module.results}">
        <fileset dir="${module.test.src}" excludes="${module.test.excludes}">
          <include name="**/${test}.java"/>
        </fileset>
      </batchtest>
    </junit>

    <antcall target="touch-failed"/>

    <condition property="failed">
      <and>
        <isfalse value="${test.failures.ignore}"/>
        <available file="${module.failed}"/>
      </and>
    </condition>

    <fail if="failed" message="TEST SUITE FAILED"/>

  </target>

  <target name="report-module" description="generate junit reports for each module">
    <junitreport todir="${module.results}">
        <fileset dir="${module.results}">
            <include name="TEST-*.xml"/>
        </fileset>
        <report format="frames" todir="${module.results}/report/html"/>
    </junitreport> 
  </target>

  <target name="touch-failed" if="test.failures">
    <touch file="${module.failed}"/>
    <touch file="${build.failed}"/>
  </target>

  <target name="copy-bin" if="module.bin.exists" description="copy bin directory if it exists to build tree">
    <copy todir="${build.bin}" failonerror="false">
      <fileset dir="${module.bin}"/>
    </copy>
    <chmod dir="${build.bin}" perm="ugo+rx" includes="**/*"/>
  </target>

  <target name="copy-bin-release" if="module.bin.exists" description="copy dependencies into module release">
    <copy todir="${module.release}/bin" failonerror="true">
      <fileset dir="${module.bin}" />
    </copy>
    <chmod dir="${module.release}/bin" perm="ugo+rx" includes="**/*"/>
  </target>

  <target name="copy-etc" if="module.etc.exists" description="copy etc directory if it exists to build tree">
    <copy todir="${build.etc}" failonerror="false">
      <fileset dir="${module.etc}"/>
    </copy>
  </target>

  <target name="copy-etc-release" if="module.etc.exists" description="copy etc directory if it exists to build tree">
    <copy todir="${module.release}/etc" failonerror="false" flatten="true">
        <fileset dir="${module.etc}"/>
    </copy>
  </target>

  <target name="postbuild" description="run after a build"/>

  <target name="build" depends="jar,jar-tests,jar-sources,libs,copy-bin,copy-etc,postbuild,copy-broker-plugin-jars" description="compile and copy resources into build tree"/>

  <target name="jar.manifest" depends="compile,copy-resources,copy-files-to-module-metainf" if="module.manifest">
    <jar destfile="${module.jar}" basedir="${module.classes}" manifest="${module.manifest}">
       <metainf dir="${module.metainf}" />
    </jar>
  </target>

  <target name="jar.nomanifest" depends="compile,copy-resources,copy-files-to-module-metainf" unless="module.manifest">
    <jar destfile="${module.jar}" basedir="${module.classes}">
       <metainf dir="${module.metainf}" />
    </jar>
  </target>

  <target name="copy-broker-plugin-jars" if="broker.plugin" description="copy broker plugins for use in release packaging">
    <copy file="${module.jar}" todir="${build.scratch.broker.plugins.lib}" failonerror="true"/>
  </target>

  <target name="copy-files-to-module-metainf" depends="copy-project-resources-metainf, copy-module-resources-metainf, copy-module-src-resources-metainf"/>

  <target name="copy-project-resources-metainf">
    <copy todir="${module.metainf}" failonerror="true">
        <fileset dir="${project.root}/resources/"/>
    </copy>
  </target>

  <target name="copy-resources" if="module.src.resources.exists">
      <echo message="Copying resources from ${module.src.resources} to ${module.classes}..."/>
      <copy todir="${module.classes}" failonerror="true">
        <fileset dir="${module.src.resources}" excludes="META-INF/**"/>
      </copy>
  </target>

  <target name="copy-module-resources-metainf" if="module.resources.dir.exists">
    <copy todir="${module.metainf}" failonerror="false" overwrite="true">
        <fileset dir="${module.resources.dir}"/>
    </copy>
  </target>

  <target name="copy-module-src-resources-metainf" if="module.src.resources.metainf.exists">
    <copy todir="${module.metainf}" failonerror="true">
        <fileset dir="${module.src.resources.metainf}"/>
    </copy>
  </target>

  <target name="jar" depends="jar.manifest,jar.nomanifest" description="create jar"/>

  <target name="jar-tests" depends="compile-tests, copy-test-resources" description="create unit test jar">
    <jar destfile="${module.test.jar}" basedir="${module.test.classes}"/>
  </target>

  <target name="jar-sources" depends="prepare" description="create sources jar">
    <jar destfile="${module.source.jar}">
      <fileset dir="${project.root}/resources">
        <include name="LICENSE"/>
        <include name="NOTICE"/>
      </fileset>
      <fileset dir="${module.src}" includes="**/*.java"/>
      <fileset dir="${module.precompiled}" includes="**/*.java"/>
    </jar>
  </target>

  <target name="libs" description="copy dependencies into build tree">
    <copylist todir="${build.lib}" dir="${project.root}" files="${module.libs}"/>
  </target>


  <target name="libs-release" description="copy dependencies into module release">
    <!-- Copy the module dependencies -->
      <echo message="${module.libs}"/>
    <copylist todir="${module.release}/lib" dir="${project.root}" files="${module.libs}"/>
    <copylist todir="${module.release}/lib" dir="${project.root}" files="${module.depends.libs}"/>

    <!-- Copy the jar for this module -->
    <copy todir="${module.release}/lib" failonerror="true">
        <fileset file="${module.jar}"/>
        <fileset dir="${build.lib}" includes="${module.depends.jars}"/>
    </copy>
  </target>

  <target name="resources" description="copy resources into build tree">
    <copy todir="${build}" failonerror="false" flatten="true">
      <fileset dir="${basedir}${file.separator}.." includes="${resources}"/>
    </copy>
  </target>

  <target name="resources-release" description="copy resources into module release">
    <copy todir="${module.release}" failonerror="false" flatten="true">
      <fileset dir="${resources}" excludes="META-INF"/>
    </copy>
  </target>

  <uptodate property="doc.done" targetfile="${module.api}/index.html">
    <srcfiles dir="${module.src}" includes="**/*.java"/>
  </uptodate>

  <property name="module.doc.access" value="package"/>
  <target name="doc" depends="prepare" unless="doc.done" description="generate api-doc">
    <javadoc access="${module.doc.access}" destdir="${module.api}" author="false" version="true" use="true"
        windowtitle="${project.name} - ${module.name} - API Documentation"
   		sourcepathref="module.src.path" classpathref="module.class.path" packagenames="*">
      <arg value="-J-Dhttp.proxyHost=${http.proxyHost}"/>
      <arg value="-J-Dhttp.proxyPort=${http.proxyPort}"/>
      <bottom><![CDATA[<em><a href="http://www.apache.org/licenses/LICENSE-2.0">Licensed to the Apache Software Foundation</a></em>]]></bottom>
      <link href="http://java.sun.com/j2se/1.5.0/docs/api/"/>
      <link href="http://download.oracle.com/docs/cd/E17477_01/javaee/5/api/"/>
      <link href="http://commons.apache.org/configuration/apidocs/"/>
      <tag name="todo" scope="all" description="Todo:" />
    </javadoc>
  </target>

  <uptodate property="test-doc.done" targetfile="${module.test.api}/index.html">
    <srcfiles dir="${module.test.src}" includes="**/*.java"/>
  </uptodate>

  <property name="module.test.doc.access" value="public"/>
  <target name="test-doc" depends="prepare" unless="testdoc.done" if="module.test.src.exists" description="generate test api-doc">
    <javadoc access="${module.test.doc.access}" destdir="${module.test.api}" author="false" version="true" use="true"
        windowtitle="${project.name} - ${module.name} - Test API Documentation"
   		sourcepathref="module.test.src.path" classpathref="module.test.path" packagenames="*">
      <arg value="-J-Dhttp.proxyHost=${http.proxyHost}"/>
      <arg value="-J-Dhttp.proxyPort=${http.proxyPort}"/>
      <bottom><![CDATA[<em><a href="http://www.apache.org/licenses/LICENSE-2.0">Licensed to the Apache Software Foundation</a></em>]]></bottom>
      <link href="http://java.sun.com/j2se/1.5.0/docs/api/"/>
      <link href="http://download.oracle.com/docs/cd/E17477_01/javaee/5/api/"/>
      <link href="http://commons.apache.org/configuration/apidocs/"/>
      <tag name="todo" scope="all" description="Todo:" />
    </javadoc>
  </target>
  
  <target name="release-bin-prepare">
    <mkdir dir="${module.release}"/>
    <available property="module.release.exists" file="${module.release}"/>
  </target>

  <target name="check-module-manifest">
    <uptodate property="module-manifest.done" targetfile="${qpid.jar}">
      <srcfiles dir="${build.lib}" includes="**/*.jar" excludes="**/${qpid.jar.name}"/>
    </uptodate>
  </target>

  <target name="module-manifest" depends="check-module-manifest" unless="module-manifest.done">
    <path id="class.path">
      <fileset dir="${module.release.lib}" >
        <include name="*.jar"/>
        <exclude name="${qpid.jar.name}"/>
      </fileset>
    </path>
    <pathconvert property="qpid.jar.classpath" pathsep=" " dirsep="/">
      <path refid="class.path"/>
      <globmapper from="${module.release.lib}${file.separator}*" to="*"/>
    </pathconvert>

    <jar destfile="${module.qpid.jar}">
      <manifest>
        <attribute name="Class-Path" value="${qpid.jar.classpath}"/>
      </manifest>
      <metainf dir="${project.root}/resources/"/>
    </jar>

    <touch file="${module.qpid.jar}"/>
  </target>


  <target name="zip-release"  depends="build-release-bin" description="build module release archive">
    <zip destfile="${module.release.zip}">
      <zipfileset dir="${module.release}" prefix="${module.namever}" filemode="755">
        <include name="bin/*"/>
	<exclude name="bin/*.txt"/>
      </zipfileset>

      <zipfileset dir="${module.release}" prefix="${module.namever}" filemode="644">
        <include name="bin/*.txt"/>
      </zipfileset>

      <zipfileset dir="${module.release}" prefix="${module.namever}" excludes="${module.release.excludes}" filemode="644" dirmode="755">
        <exclude name="bin/**"/>
	    <exclude name="**/*.class"/>          
      </zipfileset>
    </zip>
  </target>

  <target name="bundle" description="Build module osgi artifact. Override and depend on bundle-tasks to use"/>

  <target name="bundle-tasks" depends="jar">
   <taskdef resource="aQute/bnd/ant/taskdef.properties" classpath="${project.root}/${bnd}"/>
   <echo message="Bundling ${build}/lib/${module.namever}.jar with ${module.src}/${module.name}.bnd"/>
   <bnd 
      classpath="${build}/lib/${module.namever}.jar"
      eclipse="false" 
      failok="false" 
      exceptions="true"
      output="${build}/lib/${module.namever.osgi}.jar"
      files="${module.src}/${module.name}.bnd"/>
  </target>    

    <target name="tar-release" depends="zip-release" description="build release archive">
      <tar destfile="${module.release.tar}" longfile="gnu" >
        <zipfileset src="${module.release.zip}"/>
      </tar>
    </target>

    <target name="gzip-release" depends="tar-release" description="build release archive">
      <gzip src="${module.release.tar}" destfile="${module.release.tgz}"/>
    </target>

    <target name="bzip2-release" depends="tar-release" description="build release archive">
      <bzip2 src="${module.release.tar}" destfile="${module.release.bz2}"/>
    </target>

    <target name="doc-release" description="no-op override if a doc step is requried "/>


    <target name="build-release-bin" depends="release-bin-prepare,libs-release,copy-bin-release,
                                              copy-etc-release,doc-release,resources-release,release-bin-other,module-manifest"
            description="Task that includes all tasks required to create a module binary release"/>

    <!-- ,zip-release,gzip-release -->
  <target name="release-bin-tasks" depends="gzip-release" description="build all release archives except .bz2"/>

  <target name="release-bin-all-tasks" depends="bzip2-release" description="build all release archives"/>

  <!-- Dummy targets to no-op for most modules. Override if a module package is required -->
  <target name="release-bin-other" description="Override if there is tasks required for the module bin release to occur last"/>
  <target name="release-bin" description="Override and depend on release-bin-tasks to generate"/>
  <target name="release-bin-all" description="Override and depend on release-bin-tasks to generate"/>

  <target name="clean" description="remove build artifacts">
    <delete dir="${module.build}"/>
    <delete dir="${module.results}"/>
    <delete dir="${module.release.base}"/>
    <delete dir="${module.instrumented}"/>
  </target>

  <target name="instrument" depends="cobertura-init">
    <cobertura-instrument todir="${module.instrumented}"
                          datafile="${cobertura.datafile}">
      <fileset dir="${module.classes}">
        <include name="**/*.class"/>
      </fileset>
    </cobertura-instrument>
  </target>

  <target name="cover-test" depends="instrument" if="module.test.src.exists">

    <junit fork="yes" forkmode="once" maxmemory="${test.mem}" reloading="no"
           haltonfailure="${haltonfailure}" haltonerror="${haltonerror}"
           failureproperty="test.failures" printsummary="on" timeout="600000"
           dir="${project.root}" >
      <jvmarg line="${jvm.args}" />

      <syspropertyset refid="all.test.systemproperties"/>

      <sysproperty key="net.sourceforge.cobertura.datafile" file="${cobertura.datafile}" />

      <formatter type="plain"/>
      <formatter type="xml"/>

      <classpath path="${module.instrumented}"/>
      <classpath>
        <fileset dir="${build}">
          <include name="**/classes-instrumented/*.class"/>
        </fileset>
      </classpath>
      <classpath refid="module.test.runtime.path"/>
      <classpath refid="cobertura.classpath"/>      

      <batchtest todir="${module.results}">
        <fileset dir="${module.test.src}" excludes="${module.test.excludes}">
          <include name="**/${test}.java"/>
        </fileset>
      </batchtest>
    </junit>
  </target>

  <target name="coverage-report" depends="cobertura-init">
      <cobertura-report format="html"
                        destdir="${module.coverage}"
                        datafile="${cobertura.datafile}">
      <fileset dir="${module.src}" includes="**/*.java" />
    </cobertura-report>
  </target>

  <property name="version.file" location="${module.classes}/qpidversion.properties"/>
  <property file="${version.file}" prefix="old."/>

  <target name="check-version">
    <exec executable="svnversion" spawn="false" failifexecutionfails="false"
        dir="${project.root}" outputproperty="svnversion.output">
      <arg line="."/>
    </exec>
    <condition property="version.stale">
      <not>
        <equals arg1="${svnversion.output}" arg2="${old.qpid.svnversion}"/>
      </not>
    </condition>
  </target>

  <target name="create-version" depends="check-version" if="version.stale">
    <!-- Write the version.properties out.-->
    <!-- Echos exactly as shown, so leave no spaces before/after lines -->
    <echo file="${version.file}" append="false">qpid.version=${project.version}
qpid.svnversion=${svnversion.output}
qpid.name=${project.name}
</echo>
  </target>

   <!-- Additions to perform LogMessage generation
    To activate for your plugin add the following to your plugin build.xml

    <target name="precompile" depends="gen_logging"/>

   -->

    <property name="gentools.home" location="${project.root}/common/gentools" />
    <property name="gentools.build" location="${build.scratch}/common/gentools" />
    <property name="generated.dir" location="${module.precompiled}" />
    <property name="velocity.compile.dir" value="${build.scratch}/broker/velocity"/>
    <property name="velocity.timestamp" location="${generated.dir}/velocity.timestamp" />

    <target name="compile_velocity" >
        <mkdir dir="${velocity.compile.dir}" />
        <!-- Compile LogMessages Velocity Generator -->
        <javac source="${java.source}" target="${java.target}"
               destdir="${velocity.compile.dir}" debug="on" includeantruntime="false"
               deprecation="${javac.deprecation}"
               srcdir="${project.root}/broker/src/velocity/java" >
          <classpath>
            <pathelement path="${project.root}/${velocity.jar}" />
          </classpath>
          <compilerarg line="${javac.compiler.args}"/>
        </javac>
    </target>


    <target name="check_velocity_deps">
      <uptodate property="velocity.notRequired" targetfile="${velocity.timestamp}">
        <srcfiles dir="${module.src}" includes="**/*_logmessages.properties" />
        <srcfiles dir="${project.root}/broker/src/velocity/" includes="**/*.java **/*.vm" />
      </uptodate>
    </target>


    <target name="gen_logging" depends="compile_velocity,check_velocity_deps" unless="velocity.notRequired">
      <mkdir dir="${generated.dir}"/>

      <path id="logmessages.path">
        <fileset  dir="${module.src}">
          <include name="**/*_logmessages.properties"/>
        </fileset>
      </path>

      <pathconvert property="logmessages"
                   refid="logmessages.path"
                   pathsep="' '"/>

      <echo message="logmessages is ${logmessages}"/>

      <java classname="org.apache.qpid.server.logging.GenerateLogMessages" fork="true" dir="${gentools.build}/classes" failonerror="true">
        <arg line="'${logmessages}'"/>
          <arg value="-j"/>
          <arg value="-o"/>
          <arg value="${generated.dir}"/>
          <arg value="-t"/>
          <arg value="${project.root}/broker/src/velocity/templates/org/apache/qpid/server/logging/messages"/>
          <arg value="-s"/>
          <arg value="${module.src}"/>


        <classpath>
          <pathelement path="${module.src}"/>
          <pathelement path="${velocity.compile.dir}" />
          <fileset dir="${project.root}/lib/required">
            <include name="**/*.jar"/>
          </fileset>
          <pathelement path="${project.root}/${velocity.jar}" />
        </classpath>
      </java>
      <touch file="${velocity.timestamp}" />
    </target>

    <target name="eclipse" depends="eclipse-setup,eclipse-project,eclipse-source-only,eclipse-source-and-test"/>

    <target name="eclipse-setup">
      <taskdef name="eclipse" classname="prantl.ant.eclipse.EclipseTask" />

      <!-- Build set of directories representing the dependencies -->

      <dirset id="eclipse.required.projectdirs.path" dir="${project.root}" includes="${module.depends} ${module.test.depends} neverBeEmpty">
        <!-- Select only those projects from module.depends that contain a build.xml.  This serves to exclude dependencies that
             don't become Eclipse projects e.g. broker-plugins and common-tests -->
        <present targetdir="${project.root}">
          <mapper type="glob" from="*" to="*/build.xml"/>
        </present>
      </dirset>

      <!-- Convert from the set of directories into Eclipse project names proceeded by forward slashes -->

      <pathconvert property="eclipse.required.projectnames" refid="eclipse.required.projectdirs.path" pathsep=" " dirsep="-">
        <map from="${project.root}${file.separator}" to=''/>
      </pathconvert>
      <map property="eclipse.required.slashedprojectnames" value="${eclipse.required.projectnames}" join="${path.separator}">
        <globmapper from="*" to="/*"/>
      </map>

      <echo message="Ant module dependencies : ${module.depends} ${module.test.depends} converted to Eclipse required project(s): ${eclipse.required.slashedprojectnames}"/>
      <path id="eclipse.required.slashedprojectnames.path">
        <pathelement path="${eclipse.required.slashedprojectnames}"/>
      </path>
    </target>

    <!-- Create the Eclipse .project -->
    <target name="eclipse-project">
      <eclipse updatealways="${eclipse.updatealways}">
        <project name="${module.name}"/>

        <!-- If the Eclipse task were to ever support the generation of
             linked resources, we would configure it to generate
             the following:

             scratch_src -> ${module.precompiled}

             in each project.   This would avoid the 'linked sources'
             manual step documented on the Wiki.
        -->
      </eclipse>
    </target>
    
    <!-- Create the Eclipse .classpath -->
    <target name="eclipse-source-only" unless="module.test.src.exists">
      <eclipse updatealways="${eclipse.updatealways}">
        <settings>
          <jdtcore compilercompliance="${eclipse.compilercompliance}" />
        </settings>
        <classpath>
          <container path="${eclipse.container}" />
          <source path="${module.src}" />
          <source pathref="eclipse.required.slashedprojectnames.path" />
          <library pathref="module.libs"/>
          <output path="classes" />
        </classpath>
      </eclipse>
    </target>

    <!-- Create the Eclipse .classpath -->
    <target name="eclipse-source-and-test" if="module.test.src.exists">
      <eclipse updatealways="${eclipse.updatealways}">
        <settings>
          <jdtcore compilercompliance="${eclipse.compilercompliance}" />
        </settings>
        <classpath>
          <container path="${eclipse.container}" />
          <source path="${module.src}" />
          <source path="${module.test.src}" />
          <source pathref="eclipse.required.slashedprojectnames.path" />
          <library pathref="module.libs"/>
          <library pathref="module.test.libs"/>
          <output path="classes" />
        </classpath>
      </eclipse>
    </target>
</project>