• Pipeline Compare: Go now gives you the ability to select any two pipeline instances and see exactly what changed between the two builds. The comparison will display a list of checkins grouped by material. If you use Mingle 3.3 (or greater) to manage your project, you can associate a Mingle project to a pipeline to see a list of cards that were worked on in the compare range.
• Pipeline Administration: A brand new UI for administering pipelines which eliminates the need to configure via XML.
• Password Encryption: All passwords stored in Go's configuration file are now encrypted for increased security. In prior versions, although passwords were only accessible by system administrators, they were visible in plain text. This is no longer the case.
• Version Controlled Configuration: Go now maintains a history of all changes made to its configuration allowing you to audit all configuration changes.
• Job Re-runs: Go now allows you to re-run specific jobs like it was possible to re-run stages. This helps in cases like environment problems where you had to rerun an entire stage. Job re-run gets you to the same state with lower agent utilization and potentially sooner.

• Go Community no longer requires a license key.
• Grant and remove administrative privilege for users from the "User Summary" screen.
• The "Trigger with Options" popup now lets you search by a material pipeline's label.

• The ability to authorize people to administer the configuration of pipeline groups. This is especially useful if multiple projects/teams share a single Go server - it means boxes can be centrally managed, but teams are in control of their build configuration.
• Go Pipeline Gadget with OAuth 2.0 so that you can embed a view of a pipeline in any compliant OpenSocial container.
• Pipeline level Atom feeds
• A GUI for creating and configuring environments
• A GUI for server and user management
• Manage Go users from the administration UI
• The ability to parameterize templates.
• An option to force agents to perform a clean build, and to bypass version control operations.

• Ensuring that when check-ins affect multiple pipelines, changes propagate through the pipeline dependency graph correctly.
• Authorization to trigger, cancel and re-run automatically triggered stages
• Pipeline locking is no longer turned on by default within environments.
• Better handling of cloned agent conflicts
• Go now displays when a stage was triggered on the stage details page
• Test failure information is now included in notification emails.
• Access to build cause information from within the Failed Test History report.
• Access to failure message and stack trace for a failing test from within the Failed Build History report.

• Go watches the disk space available for database and shows a warning message when it becomes low.
• Go shows the disk space available for pipelines folder under agent installation root.
• Pipeline label can now be customized by material revisions number.
• Link directly from pipeline history page to the different stage histories.

• Go uses pipeline counter instead of label in artifacts and properties Restful urls.
• Mercurial material no longer updates the working copy on the server when checking for modifications.
• Go now schedules pipelines concurrently.
• Go will use the first changed material as build cause.

• Go no longer always executes 'hg clone' when the url ends with /.

• Pipelines with Mercurial or Git materials may initially take a long time to schedule. This is due to the command 'clone' running with high CPU usage.

• Upgraded jetty to 6.1.18 and turned off jetty web log as default.
• Upgraded H2DB to 1.1.115.
• Improved performance and configurability Agent/Server communication. Go now supports >100 agents.
• Improved performance for configurations with a large number of pipelines and materials defined.
• Go will always use the latest revision for filtered materials once scheduled.

• Fixed the concurrency issue with a large number of pipelines on Current Activity Page.
• Fixed installers on Mac in terms of upgraded package of Mac in June.
• Fixed that Go did not pick up username and password for Subversion repository in some cases.
• Fixed invalid CRC error which might fail artifact uploading.
• Fixed issue that pipeline with multiple materials might not be able to schedule build.
• Fixed issue where agent console logger threads are not always stopped.

• Go watch artifacts disk space and show warning message when it becomes low.
• User tab to manage email notifications, with the ability to match check-ins to users
• Run multiple Go agents on one machine
• Cancelling a stage can run a process to clean up on the agent
• Conditional task execution for jobs
• Support for Git branches and submodules
• Go server warns you when its disk space is running low
• Set environment variables containing the source control revision id when running a task
• We now support SUSE [server|agent] (tested on Linux Enterprise Server 10 SP2).
• We now support Solaris [server|agent] (tested on SunOS Solaris10 5.10).

