This article series describes the Agile Backoffice environment. STOP! Agile… what? Ok. Let us start with some details about the Agile Backoffice.

The Agile Backoffice

If you start working agile – mostly you use Scrum as first agile method – you and your team are very motivated to do this in a very agile way. The tasks are all pinned on a wall or a whiteboard, a continuous integration will be setup, the project know how will be shared in internal discussions. This works fine for a small team workingalways together in one location.

If you take a look around you see a lot of companies where this optimal conditions not exists. The teams are divided in different locations – different rooms, different floors, different locations. If your team splitted i such a way a whiteboard with pinned tasks are not a reasonable solution. Additionally to this you have a management interested in the progress of your work. For this requirements you need some tools supporting you. But you should use tools adaptable to your processes and not tools you must adaptable your processes to.

The central tool I choose for the Agile Backoffice is Atlassian Jira. It is the single proint of interest. In this tool you can see all requirements, the stories and the belonging tasks. Additionally you can get informations about changed (re)sources, running builds and – the most important – the status of a task, a story or requirement. You have a powerful reporting and a wide support for development tools: Eclipse, IntelliJ, Visual Studio.

Bit only with Jira you can’t get the result you wish. You need a continuous integration, a source control management, a repository for the deployable artifacts. Additionally you want to review and mesure the quality of your code. For this approaches there are tools but this tools should all be connected together, so there are based on the same data.

This is the goal of the Agile Backoffice and this series of articles. So stay tuned.

Do you need a tracking system to track your requirements, issues and tasks? So you can look around – and maybe – your eyes keep on the famous Atlassian Jira. At first Jira is a bug tracker. You can create, manage and close bugs with Jira. But there is more:

• Bug tracking
• Manage your projects with Jira
• Create your own workflows for tasks and issues
• Powerful Reporting
• Extensible with plugins

You can download a standalone version bundled with a Tomcat 5.5. With this download you can start directly. But typically you already have an infrastructure. For such scenarios it’s much better to use the WAR/EAR-Edition of Jira.

This article describes the installation with Apache Tomcat 6 on a Linux box. If you plan to do this on windows you only must change paths and – of course – shell against Windows Batch.

Install Tomcat

You can get Tomcat from the official projectsite. You get a ZIP- or TAR.GZ-Archive. Now you can extract the archive and do a testrun by browsing to http://localhost:8080.

If you want to deploy Jira to this instance of Tomcat you need some additional Jars not included in the web archive you will later deploy. You can get the additional jars from here. Create a new directory in you Tomcat installation directory: ext/jira/lib. Copy all Jars into this directory.

Finally you must Tomcat announce the new libraries. For this you edit the conf/catalina-properties by changing the common.loader property (the property is a single line; here are only breaks due to layout reasons):

