The post Apache Ant: A Build Tool appeared first on scmGalaxy.

A build process typically includes:

Ant uses a xml file for its configuration. This file is usually called “build.xml”. Within this build file you specify the targets for ant. A target is a step which ant will perform. You also can specific dependencies. If target A depends on target B, ant will first do B and then A. Also you specify the main target. This target is the target ant will try to execute per default. If this target depends on other targets then ant will automatically perform these task first and so on and so on.

The post Using Ant to build J2EE Applications appeared first on scmGalaxy.

Sonar with Ant
sonar.codehaus.org/a-new-hudson-plugin-f…egration-with-sonar/
old.nabble.com/Ant-Integration-td20105950.html
old.nabble.com/JUNIT—ANT-Build-File-td21797773.html
docs.codehaus.org/display/SONAR/Analyzing+Java+Projects

Regards,
Rajesh Kumar
Twitt me @ twitter.com/RajeshKumarIn

rajeshkumar replied the topic: Re: Useful links for Sonar with Ant
Sonar and Other Quality Tools

sonar.codehaus.org/what-makes-checkstyle…acker-complementary/
itspice.net/cms/tools/java-development/s…e-quality-management
ganeshrenganathan.wordpress.com/2009/07/29/sonar-hudson/

Regards,
Rajesh Kumar
Twitt me @ twitter.com/RajeshKumarIn

The post Useful links for Sonar with Ant appeared first on scmGalaxy.

Answer:

Regards,
Rajesh Kumar
Twitt me @ twitter.com/RajeshKumarIn

The post Ant cpptask with ivy appeared first on scmGalaxy.

I have one file called djir.ear and I am trying to create a folder with the same name “jir.ear” same location using ant script.
but i get error message saying that
Unable to create directory as a file alr
eady exists with that name

Can you suggest me any solution for this? as i build is failing and mkdir do not support failonerror propertry
Regards,
Rajesh Kumar
Twitt me @ twitter.com/RajeshKumarIn

The post Ant+Unable to create directory as a file already appeared first on scmGalaxy.

Hi,

I have one file called list.txt where i have mentioned all the files which need to be copied from specific directry.

can you please help me with the right copy task syntax which read the files name from list.txt and copy to destination directory???

tpatil replied the topic: Re:Help in copy files from list using ant
You can “for” loop in build to achieve this
Build.xml:-



Copying File @{val}




Build.properties:-
copy.files=${src_dir1}/build/build.xml,\
${src_dir2}/build/build.xml

rajeshkumar replied the topic: Re:Help in copy files from list using ant
I would recommend following command for same…

Regards,
Rajesh Kumar
Twitt me @ twitter.com/RajeshKumarIn

scmuser replied the topic: Re:Help in copy files from list using ant

amitanand123 replied the topic: Re:Help in copy files from list using ant

The post Help in copy files from list using ant appeared first on scmGalaxy.

2) I have another testsuit.xml file (ant build file) that works as a test suit. All the test cases in folder : bin/execute are executed in the order they appear in testsuit.xml

3) I want to write code maybe another ant test (.xml file) to make sure that all the test cases are added (executed) in the test suit.

4) Test cases in the testsuit.xml can be identified by :

Any thoughts will be extremely appreciated

Thanks

The post Ant Scripting Issue appeared first on scmGalaxy.

How can i use conditions in Ant Task execution?

Any idea?

tpatil replied the topic: Re: Condition with Task in Ant
[i]

[/i]

rajeshkumar replied the topic: Re: Condition with Task in Ant
Hi,

I guess questions was based on applying condition for Aant TASK instead of Ant Target. Following ways i mean using you can set the conditional properties value but set condition with TASK.

There is one external lib ant-contrib which can be used to put conditional Task such you can find more details in links below…..
ant-contrib.sourceforge.net/tasks/tasks/if.html
Regards,
Rajesh Kumar
Twitt me @ twitter.com/RajeshKumarIn

The post Condition with Task in Ant appeared first on scmGalaxy.

ANT is a powerful, Java based build tool developed by the Apache Foundation’s Jakarta Project. It can be used to control complex build tasks in Java and other development environments. ANT manages specific actions though “tasks” which can either be part of the core ANT distribution or available as extensions. InstallAnywhere comes with an ANT task to build installers from ANT. The InstallAnywhere ANT task is located in your InstallAnywhere application folder, inside “resource” and then inside “/build”.. Add “iaant.jar” to your classpath when executing ANT to get access to the InstallAnywhere ANT task. ANT uses an XML file to specify the order of tasks for your build process. More information on ANT can be found on the Apache Foundation’s Jakarta Project Web site.

