Ant
===

Présentation
------------

Ant est un projet open source de la fondation Apache écrit en Java qui 
vise le développement d'un logiciel d'automatisation des opérations 
répétitives tout au long du cycle de développement logiciel. 

Ant pourrait être comparé au célèbre outil make sous Unix. Il a été
développé pour fournir un outil de construction indépendant de toute 
plate-forme. Ceci est particulièrement utile pour des projets développés
sur et pour plusieurs systèmes ou pour migrer des projets d'un système 
vers un autre. Il est aussi très efficace pour de petits développements.

Ant repose sur un fichier de configuration XML qui décrit les différentes
tâches qui devront être exécutées par l'outil. Ant fournit un certain 
nombre de tâches courantes qui sont codées sous forme de classes Java. 
Ces tâches sont donc indépendantes du système sur lequel elles seront 
exécutées. De plus, il est possible d'ajouter ces propres tâches en 
écrivant de nouvelles classes Java respectant certaines spécifications. 

Installation
------------

.. code-block:: bash

    wget http://apache.mirrors.ovh.net/ftp.apache.org/dist//ant/binaries/apache-ant-1.9.4-bin.zip
    unzip apache-ant-1.9.4-bin.zip
    mv apache-ant-1.9.4 /opt
    ln -s /opt/apache-ant-1.9.4 /opt/ant

Il est possible d'ajouter dans son .bashrc

.. code-block:: bash

      alias ant="/opt/apache-ant-1.9.4/bin/ant"

et pour windows dans son alias.bat par exemple

.. code-block:: bash

      @doskey ant=C:\java\apache-ant-1.9.4\bin\ant $*

Utilisation
-----------

Toutes l'utilisation de ant est réglé par la création d'un fichier xml
contenant les tâches à réaliser.

Les tâches classiques qu'on peut réaliser:

- gestion de fichier (création, suppression, déplacement)
- gestion de répertoire (création, suppression, déplacement)
- compilation de code
- transfert
- message      

hello world!
************

notre fichier xml **build.xml**

.. code-block:: xml

    <project default="task_hello">
      <target name="task_hello">
          <echo message="hello world!"/>
      </target>
    </project>

Il suffit maintenant de lancer ant

.. code-block:: bash

    ant

et nous avons pour résultat

.. code-block:: bash

    Unable to locate tools.jar. Expected to find it in C:\Program Files\Java\jre1.8.0_31\lib\tools.jar
    Buildfile: C:\Users\faoustin\Downloads\build.xml

    task_hello:
         [echo] hello world!

    BUILD SUCCESSFUL
    Total time: 0 seconds    


Basique
*******

Il est possible de passer des arguments lors de l'appel

.. code-block:: xml

    <project default="task_hello">
       <target name="task_hello">
          <echo message="hello world!"/>
      </target>
      <target name="task_msg">
          <echo message="mon message: ${msg}"/>
      </target>
    </project>

appel de ant

.. code-block:: bash

    ant -Dmsg=coucou task_msg

.. note::

    il est possible de passer le target à lancer dans ant

et le resultat

.. code-block:: bash

    Unable to locate tools.jar. Expected to find it in C:\Program Files\Java\jre1.8.0_31\lib\tools.jar
    Buildfile: C:\Users\faoustin\Downloads\build.xml

    task_msg:
         [echo] mon message: coucou

         BUILD SUCCESSFUL
         Total time: 0 seconds


Il est possible de rajouter une balise input pour demander à l'utilisateur
le message qu'il souhaite voir

.. code-block:: xml

    <project default="task_hello">
        <target name="task_hello">
            <echo message="hello world!"/>
        </target>
        <target name="task_msg">
              <input message="tapez votre message:" 
                    addproperty="msg" 
                    defaultvalue="coucou"/>
              <echo message="mon message: ${msg}"/>
        </target>
    </project>

et voilà son utilisation

.. code-block:: bash

    Unable to locate tools.jar. Expected to find it in C:\Program Files\Java\jre1.8.0_31\lib\tools.jar
    Buildfile: C:\Users\faoustin\Downloads\build.xml

    task_msg:
        [input] tapez votre message: [coucou]
        tutu et toto sont sur un bateau
             [echo] mon message: tutu et toto sont sur un bateau

             BUILD SUCCESSFUL
             Total time: 7 seconds

Il est possible dans echo de rajouter une information de niveau de log avec 
l'attribut level qui peut avoir comme valeur:

* error
* warning
* info
* verbose
* debug

Les paramètres de la commande ant indiquant le niveau de log souhaité