common.loader=${catalina.base}/ext/jira/lib/*.jar,
       ${catalina.base}/lib,${catalina.base}/lib/*.jar,
       ${catalina.home}/lib,${catalina.home}/lib/*.jar

Jira needs a lot of memory. Sometimes Jira needs more than Tomcat can deliver. So you should add mor memory to Tomcat. This and some other properties you should set, before the next restart of Tomcat.

export JAVA_OPTS="-XX:MaxPermSize=256m -Xmx1024m

       -Dorg.apache.jasper.runtime.BodyContentImpl.LIMIT_BUFFER=true

       -Dmail.mime.decodeparameters=true"

The first both options gives more memory to Tomcat. The last both options are needed by Jira. The 3rd is needed to avoid a memory leak of Tomcat and the last option is needed to send attachments with another encoding than the default encoding.

You must restart Tomcat to activate your changes.

Installing Jira

The archive you get as WAR-Edition contains the binaries you need to deploy it to Tomcat. But the archive contains the binaries for the EAR-Edition too. And for older Tomcats and Resin and so on… Additionally this archive enables you to do customizations like configurations, templates,  additionally sources to compile and JARs. After you downloaded the archive and extract it you must change one property pointing to the data directory used by Jira by editing edit-webapp/WEB-INF/classes/jira-application.properties.

Now you can build the web archive you can use to deploy to Tomcat. In the root directory the is a build script (build.sh and build.bat) you can use to archieve this. After some time the script is ready and a new directory is created: dist-tomcat/tomcat-6. There you find the web archive and the deployment descriptor for Tomcat 6. You can simple copy this descriptor to <<tomcat-install-directory>>/conf/Catalina/localhost. Tomcat will install Jira and you can browse to http://localhost:8080/jira.

Customizing the web archive

You can overwrite every file the web archive contains. The can archieved vy copying the file into the edit-webapp directory. Please remember to create the same directory structure. For instance if you want to customize the file webapp/WEB-INF/classes/log4j.properties you must copy it to edit-webapp/WEB-INF/classes/log4j.properties. After running the build script you can reload the webapplication with Tomcat’s Manager or simply restarting Tomcat.

Speed up the build script

The build script create web archive for all tomcat versions and a generic web archive for other servlet containers. If you plan to deploy to Tomcat 6 it would be enough to build the archive for Tomcat 6. To do this you must only change the target war in the build.xml:

<target name="war" depends="clean, compile" description="Packages the WAR file">
  <!-- Build the war file -->
  <jar jarfile="${dist-generic}/${name}-${version}.war">
    <fileset dir="${build.war}"/>
  </jar>
  <!-- Tomcat-6-specific .war -->
  <jar jarfile="${dist-tomcat}/tomcat-6/${name}-${version}.war">
    <fileset dir="${build.war}">
      <exclude name="WEB-INF/lib/commons-logging*.jar"/>
      <exclude name="WEB-INF/lib/log4j-*.jar"/>
    </fileset>
  </jar>
  <copy file="etc/tomcat-6-jira.xml" tofile="${dist-tomcat}/tomcat-6/jira.xml">
    <filterset>
      <filter token="JIRA_HOME" value="${basedir}"/>
      <filter token="JIRA_WEBAPP" value="${basedir}${slash}${dist-tomcat}${slash}tomcat-6${slash}${name}-${version}.war"/>
    </filterset>
  </copy>
  <echo>
--------------------------------------------------
Deployable WARs generated:
TOMCAT:  ${basedir}${slash}${dist-tomcat}${slash}${name}-${version}.war
GENERIC: ${basedir}${slash}${dist-generic}${slash}${name}-${version}.war
See http://www.atlassian.com/software/jira/docs/latest/servers/ for install instructions
--------------------------------------------------
  </echo>
</target>

Conclusion

Now your Jira is up and running. The next steps are configuration of projects and users, but this isn’t the focus of this article.

What do I mean with development environment? Not only the developer workstation with Eclipse and the common tools like JDK, Maven, Ant and so on, but the environment you need for producing high quality software.
The following article is a kind of proposal for such an environment. I think every organization has its own needs but overall this could be a starting point, if you want to build it for your organization.

Structure of a development environment

Which roles are involved?

There are developers (in figure 1 in the top left corner), the QA (in the bottom right corner) and – of course - the customer (not shown). Of course there a many more roles in a software project – you know them as stakeholders, too.
But you know the ditch between developers and the QA-Guys? You can work well with the QA if the software they test has a good quality. But for this you need some components.

What components do you need?

Component	Description
Ticketing System	This is a must have. This component you need to track your tickets during development. Trac Jetbrains YouTrack Atlassian Jira Bugzilla Mingle Mantis …
Revision Control System	This component you need for versioning your source files. The is a great number of such systems: Subversion CVS Bazaar Mercurial Git Clearcase …
Wiki	You need something as documentation storage. Something that is agile enough not to block the development process. A Wiki can help you. But remember not every wiki is a good wiki
Continuous Integration	To produce high quality you need an automatically build and tests. Only with this you can verify your changes not breaking already existing features. With a CI-System you can achieve this. Some of this CI-Systems are: Hudson Cruise Control Atlassian Bamboo Jetbrains Teamcity Cruise …
Artifact Repository	You need always a repository where you can deploy the artifacts you build. The meaning of artifact in this context are archives like JARs, WARs, EARs but DLLs, too. Of cource you can deploy them to your Revision Control System. But it is always an good idea to have a mechanism you can resolve dependencies you have automatically. With Maven and Ivy you have Buildtools that do this for you. An Artifact Repository is a simple (or not so) storage for deployable artifacts. You can choose between 3 well-known OpenSource Products: Archiva Sonatype Nexus Artifactory

And now…

Every component must communicate with every other component. But let’s us begin with the developers. Developers working directly with the Ticketing and the Revision Control System. They need the Ticketing System to manage the development orders (or tasks or Sprint Backlog Items if you are familary with Scrum). Changes at the sources of the project will be committed to the Revision Control System. If you have a full featured Ticketing System you can log this commits and show the relevant commits in the tickets. So you can track all changes needed for the resolving of a ticket.

The Continuous Integration System (CI) is polling the Revision Control System to get notified for changes. If there are one or more changes the automatically build will be started. After the – hopefully – successful build all tests are executed – and hopefully green – and the artifacts can be deployed to the Artifact Repository. At the same time the revision (in Subversion) or the commit (in Git) can be tagged. So you have a marker for the sources the CI used to build and create the artifacts. With this tag it is every time reproducable. If you add the Ticket-ID in the commit messages the CI can add a comment to the ticket, so you can see if the buidl was successfully or not.

After some time the developer can resolve a ticket. At this time the CI should create a QA-Release. This is a special release because if the QA-Process is green this build should use for a release. The QA-Team gets notification for a testable build from the Ticket System. After the test the QA mark the ticket as tested or reopen the ticket. In the second case the developer should fix the errors or problems.

Conclusion

This was a quick view of a possible solution to build a development environment. Such an environment you need to use Scrum successfully. I am very interested in your opionion. Please leave a comment…

If you are using the famous Issue tracker JIRA by Atlassian you are able to change the workflow. Workflows are used to define the status an issue can get. Between the 2 statuses there are a transition. In JIRA you can translate the statuses (Administration | Status | Translate).

Translate statuses in JIRA

But for transitions there is not such a dialog. But there is an solution for this. You can modify the language property file. If you use an script you can do this automatically. But one step after another

1. Locate the language library

In JIRA all language files are bundled in a library. This library you find in WEB-INF/lib in your JIRA installation.For the german translation the library is named language_de_DE.jar.

2. Extract the JAR and edit the JiraWebActionSupport_de_DE.properties

The JiraWebActionSupport_de_DE.properties is in the package com/atlassian/jira/web/action. You can edit this file with a simple editor. For every transititon you must add one or two properties:

• for the title
• for the submit button, if you transition needs a dialog (e.g. the reopen issue has a dialog where you can leave a comment)

For instance you have a transition Test Issue. This transition doesn’t need a dialog. So you need only one property:

testissue.title=Testen

As an exteded example you have a transition named Issue tested. For this you need a dialog the user can leave a comment. In this case you need 2 properties:

issuetested.title=Getested
issuetested.submit=Test abschliessen

After you finished the modification you can repackage the JAR.

3. Restart JIRA

This you should really do before you start with the next steps.

4. Add the needed properties to the transitions

The next step is to create a relation between JIRA and the properties. This can be done in the panel for modifying transitions (Administration | Workflows | Steps (of the workflow you want to change) |  Click on the transition | Properties of the transition). In the page loaded then you can add the needed properties.

Add properties to transitions

What you need to add is a key-value pair. The key is for JIRA. With this key JIRA knows what kind of i18n text this property represents. The both relevant key are:

• jira.i18n.title (for the title)
• jira.i18n.submit (for the submit button)

As value you can add the properties you add to the language file (JiraWebActionSupport_de_DE.properties). After you are done you can close every dialog and activate the workflow.

As a result you see something similar to this:

Translated Transition

Hmm…there are many steps…is there a chance to simplify this?

Yes, of course. You can create a script to do this automatically. For example I have one written in Groovy doing all steps automatically:

//Points to the language_de_DE.jar
def langPack = new File("...")

//Points to the folder the modified JAR should be copied to
def targetDir = new File("...")

//Points to the folder the langPack should be extracted to
def tempDir = new File(System.properties["java.io.tmpdir"]+"/language_pack")

def langFile = new File(tempDir, "com/atlassian/jira/web/action/JiraWebActionSupport_de_DE.properties")

//Create the antbuild for some common tasks
def ant = new AntBuilder()

if (tempDir.exists()){
    ant.delete(dir:tempDir)
}

ant.mkdir(dir:tempDir)
ant.unzip(src:langPack, dest:tempDir)

//Using Groovy's multiline strings
def t = """
issuetested.title=Getested
issuetested.submit=Getested
"""

//Append the existing content with our extended properties
langFile.text = langFile.text + t
ant.zip(basedir:tempDir, destfile:new File(targetDir, "language_de_DE.jar"))
ant.delete(dir:tempDir)

//Build JIRA
"cd /opt/jira".execute()
"build.bat".execute()

//Restart Tomcat
"cd /opt/tomcat/bin".execute()
"catalina.sh start".execute()

With this simple script you can do all steps automatically. One thing isn’t really nice. The properties you append to the original languagge file are saved in the script. This should be changed if there are more than a handful properties.