If you’re like me and have to deal with Eclipse’s PDE Build system on a regular basis, you’ll eventually find your build crashing without a lot of pertinent information. I’m writing this article to help those of you who are banging your heads against the wall trying to figure out why any of the tasks are failing. For the purposes of this article, I’m using Eclipse 3.2.2 SDK under Windows XP.

First of all, you’ll need to make sure you have the Eclipse SDK installed (with all the nice source plugins).. stepping through PDE code is gonna be hard without that. Next, you’ll need to make sure that your ant script is somewhere in the workspace under a Java project. I’ve created a simple java project called fetch-project with a simple ant script build.xml shown below:


<project default="main">
<property file="build.properties"/>
<target name="main">
<eclipse.fetch
elements="${type}@${id}"
buildDirectory="${buildDirectory}"
directory="${buildDirectory}/directory.txt"
fetchTag="${fetchTag}"
configInfo="${configs}"
baseLocation="${baseLocation}"
/>
</target>
</project>


and build.properties:

type=feature
id=org.jboss.ide.eclipse.feature
buildDirectory=C:/Build/rhds-build/eclipse
directory=${buildDirectory}/directory.txt
fetchTag=HEAD
configs=*,*,*
baseLocation=C:/Build/rhds-build/clean-eclipse


Now that we have a basic ant script that we can quickly edit and execute, let’s start setting up our project’s classpath so we can debug. First, you’ll need to add pdebuild.jar and pdebuild-ant.jar to your project’s build path. This can be done by following these steps:

1. Right clicking on the project -> Build Path -> Configure Build Path
2. Click on the “Libraries” tab
3. Click “Add Variable”
4. Click on the “ECLIPSE_HOME” variable, and then click the “Extend…” button
5. Navigate down the tree, select plugins/org.eclipse.pde.build_x.x.x/pdebuild.jar (where x.x.x is your specific version), and press OK
6. Repeat steps 3 and 4
7. Navigate down the tree, select plugins/org.eclipse.pde.build_x.x.x/lib/pdebuild-ant.jar (where x.x.x is your specific version), and press OK
8. Press OK to make the Properties window go away, and you should have a project structure that looks similar to this:

Next, we will need to point JDT to the source code for the two JARs we just added. This will allow us to set breakpoints, and step through the PDE Build internal code. Follow these steps:

1. Right click on “pdebuild.jar” under your project, and click on “Properties”
2. “Java Source Attachment” should already be selected. On the right side of the window we need to select the source attachment. Press the “Variable…” button.
3. Choose “ECLIPSE_HOME” and press “OK”
4. Now we need to extend the ECLIPSE_HOME variable and add the path to the source zip. Press the “Extension…” button.
5. Navigate down the tree, select plugins/org.eclipse.pde.source_x.x.x/src/org.eclipse.pde.build_x.x.x/pdebuildsrc.zip (where x.x.x is your specific version), and press OK.
6. Press OK to make the Properties window go away.
7. Right click on “pdebuild-ant.jar” under your project, and click on “Properties”
8. Repeat steps 2-4
9. Navigate down the tree, select plugins/org.eclipse.pde.source_x.x.x/src/org.eclipse.pde.build_x.x.x/lib/pdebuild-antsrc.zip (where x.x.x is your specific version), and press OK.
10. Press OK to make the Properties window go away.
11. Expand pdebuild-ant.jar, and under it expand org.eclipse.pde.internal.build.tasks. You should see a class named “FetchTask” there. Double click it to open it in the classfile editor.
12. If you see something like this, you are on your way

A note on debugging ant scripts in Eclipse. While Eclipse does have ant debugging support (right click on ant script > Debug As > Ant Build), it doesn’t support stepping through the actual implementation of the Java code of ant tasks. Luckily for us, there is a way around that using the antRunner Eclipse application.. so let’s set that up.

1. Click on the “Run” top level menu in Eclipse, then click on “Debug…”
2. Double-click on “Eclipse Application”.
3. In the “Name:” textbox, enter a name that you can remember. I called it “fetch-debug”
4. Looking a little further down you will see a “Program to Run” group, and under it two radio buttons. Choose the “Run an application” radio button.
5. From the application dropdown, select org.eclipse.ant.core.antRunner.
6. Click on the “Arguments” tab
7. In the “Program Arguments” text box, type in the name of your build script. In my example this was simply “build.xml”.
8. Further down in the “Working Directory” group, click the “Other” radio button, and press the “Workspace…” button to select a directory in the workspace.
9. In the window that pops up, select the project that you’ve created, and press OK. In my case this was “fetch-project”. The text box should say something like “${workspace_loc:fetch-project}”.
10. Press “Apply”, and then press “Close”.

At this point, the only thing left to do is to actually set a breakpoint, and debug our new Eclipse Application to inspect the code as it’s happening. I put a breakpoint on FetchTask.execute():

Next just “Debug” the new Eclipse Application you created by going back to the “Run” > “Debug” menu, and you should be hitting the breakpoint in no time! Note that if you are developing in an environment without plugin projects, when the breakpoint is reached, you may get a new editor that says “Source not found”. If you get this, click the “Edit Source Lookup Path…”, “Add…”, “Java Classpath Variable”,and repeat the steps above to point the configuration to the 2 source JARs under the ECLIPSE_HOME variable.