Task Name and Class
The InstallAnywhere ANT task is specified as follows:

This task can be found inside the iaant.jar file, in your InstallAnywhere application
folder, inside “resource” and then inside “build”.

Parameters
After defining the task, specify any parameter necessary for the build settings:

Replace the IAlocation with the absolute path to your own InstallAnywhere
application folder. If InstallAnywhere cannot be found, ANT will search for it in one of
the default locations or look in the registry to find where InstallAnywhere was
installed to.
Specify the path and file name of the project to build in the IAProjectFile parameter.
All other properties are optional. The parameters closely match the properties found
in the Build Properties File described above. The following table shows the available
parameters.

ashok423 replied the topic: Re: ANT Build Integration with InstallAnywhere
Hi, The parameters table which you mentioned is missing from the post. Can you please post it again.

The post ANT Build Integration with InstallAnywhere appeared first on scmGalaxy.

1. Chef

• Manage nodes from a single server
• Cross-platform management for Linux, Windows, Mac OS, and more
• Integrates with major cloud providers
• Premium features available

• Permanent links
• RSS/email/IM integration
• After-the-fact tagging
• JUnit/TestNG test reporting
• Distributed builds

• Automatically enforce consistency of environments
• Works across physical and virtual machines
• A common tool-chain
• Support key DevOps best practices, including continuous delivery

• Supplies a number of built-in tasks for compiling, assembling, testing, and running Java applications
• Builds non-Java applications, such as C or C++ applications
• Pilot any type of process which can be described in terms of targets and tasks
• Extremely flexible and does not impose coding conventions or directory layouts to the Java projects which adopt it as a build tool

• Simple project setup follows best practices
• Easily work with multiple projects at one time
• Large repository of libraries and metadata that continue to grow
• Extensible, with the ability to write plugins in Java or scripting languages

• Collects, parses, and stores logs for later use
• Includes a web interface for searching and drilling into all of your logs
• Ship logs from any source, parse them, timestamp them correctly, index them, and search them

• Assemble multi-container apps and run on any infrastructure
• Compose an app using both proprietary containers and Docker Hub Official Repos
• Manage all containers of an app as a single group
• Cluster an app’s containers to optimize resources and provide high-availability

• Helps in the build, deployment, and maintenance of web software
• Application monitoring in one place
• Cross application and transaction tracing
• Database and availability and error monitoring

• Declarative builds and build-by-convention
• Language for dependency-based programming
• Structure your build
• Deep API
• Multi-project builds
• Ease of migration

• Working offline
• Fast to Work With
• Repositories Are Smaller
• Moving or Adding files
• Ignore Certain Files
• Branches
• Check the Status of Your Changes
• Stash Branches
• Cherry Pick Changes from Branches
• Find version that Introduced a bug using Binary Search

The post Top 10 DevOps Tools which is mostly used by DevOps Engineers | scmGalaxy appeared first on scmGalaxy.

Upcoming Training Dates | Training Agenda | Training Calender | FAQ | Why scmGalaxy Online Training

Click Here

Mode – Online based
Email – info@scmgalaxy.com

Lab Setup Details – Prerequisites
Operating Systems – Windows 7 or Linux(RHEL 7.X or Ubantu)
JDK 1.7 or Higher
SCM Tool Clients Installed (SVN, GIT, Perforce)
Servlet container like GlassFish and Tomcat (If one wants to host Jenkins outside) – Optional

[If trainee is having any specific learning agenda to be addressed in this training apart from the table of Content as below; please email me @ info@scmgalaxy.com]

Table of Content

Continuous Integration with Jenkins

• What is Software Configuration Management
• What is Build and Release Engineering
• Introduction of Version Control Management?
  • Basic usage of Subversion
  • Basic usage of git
• Introduction of Build Management?
  • How to write ant script?
  • How to write Maven script?
  • How to write MSBuild Script?
