How many times have you come across a .jar or .dll file and wondered what version it is? Especially when using Open Source Software?

The most frightening one for me is when I’ve looked at a cluster of production servers and noticed that the .war file for the application deployed on it is a different size on one of the nodes. Which one was the correct one to deploy? Luckily this happened to me a long time ago, but I know that people out there are still having this problem today.

The solution is what I call “Self Identifying Software”. Every build of your software needs to have something that tells you what version it is and how to get back to the source code that created it. Having a build label or release number visible in your application is a good start, but it does not make your software Self Identifying. Product companies have been doing this for ever. The problem is that for that number to be useful (particularly when you’re trying to access the source code to reproduce and fix a bug) you then need to refer to a build system or release notes to find out where the source code came from (if you’re lucky). It often also does not apply to development builds. To be truly Self Identifying you need to make sure that every build (including builds developers create on their workstations) also includes enough information from the SCM system so that anyone who has access to the source code can go right back to the exact source code that produced that binary. For example, if you use Subversion as your SCM then this will be a URL and a revision number.

This is not exactly a new concept, it’s something I (and others) have been doing for a number of years now. The reason I’ve decided to write about it now though is that recently I was showing a new guy around one of the projects I’m working on at the moment, and when I showed him how to determine which version of the app was deployed he was delighted.

How do I get my software to identify itself?

There are generally two scenarios where I would want to get the identity of some software. The first is where I have a service or system running somewhere that I would like to know the version of, and the second is where I have a binary artefact and I’m trying to determine it’s provenance.

When querying a service, the easiest is to be able to hit a well known URL (or make a well known service call) that tells me what I need to know. What the exact URL or service call is is not important, as long as those who need it know how to invoke it. This is most useful then you don’t actually have access to the binaries that power the service.

However, if you do have access to the binaries then it’s usually easiest just to examine the meta data of the file to see where it came from. Most modern binary formats allow for this in some way. If you’re working with Java then all .jar, .war and .ear files allow you to put this into the META-INF/MANIFEST.MF file. Creative use of versioninfo resources will allow you to achieve similar results if you’re dealing with Windows. Note that we’re not talking about putting this information into the file name itself – file names change.

How do I use it?

Having Self Identifying Software goes beyond just being able to quickly track down the source code that built the binaries you’re dealing with. Here are a few other uses I’ve found:

• When used as part of a Continuous Deployment system you can verify that you’ve got the correct version of the binaries before you start deploying things, and you can then use the service call to verify that the correct version of the app is up and running at the end of the deployment processes.
• When used as part of a dynamic system dashboard you can quickly and easily see what’s installed where instead of relying on spreadsheets or documents that often get forgotten.

If you find any more, please let me know…

This is always a hard one to answer. In the last place I worked as a System Administrator we used Split-Horizon DNS as one of the ways to solve connecting to the correct host for a service. Our applications had hard coded hostnames for key services such as db.internal.domain, loghost.internal.domain and mailhost.internal.domain. Depending on which environment they ran in, when the did a DNS lookup they would get an answer that pointed them to the correct server providing that service for the environment they were physically running in. Combine this with tools like an LDAP Server in each of these environments containing the rest of the system configuration and life is easy. Or is it?

DNS and LDAP servers are relatively straight forward for experienced Sys Admins to understand and maintain, but they still can’t be described as easy to use, which is probably why so few people do it. This limits our options for fixing things down to two general categories – fix DNS and LDAP admin tools so they are easy to use, or find another way to solve the problem.

We chose the path of least resistance and went for the second option – creating ESCAPE. In the Unix tradition, it’s an app that takes one problem and solves it simply and well (at least in our opinion). It provides a RESTful interface for both the setting and getting of environment configuration. GET requests will retrieve configuration, whereas POST/PUT requests will create new entries or update them.

The URL scheme we’ve decided on is most easily demonstrated by constructing an example URL:

As the tool is now usable we’ve happily released version 0.1. Currently we’re busy putting a lot of work into making the management interface understandable and intuitive to use. The closest thing we currently have to a roadmap is our ToDo list.

Please join us on the discussion group with your feedback.

