<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html lang="en-us" xml:lang="en-us">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />


<!-- /*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/ -->
<link rel="stylesheet" type="text/css" href="../../org.eclipse.wtp.doc.user/common.css" />

<title>Extended Ant Support - overview</title>
</head>
<body id="tanthome"><a name="tanthome"><!-- --></a>
<h1 class="topictitle1">Extended Ant Support - overview</h1>
<div><p>You can use the Run ANT option to check your build environment
or use the command line batch file provided for repetitive builds.</p>
<div class="section"><p>In the root of the com.ibm.etools.j2ee.ant plugin is a sample
batch file called runANT.bat. This batch file runs a "headless" workspace,
and it runs a specified ANT script file (example.xml). The ANT script file
must be a fully qualified name.</p>
<p>Edit the runANT.bat file and change
the variables to the correct location for your WebSphere<sup>®</sup> Studio installation. This
file needs to be updated to run this plugin from the command line.</p>
<p>If
you do not specify a build file, runANT will prompt you when you execute the
file. You can then select ANT, list all projects, and quit. When you specify
the build file, it is relative to the project so you must enter project name\buildfile
name. Note that this is case sensitive.</p>
<p>After you list the projects
available, select the ANT option and type in your build filename. You then
need to quit manually when the script is finished or specify another project.
The projects must all be relative to the same workspace.</p>
<p>Also included
is an example.xml file which shows how to use some of the tasks provided through
ANT. Please refer to <samp class="codeph">example.xml</samp> and <samp class="codeph">runANT.bat</samp> for
more information. Note that the tasks themselves are case sensitive but the
parameters available on each task are not.</p>
<p><span class="uicontrol">Hints and Tips</span></p>
<ul><li>When creating an ANT Script, logical order is important. For example,
if you are exporting an Enterprise Application that contains enterprise beans,
you should generate deployment code for your EJB before exporting. Your XML
should look like this: <pre>&lt;!-- Run ejbDeploy on the EJB project in an EAR file --&gt;
&lt;ejbDeploy EJBProject="MinibankEJB" IgnoreErrors="true"/&gt;

&lt;!-- Export the Application project as an EAR file --&gt;
&lt;earExport EARProjectName="MinibankExample" EARExportFile="f:\temp\sample.ear"
ExportSource="true"/&gt;</pre>
</li>
<li>If you are using the <samp class="codeph">runAnt.bat</samp> file to do multiple builds,
make sure that change the name of the output in your XML file. If your current
build is incomplete or fails in any way, you still have the previous build
to work from.</li>
</ul>
</div>
</div>
<div>
<div class="familylinks">
<div class="parentlink"><strong>Parent topic:</strong> <a href="../topics/tjant.html">Working with Ant</a></div>
</div>
</div></body>
</html>