• Introduction of Release Management?
• Benefit of Continuous Integration?
• Different Continuous Integration Tools?
• Focus on Jenkins
• Installation and Setup of Jenkinks
• Configure a Job to Build the Project using SVN /GIT and ANT/Maven
• Using Build Script (Ant, Maven and MSBuild) with Jenkins
• Authentication and Authorization in Jenkins
• Lab and Assignment
• Nodes Setup in Jenkins
• Labels, Tags and Notification using Jenkins
• Empowered with Plugins in Jenkins
• 20 Popular Plugins and Their Usage
• Integrating Jenkins with Junit for automated testing
• Integrating Jenkins with HP-QC for automated testing
• Integrating Jenkins with Cobertura for test Coverage
• Integrating Jenkins with Sonar for static code analysis
• Release and Deployments using Jenkins and Nexus
• Advance Jenkins
  • Jenkins Scripting
  • Jenkins Command line
• Reporting and Dashboard using Jenkins
• Lab and Assignment

Build and Release Training In Bangalore | Build and Release Training in India | Build and Release Training in Hyderabad | Build and Release Training in Delhi | Build and Release Training in Pune | Build and Release Trainer In Bangalore | Build and Release Trainer in India | Build and Release Trainer in Hyderabad | Build and Release Trainer in Delhi | Build and Release Trainer in Pune

The post Build and Release Course Training with Jenkins / Maven /Ant/ SVN & Git appeared first on scmGalaxy.

Course SummaryThis course introduces Ant and how to use it for test-driven Java application development. A single application of increasing complexity, followed throughout the class, shows how an application evolves and how to handle the problems of building and testing. Coverage of large-projects, Ant’s advanced features, and the details and depth of the discussion-all unavailable elsewhere is included in the course. Advanced topics include how to manage large projects, Library management, Enterprise Java Continuous integration, Deployment, writing new Ant tasks and data types.

At the end of the course, students will be able to:

• Understand Ant
• Install Ant
• Understand Ant concepts and terminologies
• Work with embedded properties and external properties using properties files
• Integrate ANT into their IDE
• Use Ant in Business Applications
• Understand Ant Tasks
• Automate their build and testing through Ant tasks
• Use Ant for automated deployment
• Create Custom Ant tasks

This course is designed for Build Engineers and Developers working on projects that use Ant as an automated build tool.

Lecture (50%) / Workshop (50%)

scmGalaxy is a community initiatives based on Software configuration management that helps community members to optimize their software development process, Software Development Life Cycle optimization, Agile Methodologies and improve productivity across all aspects of Java development, including Build Scripts, Testing, Issue Tracking, Continuous Integration, Code Quality and more. scmGalaxy group that helps organisations optimize their software development process. We provide consulting, training and mentoring services in Agile Development Practices such as Version Management, Continuous Integration, Build Management, Test-Driven Development, Acceptance-Test Driven Development, Build Automation, Code Quality Practices and Automated Testing.

We provide job oriented training in the area of Configuration management, Build and Release Engineering. Candidates with engineering or software background and looking to either start or change their career to Build and Release Engineering, would benefit most from this training. Instructor-led training course offered in India, Bangalore, Delhi, Pune, Mumbai and Hydrabad. Instructor is an expert in Software configuration management, Build and release engineering with more than 15 years industry experience in india.The Goal of the course make the training attendants equip with all the concepts of build and release engineering.

Contact us at info@scmGalaxy.com

Course Objectives
To bring your team up to speed with agile development, We can also run the from Continuous Integration to Continuous Delivery with autoamted course within your premises.

Course Schedule
This course is an intensive 1-day & 2-day workshop with a mixture of teaching and lab exercises. Currently, this course is offered exclusively as an on-site course. Please contact us for more details.

Audience
This is a hands-on, practical course designed to teach specialised skills for real-world development situations. It is thus primarily aimed at a SCM Engineer, Build/Release Engineer and developer audience.

Approach
The course is modular and flexible – depending on specific student needs and requests. Through our trainings, you benefit from the wide experience and architectural expertise of our team. We bring that experience to you in an highly interactive, intensely hands-on setting.

Assumptions
We assume participants have a reasonable understanding of Development in any language as well as a basic understanding of the Software Development Life Cycle.

Lab Work
All our courses are above all practical in nature. We believe that the best way to learn is by doing. So the course contains approximately 80% lab work.

Learning Resources
Each registrant will receive a copy of the student notes and lab solutions, a certificate of completion, and a CD containing all the tools covered in the course and CD containing all the tools covered in the course.