In the professional edition:

• Ability to group (and secure) similar pipelines
• Pipeline dependencies
• Lock down who can view and operate pipelines
• More than one material per pipeline

• Changes with multiple materials highlights what has actually changed since the previous revision. If you used multiple materials (e.g. more than one source control) in the same pipeline, Go shows the latest revision for each of the materials, even if that is the same as the previous pipeline instance. Go now highlights the changes since the previous pipeline instance.
• You can now define groups of pipelines. This makes it easier to configure and define security on pipelines based on logical grouping for your organization. See change permissions for different actions for more information.
• Go server can now be downloaded as a single jar. For more information see running Go without an install.
• The "Pipelines" tab has been removed. The Pipeline Activity page provides a much better visualizatiion.
• Manual pipelines no longer poll source control. A pipeline with a manual first stage will not check source control until it is manually triggered. This helps reduce the number of requests to source control systems.
• Artifacts to be uploaded can now be specified with wildcards. For more information see uploading test reports.
• Artifacts are now stored on the server in directories named for the pipelines. The directory for a pipeline is "pipelineName/pipelineLabel/stageName/stageCounter/jobName". Artifacts already created will still be accessible in the existing directories, but new pipelines will use the new directory layout, This was done since some operating systems restrict the number of directory entries which can cause errors when building many pipelines.
• Go will now obscure show source control passwords. Go will show passwords as "******" in the UI and in logs. Note that only the logs created by Go itself are obscured. If a tool or script prints out a password then it may appear in the logs.
• Forcing a pipeline will create a new pipeline instance even if there are no changes in the materials. In Cruise 1.2 forcing a pipeline would re-run the existing pipeline if there were no changes in the materials. After feedback from our users we have removed this change. If you do want to re-run an existing pipeline instance you can still do so, by clicking the re-run button on the first stage of that pipeline.
• Upgraded jetty to 6.1.18 with better performance.
• Use the nio selector from jetty to improve SSL performance.
• Licensing has been changed. You will need a new license if you have a paid version. Please go here to see details.

• Fixed the issue of full-checkout on agent side for Perforce.
• Fixed the issue of full-checkout on agent side for when the option of 'checkexternals' is on.
• Manually triggering a pipeline will generate a new pipeline instance even though there is no modification detected. Also it will update to most recent revision, including filtered files.

Cruise 1.2 offers many new features and enhancements in terms of usability and performance.

Support tracking tools to integrate with other management tools.

Go now supports linking to a story / bug tracking tool like Mingle from commit messages in Go. Use the folloing syntax:

<pipeline name="cruise">
    <trackingtool link="http://mingle/projects/cruise/cards/${ID}" regex="#(\d+)"/>
    ...
</pipeline>

Description: Using the regular expression above, if your commit messages contain messages of the form '#2350', you could see the link wherever you can see the commit message.

Set properties from artifact using XPath automatically.

After a job has finished on an agent, Go can parse any XML files on the agent and set properties on the server. You can use this to harvest metrics like code coverage or cyclomatic complexity from your reports into Go, and then export the complete history of your properties from the job detail page to a spreadsheet for custom reporting and analysis. Use the following syntax to tell Go the XML files to parse, the XPath to get the property value, and the property name. The following example extracts useful coverage metrics from EMMA reports..

<job name="test_analysis">
    <properties>
  <property name="coverage.class" src="target/emma/coverage.xml" xpath="substring-before(//report/data/all/coverage[starts-with(@type,'class')]/@value, '%')" />
  <property name="coverage.method" src="target/emma/coverage.xml" xpath="substring-before(//report/data/all/coverage[starts-with(@type,'method')]/@value, '%')" />
  <property name="coverage.block" src="target/emma/coverage.xml" xpath="substring-before(//report/data/all/coverage[starts-with(@type,'block')]/@value, '%')" />
  <property name="coverage.line" src="target/emma/coverage.xml" xpath="substring-before(//report/data/all/coverage[starts-with(@type,'line')]/@value, '%')" />
  </properties>
  ...