As I’m normally brought in with the developers, I’ve been trying to find efficient ways to engage with the client Operations teams. Normally I end up having one on one conversations with various members of the team, try to find out what their current processes are, what their major challenges are and what their concerns are regarding the project I’m involved in. I usually do this to keep the safety levels high. The problem though is that it takes quite a lot of time and effort to get things going and get some momentum going.

At my current client though I didn’t have the time or access to the people to do things the normal way. A meeting was arranged with the key Operations stake holders and I effectively had just 2 hours to explain our development process in general, and Continuous Integration and Build Pipelines in detail. While talking with Graham Brooks about what we wanted to cover, he came up with the idea of running it as a mini retrospective.

After the usual introductions, we gave them 15 minutes to list the Good, the Bad and the Puzzles of their current development and release process. We had good participation from the group and as expected had a high number Bad entries. After talking through the cards and grouping them into related sections, we then allowed them to vote on the ones they most wanted to talk about. Most votes went to the core pain points, and we spent the rest of the time talking about how our process would address those issues. It also helped a lot that most of the Good entries related to the automation they already have in place…

By the end of the meeting no was talking about the bad old days (lobbing releases over the wall). Everyone was engaged starting to get some spirit of collective ownership going in the whole delivery process and that breaking down the walls that exist between the various silos was high on the list of things to do. Rather than talk to them about our process and how we would like to interact with them, we had allowed them to lead the discussion on which elements from our toolbox would have the greatest value for them.

All I need to do now is learn how to be as good a facilitator as Graham was…

The list of available products out there has grown a lot in the past 18 months, and the features that they support are really great. Since I did the last review I’ve actively avoided having a look at the other tools out there to keep a clear focus on what I wanted to see in Cruise. Doing this review has been a great way for me to see what everyone else has been up to.

Just having loads of features does not automatically make for a good tool though. Instead of having a shooting match between who does what, I’ve taken a little sample Java servlet that I use for demos and tried to get it working with all the tools. This project is hosted on a local subversion repository. I’m going to try set it up to simply run unit tests and create my distributable .war file. Areas that I’m going to look at are:

• Installation (on Linux, OSX and Windows)
• Setting up my existing project
• What did the tool inspire me to try next

Tools that I’ll be trying out are (in alphabetical order):

• AntHillPro 3.5.3
• Bamboo 2.1.1
• Cruise 1.0
• CruiseControl 2.7.3
• Hudson 1.252
• Pulse 1.2.56
• TeamCity 3.1.2

AntHillPro

Installers

There are no native platform installers, but you can choose from 3 packages. Each package contains both the server and the agent components.

• Graphical Java Installer
• Windows Command Line Installer
• Unix Command Line Installer

Installation

I chose the Unix Command Line. Unpacked the tarball and ran the script. It’s unique in that all the script does is kick off an ant build that asks you questions and does the installation. The defaults all seemed pretty reasonable. Installing an agent is done separately and follows the same process. Once you start the processes, hit the web frontend and finish the setup.

Setting up my project

This is where things go interesting. There was no obvious “add your project here” button. A bit of clicking around, and I found something under the Admin tab that looked like a good place to start. Then it asked me if I want a Life-Cycle based project or a Non Life-Cycle based one? What’s a Life-Cycle in this context? I fuddled around and took random guesses, and then figured out that I needed to add a workflow to my project to actually do anything. Fair enough, only I was half way through configuring my new workflow when it asked for my repository, but only gave me a dropdown list to choose from. Back out, into the admin page, find out where to add new repositories, add a Subversion one. Once again try to finish configuring my new project (at least it remembered where I was), but then it all fell apart when trying to add the repository to the workflow. Kept on throwing up “AttributeMissingException: project is missing”. Decided that this had already taken up far too much of my time just to get to this point, and so I gave up.

Bamboo

Installers

A single installer that contains both the server and the agent.

• Windows .exe installer
• OSX .dmg file
• tarball

Installation