Contact Us
This course is provided on-site, and can be tailored to your particular requirements. If you would like our trainings delivered at your premises, or for any additional information please contact us. Please email us at info@scmGalaxy.com | Call – +91 700 483 5930 | Skype – scmGalaxy

The post Apache Ant Training | Apache Ant Course | Online | Classroom | India appeared first on scmGalaxy.

Maven Vs Ant

The post Maven Vs Ant | Maven or Ant which is better ? appeared first on scmGalaxy.

How to put comment in Ant | Comments in Apache Ant

Method 1:

<!– Comments are just as important in buildfiles, do not –>
<!– avoid writing them! –>
<!– Example build file for “Ant: The Definitive Guide” –>
<!– and its sample project: irssibot –>

Method 2: Echo
Description
Writes a message to the Ant logging facilities. A message may be supplied
as nested text to this task.
Echoes a message to the current loggers and listeners which means System.out unless overridden. A level can be specified, which controls at what logging level the message is filtered at.
The task can also echo to a file, in which case the option to append rather than overwrite the file is available, and the level option is ignored

Parameters

Examples
Style 1:
<echo message=”Hello, world”/>

Style 2:
<echo message=”Embed a line break:${line.separator}”/>

Style 3:
<echo>Embed another:${line.separator}</echo>

Style 4:
<echo>This is a longer message stretching over
two lines.
</echo>

Style 5:
<echo>
This is a longer message stretching over
three lines; the first line is a blank
</echo>

Style 5:
<echo message=”Deleting drive C:” level=”debug”/>
A message which only appears in -debug mode.

Style 6:
<echo level=”error”>
Imminent failure in the antimatter containment facility.
Please withdraw to safe location at least 50km away.
</echo>
A message which appears even in -quiet mode.

Style 7:
<echo file=”runner.csh” append=”false”>#\!/bin/tcsh
java-1.3.1 -mx1024m ${project.entrypoint} $$*
</echo>
Generate a shell script by echoing to a file. Note the use of a double $ symbol to stop Ant filtering out the single $ during variable expansion
Depending on the loglevel Ant runs, messages are print out or silently ignored:

Method 3:
Description

The post How to put comment in Ant | Comments in Apache Ant appeared first on scmGalaxy.

IntelliJ/Ant integration
By Alvin J. Alexander, devdaily.com
The fact that IntelliJ is off-the-shelf ready to work with Ant is a great, great feature. It’s also simple to configure and use.
Assuming that you already know how to use Ant, and you have a build.xml file ready to go, just follow these steps to (a) configure your build script to run from within IntelliJ, and (b) run Ant:

• Assuming you’re in an IntelliJ project, select 6: Ant Build from the slide-in menu bar (“Tool Window Bar”) on the right side of your screen.
• Click the large plus sign icon to add your build.xml file to IntelliJ’s list of known build scripts for this project.
• Navigate the filesystem until you find your build script (i.e., your build.xml file for this project). Select that file.
• To run a desired Ant task, double-click the task name that you want to run. My main task is usually named deploy, so I double-click that.
• Ant should run properly for you, and deploy your application.

It’s really that simple.
The worst problem I’ve run into so far is that when I work on projects on multiple computer systems, my build scripts rely on an environment parameter named ANT_HOST_NAME existing. So, when my build script failed the first time, I said “Oh, dummy Al, you need to set your ANT_HOST_NAME environment parameter. Once I did this and restarted IntelliJ, the Ant build process worked like a champ.
Kudos, dear IntelliJ developers. Great product feature!

Best Example of <Copy>
Type 1:
<copy todir=”${Temp}/uaw/Uaw_compilescripts” overwrite=”true” failonerror=”false”>
<fileset dir=”${SVNCheckout}/scripts/compilescripts” includes=”BuildSh,Compsh,vsamc,buildc.sh,script,compl2,main.sh,makefile,makepl1,script” />
</copy>

Type 2:
<copy todir=”${Temp}/uaw/Uaw_compilescripts” overwrite=”true” failonerror=”false”>
<fileset dir=”${SVNCheckout}/scripts/compilescripts” includes=”BuildSh,Compsh,vsamc,buildc.sh,script,compl2,main.sh,makefile,makepl1,script” />
</copy>

Type 3:
<copy todir=”${Temp}/uaw/Uaw_compilescripts” overwrite=”true” failonerror=”false”>
<fileset dir=”${SVNCheckout}/scripts/compilescripts”>
<include name=”BuildSh”/>
<include name=”Compsh”/>
<include name=”vsamc”/>
</fileset>

