Introduction

Luntbuild is a powerful build automation and management tool. Continuous Integration or nightly builds can be easily set using a clean web interface. Executed builds are well managed using functions such as search, categorization, promotion, patching, deletion, etc. It also acts as a central build artifacts repository and download area for your whole team.

Why Luntbuild?

You may ask why Luntbuild, while there are already many good build automation tools such as Cruise Control, Anthill, and others. Our answer is:

• Luntbuild aims at not only being build automation, but also build management system. Executed builds can be categorized, promoted, searched, patched, deleted, etc. This is very important for a nightly builds or Continuous Integration builds, which generate many builds over time.
• Luntbuild utilizes the project/schedule concept to easily provide build support for parallel development.
• No configuration files, all jobs are done using web interface. You can set your Luntbuild system in less than thirty minutes.

Luntbuild makes advantage of quite a few open source libraries and frameworks listed here.

Luntbuild homepage http://luntbuild.javaforge.com/

What Luntbuild does?

Basic unit of work in Luntbuild is a build. Build execution is triggered either by a schedule or it can be started manually. A build in Luntbuild performs following steps:

1. Checks out source code from the Version Control System(s) (VCS).
2. Labels the current source code based on the current build version.
3. Runs an Ant/Maven/Command/Rake build script in the source tree.
4. Runs an Ant/Maven/Command/Rake post build script in the source tree.
5. Publishes the build log and other build artifacts.

Build configuration, monitoring, and access to the build artifacts are all done using an intuitive web interface. Development and testing teams will have a central area to access the build information.

We shall see basic installation steps in the next post.

Luntbuild : Introduction is a post from: Nimal's Weblog

This work is licensed under a Creative Commons Attribution-Share Alike 3.0 License.

public class Math {	static public int add(int a, int b) {		return a + b;	}

	static public int multiply ( int a, int b) {		return a * b;	}}

import junit.framework.*;

public class TestMath extends TestCase { 

  protected void setUp() {   	// put common setup code in here  }

  protected void tearDown() {  	// put common cleanup code in here

  }

  public void testAdd() {  	int num1 = 3;  	int num2 = 2;  	int total = 5;  	int sum = 0;  	sum = Math.add(num1, num2);  	assertEquals(sum, total);  }

  public void testMulitply() {

  	int num1 = 3;   	int num2 = 7;   	int total = 21;  	int sum = 0;  	sum = Math.multiply(num1, num2);  	assertEquals("Problem with multiply", sum, total);

  	num1 = 5;   	num2 = 4;

  	total = 20;  	sum = Math.multiply(num1, num2);  	assertEquals("Problem with multiply", sum, total);  }}

<junit printsummary="yes" haltonfailure="yes" showoutput="yes" >	<classpath>		<pathelement path="${build}"/>		<fileset dir="lib">

			<include name="**/*.jar"/>		</fileset>	</classpath> 	<batchtest fork="yes" todir="${reports}/raw/">		<formatter type="xml"/> 		<fileset dir="${src}">

			<include name="**/*Test*.java"/>		</fileset>	</batchtest></junit>

[root@nimal junit-sample]# ant testBuildfile: build.xml

init:

compile:    [javac] Compiling 2 source files to /opt/junit-sample/bin

run-tests:    [junit] Running TestMath

    [junit] Tests run: 2, Failures: 0, Errors: 0, Time elapsed: 0.321 sec

test:[junitreport] Processing /opt/junit-sample/reports/TESTS-TestSuites.xml to /tmp/null1227203872[junitreport] Loading stylesheet jar:file:/usr/local/ant/lib/ant-junit.jar!/org/apache/tools/ant