I picked the “Linux” tarball, even though I’m testing on OSX. I prefer doing this when evaluating products as I think it gives me a better feel for what’s actually going to be installed, and I’m guaranteed I can get rid of it efficiently and easily when I’m done playing with it. Unpackd the tarball, ran the start script. All looks good, but when you try use it it asks you to edit a file in the webapp path pointing to the installation directory. Nasty. Once that’s fixed and started again, you’re asked for your license key. There’s a handy link at the bottom to go get your key, copy paste and you’re away through the rest of the wizard.

Setting up my project

Clicked the Create Plan link. Still has my pet hate of wanting you to specify UPPER CASE KEYS for everything. Are we still using ancient Big Blue iron here that has such limitations? Wants me to specify an ant target which is also a little weird – I just want the default target! Other than that all very nice. I like how it goes right into the activity page once you’ve set up your project and you can see what’s going on, including SVN checkout.

I then wanted to play with

Agents. Installed agents on Ubuntu and WinXP (server running on OSX). It’s pretty easy really. Agent matrix shows you which projects will build on which agents. Also went to look at all the pretty graphs, but I don’t have much build history right now. Bamboo has built in Clover integration, but I use cobertura in my project for coverage. It looks like they have some interesting reports around code coverage, but I can’t run them…

Cruise

Disclosure – I wrote the installers for Cruise, so obviously I like them.

Installers

Separate installers for the server and the agent components.

• Windows .exe installer
• OSX .app packaged in a zip
• Linux RPM and Debian packages

Installation

This is one of the few products that does not ship a generic tarball or zip file. As I’m doing all this on a Mac, I pulled down the server and agent zip files, unpacked them, and dragged the .app’s over to my Applications folder. Double click on each and we’re up. Once the server is up it opens up the admin interface in your browser. The first thing you’re asked for is your license key.

Setting up my project

The very first thing you’re hit with (after you’ve put in your license key) is a wizard to set up your project. Follow the prompts, and fill in where your test results and artefacts are stored. It won’t let you create the project until it verifies that it can connect to your source repository, so make sure it’s up before you start.

I then wanted to play with

Pipelines. I presented one of the very first papers on Build Pipelines with Jez Humble (now product manager for Cruise) and Dan North at Agile 2006. When I first started implementing them I had to do all kinds of unholy hacks with CruiseControl, but the benefit of using CI like this was well worth the pain at the time. At the moment you have to jump into nasty XML to configure pipelines in Cruise, but the whole process should be wizarded up in the next release. Having lots of agents allows you to split up jobs in your pipeline stages quite nicely so they run in parallel and speed up your feedback loop.

The other great feature I like that product companies are always asking me about is the ability to run parallel builds for a stage on multiple platforms. Whether you’ve got a .Net app that you need to test across multiple versions of Windows, or a web app that needs to be tested from a whole matrix of different web browsers, Cruise makes it easy to run the same tests in all these different environments using the same build of your application. If the tests pass on all of them, your stage will pass, and you know that your product is playing nicely with all of them.

CruiseControl

Installers

• Windows .exe installer
• Generic zip file

Installation

More unzip and run script. It just comes up with the sample project.

Setting up my project

This is where the venerable Granddaddy of CI servers really started showing it’s age. I had to manually check out my project, then edit the xml config file to get it going. If I’d not been using it for almost 4 years I’d get pissed off and move along.

I then wanted to play with

Something else. If you’re using it already and it’s doing the job you want it to, then there is no real reason to change. If you’re new to CI and are looking for something easy to get you started, then I’m sad to say I suggest you look elsewhere…

Hudson

Installers

• A single war file for everyone.

Installation

The most basic of all, just run java -jar hudson.war or drop the war file into your favourite servlet container. Makes it kinda hard to know what version you have though, and by the look if it they release new versions quite regularly.

Setting up my project

Not too bad. Pointing at unit test and artefacts was a bit weird as it starts one level higher than I expected. I liked the weather reports. Because the build was failing (because it could not publish any artefacts or find test results), it had little storm clouds. Nice.

I then wanted to play with

The plugins. There’s quite a few, and I like how you can just download them and go.

Pulse

Installers

• Windows .exe installer
• tarball
• zip

Installation

Another unpack the tarball and run the start script. I see a trend here. Hit the web interface and it asks you for a data directory. Also needs a license key to get going, but has a nice link there to go get one.