</copy>

Type4:
<copy todir=”${Temp}/uaw/Uaw_compilescripts” overwrite=”true” failonerror=”false”>
<fileset dir=”${SVNCheckout}/scripts/compilescripts”>
<includesfile name=”${List}/Uaw_compilescripts_list.txt”/>
</fileset>
</copy>

The post How to run ant build in intellij? – IntelliJ/Ant integration Guide appeared first on scmGalaxy.

A sample Ant build script that builds a WAR file

<project name=”MyWebApplication” basedir=”..” default=”install”>

<!– project-specific variables –>
<property name=”jsp.dir.name” value=”myapp” />
<property name=”package.name” value=”${jsp.dir.name}.war” />
<property name=”webapp.dir” value=”/Users/al/tomcat-6.0.16/webapps” />

<property environment=”env” />
<property name=”build.dir” value=”build” />
<property file=”${build.dir}/build.${env.HOSTNAME}” />

<property name=”lib.dir” value=”lib” />
<property name=”pages.dir” value=”pages” />
<property name=”src.dir” value=”src” />
<property name=”src.tests.dir” value=”src-tests” />
<property name=”resources.dir” value=”resources” />
<property name=”dest.dir” value=”target” />

<!– put everything in a temp folder with the right structure during the build –>
<property name=”temp.dir” value=”temp” />
<property name=”temp.dir.web-inf” value=”${temp.dir}/WEB-INF” />
<property name=”temp.dir.lib” value=”${temp.dir.web-inf}/lib” />
<property name=”temp.dir.classes” value=”${temp.dir.web-inf}/classes” />
<property name=”temp.dir.meta-inf” value=”${temp.dir}/META-INF” />

<property name=”package.file” value=”${dest.dir}/${package.name}” />

<path id=”build.class.path”>
<fileset dir=”lib”>
<include name=”**/*.jar” />
</fileset>
</path>

<target name=”clean”>
<delete>
<fileset dir=”${dest.dir}” includes=”**/*”/>
</delete>
<delete dir=”${temp.dir}” />
<delete dir=”${temp.dir.classes}” />
<delete dir=”${temp.dir.meta-inf}” />
<delete dir=”${temp.dir.web-inf}” />
</target>

<target name=”prepare” depends=”clean”>
<mkdir dir=”${dest.dir}” />
<mkdir dir=”${temp.dir}” />
<mkdir dir=”${temp.dir.lib}” />
<mkdir dir=”${temp.dir.meta-inf}” />
<mkdir dir=”${temp.dir.web-inf}” />
<mkdir dir=”${temp.dir.classes}” />
</target>

<!– COMPILE –>
<target name=”compile” depends=”prepare”>
<echo>=== COMPILE ===</echo>
<echo>Compiling ${src.dir} files …</echo>
<javac debug=”on” srcdir=”${src.dir}” destdir=”${temp.dir.classes}” includes=”**/*”>
<classpath refid=”build.class.path” />
</javac>

<!– compile files on the src-tests path –>
<echo>Compiling ${src.tests.dir} files …</echo>
<javac debug=”on” srcdir=”${src.tests.dir}” destdir=”${temp.dir.classes}” includes=”com/**”>
<classpath refid=”build.class.path” />
</javac>
</target>

<!– PACKAGE –>
<target name=”package” depends=”compile”>
<echo>=== PACKAGE ===</echo>

<!– copy the config files –>
<copy file=”${resources.dir}/MANIFEST.MF” tofile=”${temp.dir.meta-inf}/MANIFEST.MF” overwrite=”true” />
<copy file=”${resources.dir}/web.xml” tofile=”${temp.dir.web-inf}/web.xml” overwrite=”true” />
<copy file=”${resources.dir}/managed-beans.xml” tofile=”${temp.dir.web-inf}/managed-beans.xml” overwrite=”true” />
<copy file=”${resources.dir}/navigation-rules.xml” tofile=”${temp.dir.web-inf}/navigation-rules.xml” overwrite=”true” />

<copy todir=”${temp.dir.classes}”>
<fileset dir=”${src.dir}”>
<include name=”**/*.xml”/>
<include name=”**/*.xsl”/>
</fileset>
</copy>

<!– with all resources in place, create the war file –>
<war destfile=”${package.file}” webxml=”${temp.dir.web-inf}/web.xml” basedir=”${temp.dir}”>
<fileset dir=”${pages.dir}”/>
<lib dir=”${lib.dir}” />
<classes dir=”${temp.dir.classes}” />
</war>
</target>

<!– JUST DEPLOY JSP’s –>
<target name=”jsps”>
<echo>=== DEPLOY JSP’S ===</echo>
<!– i’m trying to be explicit about what i put out there –>
<copy todir=”${webapp.dir}/${jsp.dir.name}”>
<fileset dir=”${pages.dir}”>
<include name=”**/*.jsp”/>
<include name=”**/*.html”/>
<include name=”**/*.css”/>
<include name=”**/*.gif”/>
<include name=”**/*.jpg”/>
<include name=”**/*.png”/>
<include name=”**/*.js”/>
</fileset>
</copy>
</target>

