Continuum and SSL authentication solved

We got SSL authentication working in Continuum this Friday, by applying this one-line patch that we found in the JIRA. These are the steps that we followed, roughly:

1. Checkout the source:
   

   
   svn co http://svn.apache.org/repos/asf/maven/continuum/tags/continuum-1.0.3/

2. Apply the patch (it's just one line, so it's trivial to apply it by hand).
3. Build the whole thing with Maven:
   

   
   mvn -Dmaven.test.skip=true -DappProperties=app.properties install

   Some tests failed, and I didn't have the time to investigate further, and one of the modules failed to find the app.properties file automatically. Also, you may need to download and install some Sun jars manually, but that's not a big problem since Maven hands you a command line to use.

Now Continuum is ready to run, if the build succeeds. There is a build guide, and a README that contains additional information. In our case, we have a hierarchy of projects which are automatically identified and set up in Continuum. Very handy!

New job

I've just completed the first week on my new assignment: consulting team member on a medium sized project for Eniro. It's been a great experience so far, and although I can't reveal the exact nature of the project, I can say that it's based on high profile open source Java EE components such as Spring, Hibernate, MySQL, Linux, Velocity and Maven.

I've worked quite a bit with most of the stuff before, but one thing that's new to me is Maven multi-module project hierarchies which works quite well, and makes Maven look even better. Another nice thing that I've never used before is Maven Proxy.

One thing we decided on early on was to use contiuous integration, and since we're heavy users of Maven already, Continuum seemed like a sane choice for server. Unfortunately we've having problems getting it to work with SSL+authentication...

The project is based on an older application which has been split into three major parts, with each part having two or three sub-parts. The older application did have a partial test suite, but it hadn't really been kept up to date the latter half, so the first step will be to resurrect and/or rewrite the testsuite. This situation is fairly common in my experience, where you start out writing tests for everything, but as the project progresses, people pay less and less attention to testing, and the suite drifts further away from the code base. Hopefully CI will counter this behaviour :-)

My methodology for writing DAO testing against a database was accepted with some enthusiasm. I've written a little about it in "Rolling with Spring and Hibernate", but I'm planning a larger entry on that subject. An update on that article is planned, too. Stay tuned!

Patch accepted

I got my first patch accepted into Spring today, a small fix for the FreeMarker view class. It'll be present in 2.0.1. Very fast response from the core team (Jürgen), impressive!

I've also worked a little on the CSS of this blog. I really think serif fonts are more readable in the long run. Gotta do something about that awful header though. This was the only Blogger template I could find that spanned the full width of the page, so I figured I'd start from there and customize it later on.

About the "Rolling with..." article

For those of you interested in reading the "Rolling with Spring and Hibernate" article series, here's a quick recap of the contents:

1. The first part is just about APIs and development environment.
   
2. The second part begins the building of the model, with Hibernate and transaction configuration and a basic CRUD-able entity class.
3. In the third part a controller and a few views are added, and the application is deployed for the first time. Also a few notes about AspectJ weaving and Jetty.
4. Part four adds a second class to the model, and a relation between the two model classes. Here we can see what amount of work is needed to add one more model class to an existing application.
5. Testing is covered in part five, both mock testing and integration testing against a database.
6. And in the final part I comment a little on the differences between Rails and the stack at hand, and some suggestions for Spring improvement.

Any comments and suggestions are welcome. The code is available as a Google Code project. Embarassingly enough, I've misspellt "Recipe" as "Recipie" thoughout the application, but the blog text is corrected. Refactoring recipie->recipe is left as en excercise to the reader :-)

Update: those of you who find this article interesting, might also enjoy this more recent in-depth look at implementing the ActiveRecord pattern using Spring and Hibernate.