Setting up my project

Nice start screen with list of things to do. Hit add project, then got confused about what the URL was it was asking for. Got a test button for your SCM – yay! Setting up the artefacts you want is easy, it all just works. Only thing I can moan about is that I can’t see what’s going on in the builds, and it feels slower than the rest for some reason.

I then wanted to play with

Personal builds! It’s not something I’ve ever played around with, but it looked kinda straight forward with pulse, and it is! Just install a little tool on your development workstation and use it to invoke a personal build. Does require a bit of extra data in the project, but it’s great.

It also has agents. I love agents. They have an interesting way of doing them though. You point the agent at the server. I suppose that’s one way of getting around the security implications of other people getting their hands on your code. Agents auto-discover what their hosts provide, and when configuring a project you get a drop down list of what’s provided already. You’ve still got the freedom to add your own stuff too.

It has stages, kinda like our build pipelines. To use them nicely though you need to start editing their XML, but they’ve got great help along the right for you to see what your options are. Their stages run in parallel, so it’s not really like our Cruise pipelines, but at least they got the parallel stuff going.

Team City

Installers

• Windows .exe installer
• tarball

Installation

Unpack the tarball, find and run the start script.

Setting up my project

Hit the Create Project button. Interesting that you create the project first, then add the config after. Test SCM button. Auto tagging and code coverage built in. Nice. Also agent based. Option to automagically run emma for you. Tried it, but because I already use cobertura it barfed. It lost my artefacts config somehow. Lots of options. Also by default does not trigger a build on check in – what’s with that?

I then wanted to play with

Integration with IntelliJ. I’m a big fan of IntelliJ and use it a lot. It makes sense in a developer centric world, because the IDE is the developers portal into the world of code. I like the way you can click on a failed test and it takes you to the test code, as well as the ability to take responsibility for fixing a broken build.

Summary

The world of CI servers has come a long way in the past 18 months. It’s certainly reinforced my belief that competition is a great driver for innovation. When I started at ThoughtWorks clients would often complain that they’d like to do Continuous Integration, but setting up a CI server was way too hard. Complexity of tool configuration is now no longer an acceptable excuse for not doing CI.

It’s also great to see the trend of agents being so popular. The days of having a big mother of a build server for a project or small group of teams is over. After one of the Cruise demos I did here in the UK our client commented that it was great that he could finally find a use for all the overpowered desktop machines their managers have – use them as build agents!

As a final note for those of you who are trying to decide on what CI server to use – remember to pick one that supports your process and what you want CI to do for you.

Last year at the conference I got a chance to show off the new UI we did for CruiseControl with Erik Dörnenburg. Afterwards I was having a chat with Martin Fowler, and I commented on how I’d like to see a whole track at JAOO dedicated to Building and Deploying software. While I’m sure I can’t take all the credit for it, this year there is going to be a short Build track with me talking about Continous Integration. Hope to see you there…

package com.example.service.utils;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;

public class ListControllers {
    public static void main(String[] args) throws IOException {
        String outputFile = args[0];
        String srcDir = args[1];
        File f = new File(srcDir);
        File serverDir = new File(f, "com/example/service/server");
        String[] entries = serverDir.list();
        Arrays.sort(entries);
        BufferedWriter writer = new BufferedWriter(new FileWriter(outputFile, false));
        for(String entry : entries) {
            if(entry.endsWith("Controller.java")) {
                writer.write(name + "\n");
            }
        }
        writer.flush();
        writer.close();
    }
}

This was then called by the following Ant snippet:

<mkdir dir="${target.dir}/war/WEB-INF/classes"/>
<java classname="com.example.service.utils.ListControllers"
      classpath="${main.jar}" failonerror="true">
    <arg value="${target.dir}/war/WEB-INF/classes/controller.list"/>
    <arg value="${src.dir}"/>
</java>

This was then bundled up in the war file so that he could get his mits on it at runtime. It works, but is not without problems. My primary complaint is that it makes the build harder to understand. To figure out what’s going you need to find and open up the .java file, and be able to understand Java in the first place.

After a few minutes of pairing we managed to fix it with the following Ant snippet:

<mkdir dir="${target.dir}/war/WEB-INF/classes"/>
<pathconvert property="controller.list.propery"
             pathsep="${line.separator}">
    <sort>
        <path>
            <fileset dir="${src.dir}/com/example/service/server"
                     includes="*Controller.java"/>
        </path>
    </sort>
    <map from="${src.dir}/com/example/service/server/" to=""/>
</pathconvert>
<echo message="${controller.list.propery}"
    file="${target.dir}/war/WEB-INF/classes/controller.list"/>

Not only is it now easy to see what we’re trying to do in the build file, but we managed to replace 29 lines of Java + Ant with 10 lines of Ant. Sweet!

As always, there were also people who were interested in hearing about how it can be used for non Java projects. I had a good chat to one person who is interested in using it on a mixed Common LISP and Erlang project he’s working on. I’m looking forward to hearing how it goes for him. Due to lack of experience on my part I could unfortunately not help him much with the darcs problems he’s having though. Some people have all the fun…

It was also quite useful to speak to people about the problems they’re currently facing when trying to use CruiseControl. A common theme is people trying to manage large numbers of builds, or trying to build products across large numbers of different platforms. These are problems the dedicated ThoughtWorks development team are currently working on, so it’s great to get the validation that we’re putting effort into the things people care about now.

There are a number of ways to do this, and they all really depend on what you’re using Cruise for. If you’re simply using it for compilation, then you can simply use <exec> to call make (or whatever you’re building with). By default it will break the build if the command returns a non-zero return code, so it should be smart enough to do this out of the box. I know that some of our Ruby projects that use this method too.

My personal preference is to get CruiseControl to do an Ant build, which has some additional logic, including taging the source repository with the build label if the build passes. The approach is very similar in this case, and has the following steps:

• Have ant do any additional work/checks you want to ensure the environment is how you want it.
• Update my working copy to an exact known version that can be tagged at a later stage if the build is good (primarily a CVS problem, not really needed if you’re using Subversion).
• Use the <exec> task from ant to run the build
• If you have additional tests to run, use an <exec> within a <parallel> block to start your newly built binary in the background, then run the tests
• If everything is good and passes, tag your source code with the build label.

So, although it is fairly easy to add build plugins for various other projects, you can save yourself a bit of pain simply using the one <exec> or shelling out of an <ant> builder.

One of the things I wanted to see was how quick and easy it was to get these tools up and running. With this in mind, I specifically decided in advance to pull down the .war bundle of each one and try that out. In my experience, this would be the one that most of the clients I’ve been at would have gone for.

Notes:

• This is very much a first impressions run of the products – I had a limited time window (2 hours total) to do this in.
• People could quite fairly say that I have a biased view, but I’ve tried to keep this as fair as possible.
• I only tested doing an Ant build of a simple sample webapp from a subversion repository.
• You have to buy a license for TeamCity and Bamboo (I got evaluation licenses for both), but CruiseControl is still free…

Test Environment:

• Fedora Core 4
• Via C3 800 server with 512Mb RAM
• Sun Java 1.6.0-b105
• Apache Ant 1.7.0
• Jetty 6.1.1
• Subversion 1.2.3

TeamCity 1.2

This is the one I’ve heard the most about, and the one I’ve been most keen to try out. Back in the days when I used to be a developer, our IDE’s were nothing much more than glorified syntax highlighters. I’d poked Eclipse a few times in the early days, and not really seen what the fuss was about. Then I spent 10 weeks in a small room Alistair Jones and James Lewis. They kindly took some time to show me all the funky thinks IntelliJ could do. If JetBrains can write an IDE that is so good, what could they do if they turned their minds to CI?

Getting the webapp up and running was pretty simple (as expected). I did notice some errors scroll past the Jetty console, but chose to ignore them initially as things didn’t seem too bad. Things started to get a bit wobbly when it came to getting the agent running though. There are some basic typos in their install documentation that had me scratching my head for a minute or two. Trying to get the agent to play nice with the webapp was more of a pain, lots of NullPointerExceptions all over the place. As it all seemed to be in XML parsing, I decided to gear back to Java 1.5 and this got all the NPE’s to go away. I now had an agent up and running! Which is where my first concern pops up. It appears anyone can just spark up an agent and point it at TeamCity. I can see all those afflicted with SarBox liking that.

