I know this is Hungary, but I very much fear this is also the case for most countries and most companies.

Take one of my last tasks as an example, I cannot be allocated for another project, but I was “borrowed” for a couple of days to set up a project environment for a very urgent and important job. The project was then handed over to two less then qualified developers. It was fun to set the project up, as the technologies I’ve chosen integrated nicely and resulted in an easy to maintain, compact environment. However I was forced to skip adding unit testing, as there was no way the project would fit writing a single test case.

Anyway I was going to write about the project itself and not mourn about the problems I can’t help.

The project is planned on simple grounds, there is a need for a GUI client, as a quite sophisticated editor is required. There is a need for small simple clients, so the the users would be able to use it with a relatively small configuration. The software delivery should be simple, so it would not burden the helpdesk. There is a need for security, as the application has some financial perspective to it. The project must be simple, so the not to advanced developers would be able to finish it. Ah yes, and I have two days to bang it together.

Well… Let’s start… The main constraint is the developers, they know some Hibernate, they know some Java, but know nothing about WSDL. Then the technology, to be easily deliverable it’s best to use Webstart, this will zero the deploy costs choosing Swing as the windowing environment enables the developers to use visual editors to bang some forms together, while reduces the deployment size greatly, if we consider the SWT alternative. The application will communicate with the server through web service through SSL to ensure security.

I have thus set up a project which contains both the client and the server code and the common codebase as well (the interfaces and POJOs used in web services), there is an ANT script to generate the WSDL, the code for Axis based web service classes, and the Hibernate POJO, and DAO-s. The generated code is stored in it’s respective folders, separated from the handwritten code. The ANT script is then compiles the files and it is also able to create the WAR and deploy on either Tomcat or WebSphere Application Server. The project is set up in an Anthill to ensure that at least the developers are notified if their committed code breaks the application.

Even though I’ve created this environment as simple as humanly possible, when I handled it over to the developers-to-be they were less than understandig.

I can only hope they don’t mess it up too bad.

Hard to identify InvocationTarget exceptions
Our build environment was a Tomcat 6.0.x running on Sun JDK 1.6 on Debian Linux on x86, while the test and production environments are Websphere Application Servers 6.0.12 running the default IBM JDK 1.4.2 on AIX on Power5. Upon deploying to the test server we used the images created on the build environment using the Anthill’s build as version functions. Since the target source and target levels are Java 1.4, these options were specified in the javac ant task, so the code produced can run on the target environments.
This setup worked perfectly for months on our projects, but after a while strange exceptions started popping up on the test server. Compiling and deploying the application using the same options as the ones set in Anthill on our local Websphere servers got rid of the problems, while the one deployed on the AIX running the WAS we got the exceptions. Since there didn’t seem to be any difference between the builds we didn’t suspect Anthill for quite a time, and thought it was some strange JDK problem on AIX.
The simple code:
new BigDecimal(1);
worked perfectly on our Tomcat, on our local WAS but threw an exception on the test server’s WAS. Changing the code to
new BigDecimal("1");
worked perfectly on all environments.
A collegue worked out the reason after a few days of searching. He noticed, that these issues occur, when we use methods, that have been extended in Java 1.5. For example the code above would map to BigDecimal(int i) while it will map to BigDecimal(double d). We realized, that however the generated code will be created to be ran under Java 1.4, it will be compiled for the actual runtime of the ant ran from the Anthill. Since the JRE in WAS doesn’t contain the signatures for the given method, this will throw the InvocationTargetException, which looks strange at that point of the code.
After identifying the problem, solving it was quite easy after checking out the official documentation, changing the javac block to look something like:

destdir="${build}"
fork="yes"
executable="${java.home}/../bin/javac"
/>
and passing the option -Djava.home=/my/jdk/home/dir will enable to build the project both under Anthill and Eclipse.

Publishing under WAS
Our current project is to be deployed on WebSphere, and we wanted to use Anthill to deploy automatically on WAS. This is a real pain in the backside, since if you take FOSS servlet containers and application servers (Tomcat, Jetty, Jboss, Geronimo), they are pretty friendly when it comes to deploying an application on. You just copy the WAR/EAR in a directory and it is deployed automatically. On WAS hovewer this is not half as simple.
WAS has a very specific way of accessing the administration interface ws_ant. It first seems like a very simple shell script running ant scripts, but try as you might you’ll never be able to invoke it from inside your normal ant. Rumor has it, that IBM modified the ant for some weird reason. After several failed attempts, we used the most trivial and ugly way to invoke the tasks.
Based on the forums and even IBM’s InfoCenter it seems that invoking the ws_ant with the exec task with the required arguments. I have to mention two points here, one is that there seems to be no way to handle the return value of the exec. The other is that it’s quite annoying, that all arguments of the exec must be specified using separate args.