 /taskdefs/optional/junit/xsl/junit-frames.xsl[junitreport] Transform time: 1714ms[junitreport] Deleting: /tmp/null1227203872

BUILD SUCCESSFULTotal time: 6 seconds

Attachments

• ant-junit-sample.zip (109.6 kB) -Scripts for Test ,
• build.xml (2.7 kB) -Ant+JUnit build script ,

Ant: Simple JUnit Test is a post from: Nimal's Weblog

This work is licensed under a Creative Commons Attribution-Share Alike 3.0 License.

The previous posts on Ant can be found here:

1. Apache Ant
2. Ant: Installation
3. Ant: Hello World in Ant
4. Ant: Java Hello World in Ant

Java Swing Program

Create the following simple swing program and save it as HelloWorldSwing.java in a sub folder src:

import javax.swing.JFrame;import javax.swing.JLabel;

public class HelloWorldSwing {public static void main(String[] args) {JFrame frame = new JFrame("HelloWorldSwing");final JLabel label = new JLabel("Hello World");frame.getContentPane().add(label);frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frame.pack();frame.setVisible(true);   }}

Ant Script

Use a text editor to create a file called build.xml and place it in the main folder:

<?xml version="1.0" encoding="UTF-8"?><project name="Run Test" default="run" basedir=".">

<target name="clean">   <delete dir="build"/></target>

<target name="compile" depends="clean">   <mkdir dir="build/classes"/>   <javac srcdir="src" destdir="build/classes"/></target>

<target name="jar" depends="compile">   <mkdir dir="build/jar"/>   <jar destfile="build/jar/HelloWorldSwing.jar" basedir="build/classes">       <manifest>           <attribute name="Main-Class" value="HelloWorldSwing"/>       </manifest>   </jar></target>

<target name="run" depends="jar">   <java jar="build/jar/HelloWorldSwing.jar" fork="true"/></target>

</project>

Outputs and Problems

When we run this is text mode it, it compiles but fails to run. But when in GUI it runs.

[root@sanjaya-vm ant-swing]# antBuildfile: build.xml

clean:[delete] Deleting directory /opt/ant-swing/build

compile:[mkdir] Created dir: /opt/ant-swing/build/classes[javac] Warning: HelloWorldSwing.java modified in the future.[javac] Compiling 1 source file to /opt/ant-swing/build/classes

jar:[mkdir] Created dir: /opt/ant-swing/build/jar[jar] Building jar: /opt/ant-swing/build/jar/HelloWorldSwing.jar

run:......[java] at java.awt.Window.<init>(Window.java:406)[java] at java.awt.Frame.<init>(Frame.java:402)[java] at javax.swing.JFrame.<init>(JFrame.java:207)[java] at HelloWorldSwing.main(Unknown Source)[java] Java Result: 1

BUILD SUCCESSFULTotal time: 3 seconds

This is one another basic level post and I strongly advice you to refer to any more advanced document, if you are going to do this for any production system.

Feedback and questions are welcome via comment or you can email me at talkout AT SPAMFREE gmail DOT com

Ant: Java Swing Hello World in Ant is a post from: Nimal's Weblog

This work is licensed under a Creative Commons Attribution-Share Alike 3.0 License.

The previous posts on Ant can be found here:

1. Apache Ant
2. Ant: Installation
3. Ant: Hello World in Ant

Java Program

Create the following simple program and save it as HelloWorld.java in a sub folder src:

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

Ant Script

Use a text editor to create a file called build.xml and place it in the main folder:

<?xml version="1.0" encoding="UTF-8"?><project name="Run Test" default="run" basedir=".">

<target name="clean">  <delete dir="build"/></target>

<target name="compile" depends="clean">  <mkdir dir="build/classes"/>  <javac srcdir="src" destdir="build/classes"/></target>

<target name="jar" depends="compile">  <mkdir dir="build/jar"/>  <jar destfile="build/jar/HelloWorld.jar"          basedir="build/classes">      <manifest>          <attribute name="Main-Class" value="HelloWorld"/>      </manifest>  </jar></target>

<target name="run" depends="jar">  <java jar="build/jar/HelloWorld.jar" fork="true"/></target>

</project>

Output

Run ant in command line:

[root@nimal ant-hw]# antBuildfile: build.xml

clean:[delete] Deleting directory /opt/ant-hw/build

compile:[mkdir] Created dir: /opt/ant-hw/build/classes[javac] Warning: HelloWorld.java modified in the future.[javac] Compiling 1 source file to /opt/ant-hw/build/classes

jar:[mkdir] Created dir: /opt/ant-hw/build/jar[jar] Building jar: /opt/ant-hw/build/jar/HelloWorld.jar

run:[java] Hello WorldBUILD SUCCESSFULTotal time: 4 seconds

Enhance the build file

Now we have a working buildfile we could do some enhancements: many time you are referencing the same directories, main-class and jar-name are hard coded, and while invocation you have to remember the right order of build steps.

<project name="HelloWorld" basedir="." default="main">

<property name="src.dir" value="src"/><property name="build.dir" value="build"/><property name="classes.dir" value="${build.dir}/classes"/><property name="jar.dir" value="${build.dir}/jar"/><property name="main-class" value="HelloWorld"/><target name="clean">  <delete dir="${build.dir}"/></target>

<target name="compile">  <mkdir dir="${classes.dir}"/>  <javac srcdir="${src.dir}" destdir="${classes.dir}"/></target>

<target name="jar" depends="compile">  <mkdir dir="${jar.dir}"/>   <jar destfile="${jar.dir}/${ant.project.name}.jar"          basedir="${classes.dir}">      <manifest>          <attribute name="Main-Class" value="${main-class}"/>      </manifest>  </jar></target>

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

<target name="clean-build" depends="clean,jar"/>

<target name="main" depends="clean,run"/>

</project>

Feedback and questions are welcome via comment or you can email me at talkout AT SPAMFREE gmail DOT com

Ant: Java Hello World in Ant is a post from: Nimal's Weblog

This work is licensed under a Creative Commons Attribution-Share Alike 3.0 License.

In this series of Ant, I put and introductory post which is followed by a Hello World post, and then I got a couple of IMs asking how could one come to Hello World before an installation post. (Seems thats the standard way of tutorial, so I said I’m not writing any tutorials, but thought of posting this now… … ).

System Requirements for Ant

Ant has been used successfully on many platforms, including Linux, MacOS X, Windows XP and Unix. To build and use Ant, you must have a JAXP-compliant XML parser installed and available on your classpath, such as Xerces.

Note: I did this installation on a HP server running Red Hat Enterprise Linux WS Version 4 Update 4.

For the current version of Ant, you will also need a JDK installed on your system, version 1.2 or later required, 1.5 or later strongly recommended. The later the version of Java, the more Ant tasks you get.

Note: If a JDK is not present, only the JRE runtime, then many tasks will not work.

Building Ant

Obtaining Ant

To build Ant from source, you can either install the Ant source distribution or checkout the Ant module from SVN. I obtained the Ant source version and placed it at /opt/

Once you have obtained the source, change into the installation directory and run,

[root@nimal opt]# tar -xzvf apache-ant-1.7.0-src.tar.gz

This will creat Set the JAVA_HOME environment variable to the directory where the JDK is installed. See Installing Ant for examples on how to do this for your operating system.

Note: The bootstrap process of Ant requires a greedy compiler like Sun’s javac or jikes. It does not work with gcj or kjc.

Make sure you have downloaded any auxiliary jars required to build tasks you are interested in. These should be added to the lib/optional directory of the source tree. See Library Dependencies for a list of JAR requirements for various features. Note that this will make the auxiliary JAR available for the building of Ant only. For running Ant you will still need to make the JARs available as described under Installing Ant.

In our case we need the JUnit jar.

Environment Settings

Linux/Unix (bash)

Assume Ant is installed in /usr/local/ant. The following sets up the environment:

export ANT_HOME=/usr/local/ant export JAVA_HOME=/usr/java/jdk1.6.0/ export PATH=${PATH}:${ANT_HOME}/bin

The above can be set by editing the .bashrc file.

[root@nimal ~]# vi ~/.

Once this file is opened it will look like this.

# .bashrc

# User specific aliases and functions

alias rm='rm -i'alias cp='cp -i'alias mv='mv -i'

# Source global definitionsif [ -f /etc/bashrc ]; then      . /etc/bashrcfi

Append these lines below the end of the if clause below fi

export ANT_HOME=/usr/local/ant/export JAVA_HOME=/usr/java/jdk1.6.0/export PATH=${PATH}:${ANT_HOME}/bin

And the final file should look like this; save and close the file.

# .bashrc

# User specific aliases and functions

alias rm='rm -i'alias cp='cp -i'alias mv='mv -i'

# Source global definitionsif [ -f /etc/bashrc ]; then      . /etc/bashrcfi

export ANT_HOME=/usr/local/ant/export JAVA_HOME=/usr/java/jdk1.6.0/export PATH=${PATH}:${ANT_HOME}/bin

Normal build and install

Your are now ready to build Ant:

build -Ddist.dir=<directory_to_contain_Ant_distribution> dist (Windows) sh build.sh -Ddist.dir=<directory_to_contain_Ant_distribution> dist (Unix)

[root@nimal opt]# cd /opt/apache-ant-1.7.0/[root@nimal apache-ant-1.7.0]# sh build.sh -Ddist.dir=/usr/local/ant/ distBuildfile: build.xml

dist:

prepare:

check_for_optional_packages:

build:  [copy] Copying 2 files to /opt/apache-ant-1.7.0/build/classes

jars:  [jar] Building jar: /opt/apache-ant-1.7.0/build/lib/ant.jar