<!– INSTALL –>
<target name=”install” depends=”package”>
<echo>=== INSTALL ===</echo>
<copy file=”${package.file}” tofile=”${webapp.dir}/${package.name}” overwrite=”true” />
</target>

</project>

The post A sample Ant build script that builds a WAR file – Guide appeared first on scmGalaxy.

Samples of the Ant copy task

<copy file=”${resources.dir}/MANIFEST.MF” tofile=”${temp.dir.meta-inf}/MANIFEST.MF” overwrite=”true” />
<copy file=”${resources.dir}/managed-beans.xml” tofile=”${temp.dir.web-inf}/managed-beans.xml” overwrite=”true” />
<copy file=”${resources.dir}/navigation-rules.xml” tofile=”${temp.dir.web-inf}/navigation-rules.xml” overwrite=”true” />
<copy file=”${resources.dir}/monitoring-managed-beans.xml” tofile=”${temp.dir.web-inf}/monitoring-managed-beans.xml” overwrite=”true” />
<copy file=”${resources.dir}/monitoring-navigation-rules.xml” tofile=”${temp.dir.web-inf}/monitoring-navigation-rules.xml” overwrite=”true” />
<copy file=”${resources.dir}/faces-config.xml” tofile=”${temp.dir.web-inf}/faces-config.xml” overwrite=”true” />
<copy file=”${resources.dir}/log4j.properties” tofile=”${temp.dir.classes}/log4j.properties” overwrite=”true” />
<copy file=”${resources.dir}/commons-logging.properties” tofile=”${temp.dir.classes}/commons-logging.properties” overwrite=”true” />

<copy todir=”${temp.dir.classes}”>
<fileset dir=”${src.dir}”>
<include name=”**/*.xml”/>
<include name=”**/*.xsl”/>
<include name=”**/*.properties”/>
</fileset>
</copy>

<copy todir=”${dist}”>
<fileset dir=”${src}”
includes=”**/images/*”
excludes=”**/*.gif”
/>
</copy>

This copies all files in directories called images that are located in the directory tree defined by ${src} to the destination directory defined by ${dist}, but excludes all *.gif files from the copy.

<copy todir=”${dist}”>
<fileset dir=”${src}”>
<include name=”**/images/*”/>
<exclude name=”**/*.gif”/>
</fileset>
</copy>

The same as the example above, but expressed using nested elements.

<delete dir=”${dist}”>
<include name=”**/images/*”/>
<exclude name=”**/*.gif”/>
</delete>

Deleting the original set of files, the delete task can act as an implicit fileset.

Flatten directories when performing an Ant copy
Here’s a code snippet from an Ant build script where I begin with a hierarchical structure of jar files in my development environment, then flatten out all my lib subdirectories into one directory in my production environment when I copy all the jar files to my production library directory:

<!– build a temporary lib dir, and flatten out the jars into one folder –>

<copy todir=”${temp.dir.lib}” flatten=”true”>
<fileset dir=”${lib.dir}”>
<exclude name=”${cob.lib.dir}” />
<exclude name=”junit*” />
<include name=”**/*.jar”/>
<include name=”**/*.zip”/>
</fileset>
</copy>

The post Samples/Examples of the Ant copy task – Guide appeared first on scmGalaxy.

Nurflugel AntScript Visualizer

Link:
http://www.nurflugel.com/webstart/AntScriptVisualizer

About:
Ant Script Visualizer is a program I’ve written to make visualizing how your Ant targets and scripts are related to one another.

Ever take a look at an Ant build script and, although perfectly readable, not really “see” all the dependencies between targets?