There was not much that was configurable for the rest of the system. Mail and IM server details were pretty much it, so I decided to move on to trying to get it to do some builds.

I did manage to get a project configured, but things pretty much went downhill from there. I got lots of strange errors all over the place when trying to look at build reports. Bouncing the webapp seemed to trigger the agent into doing a build, but I could not get it to trigger a build from a checkin.

In short – quite a disappointment really. I’ll have to try out the release they bundle with Tomcat to see if that is any better. I also didn’t try get it to play with IDEA, which I’m starting to feel is what it’s all about really.

Bamboo 1.0

I’d only recently heard of Bamboo. I’ve used other Atlassian products (Jira and Confluence) in the past, and so was a bit apprehensive about what this would be like as I find their other products a bit heavy. Would this be more of the same?

Installation was a breeze (as it is with their other products). The only bump was having to unpack the war file (one of my pet hates) to open up a properties file to set the bamboo.home property. It was only once I edited the file that I saw this could be set as a system property. It would have made me a whole lot happier if the nice initial system check screen had told me I could set this as a property instead of telling me to unpack a .war.

There are quite a few interesting system options you can set. I quite liked having a global build expiry option, and the separate build queues concept (didn’t get to play with it though). Other options I quite liked were the global JVM and Builder lists. Time to move on to actually setting something up.

Creating a project is pretty simple, the only thing that annoyed me the typical Atlassian fixation for mainframe style descriptors. Each project needs to have a ALLCAPSNOSPACESDESCRIPTOR to identify itself. Most intuitive. Everything else was pretty self explanitory. Even selecting build artifacts was a joy. Once the project is created, it does an initial checkout and build.

Now to trigger a build. This is one area they still need a bit of work on. While Bamboo did trigger a build correctly when I made repository changes, the polling mechanism is a bit heavy. It seems to do an update, and then if anything has changed it will build. Finding details on what exactly triggered the build also takes some digging, it’s not that obvious. One thing I do like though is that it keeps a history of individuals activity. You can drill down to each user and see their checkin rate, build breaking rate, build fixing rate, etc. I can see the PHB types signing the cheque for this feature alone.

Other features I like are the way they show the ant log files for each build, and also how you can effectively tail the log file of a build in progress. The way it parses your JUnit results is also pretty nifty, going as far as building an English sentence for each of your tests if you name them in the recommended testShouldDescribeWhatTheTestIsDoing format.

Things that I felt were missing were auto refresh of your status screen, and the email reports didn’t trigger when I expected them too, and the format was pretty primitive. It also takes a long time for the app to start (probably because of the Hibernate over HSQL database it keeps everything in), and app response is pretty slow.

In short – not bad for a 1.0 release! Functional, but not sure if I’d use it…

CruiseControl 2.6

I’ve not had a chance, or the need, to upgrade any of the systems I look after to Cruise 2.6. They’re all running on 2.5 and doing pretty well. While I admit that using this on a daily basis gives it somewhat of an unfair advantage, I think it also means I’ve probably got less to say about it.

First off, installation is pretty easy if you’re using the embedded Jetty for your reporting. If you want to do what I’ve done with the others and run it in your own container, it’s not that much harder. The only things you need to do are edit the startup script, and edit the web.xml file in the webapp to point it to all the correct directories. As I said above, this is a pet hate of mine.

Configuring a new project is a real bitch after using the other two. Even with my experience, and even using the sample connectfour project as a template, I still managed to get a type in there. Enough said on the configuration front.

Things I still liked about it compared to the others was the speed. It’s small, simple, and fast. That’s a key thing for me as CI is all about fast feedback, and if your tools are taking their time, you’re reducing your feedback loop. The other important thing about feedback is the information. Although the others all look pretty, there is still some basic information they’re missing for the builds – who changed what and why.

The new kids on the block are really make the grand pappy of them all show its age. I don’t think this is a bad thing though. New ideas should always be welcome in any field. They also show how much they still have to learn.