build.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!--
 ~ 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 basedir="." default="build" name="apache-cassandra"
         xmlns:artifact="antlib:org.apache.maven.artifact.ant">
    <property environment="env"/>
    <property file="build.properties" />
    <property file="build.properties.default" />
    <property name="debuglevel" value="source,lines,vars"/>

    <!-- default version and SCM information (we need the default SCM info as people may checkout with git-svn) -->
    <property name="base.version" value="0.8.2-dev"/>
    <property name="scm.default.path" value="cassandra/branches/cassandra-0.8"/>
    <property name="scm.default.connection" value="scm:svn:http://svn.apache.org/repos/asf/${scm.default.path}"/>
    <property name="scm.default.developerConnection" value="scm:svn:https://svn.apache.org/repos/asf/${scm.default.path}"/>
    <property name="scm.default.url" value="http://svn.apache.org/viewvc/${scm.default.path}"/>

    <!-- directory details -->
    <property name="basedir" value="."/>
    <property name="build.src" value="${basedir}/src"/>
    <property name="build.src.java" value="${basedir}/src/java"/>
    <property name="build.src.resources" value="${basedir}/src/resources"/>
    <property name="avro.src" value="${basedir}/src/avro"/>
    <property name="build.src.gen-java" value="${basedir}/src/gen-java"/>
    <property name="build.lib" value="${basedir}/lib"/>
    <property name="build.dir" value="${basedir}/build"/>
    <property name="build.dir.lib" value="${basedir}/build/lib"/>
    <property name="build.test.dir" value="${build.dir}/test"/>
    <property name="build.classes" value="${build.dir}/classes"/>
    <property name="build.classes.main" value="${build.classes}/main" />
    <property name="build.classes.thrift" value="${build.classes}/thrift" />
    <property name="javadoc.dir" value="${build.dir}/javadoc"/>
    <property name="javadoc.jars.dir" value="${build.dir}/javadocs"/>
    <property name="interface.dir" value="${basedir}/interface"/>
    <property name="interface.thrift.dir" value="${interface.dir}/thrift"/>
    <property name="interface.thrift.gen-java" value="${interface.thrift.dir}/gen-java"/>
    <property name="test.dir" value="${basedir}/test"/>
    <property name="test.resources" value="${test.dir}/resources"/>
    <property name="test.lib" value="${build.dir}/test/lib"/>
    <property name="test.classes" value="${build.dir}/test/classes"/>
    <property name="test.conf" value="${test.dir}/conf"/>
    <property name="test.data" value="${test.dir}/data"/>
    <property name="test.name" value="*Test"/>
    <property name="test.unit.src" value="${test.dir}/unit"/>
    <property name="test.long.src" value="${test.dir}/long"/>
    <property name="test.distributed.src" value="${test.dir}/distributed"/>
    <property name="dist.dir" value="${build.dir}/dist"/>
    <condition property="version" value="${base.version}">
      <isset property="release"/>
    </condition>
    <property name="version" value="${base.version}-SNAPSHOT"/>
    <property name="version.properties.dir"
              value="${build.classes.main}/org/apache/cassandra/config/" />
    <property name="final.name" value="${ant.project.name}-${version}"/>
 
    <!-- details of what version of Maven ANT Tasks to fetch -->
    <property name="maven-ant-tasks.version" value="2.1.3" />
    <property name="maven-ant-tasks.local" value="${user.home}/.m2/repository/org/apache/maven/maven-ant-tasks"/>
    <property name="maven-ant-tasks.url"
              value="http://repo2.maven.org/maven2/org/apache/maven/maven-ant-tasks" />
    <!-- details of how and which Maven repository we publish to -->
    <property name="maven.version" value="3.0.3" />
    <condition property="maven-repository-url" value="https://repository.apache.org/service/local/staging/deploy/maven2">
      <isset property="release"/>
    </condition>
    <condition property="maven-repository-id" value="apache.releases.https">
      <isset property="release"/>
    </condition>
    <property name="maven-repository-url" value="https://repository.apache.org/content/repositories/snapshots"/>
    <property name="maven-repository-id" value="apache.snapshots.https"/>

    <property name="test.timeout" value="60000" />
    <property name="test.long.timeout" value="300000" />

    <!-- http://cobertura.sourceforge.net/ -->
    <property name="cobertura.version" value="1.9.4.1"/>
    <property name="cobertura.build.dir" value="${build.dir}/cobertura"/>
    <property name="cobertura.report.dir" value="${cobertura.build.dir}/report"/>
    <property name="cobertura.classes.dir" value="${cobertura.build.dir}/classes"/>
    <property name="cobertura.datafile" value="${cobertura.build.dir}/cobertura.ser"/>

    <condition property="maven-ant-tasks.jar.exists">
      <available file="${build.dir}/maven-ant-tasks-${maven-ant-tasks.version}.jar" />
    </condition>

    <condition property="maven-ant-tasks.jar.local">
      <available file="${maven-ant-tasks.local}/${maven-ant-tasks.version}/maven-ant-tasks-${maven-ant-tasks.version}.jar" />
    </condition>

    <condition property="is.source.artifact">
      <available file="${build.src.java}" type="dir" />
    </condition>

    <condition property="scm.provider.git-svn">
      <available file="${basedir}/.git" type="dir"/>
    </condition>

    <condition property="scm.provider.svn">
      <available file="${basedir}/.svn" type="dir"/>
    </condition>

    <tstamp>
      <format property="YEAR" pattern="yyyy"/>
    </tstamp>

    <!--
         Add all the dependencies.
    -->
    <path id="maven-ant-tasks.classpath" path="${build.dir}/maven-ant-tasks-${maven-ant-tasks.version}.jar" />
    <path id="cassandra.classpath">
        <pathelement location="${cobertura.classes.dir}"/>
        <pathelement location="${build.classes.main}" />
        <pathelement location="${build.classes.thrift}" />
        <fileset dir="${build.lib}">
          <include name="**/*.jar" />
        </fileset>
        <fileset dir="${build.dir.lib}">
          <include name="**/*.jar" />
        </fileset>
    </path>

  <macrodef name="create-javadoc">
    <attribute name="destdir"/>
    <element name="filesets"/>
    <sequential>
      <javadoc destdir="@{destdir}" author="true" version="true" use="true"
        windowtitle="${ant.project.name} API" classpathref="cassandra.classpath"
        bottom="Copyright &amp;copy; ${YEAR} The Apache Software Foundation"
        useexternalfile="yes"
        maxmemory="256m">
        <filesets/>
      </javadoc>
    </sequential>
  </macrodef>

    <!--
        Setup the output directories.
    -->
    <target name="init">
        <fail unless="is.source.artifact"
            message="Not a source artifact, stopping here." />
        <mkdir dir="${build.classes.main}"/>
        <mkdir dir="${build.classes.thrift}"/>
        <mkdir dir="${test.lib}"/>
        <mkdir dir="${test.classes}"/>
        <mkdir dir="${build.src.gen-java}"/>
    </target>

    <target name="clean" description="Remove all locally created artifacts">
        <delete dir="${build.test.dir}" />
        <delete dir="${build.classes}" />
        <delete dir="${cobertura.classes.dir}" />
        <delete dir="${build.src.gen-java}" />
        <delete file="${build.dir}/internode.avpr" />
    </target>
    <target depends="clean" name="cleanall"/>

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

    <!--
       This generates the CLI grammar files from Cli.g
    -->
    <target name="check-gen-cli-grammar">
        <uptodate property="cliUpToDate"
                srcfile="${build.src.java}/org/apache/cassandra/cli/Cli.g"
                targetfile="${build.src.gen-java}/org/apache/cassandra/cli/Cli.tokens"/>
    </target>

    <target name="gen-cli-grammar" depends="check-gen-cli-grammar" unless="cliUpToDate">
      <echo>Building Grammar ${build.src.java}/org/apache/cassandra/cli/Cli.g  ....</echo>
      <java classname="org.antlr.Tool"
            classpath="${build.lib}/antlr-3.2.jar"
            fork="true"
            failonerror="true">
         <arg value="${build.src.java}/org/apache/cassandra/cli/Cli.g" />
         <arg value="-fo" />
         <arg value="${build.src.gen-java}/org/apache/cassandra/cli/" />
      </java>
    </target>

    <!--
       This generates the CQL grammar files from Cql.g
    -->
    <target name="check-gen-cql-grammar">
      <uptodate property="cqlcurrent" 
                srcfile="${build.src.java}/org/apache/cassandra/cql/Cql.g" 
                targetfile="${build.src.gen-java}/org/apache/cassandra/cql/Cql.tokens"/>
    </target>
 
    <target name="gen-cql-grammar" depends="check-gen-cql-grammar" unless="cqlcurrent">
      <echo>Building Grammar ${build.src.java}/org/apache/cassandra/cql/Cql.g  ...</echo>
      <java classname="org.antlr.Tool"
            classpath="${build.lib}/antlr-3.2.jar"
            fork="true"
            failonerror="true">
         <arg value="${build.src.java}/org/apache/cassandra/cql/Cql.g" />
         <arg value="-fo" />
         <arg value="${build.src.gen-java}/org/apache/cassandra/cql/" />
      </java> 
    </target>
	
	<target name="generate-cql-html" depends="maven-ant-tasks-init" description="Generate HTML from textile source">
	  <artifact:dependencies pathId="wikitext.classpath">
	    <dependency groupId="com.datastax.wikitext" artifactId="wikitext-core-ant" version="1.3"/>	    	  
	    <dependency groupId="org.fusesource.wikitext" artifactId="textile-core" version="1.3"/>		          
	  </artifact:dependencies>
      <taskdef classpathref="wikitext.classpath" resource="wikitexttasks.properties" />
	    <wikitext-to-html markupLanguage="Textile">
		  <fileset dir="${basedir}">
    		<include name="doc/cql/*.textile"/>
		  </fileset>
		</wikitext-to-html>
	</target>

    <target name="scm-svn-info" description="Determines the current Subversion URL with peg revision"
            if="scm.provider.svn">
      <exec executable="svn" dir="${basedir}" output="${build.dir}/svn-info.xml">
        <arg line="info --xml"/>
      </exec>
      <xmlproperty file="${build.dir}/svn-info.xml" collapseAttributes="true" prefix="svn" keepRoot="false"/>
      <echo file="${build.dir}/scm.properties">