</job>

Description: When you specify this configuration, you can see the properties in the sub-tab 'properties' on job detail page, and export their history to a spreadsheet.

Support to access re-run stages.

Although Go has always stored results of re-run stages, you can now access previous runs of a stage easily. We've introduced a 'stage counter' which indexes the runs of the stage.

• The stage history is ordered by time rather than pipeline label in the Stage Detail Page.
• Access any stage details page by the Go API http://[your_cruise_server]:8153/cruise/pipelines/[pipeline_name]/[pipeline_label]/[stage_name]/[stage_counter]

Support multiple repositories for Subversion

Go lets you define multiple repositories in cruise-config.xml if you are using Subversion as you VCS. This means you can easily create pipelines for applications that rely on multiple repositories.

<pipeline name="main">
    <materials>
  <svn url="http://xxx.xxx.xxx/trunk" username="yyyy" password="xxx" dest="client">
  <svn url="http://zzz.zzz.zzz/trunk" username="yyyy" password="xxx" dest="server">
    </materials>
</pipeline>

You can see material revisions for each pipeline in the sub-tab 'materials' on the job detail page and stage details page, and the tooltips as well. Note that this version of Go also treats upstream pipelines as materials, just like source control, which means you can see exactly which version of your upstream pipeline triggered this one (see the screenshot below). Use this syntax to define dependencies between pipelines.

Ability to filter materials

Go allows you to specify files in your version control repository that shouldn't trigger a new build when they change (for example requirements documents). You can specify multiple "ignore" blocks with patterns to match, using ant-like syntax.

The pattern takes the root directory of the SCM repository as the root directory, not the sandbox in the agent side or the materials URL.

For example, the structrure of a subversion repository is following:

The material and changes look like

If we want to ignore files under /trunk/lib/tmp, the configuration is:

    <svn url="http://10.18.3.171:8080/svn/connect4/trunk/lib" username="cce" password="cru1s3" dest="lib">
      <filter>
        <ignore pattern="trunk/lib/tmp/**/*.*" />
      </filter>
    </svn>
    

• Refactored Go API and remove some calls. See the Go API topic for more details.
• Treate the dependency of pipelines as the materials of the pipelines. This means you can see which version of your upstream pipeline triggered the current pipeline anywhere on the UI you see modifications. Your configuration will be upgraded automatically.
• Limit the number of materials of pipelines. Go Free Edition supports only one material, and Enterprise Edition support unlimited materials. The other versions support three materials.
• Go agent no longer bundles Ant as of version 1.2.
• Clean the folders which is not under any 'dest' folders of all mateirial on agents.

• Installing Go server
• Installing Go agent
• Upgrading Go

Cruise 1.1 offers many new features and enhancements in terms of usability and performance.

UI improvements for pipeline activity

The Pipeline Activity tab has an improved user interface.

Better console out information

Go now reports agent actions (such as checking out, or uploading artifacts) in the Go log that can be viewed through the web page. This makes it much easier to debug issues with source control systems and other Go agent actions.

De-authorize agents through UI

The agents can be disabled from the server through the user interface which means that the agent will no longer process any work. Click the Enable button to start builds on the agent again.

• Go no longer bundles SVN - the server and all agents need to have Subversion installed and available in the system path
• Approvals are now at the start of a stage not the end of the stage. This means that it is possible to add a pipeline that will only be run if you manually trigger it (in other words, revision control changes will not automatically trigger it). To do this, add a manual approval to the start of the first stage.

• Installing Go server
• Installing Go agent
• Upgrading Go