- -debug
- -verbose
- -quiet

Ssh
***

exemple de build.xml permettant de lancer des commandes sur un serveur distant

.. code-block:: xml

    <project default="test">
        <target name="test">
            <sshexec host="192.168.136.128"
                username="your-user"
                password="your-password"
                command="/etc/init.d/exim4 restart"
                trust="true"/>
        </target>
    </project>

.. note::

    sshexec nécessite la librairie **jsch** qu 'il faut télécharger sur le net

    .. code-block:: bash

        wget http://sourceforge.net/projects/jsch/files/jsch.jar/0.1.51/jsch-0.1.51.jar/download
        mv download /opt/ant/lib

.. warning::

    l'utilisation de l'attribut **trust** permet de se connecter sur le serveur
    sans vérifier que le serveur est inscrit dans $home/.ssh/know_hosts cela
    est une faille de sécurité
    

Sql
***

Il est possible de lancer une commande sql ou un fichier sql via une tâche ant

.. code-block:: xml

    <project default="test">
        <target name="test">
               <sql driver="org.postgresql.Driver"
                    url="jdbc:postgresql://localhost/test"
                    userid="postgres"
                    password="postgres"
                    autocommit="true">
               INSERT INTO TABLETEST(ID,LIB) VALUES (1,'tutu');     
               </sql>
        </target>
    </project>

.. note::

    on peut utiliser l'attribut src, la balise transaction pour utiliser un ou
    plusieurs fichiers sql

.. warning::

    il faut trouver dans le classpath ou dans le dossier lib de ant la librairie
    jar du driver jdbc


Git
***

Il n'existe pas de fonction git native dans ant, mais on peut les définir

.. code-block:: xml

    <macrodef name = "git">
        <attribute name = "command" />
        <attribute name = "dir" default = "" />
        <element name = "args" optional = "true" />
        <sequential>
            <echo message = "git @{command}" />
            <exec executable = "git" dir = "@{dir}">
                <arg value = "@{command}" />
                <args/>
            </exec>
        </sequential>
    </macrodef>

    <macrodef name = "git-clone-pull">
        <attribute name = "repository" />
        <attribute name = "dest" />
        <sequential>
            <git command = "clone">
                <args>
                    <arg value = "@{repository}" />
                    <arg value = "@{dest}" />
                </args>
            </git>
            <git command = "pull" dir = "@{dest}" />
        </sequential>
    </macrodef>

l'utilisation est alors simple, pour un clone

.. code-block:: xml

    <git command = "clone">
        <args>
            <arg value = "git://github.com/280north/ojunit.git" />
            <arg value = "ojunit" />
        </args>
    </git>

pour un pull

.. code-block:: xml

    <git command = "pull" dir = "repository_path" />


Un projet Java
**************

On souhait avoir un fichier build.xml qui puisse

- compiler du code java
- générer un jar
- lancer le jar

notre projet est constitué ainsi

::

    projet
     |__ bin
     |__ src
          |__ org
              |__ sdf
                    |__ HelloWorld.java
                    
Le fichier HelloWorld.java est ainsi

.. code-block:: java


    package org.sdf;

    public class HelloWorld {
    public static void main(String[] args) {
    System.out.println("Hello World");
    }
    }
                    

le build.xml

.. code-block:: xml

    <project default="run">

    <property name="src.dir"     value="src"/>
    <property name="bin.dir"   value="bin"/>
    <property name="jar.dir" value="exe"/>
    <property name="main-class"  value="org.sdf.HelloWorld"/>

    <target name="clean">
    <delete dir="${bin.dir}"/>
    <delete dir="${jar.dir}"/>
    <echo message="nettoyage termine"/>
    </target>

    <target name="compile" depends="clean">
    <mkdir dir="${bin.dir}"/>
    <javac srcdir="${src.dir}" destdir="${bin.dir}"/>
    <echo message="compilation terminee"/>
    </target>

    <target name="jar" depends="compile">
    <mkdir dir="${jar.dir}"/>
      <jar destfile="${jar.dir}/sdf.jar" basedir="${bin.dir}">
        <manifest>
          <attribute name="Main-Class" value="${main-class}"/>
        </manifest>
      </jar>
    <echo message="Creation du fichier Jar terminee"/>
    </target>

    <target name="run" depends="jar">
    <java jar="${jar.dir}/sdf.jar" fork="true"/>
    </target>

    </project>



http://skebir.developpez.com/tutoriels/java/ant/
ant et git http://tlrobinson.net/blog/2008/11/ant-tasks-for-git/