Overview of the Build Tools in Rational Team Concert

Introduction

The purpose of this paper is to break down the various build offerings from IBM and Eclipse and discuss their features. By referencing this paper, a build user should be able to determine which build tool best fits his or her build needs.

Jazz Build Engine

Jazz Build Engine (JBE) is a simple Eclipse based engine. It integrates easily with RTC and is particularly strong leveraging the Jazz SCM. In particular continuous integration (CI) builds with Jazz SCM can be set up quickly. The integration with RTC also means it is relatively easily for developers to create their own builds. The engine is built on the Eclipse framework and is very good at handling Java code and Ant builds. However JBE does have some drawbacks. The build process is not threaded. It will pick up a single build and run it to completion before going back to the build queue. This is addressed by allowing a single install of the JBE to be instantiated multiple times, but since JBE is based on Eclipse and Java the memory footprint is not small. JBE does not scale well into larger builds since it does not link builds together nor does it handle dependency builds. Each build is atomic, but does not easily link together to create larger builds. However this can be overcome with additional Ant scripting, particularly with the RTC Build Ant Tasks, which is what the Jazz team does for its own builds on JBE. JBE then is ideal for smaller teams with fairly simple builds. With more Ant scripting work it can be adapted to service larger teams with more complex builds.

Build Forge

Build Forge is the Rational build orchestrater offering. Build Forge offers lots of features and can handle extremely complex builds. Those features include dynamic build server pools, linking builds, custom CI builds, and conditional steps amongst other features. Build Forge can handle enterprise level build requirements and will scale well even with large deployments. Build Forge, however, is not very developer-friendly. The product is more geared toward the build engineer. This can be mitigated by using the RTC integration, which may make it easier for developers to access and run their own builds. The other drawback would be the complexity of the product. It takes a lot of setup to even get a simple build running in Build Forge. Also the Build Forge server itself is a separate install from RTC/CLM with its own database. Setting up a build in Build Forge should not be approached lightly and should be planned out beforehand.

Build Forge Agent

The Build Forge agent is not really a build tool in and of itself. It is a lightweight process installed for Build Forge to create build farms. The process can be considered as a remote shell, which is why the Enterprise Extensions team finds it particularly useful. RTC is able communicate to these agents directly, and it is distributed with the RTC build toolkit, so it should be included for consideration of build tools. The Build Forge agent through a RTC build definition can execute a single shell command with a pre and post command. The agent itself can be executed multiple times concurrently, but RTC limits a Build Forge agent engine to a single build per engine. The agent is exactly what it appears to be. It will not do dependency builds or anything else on its own. It is simply for executing shell commands on the Agent machine.

Hudson/Jenkins

Hudson and Jenkins are very popular open source build tools, or “Continuous Integration systems”. Hudson joined the Eclipse foundation and is part of the Eclipse open source offerings, and Jenkins continues to be an independent open source community offering. Hudson and Jenkins are very easy to setup and configure. They support a rudimentary build pool and allow for multiple concurrent steps. The space that it occupies is somewhere in between Build Forge and the JBE. It can handle more complexity than JBE, but also is easier to configure than Build Forge. It is a good compromise between the ease of JBE, and the features of Build Forge.

UrbanCode Deploy

UrbanCode Deploy is a tool for automating application deployments. It provides the flexibility of setting up environments for application deployment and roll back of the same. Rational Team Concert integration with UrbanCode Deploy is for post build operations. Once a build user has decided which tool to build their application with, they can deploy the built application by enabling “Post Build” in build definition configuration. It also gives the flexibility to chose the components to publish to UrbanCode Deploy, select a custom version and include or exclude files. However a user wont get the option to fail a build upon failure of Post Build delivery operation.

FeaturesJazz Build EngineBuild ForgeBuild Forge AgentJenkins/Hudson
Dependency BuildNoYesOnly on zOS. iOS support added in 4.0Yes (provided a plugin exists for the SCM being used)
Multiple StepsNoYesOnly three from RTC build definitionsYes
Concurrent BuildsNoYesYes, but RTC limits BF Agent engines to a single concurrent build per engine definitionYes
Conditional steps/projectsNoYesNoNo
Continuous IntegrationOnly with Jazz SCMYesNothing native*Yes
Load sources directly from Repository workspace, Stream or SnapshotStream and Repository WorkspaceNoNoYes
*By itself the BF Agent doesn’t do CI, however it is an integral part of the Enterprise Extensions build definitions Jazz SCM CI setup. So while there is nothing native in the agent itself, it can certainly be leveraged to accomplish continuous integration.

Summary

The differences between the build engines should now be clear. The JBE is the native build tool for the Jazz CLM product, and as such integrates very well with Jazz. The Build Forge Agent is very simple and does not do anything natively, but will run almost anything, anywhere. Hudson/Jenkins is fast to set up and can handle more build complexity. Build Forge can handle any build situation, but is hard to configure in the first place. While JBE is the native build solution, RTC Build has integrations available to all of these tools, so no matter which build solution you choose, RTC will work with it. Additionally RTC has integration with UrbanCode Deploy which gives the capability to perform post build operations on custom environments.


For more information


About the author

Spencer Murata currently works in the RTC Level 3 Team in Littleton MA. He can be contacted at murata@us.ibm.com.

Feedback
Was this information helpful? Yes No 5 people rated this as helpful.