common-shims-build.xml

<!--===========================================================================
  This is the common build file for all shim implementation projects. This
  requires the api project to be jar'd up first; it is directly referenced.
  
  See ../build-res/subfloor.xml for more details
============================================================================-->
<project name="common-shims-build" xmlns:ivy="antlib:org.apache.ivy.ant">
  <import file="build-res/subfloor-pkg.xml" />

  <property name="common.dir" value="../common" />

  <property name="hbase.generation" value="pre1.0"/>
  <property name="lib.provided.dir" value="lib-provided" description="Ivy dependencies of 'provided' configuration are placed here"/>
  <property name="lib.pmr.dir" value="lib/pmr" description="Ivy dependencies of 'pmr' configuration are placed here. Placed under lib/ so they are packaged that way."/>
  <property name="lib.client.dir" value="lib/client" description="Ivy dependencies of 'client' configuration are placed here. Placed under lib/ so they are packaged that way."/>
  <property name="src.common.dir" value="${common.dir}/src" description="Source files that are common to all shims"/>
  <property name="classes.common-mapred.dir" value="${bin.dir}/classes-mapred" description="Common mapred source files are compiled into here" />
  <property name="src.common-mapred.dir" value="${common.dir}/src-mapred" description="Common mapred sources" />
  <property name="testsrc.common.dir" value="${common.dir}/test-src" description="Common test sources" />
  <property name="package.common.resdir" value="${common.dir}/package-res" description="Common package resources" />
  <property name="ivy.artifact.mapred.id" value="${ivy.artifact.id}-mapred" description="Name of artifact id for the mapred jar" />
  <property name="mapred.artifact.name" value="${ivy.artifact.mapred.id}-${project.revision}.jar" description="Name of the mapred jar file to create"/>
  <property name="hbase-comparators.artifact.name" value="${ivy.artifact.id}-hbase-comparators-${project.revision}.jar" description="Name of the mapred jar file to create"/>

  <target name="init-common" depends="install-antcontrib">
    <property name="src.common-hbase.dir" value="${common.dir}/src-hbase-${hbase.generation}"/>
    <if>
      <istrue value="${common.modern.shim.include}"/>
      <then>
        <property name="src.common.modern.shim.dir" value="${common.dir}/src-modern"/>
        <property name="test-src.common.modern.shim.dir" value="${common.dir}/test-src-modern"/>
      </then>
      <else>
        <property name="src.common.modern.shim.dir" value="${common.dir}/src-dummy"/>
        <property name="test-src.common.modern.shim.dir" value="${common.dir}/src-dummy"/>
      </else>
    </if>
    <if>
      <isset property="common.hadoop.shim.version"/>
      <then>
        <property name="src.common.hadoop.shim.dir" value="${common.dir}/src-hadoop-shim-${common.hadoop.shim.version}"/>
        <property name="test-src.common.hadoop.shim.dir" value="${common.dir}/test-src-hadoop-shim-${common.hadoop.shim.version}"/>
      </then>
      <else>
        <property name="src.common.hadoop.shim.dir" value="${common.dir}/src-dummy"/>
        <property name="test-src.common.hadoop.shim.dir" value="${common.dir}/src-dummy"/>
      </else>
    </if>
    <if>
      <isset property="common.hbase.shim.version"/>
      <then>
        <property name="src.common.hbase.shim.dir" value="${common.dir}/src-hbase-shim-${common.hbase.shim.version}"/>
        <property name="test-src.common.hbase.shim.dir" value="${common.dir}/test-src-hbase-shim-${common.hbase.shim.version}"/>
      </then>
      <else>
        <property name="src.common.hbase.shim.dir" value="${common.dir}/src-dummy"/>
        <property name="test-src.common.hbase.shim.dir" value="${common.dir}/src-dummy"/>
      </else>
    </if>
    <if>
      <isset property="common.pig.shim.version"/>
      <then>
        <property name="src.common.pig.shim.dir" value="${common.dir}/src-pig-shim-${common.pig.shim.version}"/>
        <property name="test-src.common.pig.shim.dir" value="${common.dir}/test-src-pig-shim-${common.pig.shim.version}"/>
      </then>
      <else>
        <property name="src.common.pig.shim.dir" value="${common.dir}/src-dummy"/>
        <property name="test-src.common.pig.shim.dir" value="${common.dir}/src-dummy"/>
      </else>
    </if>
  </target>

  <!-- Setup the compile classpath to include the provided jars and the api jar -->
  <path id="classpath">
    <fileset dir="${devlib.dir}">
      <include name="**/*.jar" />
    </fileset>
    <fileset dir="${lib.dir}">
      <include name="**/*.jar" />
    </fileset>
    <fileset dir="${lib.provided.dir}">
      <include name="**/*.jar" />
    </fileset>
  </path>

  <!-- Setup the classpath used for testing to include the provided jars -->
  <path id="test.classpath">
    <fileset dir="${devlib.dir}">
      <include name="**/*.jar" />
    </fileset>
    <fileset dir="${lib.dir}">
      <include name="**/*.jar" />
    </fileset>
    <fileset dir="${lib.provided.dir}">
      <include name="**/*.jar" />
    </fileset>
    <fileset dir="${testlib.dir}">
      <include name="**/*.jar" />
    </fileset>
    <pathelement path="${testclasses.dir}" />
    <pathelement path="${classes.dir}" />
    <pathelement path="${classes.common-mapred.dir}" />
  </path>

  <!-- override init so we can create our mapred.classes.dir -->
  <target name="init" depends="init-common,subfloor.init">
    <mkdir dir="${classes.common-mapred.dir}" />
    <mkdir dir="${common.dir}/src-dummy" />
  </target>

  <!-- 
  resolve related targets so we can resolve "provided" jars separate from 
  normal ones so they don't get automatically packaged in with the archives.
  -->
  <target name="clean-jars" depends="subfloor.clean-jars">
    <delete dir="${lib.provided.dir}"/>
    <delete dir="${common.dir}/src-dummy"/>
  </target>

  <!-- Resolve provided dependencies to a separate directory -->
  <target name="resolve-default" depends="subfloor.resolve-default">
    <ivy:resolve file="${ivyfile}" conf="provided" />
    <ivy:retrieve conf="provided" pattern="${lib.provided.dir}/[module]-[revision](-[classifier]).[ext]" symlink="${ivy.use.symlinks.internal}" />
    <ivy:resolve file="${ivyfile}" conf="pmr" />
    <ivy:retrieve conf="pmr" pattern="${lib.pmr.dir}/[module]-[revision](-[classifier]).[ext]" symlink="${ivy.use.symlinks.internal}" />
    <ivy:resolve file="${ivyfile}" conf="client" />
    <ivy:retrieve conf="client" pattern="${lib.client.dir}/[module]-[revision](-[classifier]).[ext]" symlink="${ivy.use.symlinks.internal}" />
  </target>

  <!-- Override compile.compile to include common source -->
  <target name="compile.compile" depends="init, compile-mapred">
    <javac destdir="${classes.dir}"
           debug="${javac.debug}"
           deprecation="${javac.deprecation}"
           fork="true"
           memorymaximumsize="${javac.maxmemory}"
           source="${javac.source}"
           target="${javac.target}">
      <classpath>
        <path refid="classpath" />
        <path location="${classes.common-mapred.dir}" />
      </classpath>
      <src path="${src.dir}" />
      <src path="${src.common.dir}" />
      <src path="${src.common.modern.shim.dir}" />
      <src path="${src.common.hadoop.shim.dir}" />
      <src path="${src.common.hbase.shim.dir}" />
      <src path="${src.common.pig.shim.dir}" />
    </javac>
  </target>

  <!-- Compile the mapreduce source into a separate output directory so it can be independently packaged -->
  <target name="compile-mapred" depends="init">
    <javac destdir="${classes.common-mapred.dir}"
           debug="${javac.debug}"
           deprecation="${javac.deprecation}"
           fork="true"
           source="${javac.source}"
           target="${javac.target}">
      <classpath>
        <path refid="classpath"/>
      </classpath>
      <src path="${src.common-mapred.dir}" />
      <src path="${src.common-hbase.dir}" />
    </javac>
    <copy todir="${classes.common-mapred.dir}" flatten="false">
      <fileset dir="${src.common-mapred.dir}" excludes="**/*.java" />
      <fileset dir="${src.common-hbase.dir}" excludes="**/*.java" />
    </copy>
  </target>

  <!-- Copy additional resources into bin directory -->
  <target name="compile.res_copy" depends="subfloor.compile.res_copy">
    <if>
      <not>
        <isset property="jar.include.source" />
      </not>
      <then>
        <copy todir="${classes.dir}" flatten="false">
          <fileset dir="${src.common.dir}" excludes="**/*.java" />
          <fileset dir="${src.common-mapred.dir}" excludes="**/*.java" />
          <fileset dir="${src.common-hbase.dir}" excludes="**/*.java" />
          <fileset dir="${src.common.modern.shim.dir}" excludes="**/*.java" />
          <fileset dir="${src.common.hadoop.shim.dir}" excludes="**/*.java" />
          <fileset dir="${src.common.hbase.shim.dir}" excludes="**/*.java" />
          <fileset dir="${src.common.pig.shim.dir}" excludes="**/*.java" />
        </copy>
      </then>
    </if>
  </target>

  <!-- Compile the common tests too -->
  <target name="compile-tests" depends="subfloor.compile-tests">
    <javac destdir="${testclasses.dir}"
           debug="true"
           optimize="false"
           source="${javac.source}"
           target="${javac.target}"
           fork="true">
      <src path="${testsrc.common.dir}" />
      <src path="${test-src.common.modern.shim.dir}" />
      <src path="${test-src.common.hadoop.shim.dir}" />
      <src path="${test-src.common.hbase.shim.dir}" />
      <src path="${test-src.common.pig.shim.dir}" />
      <classpath refid="test.classpath" />
    </javac>

    <!-- Copy the non-java files from the source directory to the test classes directory -->
    <copy todir="${testclasses.dir}">
      <fileset dir="${testsrc.dir}">
        <exclude name="**/*.java" />
      </fileset>
      <fileset dir="${testsrc.common.dir}">
        <exclude name="**/*.java" />
      </fileset>
      <fileset dir="${test-src.common.modern.shim.dir}">
        <exclude name="**/*.java" />
      </fileset>
      <fileset dir="${test-src.common.hadoop.shim.dir}">
        <exclude name="**/*.java" />
      </fileset>
      <fileset dir="${test-src.common.hbase.shim.dir}">
        <exclude name="**/*.java" />
      </fileset>
      <fileset dir="${test-src.common.pig.shim.dir}">
        <exclude name="**/*.java" />
      </fileset>
    </copy>
  </target>

  <!-- Instrument the mapred classes too -->
  <target name="cobertura.instrument-classes" depends="cobertura.clean-instrumented-classes,install-cobertura,compile">
    <cobertura-instrument todir="${instrumented.classes.dir}" datafile="${cobertura.data.dir}/cobertura.ser">
      <ignore regex="org.apache.log4j.*" />
      <fileset dir="${classes.dir}">
        <!--
          Instrument all the application classes, but
          don't instrument the test classes.
        -->
        <include name="**/*.class" />
        <exclude name="**/*Test.class" />
      </fileset>
      <fileset dir="${classes.common-mapred.dir}">
        <!--
          Instrument all the application classes, but
          don't instrument the test classes.
        -->
        <include name="**/*.class" />
        <exclude name="**/*Test.class" />
      </fileset>
    </cobertura-instrument>
  </target>

  <!-- Run normal and common tests -->
  <target name="test" depends="compile,compile-tests,init-test-reports" description="Compiles and runs unit tests">
    <junit maxmemory="${junit.maxmemory}"
           fork="yes"
           failureProperty="test.failed"
           haltonfailure="${junit.haltonfailure}"
           printsummary="yes">
      <sysproperty key="java.awt.headless" value="${headless.unittest}" />

      <syspropertyset>
        <propertyref prefix="junit.sysprop." />
        <mapper type="glob" from="junit.sysprop.*" to="*"/>
      </syspropertyset>

      <classpath refid="test.classpath" />
      <formatter type="xml" />
      <test name="${testcase}" todir="${testreports.xml.dir}" if="testcase" />
      <batchtest fork="yes" todir="${testreports.xml.dir}" unless="testcase">
        <fileset dir="${testsrc.dir}" casesensitive="yes">
          <include name="**/*Test.java" />
        </fileset>
        <fileset dir="${testsrc.common.dir}" casesensitive="yes">
          <include name="**/*Test.java" />
        </fileset>
        <fileset dir="${test-src.common.modern.shim.dir}" casesensitive="yes">
          <include name="**/*Test.java" />
        </fileset>
        <fileset dir="${test-src.common.hadoop.shim.dir}" casesensitive="yes">
          <include name="**/*Test.java" />
        </fileset>
        <fileset dir="${test-src.common.hbase.shim.dir}" casesensitive="yes">
          <include name="**/*Test.java" />
        </fileset>
        <fileset dir="${test-src.common.pig.shim.dir}" casesensitive="yes">
          <include name="**/*Test.java" />
        </fileset>
      </batchtest>
    </junit>

    <junitreport todir="${testreports.html.dir}">
      <fileset dir="${testreports.xml.dir}">
        <include name="TEST-*.xml" />
      </fileset>
      <report format="frames" todir="${testreports.html.dir}" />
    </junitreport>
  </target>

  <!-- Run normal and common tests -->
  <target name="cobertura.test-instrumented"
          depends="init-test-reports,install-cobertura,compile,compile-tests,cobertura.instrument-classes">
    <mkdir dir="${instrumented.classes.dir}" />
    <path id="cobertura.classpath">
      <fileset dir="${subfloor.resources.dir}/cobertura">
        <include name="*.jar" />
      </fileset>
    </path>
    <junit fork="yes"
           maxmemory="${junit.maxmemory}"
           failureProperty="test.failed"
           haltonfailure="${junit.haltonfailure}">
      <sysproperty key="java.awt.headless" value="${headless.unittest}" />

      <!-- Specify the name of the coverage data file to use. -->
      <sysproperty key="net.sourceforge.cobertura.datafile" file="${cobertura.data.dir}/cobertura.ser" />

      <syspropertyset>
        <propertyref prefix="junit.sysprop." />
        <mapper type="glob" from="junit.sysprop.*" to="*"/>
      </syspropertyset>

      <!--
        Note the classpath order: instrumented classes are before the
        original (uninstrumented) classes.  This is important.
      -->
      <classpath location="${instrumented.classes.dir}" />
      <classpath location="${classes.dir}" />
      <classpath location="${classes.common-mapred.dir}" />
      <classpath location="${testclasses.dir}" />
      <classpath refid="test.classpath" />
      <classpath refid="cobertura.classpath" />

      <formatter type="xml" />
      <test name="${testcase}" todir="${testreports.xml.dir}" if="testcase" />
      <batchtest todir="${testreports.xml.dir}" unless="testcase">
        <fileset dir="${testsrc.dir}" casesensitive="yes">
          <include name="**/*Test.java" />
        </fileset>
        <fileset dir="${testsrc.common.dir}" casesensitive="yes">
          <include name="**/*Test.java" />
        </fileset>
        <fileset dir="${test-src.common.modern.shim.dir}" casesensitive="yes">
          <include name="**/*Test.java" />
        </fileset>
        <fileset dir="${test-src.common.hadoop.shim.dir}" casesensitive="yes">
          <include name="**/*Test.java" />
        </fileset>
        <fileset dir="${test-src.common.hbase.shim.dir}" casesensitive="yes">
          <include name="**/*Test.java" />
        </fileset>
        <fileset dir="${test-src.common.pig.shim.dir}" casesensitive="yes">
          <include name="**/*Test.java" />
        </fileset>
      </batchtest>
    </junit>

    <junitreport todir="${testreports.html.dir}">
      <fileset dir="${testreports.xml.dir}">
        <include name="TEST-*.xml" />
      </fileset>
      <report format="frames" todir="${testreports.html.dir}" />
    </junitreport>
  </target>

  <!-- override jar.main so we can jar up our mapred stuff too -->
  <target name="jar" depends="subfloor-pkg.jar,jar-mapred,jar-hbase-comparators"/>

  <!-- Jar the mapreduce libraries separately to reduce the payload when submitting
  MapReduce jobs to hadoop -->
  <target name="jar-mapred" depends="compile-mapred,generate.manifest">
    <jar destfile="${dist.dir}/${mapred.artifact.name}" manifest="${dist.manifest.file}">
      <fileset dir="${classes.common-mapred.dir}" />
    </jar>
  </target>

  <target name="jar-hbase-comparators" depends="compile.compile">
    <jar destfile="${dist.dir}/${hbase-comparators.artifact.name}" manifest="${dist.manifest.file}">
      <fileset dir="${classes.dir}" includes="**/*Comparator*"/>
    </jar>
  </target>

  <!-- Override assemble.copy-libs to put our jar in the root of the package -->
  <target name="assemble.copy-libs">
    <copy todir="${approot.stage.dir}/lib">
      <fileset dir="${lib.dir}" />
      <fileset file="${dist.dir}/${mapred.artifact.name}" />
    </copy>
    <copy todir="${approot.stage.dir}">
      <fileset file="${dist.dir}/${ivy.artifact.id}-${project.revision}.jar" />
      <fileset file="${dist.dir}/${hbase-comparators.artifact.name}" />
    </copy>
  </target>

  <target name="common-assemble">
    <!-- Copy common package resources over as well -->
    <copy todir="${approot.stage.dir}" overwrite="true">
      <fileset dir="${package.common.resdir}" />
    </copy>
  </target>

  <!-- override assemble to copy common package resources into the staging directory -->
  <target name="assemble" depends="common-assemble,subfloor-pkg.assemble">
  	<if>
  		<isset property="oss-license.filename"/>
  		<then>
  		    <ivy:resolve file="${ivyfile}" conf="oss-licenses" />
  		    <ivy:retrieve conf="oss-licenses" pattern="${bin.dir}/[module].[ext]" />
  			<echo message="copying ${oss-license.filename} to ${approot.stage.dir}" />
  		    <unzip src="${bin.dir}/oss-licenses.zip" dest="${approot.stage.dir}">
  		      <patternset>
  		        <include name="${oss-license.filename}"/>
  		      </patternset>
  		    </unzip>
  		</then>
  	</if>
  </target>

  <!-- Publish the mapred jar as well -->
  <target name="publish-local-nojar.post">
    <antcall target="publish-local-nojar.internal">
      <param name="ivy.artifact.id" value="${ivy.artifact.mapred.id}"/>
    </antcall>
  </target>

  <!-- Build the mapred source jar that is required when publishing to a non-local repository -->
  <target name="source.jar" depends="subfloor.source.jar">
    <jar jarfile="${dist.dir}/${ivy.artifact.mapred.id}-${project.revision}-sources.jar" basedir="${src.common-mapred.dir}" />
  </target>

  <!-- Publish the mapred jar as well -->
  <target name="publish-nojar" depends="subfloor.publish-nojar,subfloor-pkg.publish-nojar">
    <antcall target="publish-nojar.internal">
      <param name="ivy.artifact.id" value="${ivy.artifact.mapred.id}"/>
    </antcall>
  </target>


	<!--=======================================================================
      Overrride subfloor 'jacoco' target definition to include common tests
      ====================================================================-->
	<target name="jacoco" depends="install-jacoco,compile,compile-tests, init-test-reports"
          description="Compiles and runs unit tests with Jacoco code coverage.">

		<mkdir dir = "${jacoco.report.dir}" />

		<taskdef name="junit" classname="org.apache.tools.ant.taskdefs.optional.junit.JUnitTask">
			<classpath>
				<path refid="classpath"/>
				<path refid="test.classpath"/>
			</classpath>
		</taskdef>

		<path id="tests.path" cache="true">
			<path refid="base.path"/>
			<pathelement location="testclasses"/>
		</path>


		<path id="jacoco.classpath">
			<fileset dir="${subfloor.resources.dir}/org.jacoco.ant-${jacoco.version}">
				<include name="*.jar"/>
			</fileset>
		</path>

		<!-- Import the JaCoCo Ant Task -->
		<taskdef uri="antlib:org.jacoco.ant" resource="org/jacoco/ant/antlib.xml">
			<classpath>
				<path refid="jacoco.classpath"/>
			</classpath>
		</taskdef>

		<if>
			<equals arg1="${junit.available}" arg2="true"/>
			<then>
				<!-- Run unit tests, adding the JaCoCo agent -->
				<jacoco:coverage destfile="${jacoco.execfile.path}" xmlns:jacoco="antlib:org.jacoco.ant" >

				<junit maxmemory="${junit.maxmemory}"
		             dir="${junit.base.dir}"
		             fork="yes"
		             forkmode="${junit.forkmode}"
		             failureProperty="test.failed"
		             haltonfailure="${junit.haltonfailure}"
		             haltonerror="${junit.haltonerror}"
		             printsummary="yes">
					<sysproperty key="java.awt.headless" value="${headless.unittest}"/>

          <jvmarg line="${junit.jvmargs}"/>

					<syspropertyset>
						<propertyref prefix="junit.sysprop."/>
						<mapper type="glob" from="junit.sysprop.*" to="*"/>
					</syspropertyset>

					<classpath refid="test.classpath"/>
					<classpath refid="jacoco.classpath"/>

					<formatter type="xml"/>
					<test name="${testcase}" todir="${testreports.xml.dir}" if="testcase"/>
					<batchtest fork="yes" todir="${testreports.xml.dir}" unless="testcase">
						<fileset dir="${testsrc.dir}" casesensitive="yes">
              <include name="${junit.test.pattern}"/>
						</fileset>
						<fileset dir="${testsrc.common.dir}" casesensitive="yes">
              <include name="${junit.test.pattern}"/>
						</fileset>
            <fileset dir="${test-src.common.modern.shim.dir}" casesensitive="yes">
              <include name="${junit.test.pattern}"/>
						</fileset>
            <fileset dir="${test-src.common.hadoop.shim.dir}" casesensitive="yes">
              <include name="${junit.test.pattern}"/>
						</fileset>
            <fileset dir="${test-src.common.hbase.shim.dir}" casesensitive="yes">
              <include name="${junit.test.pattern}"/>
						</fileset>
            <fileset dir="${test-src.common.pig.shim.dir}" casesensitive="yes">
              <include name="${junit.test.pattern}"/>
						</fileset>
					</batchtest>
				</junit>
				</jacoco:coverage>
			</then>
		</if>

		<if>
			<!-- if there is no exec file (no tests or faulty tests), cannot gen report -->
			<available file="${jacoco.execfile.path}" property="jacoco.exec.file.found"/>
			<then>
				<jacoco:report xmlns:jacoco="antlib:org.jacoco.ant">
					<executiondata>
						<file file="${jacoco.execfile.path}"/>
					</executiondata>
					<structure name="${ivy.artifact.id}">
						<classfiles>
							<fileset dir="${classes.dir}">
                <exclude name="${jacoco.ui.class.exclude.pattern}"/>
              </fileset>
							<fileset dir="${classes.common-mapred.dir}">
                <exclude name="${jacoco.ui.class.exclude.pattern}"/>
              </fileset>
						</classfiles>
						<sourcefiles encoding="UTF-8">
							<fileset dir="${src.dir}"/>
							<fileset dir="${src.common-mapred.dir}"/>
							<fileset dir="${src.common-hbase.dir}"/>
              <fileset dir="${src.common.modern.shim.dir}"/>
              <fileset dir="${src.common.hbase.shim.dir}"/>
              <fileset dir="${src.common.hadoop.shim.dir}"/>
              <fileset dir="${src.common.pig.shim.dir}"/>
						</sourcefiles>
					</structure>
					<html destdir="${jacoco.report.dir}"/>
					<csv destfile="${jacoco.report.dir}/report.csv"/>
					<xml destfile="${jacoco.report.dir}/report.xml"/>
				</jacoco:report>
			</then>
		</if>

		<junitreport todir="${testreports.html.dir}">
			<fileset dir="${testreports.xml.dir}">
				<include name="TEST-*.xml"/>
			</fileset>
			<report format="frames" todir="${testreports.html.dir}"/>
		</junitreport>

	</target>

</project>