What targets depend on a certain taskdef? Or a macrodef? Do macrodefs rely on other macrodefs? And all those imported Ant scripts – where do they fit in? This program was designed to show that, by importing your Ant scripts and creating graphic file representations of them. Say what?

OK, here’s an example of the output for the build file used for this program:

Features
# Parses build files for the following task usages:

* target
* ant
* antcall
* depends
* property
* import
* taskdef
* macrodef

# Groups results by build file subgraphs (default), or optionally, all items together in one graph
# Ability to filter/show included obects by target, imported files, ant calls, taskdefs, and macrodefs
# Output formats: PNG (default for PC), PDF (default for OS X, not available otherwise), SVG.

Grand

Links:
http://www.ggtools.net/grand/
About:
Grand is a tool to create visual representation of ant target dependencies. It differs from tools like Vizant or AntGraph  by a totally different approach, relying on the Ant API rather than parsing directly the XML files. This enables Grand to provide some nifty features such as the support of the ant 1.6.x tasks like import or subant.

Vizant

Links:
http://vizant.sourceforge.net/

About:
Vizant is an Apache Ant task to create Graphviz DOT source code from an Ant buildfile. The image created from the DOT source code shows the targets dependency.

The post Flow Diagram and GUI tools for Apache Ant appeared first on scmGalaxy.

SVNAnt
SVNAnt is an Ant task allowing you to interact with Subversion within the convenience of your Ant build script. No more writing custom scripts to get the revision of your repository to tag your release jars. Nor do you have to make command line calls to checkout your latest and greatest as part of your continuous integration process. With SVNAnt, you have the familiarity of the Ant syntax and the flexibility you need for interacting with Subversion.
Features
SVNAnt is a full-featured Subversion client capable of using the native Java bindings or command-line wrappering depending on which is available. Beyond how it works, SVNAnt allows you to do all svn subcommands but the following:

If the svn subcommand is not listed here, you can use it in your Ant build file. Before we continue start using SVNAnt, we have to install it and configure Ant to use it.
Installation
Now that we know what SVNAnt is and what its features are, lets install SVNAnt so that you can begin to use SVNAnt to access Subversion within your Ant build cycle.

Step 1. (Download, Compile and Extract)
This step will download, compile, and “install” the latest version of SVNAnt.
1.1 Using Subversion, checkout the SVNAnt project located here: http://subclipse.tigris.org/svn/subclipse/trunk/svnant
1.2 From the command line, while inside of the location where you checked out SVNAnt to, run “ant makeDistrib”
1.3 Extract the .zip file created in the build directory of your SVNAnt source to a location of your choosing

Step 2. (Modify your build.xml)
The next step is to tell Ant how to find your SVNAnt task by adding the following to your build.xml file:
<path id= “svnant.classpath” >
<fileset dir= “/PATH/TO/YOUR/EXTRACTED/SVNANT-ZIP” >
<include name= “*.jar” />
</fileset>
</path>

<typedef resource=”org/tigris/subversion/svnant/svnantlib.xml” classpathref=”svnant.classpath” />
That should be it. I know that it appears to be too good to be true so lets verify this.

Step 3. (Verify installation)
Building upon Step 2, lets create a new ant task that will use the wcVersion feature of SVNAnt to get some information about your repository from a local working copy:
<target name=”testSVNAnt”>
<svn>
<wcVersion path= “PATH/TO/YOUR/WORKINGCOPY” />
</svn>

<echo message= “Subversion repository url: ${repository.url}” />
</target>
(Note: In the event that you need to pass credentials to Subversion, look here.)
The output should be something similar to this:
$ ant testSVNAnt

Buildfile: build.xml

testSVNAnt:
[svn] <WcVersion> started …
[svn]  finished.
[echo] Subversion repository url: http://svn.apache.org/repos/asf/incubator/openejb/trunk

BUILD SUCCESSFUL
Total time: 43 seconds

Pat yourself on the back. You have successfully installed SVNAnt and you are ready to implement Subversion into your Ant build cycle. Instead of us going through each available feature for SVNAnt, please view the SVNAnt Documentation. Now lets talk about why you may want to use SVNAnt to allow for Subversion interaction inside of your Ant build cycle.

The post How to Integrate Subversion Into Your Ant Build ? – Step by step guide appeared first on scmGalaxy.

The post Apache Ant – A Complete TASK Reference appeared first on scmGalaxy.