  .  .  .

compile-tests:

test-jar:

dist-lite: [mkdir] Created dir: /usr/local/ant [mkdir] Created dir: /usr/local/ant/bin [mkdir] Created dir: /usr/local/ant/lib [copy] Copying 8 files to /usr/local/ant/lib [copy] Copying 2 files to /usr/local/ant/lib [copy] Copying 13 files to /usr/local/ant/bin

javadoc_check:

javadocs: [mkdir] Created dir: /opt/apache-ant-1.7.0/build/javadocs [javadoc] Generating Javadoc

 . . .

[javadoc] 114 warnings

dist_javadocs:  [mkdir] Created dir: /usr/local/ant/docs/manual/api  [copy] Copying 1180 files to /usr/local/ant/docs/manual/api

internal_dist:  [mkdir] Created dir: /usr/local/ant/etc  [copy] Copying 1 file to /usr/local/ant/lib  [copy] Copying 1 file to /usr/local/ant/lib  [copy] Copying 25 files to /usr/local/ant/lib  [copy] Copying 1 file to /usr/local/ant/lib  [copy] Copying 259 files to /usr/local/ant/docs  [copy] Copying 33 files to /usr/local/ant/docs  [copy] Copying 11 files to /usr/local/ant  [copy] Copying 15 files to /usr/local/ant/etc

BUILD SUCCESSFULTotal time: 59 seconds

This will create a binary distribution of Ant in the directory you specified.

The above action does the following:

• If necessary it will bootstrap the Ant code. Bootstrapping involves the manual compilation of enough Ant code to be able to run Ant. The bootstrapped Ant is used for the remainder of the build steps.
• Invokes the bootstrapped Ant with the parameters passed to the build script. In this case, these parameters define an Ant property value and specify the “dist” target in Ant’s own build.xml file.
• Create the ant.jar and ant-launcher.jar JAR files
• Create optional JARs for which the build had the relevant libraries. If a particular library is missing from ANT_HOME/lib/optional, then the matching ant- JAR file will not be created. For example, ant-junit.jar is only built if there is a junit.jar in the optional directory.

Other ways to build and install

On most occasions you will not need to explicitly bootstrap Ant since the build scripts do that for you. If however, the build file you are using makes use of features not yet compiled into the bootstrapped Ant, you will need to manually bootstrap. Run bootstrap.bat (Windows) or bootstrap.sh (UNIX) to build a new bootstrap version of Ant. If you wish to install the build into the current ANT_HOME directory, you can use:

  build install        (Windows) sh build.sh install  (Unix)

You can avoid the lengthy Javadoc step, if desired, with:

  build install-lite        (Windows) sh build.sh install-lite  (Unix)

This will only install the bin and lib directories.

Both the install and install-lite targets will overwrite the current Ant version in ANT_HOME.

Checking the Installation

Now we have built and installed Ant, and we can check if everything works properly, as shown below.

[root@nimal ~]# which ant/usr/local/ant/bin/ant[root@nimal ~]# ant -versionApache Ant version 1.7.0 compiled on November 13 2007

Reference: http://ant.apache.org/manual/install.html

Ant: Installation is a post from: Nimal's Weblog

This work is licensed under a Creative Commons Attribution-Share Alike 3.0 License.

<?xml version="1.0"?><project name="My Project" default="hello">    <target name="hello">       <echo>Hello World!</echo>

    </target>  </project>

[root@nimal ant-tests]# antBuildfile: build.xml

hello:     [echo] Hello World!

BUILD SUCCESSFULTotal time: 1 second[root@nimal ant-tests]# 

<echo message="Hello There!"></echo><echo message="Hello There!"/>

Ant: Hello World in Ant is a post from: Nimal's Weblog

This work is licensed under a Creative Commons Attribution-Share Alike 3.0 License.

Apache Ant (or simply Ant) is an XML-based build scripting language used heavily by the Open Source community. This is specially handy when it come is to automating the build process. Also Ant is infamous for its good going with Java projects, though it is very much capable of doing various other stuff.

Apache Ant:

• An operating system and language neutral XML based “Build Tool”
• A scripting language for executing any complex file-system processes that can be run from a command line interface
• A.N.T. – Another Neat Tool
• User for Building the Project

Ant Terminology

• Ant Project – a collection of named targets that can run in any order depending on the time stamps of the files in the file system. Each build file contains one project.
• Ant Target – a fixed series of ant tasks in a specified order that can depend on other named targets. Targets can depend only on other targets, not on projects or tasks.
• Ant Task – something that ant can execute such as a compile, copy or replace. Most tasks have very convenient default values. See the Ant manual for a complete list of tasks.

Links

There is lot more to read and learn about Ant and even I don’t know much about it except to my using it for a build automation project. So it’ll be best to read from some external resources to get a better idea about it.

• Wikipedia
• Wikibooks

Happy Building with Apache Ant…!

Apache Ant is a post from: Nimal's Weblog

This work is licensed under a Creative Commons Attribution-Share Alike 3.0 License.