connection=scm:svn:${svn.entry.url}@${svn.entry.commit.revision}
developerConnection=scm:svn:${svn.entry.url}@${svn.entry.commit.revision}
url=${svn.entry.url}?pathrev=${svn.entry.commit.revision}
      </echo>
      <replace file="${build.dir}/scm.properties">
        <replacefilter token="connection=scm:svn:https:" value="connection=scm:svn:http:"/>
        <replacefilter token="Connection=scm:svn:http:" value="Connection=scm:svn:https:"/>
        <replacefilter token="url=${svn.entry.repository.root}" value="url=http://svn.apache.org/viewvc"/>
      </replace>
      <property file="${build.dir}/scm.properties" prefix="scm"/>
    </target>

    <target name="scm-info" description="Determines the SCM details"
            unless="scm.connection" depends="scm-svn-info">
      <property name="scm.connection" value="${scm.default.connection}"/>
      <property name="scm.developerConnection" value="${scm.default.developerConnection}"/>
      <property name="scm.url" value="${scm.default.url}"/>
    </target>
    <!--
       Fetch Maven Ant Tasks and Cassandra's dependencies
       These targets are intentionally free of dependencies so that they
       can be run stand-alone from a binary release artifact.
    -->
    <target name="maven-ant-tasks-localrepo" unless="maven-ant-tasks.jar.exists" if="maven-ant-tasks.jar.local"
            description="Fetch Maven ANT Tasks from Maven Local Repository">
      <mkdir dir="${build.dir}" />
      <copy file="${maven-ant-tasks.local}/${maven-ant-tasks.version}/maven-ant-tasks-${maven-ant-tasks.version}.jar"
           tofile="${build.dir}/maven-ant-tasks-${maven-ant-tasks.version}.jar"/>
      <property name="maven-ant-tasks.jar.exists" value="true"/>
    </target>

    <target name="maven-ant-tasks-download" depends="maven-ant-tasks-localrepo" unless="maven-ant-tasks.jar.exists"
            description="Fetch Maven ANT Tasks from Maven Central Repositroy">
      <echo>Downloading Maven ANT Tasks...</echo>
      <mkdir dir="${build.dir}" />
      <get src="${maven-ant-tasks.url}/${maven-ant-tasks.version}/maven-ant-tasks-${maven-ant-tasks.version}.jar"
           dest="${build.dir}/maven-ant-tasks-${maven-ant-tasks.version}.jar" usetimestamp="true" />
    </target>

    <target name="maven-ant-tasks-init" depends="maven-ant-tasks-download" unless="maven-ant-tasks.initialized"
            description="Initialize Maven ANT Tasks">
      <mkdir dir="${build.dir.lib}"/>
      <typedef uri="antlib:org.apache.maven.artifact.ant" classpathref="maven-ant-tasks.classpath" />

      <!-- define the remote repositories we use -->
      <artifact:remoteRepository id="central"   url="${artifact.remoteRepository.central}"/>
      <artifact:remoteRepository id="java.net2" url="${artifact.remoteRepository.java.net2}"/>
      <artifact:remoteRepository id="apache"    url="${artifact.remoteRepository.apache}"/>
      <!-- for distributed tests -->
      <artifact:remoteRepository id="jclouds"   url="${artifact.remoteRepository.jclouds}"/>
      <artifact:remoteRepository id="oauth"     url="${artifact.remoteRepository.oauth}"/>

      <macrodef name="install">
        <attribute name="pomFile"/>
        <attribute name="file"/>
        <attribute name="classifier" default=""/>
        <attribute name="packaging" default="jar"/>
        <sequential>
          <artifact:mvn mavenVersion="${maven.version}" fork="true" failonerror="true">
            <arg value="org.apache.maven.plugins:maven-install-plugin:2.3.1:install-file" />
            <arg value="-DpomFile=@{pomFile}" />
            <arg value="-Dfile=@{file}" />
            <arg value="-Dclassifier=@{classifier}" />
            <arg value="-Dpackaging=@{packaging}" />
          </artifact:mvn>
        </sequential>
      </macrodef>

      <macrodef name="deploy">
        <attribute name="pomFile"/>
        <attribute name="file"/>
        <attribute name="classifier" default=""/>
        <attribute name="packaging" default="jar"/>
        <sequential>
          <artifact:mvn mavenVersion="${maven.version}" fork="true" failonerror="true">
            <jvmarg value="-Xmx512m"/>
            <arg value="org.apache.maven.plugins:maven-gpg-plugin:1.2:sign-and-deploy-file" />
            <arg value="-Durl=${maven-repository-url}" />
            <arg value="-DrepositoryId=${maven-repository-id}" />
            <arg value="-DpomFile=@{pomFile}" />
            <arg value="-Dfile=@{file}" />
            <arg value="-Dclassifier=@{classifier}" />
            <arg value="-Dpackaging=@{packaging}" />
            <arg value="-Papache-release" />
          </artifact:mvn>
        </sequential>
      </macrodef>

      <property name="maven-ant-tasks.initialized" value="true"/>
    </target>

    <!-- this task defines the dependencies that will be fetched by Maven ANT Tasks
         the dependencies are re-used for publishing artifacts to Maven Central
         in order to keep everything consistent -->
    <target name="maven-declare-dependencies" depends="maven-ant-tasks-init, scm-info"
            description="Define dependencies and dependency versions">
      <!-- The parent pom defines the versions of all dependencies -->
      <artifact:pom id="parent-pom"
                    groupId="org.apache.cassandra"
                    artifactId="cassandra-parent"
                    packaging="pom"
                    version="${version}"
                    url="http://cassandra.apache.org"
                    name="Apache Cassandra"
                    inceptionYear="2009"
                    description="The Apache Cassandra Project develops a highly scalable second-generation distributed database, bringing together Dynamo's fully distributed design and Bigtable's ColumnFamily-based data model.">
        <license name="The Apache Software License, Version 2.0" url="http://www.apache.org/licenses/LICENSE-2.0.txt"/>
        <scm connection="${scm.connection}" developerConnection="${scm.developerConnection}" url="${scm.url}"/>
        <dependencyManagement>
          <dependency groupId="com.google.guava" artifactId="guava" version="r08"/>
          <dependency groupId="commons-cli" artifactId="commons-cli" version="1.1"/>
          <dependency groupId="commons-codec" artifactId="commons-codec" version="1.2"/>
          <dependency groupId="commons-lang" artifactId="commons-lang" version="2.4"/>
          <dependency groupId="com.googlecode.concurrentlinkedhashmap" artifactId="concurrentlinkedhashmap-lru" version="1.2"/>
          <dependency groupId="org.antlr" artifactId="antlr" version="3.2"/>
          <dependency groupId="org.slf4j" artifactId="slf4j-api" version="1.6.1"/>
          <dependency groupId="org.slf4j" artifactId="slf4j-log4j12" version="1.6.1"/>
          <dependency groupId="org.codehaus.jackson" artifactId="jackson-core-asl" version="1.4.0"/>
          <dependency groupId="org.codehaus.jackson" artifactId="jackson-mapper-asl" version="1.4.0"/>
          <dependency groupId="jline" artifactId="jline" version="0.9.94">
            <exclusion groupId="junit" artifactId="junit"/>
          </dependency>
          <dependency groupId="com.googlecode.json-simple" artifactId="json-simple" version="1.1"/>
          <dependency groupId="com.github.stephenc.high-scale-lib" artifactId="high-scale-lib" version="1.1.2"/>
          <dependency groupId="com.github.stephenc" artifactId="jamm" version="0.2.4"/>
          <dependency groupId="org.yaml" artifactId="snakeyaml" version="1.6"/>
          <dependency groupId="org.apache.cassandra.deps" artifactId="avro" version="1.4.0-cassandra-1">
            <exclusion groupId="org.jboss.netty" artifactId="netty"/>
            <exclusion groupId="com.thoughtworks.paranamer" artifactId="paranamer"/>
            <exclusion groupId="com.thoughtworks.paranamer" artifactId="paranamer-ant"/>
            <exclusion groupId="org.apache.velocity" artifactId="velocity"/>
          </dependency>
          
          <dependency groupId="org.apache.thrift" artifactId="libthrift" version="0.6.1">
            <exclusion groupId="org.slf4j" artifactId="slf4j-log4j12"/>
          </dependency>

          <dependency groupId="com.thoughtworks.paranamer" artifactId="paranamer-ant" version="2.1"/>
          <dependency groupId="junit" artifactId="junit" version="4.6" />
          <dependency groupId="commons-logging" artifactId="commons-logging" version="1.1.1"/>
          <dependency groupId="org.apache.rat" artifactId="apache-rat" version="0.6" />
          <dependency groupId="org.apache.hadoop" artifactId="hadoop-core" version="0.20.203.0"/>
          <dependency groupId="net.sf.jopt-simple" artifactId="jopt-simple" version="3.2"/>
          <dependency groupId="net.java.dev.jna" artifactId="jna" version="3.2.7"/>

          <dependency groupId="net.sourceforge.cobertura" artifactId="cobertura" version="${cobertura.version}"/>

          <dependency groupId="org.apache.whirr" artifactId="whirr-core" version="0.4.0-incubating"/>
          <dependency groupId="org.apache.whirr" artifactId="whirr-cli" version="0.4.0-incubating"/>
          <dependency groupId="org.jclouds.provider" artifactId="aws-s3" version="1.0-beta-9b" />

          <dependency groupId="log4j" artifactId="log4j" version="1.2.16" />
          <dependency groupId="org.apache.cassandra" artifactId="cassandra-all" version="${version}" />
          <dependency groupId="org.apache.cassandra" artifactId="cassandra-thrift" version="${version}" />
        </dependencyManagement>
        <developer id="alakshman" name="Avinash Lakshman"/>
        <developer id="antelder" name="Anthony Elder"/>
        <developer id="brandonwilliams" name="Brandon Williams"/>
        <developer id="eevans" name="Eric Evans"/>
        <developer id="gdusbabek" name="Gary Dusbabek"/>
        <developer id="goffinet" name="Chris Goffinet"/>
        <developer id="jaakko" name="Laine Jaakko Olavi"/>
        <developer id="jake" name="T Jake Luciani"/>
        <developer id="jbellis" name="Jonathan Ellis"/>
        <developer id="johan" name="Johan Oskarsson"/>
        <developer id="junrao" name="Jun Rao"/>
        <developer id="mriou" name="Matthieu Riou"/>
        <developer id="pmalik" name="Prashant Malik"/>
        <developer id="slebresne" name="Sylvain Lebresne"/>
      </artifact:pom>

      <!-- each dependency set then defines the subset of the dependencies for that dependency set -->
      <artifact:pom id="build-deps-pom"
                    artifactId="cassandra-build-deps">
        <parent groupId="org.apache.cassandra"
                artifactId="cassandra-parent"
                version="${version}"/>
        <!-- FIXME: paranamer can be dropped after we're depending on avro
        (since it depends on them). -->
        <dependency groupId="com.thoughtworks.paranamer" artifactId="paranamer-ant"/>
        <dependency groupId="junit" artifactId="junit"/>
        <dependency groupId="commons-logging" artifactId="commons-logging"/>
        <dependency groupId="org.apache.rat" artifactId="apache-rat"/>
        <dependency groupId="org.apache.hadoop" artifactId="hadoop-core"/>
        <dependency groupId="net.sf.jopt-simple" artifactId="jopt-simple"/>

        <dependency groupId="net.java.dev.jna" artifactId="jna"/>
      </artifact:pom>

      <artifact:pom id="coverage-deps-pom"
                    artifactId="cassandra-coverage-deps">
        <parent groupId="org.apache.cassandra"
                artifactId="cassandra-parent"
                version="${version}"/>
        <dependency groupId="net.sourceforge.cobertura" artifactId="cobertura"/>
      </artifact:pom>

      <artifact:pom id="test-deps-pom"
                    artifactId="cassandra-test-deps">
        <parent groupId="org.apache.cassandra"
                artifactId="cassandra-parent"
                version="${version}"/>
        <dependency groupId="org.apache.whirr" artifactId="whirr-core"/>
        <dependency groupId="org.apache.whirr" artifactId="whirr-cli"/>
        <dependency groupId="org.jclouds.provider" artifactId="aws-s3"/>
      </artifact:pom>

      <!-- now the pom's for artifacts being deployed to Maven Central -->

      <artifact:pom id="all-pom"
                    artifactId="cassandra-all"
                    url="http://cassandra.apache.org"
                    name="Apache Cassandra">
        <parent groupId="org.apache.cassandra"
                artifactId="cassandra-parent"
                version="${version}"/>
        <scm connection="${scm.connection}" developerConnection="${scm.developerConnection}" url="${scm.url}"/>
        <dependency groupId="com.google.guava" artifactId="guava"/>
        <dependency groupId="commons-cli" artifactId="commons-cli"/>
        <dependency groupId="commons-codec" artifactId="commons-codec"/>
        <dependency groupId="commons-lang" artifactId="commons-lang"/>
        <dependency groupId="com.googlecode.concurrentlinkedhashmap" artifactId="concurrentlinkedhashmap-lru"/>
        <dependency groupId="org.antlr" artifactId="antlr"/>
        <dependency groupId="org.slf4j" artifactId="slf4j-api"/>
        <dependency groupId="org.apache.cassandra.deps" artifactId="avro"/>
        <dependency groupId="org.codehaus.jackson" artifactId="jackson-core-asl"/>
        <dependency groupId="org.codehaus.jackson" artifactId="jackson-mapper-asl"/>
        <dependency groupId="jline" artifactId="jline"/>
        <dependency groupId="com.googlecode.json-simple" artifactId="json-simple"/>
        <dependency groupId="com.github.stephenc.high-scale-lib" artifactId="high-scale-lib"/>
        <dependency groupId="org.yaml" artifactId="snakeyaml"/>
        
        <dependency groupId="log4j" artifactId="log4j"/>
        <!-- cassandra has a hard dependency on log4j, so force slf4j's log4j provider at runtime -->
        <dependency groupId="org.slf4j" artifactId="slf4j-log4j12" scope="runtime"/>

        <dependency groupId="org.apache.thrift" artifactId="libthrift"/>
        <dependency groupId="org.apache.cassandra" artifactId="cassandra-thrift"/>
        
        <!-- don't need hadoop classes to run, but if you use the hadoop stuff -->
        <dependency groupId="org.apache.hadoop" artifactId="hadoop-core" optional="true"/>
        
        <!-- don't need jna to run, but nice to have -->
        <dependency groupId="net.java.dev.jna" artifactId="jna" optional="true"/>
        
        <!-- don't need jamm unless running a server in which case it needs to be a -javagent to be used anyway -->
        <dependency groupId="com.github.stephenc" artifactId="jamm"/>
      </artifact:pom>
      <artifact:pom id="thrift-pom"
                    artifactId="cassandra-thrift"
                    url="http://cassandra.apache.org"
                    name="Apache Cassandra">
        <parent groupId="org.apache.cassandra"
                artifactId="cassandra-parent"
                version="${version}"/>
        <scm connection="${scm.connection}" developerConnection="${scm.developerConnection}" url="${scm.url}"/>
        <dependency groupId="commons-lang" artifactId="commons-lang"/>
        <dependency groupId="org.slf4j" artifactId="slf4j-api"/>
        <dependency groupId="org.apache.thrift" artifactId="libthrift"/>
      </artifact:pom>

      <artifact:pom id="dist-pom"
                    artifactId="apache-cassandra"
                    packaging="pom"
                    url="http://cassandra.apache.org"
                    name="Apache Cassandra">
        <parent groupId="org.apache.cassandra"
                artifactId="cassandra-parent"
                version="${version}"/>
        <scm connection="${scm.connection}" developerConnection="${scm.developerConnection}" url="${scm.url}"/>
      </artifact:pom>
    </target>

    <target name="maven-ant-tasks-retrieve-build" depends="maven-declare-dependencies">
      <artifact:dependencies pomRefId="build-deps-pom"
                             filesetId="build-dependency-jars" 
                             sourcesFilesetId="build-dependency-sources" 
                             cacheDependencyRefs="true" 
                             dependencyRefsBuildFile="${build.dir}/build-dependencies.xml">
          <remoteRepository refid="central"/>
          <remoteRepository refid="apache"/>
          <remoteRepository refid="java.net2"/>
      </artifact:dependencies>
      <artifact:dependencies pomRefId="coverage-deps-pom"
                             pathId="cobertura.classpath">
          <remoteRepository refid="central"/>
      </artifact:dependencies>

      <copy todir="${build.dir.lib}/jars">
          <fileset refid="build-dependency-jars"/>
          <mapper type="flatten"/>
      </copy>
      <copy todir="${build.dir.lib}/sources">
          <fileset refid="build-dependency-sources"/>
          <mapper type="flatten"/>
      </copy>
    </target>

    <target name="maven-ant-tasks-retrieve-test" depends="maven-ant-tasks-init">
      <artifact:dependencies pomRefId="test-deps-pom"
                             filesetId="test-dependency-jars"
                             sourcesFilesetId="test-dependency-sources" 
                             cacheDependencyRefs="true" 
                             dependencyRefsBuildFile="${build.dir}/test-dependencies.xml">
        <remoteRepository refid="apache"/>
        <remoteRepository refid="central"/>
        <remoteRepository refid="jclouds"/>
        <remoteRepository refid="oauth"/>
      </artifact:dependencies>
      <copy todir="${test.lib}/jars">
        <fileset refid="test-dependency-jars"/>
        <mapper type="flatten"/>
      </copy>
      <copy todir="${test.lib}/sources">
        <fileset refid="test-dependency-sources"/>
        <mapper type="flatten"/>
      </copy>
    </target>

    <!--
       Generate avro code
    -->
    <target name="check-avro-generate" depends="maven-ant-tasks-init">
      <taskdef name="avro-protocol" classname="org.apache.avro.specific.ProtocolTask">
        <classpath refid="cassandra.classpath" />
      </taskdef>
      <uptodate property="avroINProtoUpToDate" srcfile="${avro.src}/internode.genavro"
                targetfile="${build.dir}/internode.avpr" />
    </target>

    <target name="avro-generate"
            depends="avro-interface-generate-internode"
            description="Generates Java Avro classes for client and internal use." />
    
    <target name="avro-interface-generate-internode" unless="avroINProtoUpToDate"
            depends="init,check-avro-generate,maven-ant-tasks-retrieve-build">
      <avromacro protocolname="internode" inputfile="${avro.src}/internode.genavro"
                 jsondir="${build.dir}" outputdir="${build.src}"/>
    </target>

    <macrodef name="avromacro">
      <attribute name="protocolname" />
      <attribute name="inputfile" />
      <attribute name="jsondir" />
      <attribute name="outputdir" />
      <sequential>
        <echo message="Generating Avro @{protocolname} code..." />
        <mkdir dir="@{jsondir}" />
        <!-- Generate json schema from genavro IDL -->
        <java classname="org.apache.avro.tool.Main" fork="true">
          <classpath refid="cassandra.classpath" />
          <arg value="idl" />
          <arg value="@{inputfile}" />
          <arg value="@{jsondir}/@{protocolname}.avpr" />
        </java>

        <!-- Generate java code from JSON protocol schema -->
        <avro-protocol destdir="@{outputdir}/gen-java">
            <fileset file="@{jsondir}/@{protocolname}.avpr" />
        </avro-protocol>
      </sequential>
    </macrodef>


    <!--
       Generate thrift code.  We have targets to build java because
       Cassandra depends on it, and python because that is what the system
       tests run.
    -->
    <target name="gen-thrift-java" depends="rat-init" description="Generate Thrift Java artifacts">
      <echo>Generating Thrift Java code from ${basedir}/interface/cassandra.thrift ....</echo>
      <exec executable="thrift" dir="${basedir}/interface" failonerror="true">
        <arg line="--gen java:hashcode" />
        <arg line="-o ${interface.thrift.dir}" />
        <arg line="cassandra.thrift" />
      </exec>
      <java classname="org.apache.rat.Report" fork="true"
            output="${build.dir}/rat-report.log">
        <classpath refid="rat.classpath" />
        <arg value="-a" />
        <arg value="--force" />
        <arg value="interface/thrift" />
      </java>
    </target>
    <target name="gen-thrift-py" description="Generate Thrift Python artifacts">
      <echo>Generating Thrift Python code from ${basedir}/interface/cassandra.thrift ....</echo>
      <exec executable="thrift" dir="${basedir}/interface" failonerror="true">
        <arg line="--gen py" />
        <arg line="-o ${interface.thrift.dir}" />
        <arg line="cassandra.thrift" />
      </exec>
      <exec executable="thrift" dir="${basedir}/interface" failonerror="true">
        <arg line="--gen py:twisted" />
        <arg line="-o ${interface.thrift.dir}" />
        <arg line="cassandra.thrift" />
      </exec>
    </target>

    <!-- create properties file with C version -->
    <target name="createVersionPropFile">
      <taskdef name="propertyfile" classname="org.apache.tools.ant.taskdefs.optional.PropertyFile"/>
      <propertyfile file="${version.properties.dir}/version.properties">
        <entry key="CassandraVersion" value="${version}"/>
      </propertyfile>
    </target>

    <!--
        The build target builds all the .class files
    -->
    <target name="build"
        depends="maven-ant-tasks-retrieve-build,avro-generate,build-subprojects,build-project" description="Compile Cassandra classes"/>
    <target name="build-subprojects" description="Compile Cassandra contrib projects"/>
    <target name="codecoverage" depends="cobertura-instrument,test,cobertura-report" description="Create code coverage report"/>

    <target depends="init,avro-generate,gen-cli-grammar,gen-cql-grammar"
            name="build-project">
        <echo message="${ant.project.name}: ${ant.file}"/>
        <!-- Order matters! -->
        <javac debug="true" debuglevel="${debuglevel}"
               destdir="${build.classes.thrift}" includeantruntime="false">
            <src path="${interface.thrift.dir}/gen-java"/>
            <classpath refid="cassandra.classpath"/>
        </javac>
        <javac debug="true" debuglevel="${debuglevel}"
               destdir="${build.classes.main}" includeantruntime="false">
            <src path="${build.src.java}"/>
            <src path="${build.src.gen-java}"/>
            <classpath refid="cassandra.classpath"/>
        </javac>
        <copy todir="${build.classes.main}">
            <fileset dir="${build.src.resources}" />
        </copy>
        <taskdef name="paranamer" classname="com.thoughtworks.paranamer.ant.ParanamerGeneratorTask">
          <classpath refid="cassandra.classpath" />
        </taskdef>

        <antcall target="createVersionPropFile"/>
    </target>


    <!--
        The jar target makes cassandra.jar output.
    -->
    <target name="jar" depends="maven-declare-dependencies,build" description="Assemble Cassandra JAR files">
      <mkdir dir="${build.classes.main}/META-INF" />
      <mkdir dir="${build.classes.thrift}/META-INF" />
      <copy file="LICENSE.txt"
            tofile="${build.classes.main}/META-INF/LICENSE.txt"/>
      <copy file="LICENSE.txt"
            tofile="${build.classes.thrift}/META-INF/LICENSE.txt"/>
      <copy file="NOTICE.txt"
            tofile="${build.classes.main}/META-INF/NOTICE.txt"/>
      <copy file="NOTICE.txt"
            tofile="${build.classes.thrift}/META-INF/NOTICE.txt"/>

      <artifact:writepom pomRefId="parent-pom" file="${build.dir}/${final.name}-parent.pom"/>

      <!-- Thrift Jar -->
      <artifact:writepom pomRefId="thrift-pom" 
              file="${build.dir}/${ant.project.name}-thrift-${version}.pom"/>
      <jar jarfile="${build.dir}/${ant.project.name}-thrift-${version}.jar"
           basedir="${build.classes.thrift}">
        <manifest>
          <attribute name="Implementation-Title" value="Cassandra"/>
          <attribute name="Implementation-Version" value="${version}"/>
          <attribute name="Implementation-Vendor" value="Apache"/>
        </manifest>
      </jar>

      <!-- Main Jar -->
      <artifact:writepom pomRefId="all-pom" 
              file="${build.dir}/${final.name}.pom"/>
      <jar jarfile="${build.dir}/${final.name}.jar"
           basedir="${build.classes.main}">
        <manifest>
        <!-- <section name="org/apache/cassandra/infrastructure"> -->
          <attribute name="Implementation-Title" value="Cassandra"/>
          <attribute name="Implementation-Version" value="${version}"/>
          <attribute name="Implementation-Vendor" value="Apache"/>
          <attribute name="Premain-Class"
                     value="org.apache.cassandra.infrastructure.continuations.CAgent"/>
          <attribute name="Class-Path"
                     value="${ant.project.name}-thrift-${version}.jar" />
        <!-- </section> -->
        </manifest>
      </jar>
    </target>

    <!--
        The javadoc-jar target makes cassandra-javadoc.jar output required for publishing to Maven central repository.
    -->
    <target name="javadoc-jar" description="Assemble Cassandra JavaDoc JAR file">
      <mkdir dir="${javadoc.jars.dir}"/>
      <create-javadoc destdir="${javadoc.jars.dir}/thrift">
        <filesets>
          <fileset dir="${interface.thrift.dir}/gen-java" defaultexcludes="yes">
            <include name="org/apache/**/*.java"/>
          </fileset>
        </filesets>
      </create-javadoc>
      <jar jarfile="${build.dir}/${ant.project.name}-thrift-${version}-javadoc.jar"
           basedir="${javadoc.jars.dir}/thrift"/>

      <create-javadoc destdir="${javadoc.jars.dir}/main">
        <filesets>
        <fileset dir="${build.src.java}" defaultexcludes="yes">
          <include name="org/apache/**/*.java"/>
        </fileset>
        <fileset dir="${build.src.gen-java}" defaultexcludes="yes">
          <include name="org/apache/**/*.java"/>
        </fileset>
        </filesets>
      </create-javadoc>
      <jar jarfile="${build.dir}/${final.name}-javadoc.jar"
           basedir="${javadoc.jars.dir}/main"/>

      <!-- javadoc task always rebuilds so might as well remove the generated docs to prevent 
           being pulled into the distribution by accident -->
      <delete quiet="true" dir="${javadoc.jars.dir}"/>
    </target>

    <!--
        The sources-jar target makes cassandra-sources.jar output required for publishing to Maven central repository.
    -->
    <target name="sources-jar" depends="init,avro-generate" description="Assemble Cassandra Sources JAR file">
      <jar jarfile="${build.dir}/${ant.project.name}-thrift-${version}-sources.jar">
        <fileset dir="${interface.thrift.dir}/gen-java" defaultexcludes="yes">
          <include name="org/apache/**/*.java"/>
        </fileset>
      </jar>
      <jar jarfile="${build.dir}/${final.name}-sources.jar">
        <fileset dir="${build.src.java}" defaultexcludes="yes">
          <include name="org/apache/**/*.java"/>
        </fileset>
        <fileset dir="${build.src.gen-java}" defaultexcludes="yes">
          <include name="org/apache/**/*.java"/>
        </fileset>
      </jar>
    </target>

    <!-- creates release tarballs -->
    <target name="artifacts" depends="jar,javadoc"
            description="Create Cassandra release artifacts">
      <mkdir dir="${dist.dir}"/>
      <copy todir="${dist.dir}/lib">
        <fileset dir="${build.lib}"/>
        <fileset dir="${build.dir}">
          <include name="${final.name}.jar" />
          <include name="${ant.project.name}-thrift-${version}.jar" />
        </fileset>
      </copy>
      <copy todir="${dist.dir}/javadoc">
        <fileset dir="${javadoc.dir}"/>
      </copy>
      <copy todir="${dist.dir}/bin">
        <fileset dir="bin"/>
      </copy>
      <copy todir="${dist.dir}/conf">
        <fileset dir="conf"/>
      </copy>
      <copy todir="${dist.dir}/interface">
        <fileset dir="interface">
          <include name="**/*.thrift" />
        </fileset>
      </copy>
      <copy todir="${dist.dir}/">
        <fileset dir="${basedir}">
          <include name="*.txt" />
        </fileset>
      </copy>

      <artifact:writepom pomRefId="dist-pom" 
            file="${build.dir}/${final.name}-dist.pom"/>
      <tar compression="gzip" longfile="gnu"
        destfile="${build.dir}/${final.name}-bin.tar.gz">

        <!-- Everything but bin/ (default mode) -->
        <tarfileset dir="${dist.dir}" prefix="${final.name}">
          <include name="**"/>
          <exclude name="bin/*" />
        </tarfileset>
        <!-- Shell includes in bin/ (default mode) -->
        <tarfileset dir="${dist.dir}" prefix="${final.name}">
          <include name="bin/*.in.sh" />
        </tarfileset>
        <!-- Executable scripts in bin/ -->
        <tarfileset dir="${dist.dir}" prefix="${final.name}" mode="755">
          <include name="bin/*"/>
          <not>
                <filename name="bin/*.in.sh" />
          </not>
        </tarfileset>
      </tar>

      <tar compression="gzip" longfile="gnu"
           destfile="${build.dir}/${final.name}-src.tar.gz">

        <tarfileset dir="${basedir}"
                    prefix="${final.name}-src">
          <include name="**"/>
          <exclude name="build/**" />
          <exclude name="src/gen-java/**" />
          <exclude name=".git/**" />
          <exclude name="bin/*" /> <!-- handled separately below -->
          <!-- exclude Eclipse files -->
          <exclude name=".project" />
          <exclude name=".classpath" />
          <exclude name=".settings/**" />
          <exclude name=".externalToolBuilders/**" />
        </tarfileset>

        <!-- Shell includes and batch files in bin/ -->
        <tarfileset dir="${basedir}" prefix="${final.name}-src">
          <include name="bin/*.in.sh" />
          <include name="bin/*.bat" />
        </tarfileset>
        <!-- Everything else (assumed to be scripts), is executable -->
        <tarfileset dir="${basedir}" prefix="${final.name}-src" mode="755">
          <include name="bin/*"/>
          <exclude name="bin/*.in.sh" />
          <exclude name="bin/*.bat" />
        </tarfileset>
      </tar>
    </target>

    <target name="release" depends="artifacts,rat-init"
            description="Create and QC release artifacts">
      <checksum forceOverwrite="yes" todir="${build.dir}" fileext=".md5"
                algorithm="MD5">
        <fileset dir="${build.dir}">
          <include name="*.tar.gz" />
        </fileset>
      </checksum>
      <checksum forceOverwrite="yes" todir="${build.dir}" fileext=".sha"
                algorithm="SHA">
        <fileset dir="${build.dir}">
          <include name="*.tar.gz" />
        </fileset>
      </checksum>

      <rat:report xmlns:rat="antlib:org.apache.rat.anttasks"
                  reportFile="${build.dir}/${final.name}-bin.rat.txt">
        <tarfileset>
          <gzipresource>
            <file file="${build.dir}/${final.name}-bin.tar.gz" />
          </gzipresource>
        </tarfileset>
      </rat:report>

      <rat:report xmlns:rat="antlib:org.apache.rat.anttasks"
                  reportFile="${build.dir}/${final.name}-src.rat.txt">
        <tarfileset>
          <gzipresource>
            <file file="${build.dir}/${final.name}-src.tar.gz" />
          </gzipresource>
        </tarfileset>
      </rat:report>
    </target>

  <target name="build-test" depends="build" description="Compile test classes">
    <javac
     debug="true"
     debuglevel="${debuglevel}"
     destdir="${test.classes}">
      <classpath>
        <path refid="cassandra.classpath"/>
      </classpath>
      <src path="${test.unit.src}"/>
      <src path="${test.long.src}"/>
    </javac>

    <!-- Non-java resources needed by the test suite -->
    <copy todir="${test.classes}">
      <fileset dir="${test.resources}"/>
    </copy>
  </target>

  <target name="build-distributed-test" depends="build-test,maven-ant-tasks-retrieve-test" description="Compile distributed test classes (which have additional deps)">
    <javac
     debug="true"
     debuglevel="${debuglevel}"
     destdir="${test.classes}">
      <classpath>
          <path refid="cassandra.classpath"/>
          <pathelement location="${test.classes}"/>
          <fileset dir="${test.lib}">
            <include name="**/*.jar" />
          </fileset>
      </classpath>
      <src path="${test.distributed.src}"/>
    </javac>
  </target>

  <macrodef name="testmacro">
    <attribute name="suitename" />
    <attribute name="inputdir" />
    <attribute name="timeout" />
    <attribute name="forkmode" default="perTest"/>
    <element name="optjvmargs" implicit="true" optional="true" />
    <attribute name="filter" default="**/${test.name}.java"/>
    <sequential>
      <echo message="running @{suitename} tests"/>
      <mkdir dir="${build.test.dir}/cassandra"/>
      <mkdir dir="${build.test.dir}/output"/>
      <junit fork="on" forkmode="@{forkmode}" failureproperty="testfailed" maxmemory="1024m" timeout="@{timeout}">
        <sysproperty key="net.sourceforge.cobertura.datafile" file="${cobertura.datafile}"/>
        <formatter type="xml" usefile="true"/>
        <formatter type="brief" usefile="false"/>
        <jvmarg value="-Dstorage-config=${test.conf}"/>
        <jvmarg value="-Daccess.properties=${test.conf}/access.properties"/>
        <jvmarg value="-Dlog4j.configuration=log4j-junit.properties" />
        <jvmarg value="-javaagent:${basedir}/lib/jamm-0.2.4.jar" />
        <jvmarg value="-ea"/>
        <optjvmargs/>
        <classpath>
          <path refid="cassandra.classpath" />
          <pathelement location="${test.classes}"/>
          <path refid="cobertura.classpath"/>
          <pathelement location="${test.conf}"/>
          <fileset dir="${test.lib}">
            <include name="**/*.jar" />
          </fileset>
        </classpath>
        <batchtest todir="${build.test.dir}/output">
          <fileset dir="@{inputdir}" includes="@{filter}" />
        </batchtest>
      </junit>
      <fail message="Some @{suitename} test(s) failed.">
        <condition>
            <and>
            <isset property="testfailed"/>
            <not>
              <isset property="ant.test.failure.ignore"/>
            </not>
          </and>
        </condition>
      </fail>
    </sequential>
  </macrodef>

  <target name="test" depends="build-test" description="Execute unit tests">
    <testmacro suitename="unit" inputdir="${test.unit.src}" timeout="60000">
      <jvmarg value="-Dlegacy-sstable-root=${test.data}/legacy-sstables"/>
      <jvmarg value="-Dcorrupt-sstable-root=${test.data}/corrupt-sstables"/>
    </testmacro>
  </target>

  <target name="test-compression" depends="build-test" description="Execute unit tests with sstable compression enabled">
    <testmacro suitename="unit" inputdir="${test.unit.src}" timeout="60000">
      <jvmarg value="-Dlegacy-sstable-root=${test.data}/legacy-sstables"/>
      <jvmarg value="-Dcorrupt-sstable-root=${test.data}/corrupt-sstables"/>
      <jvmarg value="-Dcassandra.test.compression=true"/>
    </testmacro>
  </target>
    
  <target name="msg-ser-gen-test" depends="build-test" description="Generates message serializations">
    <testmacro suitename="unit" inputdir="${test.unit.src}" 
               timeout="60000" filter="**/SerializationsTest.java">
      <jvmarg value="-Dcassandra.test-serialization-writes=True"/>
    </testmacro>
  </target>
  
  <target name="msg-ser-test" depends="build-test" description="Tests message serializations">
    <testmacro suitename="unit" inputdir="${test.unit.src}" timeout="60000"
               filter="**/SerializationsTest.java"/>
  </target>
  
  <target name="msg-ser-test-7" depends="build-test" description="Generates message serializations">
    <testmacro suitename="unit" inputdir="${test.unit.src}" 
               timeout="60000" filter="**/SerializationsTest.java">
      <jvmarg value="-Dcassandra.version=0.7"/>
    </testmacro>
  </target>


  <target name="long-test" depends="build-test" description="Execute functional tests">
    <testmacro suitename="long" inputdir="${test.long.src}"
               timeout="${test.long.timeout}" />
  </target>

  <!-- Depends on artifacts so that we can push a tarball to remote nodes, and has its own build target for cloudy deps. -->
  <target name="distributed-test" depends="build-distributed-test,artifacts" description="Execute distributed tests: see ${test.distributed.src}/README.txt">
    <testmacro suitename="distributed" inputdir="${test.distributed.src}" timeout="1200000" forkmode="once">
      <jvmarg value="-Dwhirr.config=${whirr.config}"/>
      <jvmarg value="-Dwhirr.cassandra_tarball=${build.dir}/${final.name}-bin.tar.gz"/>
    </testmacro>
  </target>

  <!-- instruments the classes to later create code coverage reports -->
  <target name="cobertura-instrument" depends="build,build-test">
    <taskdef resource="tasks.properties">
      <classpath refid="cobertura.classpath"/>
    </taskdef>

    <delete file="${cobertura.datafile}"/>

    <cobertura-instrument todir="${cobertura.classes.dir}" datafile="${cobertura.datafile}">
      <ignore regex="org.apache.log4j.*"/>

      <fileset dir="${build.classes.main}">
        <include name="**/*.class"/>
        <exclude name="**/*Test.class"/>
        <exclude name="**/*TestCase.class"/>
        <exclude name="**/test/*.class"/>
        <!-- cobertura modifies the serialVersionUID of classes. Some of our unit tests rely on backward
        wire compatability of these classes.  It was easier to exlude them from instrumentation than to
        force their serialVersinUIDs. -->
        <exclude name="**/*Token.class"/>
        <exclude name="${cobertura.excludes}"/>
      </fileset>

    </cobertura-instrument>
  </target>

  <!-- create both html and xml code coverage reports -->
  <target name="cobertura-report">
    <cobertura-report format="html" destdir="${cobertura.report.dir}" srcdir="${build.src.java}"
      datafile="${cobertura.datafile}"/>
    <cobertura-report format="xml" destdir="${cobertura.report.dir}" srcdir="${build.src.java}"
      datafile="${cobertura.datafile}"/>
  </target>

  <!--
    License audit tool
  -->
  <target name="rat-init" depends="maven-ant-tasks-init">
    <artifact:dependencies pathId="rat.classpath">
      <dependency groupId="org.apache.rat" artifactId="apache-rat-tasks" version="0.6" />
    </artifact:dependencies>
    <typedef uri="antlib:org.apache.rat.anttasks" classpathref="rat.classpath"/>
  </target>

  <target name="rat-check" depends="rat-init">
    <rat:report xmlns:rat="antlib:org.apache.rat.anttasks"
                reportFile="${build.dir}/rat-report.log">
      <fileset dir="."  excludesfile=".rat-excludes" />
    </rat:report>
    <condition property="rat.passed">
      <isfileselected file="${build.dir}/rat-report.log">
        <containsregexp expression="^0 Unknown Licenses"/>
      </isfileselected>
    </condition>
    <fail unless="rat.passed">Unknown licenses: See build/rat-report.log.</fail>
  </target>

  <target name="rat-write" depends="rat-init">
    <echo>RAT: invoking addLicense to write missing headers</echo>
    <java classname="org.apache.rat.Report" fork="true"
          output="${build.dir}/rat-report.log">
      <classpath refid="rat.classpath" />
      <arg value="-a" />
      <arg value="--force" />
      <arg value="." />
    </java>
  </target>

  <target name="javadoc" depends="init" description="Create javadoc">
    <create-javadoc destdir="${javadoc.dir}">
      <filesets>
      <fileset dir="${build.src.java}" defaultexcludes="yes">
        <include name="org/apache/**/*.java"/>
      </fileset>
      <fileset dir="${interface.thrift.gen-java}" defaultexcludes="yes">
        <include name="org/apache/**/*.java"/>
      </fileset>
      </filesets>
    </create-javadoc>
   </target>

  <!-- Generate Eclipse project description files -->
  <target name="generate-eclipse-files" depends="build">
    <echo file=".project"><![CDATA[<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
  <name>${eclipse.project.name}</name>
  <comment></comment>
  <projects>
  </projects>
    <buildSpec>
      <buildCommand>
        <name>org.eclipse.ui.externaltools.ExternalToolBuilder</name>
        <triggers>full,incremental,auto,clean,</triggers>
        <arguments>
          <dictionary>
            <key>LaunchConfigHandle</key>
            <value>&lt;project&gt;/.externalToolBuilders/Cassandra_Ant_Builder.launch</value>
          </dictionary>
        </arguments>
      </buildCommand>
    </buildSpec>
  <natures>
    <nature>org.eclipse.jdt.core.javanature</nature>
  </natures>
</projectDescription>]]>
    </echo>
	<echo file=".classpath"><![CDATA[<?xml version="1.0" encoding="UTF-8"?>
<classpath>
  <classpathentry kind="src" path="src/java"/>
  <classpathentry kind="src" path="src/gen-java"/>
  <classpathentry kind="src" path="interface/thrift/gen-java"/>
  <classpathentry kind="src" path="test/unit"/>
  <classpathentry kind="src" path="test/long"/>
  <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
  <classpathentry kind="output" path="build/classes/main"/>
  <classpathentry kind="lib" path="build/classes/thrift"/>
  <classpathentry kind="lib" path="build/test/classes"/>
  <classpathentry kind="lib" path="test/conf"/>
]]>
	</echo>	  
  	<path id="eclipse-project-libs-path">
  	 <fileset dir="lib">
  	    <include name="**/*.jar" />
     </fileset>
 	 <fileset dir="build/lib/jars">
  	    <include name="**/*.jar" />
  	 </fileset>
  	</path>
  	<property name="eclipse-project-libs" refid="eclipse-project-libs-path"/>
  	<script language="javascript"> <![CDATA[
  		importClass(java.io.File);
  		jars = project.getProperty("eclipse-project-libs").split(":");  
  		
  		cp = "";
  	    for (i=0; i< jars.length; i++) {
  	       cp += ' <classpathentry kind="lib" path="'+jars[i]+'"/>\n';
  		}
  		
  		cp += '</classpath>';
  	    
  		echo = project.createTask("echo");
  	    echo.setMessage(cp);
  		echo.setFile(new File(".classpath"));
  		echo.setAppend(true);
  	    echo.perform();	     
  	]]> </script>
    <mkdir dir=".settings" />
    <mkdir dir=".externalToolBuilders" />
    <echo file=".externalToolBuilders/Cassandra_Ant_Builder.launch"><![CDATA[<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<launchConfiguration type="org.eclipse.ant.AntBuilderLaunchConfigurationType">
<stringAttribute key="org.eclipse.ant.ui.ATTR_ANT_AFTER_CLEAN_TARGETS" value="build-test,"/>
<stringAttribute key="org.eclipse.ant.ui.ATTR_ANT_AUTO_TARGETS" value="build-test,"/>
<stringAttribute key="org.eclipse.ant.ui.ATTR_ANT_CLEAN_TARGETS" value="clean"/>
<stringAttribute key="org.eclipse.ant.ui.ATTR_ANT_MANUAL_TARGETS" value="build-test,"/>
<booleanAttribute key="org.eclipse.ant.ui.ATTR_TARGETS_UPDATED" value="true"/>
<booleanAttribute key="org.eclipse.ant.ui.DEFAULT_VM_INSTALL" value="false"/>
<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
<listEntry value="/${eclipse.project.name}/build.xml"/>
</listAttribute>
<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
<listEntry value="1"/>
</listAttribute>
<booleanAttribute key="org.eclipse.debug.ui.ATTR_LAUNCH_IN_BACKGROUND" value="false"/>
<stringAttribute key="org.eclipse.jdt.launching.CLASSPATH_PROVIDER" value="org.eclipse.ant.ui.AntClasspathProvider"/>
<booleanAttribute key="org.eclipse.jdt.launching.DEFAULT_CLASSPATH" value="true"/>
<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="${eclipse.project.name}"/>
<stringAttribute key="org.eclipse.ui.externaltools.ATTR_LOCATION" value="$${workspace_loc:/${eclipse.project.name}/build.xml}"/>
<stringAttribute key="org.eclipse.ui.externaltools.ATTR_RUN_BUILD_KINDS" value="full,incremental,auto,clean,"/>
<booleanAttribute key="org.eclipse.ui.externaltools.ATTR_TRIGGERS_CONFIGURED" value="true"/>
<stringAttribute key="org.eclipse.ui.externaltools.ATTR_WORKING_DIRECTORY" value="$${workspace_loc:/${eclipse.project.name}}"/>
</launchConfiguration>]]>
    </echo>
  </target>

  <pathconvert property="eclipse.project.name">
    <path path="${basedir}" />
    <regexpmapper from="^.*/([^/]+)$$" to="\1" handledirsep="yes" />
  </pathconvert>

  <!-- Clean Eclipse project description files -->
  <target name="clean-eclipse-files">
    <delete file=".project" />
    <delete file=".classpath" />
    <delete dir=".settings" />
  	<delete dir=".externalToolBuilders" />
  	<delete dir="build/eclipse-classes" />
  </target>

  <!-- Publish artifacts to Maven repositories -->
  <target name="mvn-install"
          depends="maven-declare-dependencies,artifacts,jar,sources-jar,javadoc-jar"
          description="Installs the artifacts in the Maven Local Repository">
          
    <!-- the parent -->
    <install pomFile="${build.dir}/${final.name}-parent.pom"
             file="${build.dir}/${final.name}-parent.pom"
             packaging="pom"/>

    <!-- the distribution -->
    <install pomFile="${build.dir}/${final.name}-dist.pom"
             file="${build.dir}/${final.name}-dist.pom"
             packaging="pom"/>
    <install pomFile="${build.dir}/${final.name}-dist.pom"
             file="${build.dir}/${final.name}-bin.tar.gz"
             packaging="tar.gz"
             classifier="bin"/>
    <install pomFile="${build.dir}/${final.name}-dist.pom"
             file="${build.dir}/${final.name}-src.tar.gz"
             packaging="tar.gz"
             classifier="src"/>
          
    <!-- the cassandra-thrift jar -->  
    <install pomFile="${build.dir}/${ant.project.name}-thrift-${version}.pom"
             file="${build.dir}/${ant.project.name}-thrift-${version}.jar"/>
    <install pomFile="${build.dir}/${ant.project.name}-thrift-${version}.pom"
             file="${build.dir}/${ant.project.name}-thrift-${version}-sources.jar"
             classifier="sources"/>
    <install pomFile="${build.dir}/${ant.project.name}-thrift-${version}.pom"
             file="${build.dir}/${ant.project.name}-thrift-${version}-javadoc.jar"
             classifier="javadoc"/>

    <!-- the cassandra-all jar -->
    <install pomFile="${build.dir}/${final.name}.pom"
             file="${build.dir}/${final.name}.jar"/>
    <install pomFile="${build.dir}/${final.name}.pom"
             file="${build.dir}/${final.name}-sources.jar"
             classifier="sources"/>
    <install pomFile="${build.dir}/${final.name}.pom"
             file="${build.dir}/${final.name}-javadoc.jar"
             classifier="javadoc"/>
  </target>

  <target name="publish"
          depends="mvn-install"
          if="release"
          description="Publishes the artifacts to the Maven repository">
          
    <!-- the parent -->
    <deploy pomFile="${build.dir}/${final.name}-parent.pom"
            file="${build.dir}/${final.name}-parent.pom"
            packaging="pom"/>

    <!-- the distribution -->
    <deploy pomFile="${build.dir}/${final.name}-dist.pom"
            file="${build.dir}/${final.name}-dist.pom"
            packaging="pom"/>
    <deploy pomFile="${build.dir}/${final.name}-dist.pom"
            file="${build.dir}/${final.name}-bin.tar.gz"
            packaging="tar.gz"
            classifier="bin"/>
    <deploy pomFile="${build.dir}/${final.name}-dist.pom"
            file="${build.dir}/${final.name}-src.tar.gz"
            packaging="tar.gz"
            classifier="src"/>
          
    <!-- the cassandra-thrift jar -->  
    <deploy pomFile="${build.dir}/${ant.project.name}-thrift-${version}.pom"
            file="${build.dir}/${ant.project.name}-thrift-${version}.jar"/>
    <deploy pomFile="${build.dir}/${ant.project.name}-thrift-${version}.pom"
            file="${build.dir}/${ant.project.name}-thrift-${version}-sources.jar"
            classifier="sources"/>
    <deploy pomFile="${build.dir}/${ant.project.name}-thrift-${version}.pom"
            file="${build.dir}/${ant.project.name}-thrift-${version}-javadoc.jar"
            classifier="javadoc"/>

    <!-- the cassandra-all jar -->
    <deploy pomFile="${build.dir}/${final.name}.pom"
            file="${build.dir}/${final.name}.jar"/>
    <deploy pomFile="${build.dir}/${final.name}.pom"
            file="${build.dir}/${final.name}-sources.jar"
            classifier="sources"/>
    <deploy pomFile="${build.dir}/${final.name}.pom"
            file="${build.dir}/${final.name}-javadoc.jar"
            classifier="javadoc"/>
  </target>

</project>