Jacksum – a java checksum utility – Introduction and usage


Jacksum, a java checksum utility

Software Name : Jacksum

Website : http://jacksum.net/en/index.html

Version : 1.7.0

Jacksum is a platform independent checksum utility (written entirely in Java) for computing and verifying (integrity check) checksums, CRC and hashes (fingerprints). It supports 58 popular hash algorithms and a lot of unique features.

The Jacksum is a freeware tool and suitable for more advanced users verify checksum values. It is platform independent software (support Windows and Unix) and supports 58 popular standard algorithms (Adler32, BSD sum, Bzip2’s CRC-32, POSIX cksum, CRC-8, CRC-16, CRC-24, CRC-32 (FCS-32), CRC-64, ELF-32, eMule/eDonkey, FCS-16, GOST R 34.11-94, HAS-160, HAVAL (3/4/5 passes, 128/160/192/224/256 bits), MD2, MD4, MD5, MPEG-2’s CRC-32, RIPEMD-128, RIPEMD-160, RIPEMD-256, RIPEMD-320, SHA-0, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, Tiger-128, Tiger-160, Tiger, Tiger2, Tiger Tree Hash, Tiger2 Tree Hash, Unix System V sum, sum8, sum16, sum24, sum32, Whirlpool-0, Whirlpool-1, Whirlpool and xor8).
The Jacksum is written in Java and open source, we can download the source code and try to understand how Jacksum implement the above algorithm.
Use of Jacksum

  • Often time, while we downloading files or software via some secure website, “Checksum” values in MD5 or SHA1 format are provided to protect users from downloading corrupted files or trojan infected files. Unfortunately, many users has no idea how to verify the downloaded file with “Checksum” value, end up in downloading virus or trojan infected files.
  • With Jacksum you can check if a filetransfer was successful. If you download software or huge files, like CD-images (so called iso files) from the internet, often there is a checksum or a hashcode provided. With Jacksum you can calculate such a checksum or hashcode from your local copy. If both checksequences are identical you know that the filetransfer was successful.
  • As Jacksum supports recursively file processing, you can compare two directory trees. Therefore you will be able to verify, if your copies or backups are identical with the original source, even if you don’t have access to both trees at the same time (compare two DVDs with just one drive for example).
  • Jacksum can assist you if you want to perform an unidirectional sync of two directory trees, even if they are on two different computer without a connection in between.
    As Jacksum reads each byte of a file, you can check if all files are still readable on your CD-ROM or DVD.
  • As Jacksum supports a platform independent and compatible file format, it helps you to verify data integrity of burned data on CD-ROMs or DVDs even after many years and even if you will have changed your Operating System.
  • Jacksum can help you to create incremental backups. If you are a developer, Jacksum can help you to create patches for your customers.
  • You can use Jacksum for intrusion detection, because Jacksum can check whether and what files have been changed or deleted on your system. Jacksum can not only check the content of each file you want, but also the file timestamps.
  • Use Jacksum for website content change detection, so get informed if something has changed on your favorite website (can be useful if the website has no announcement-mail-alias).
  • This software is OSI Certified Open Source software
  • It is entirely free software (it runs on free platforms and therefore it is listed also at the Free
  • Software Foundation directory)
  • It is free of charge, it costs nothing
  • It is free of registration (well, I’m happy if you write an e-mail to jonelo@jonelo.de for feedback
  • It never expires
    Requirements:· JRE version 1.3.1 or later


Tagged : / / / / / / / / / / / / / / /

Introduction of RFT(Rational Functional Testing)


Introduction of RFT(Rational Functional Testing)

Functional Tester is available in two integrated development environments and two scripting languages.
Functional Tester, Java™ Scripting uses the Java language and the IBM® Rational® Software Delivery Platform.
Functional Tester, VB.NET Scripting uses the VB.NET language and the Microsoft® Visual Studio .NET development environment.
Use Functional Tester to:

  • Perform full functional testing. Record and play back scripts that navigate through your application and test the state of objects through verification points.
  • Create and edit simple and easy-to-read, object-oriented test scripts. In addition to automatically recording test scripts, Functional Tester contains wizards for generating code, for example, for automatically creating a verification point. Functional Tester’s test scripts are implemented in your choice of Java or VB.NET.

Object Based Testing
The object-oriented recording technology in Functional Tester lets you generate scripts quickly by recording applications against the application-under-test. Functional Tester uses object-oriented technology to identify objects by their internal object properties, not by screen coordinates. If the location or text of an object changes, Functional Tester can still find it on playback.
The object testing technology in Functional Tester enables you to test any object in the application-under-test, including the object’s properties and data. You can test objects in Java, VB.NET, Windows®, and Web-based applications, whether they are visible or hidden in the interface.
When you record a script, Functional Tester automatically creates a test object map for the application-under-test. The Functional Tester test object map lists the test objects available in the application, whether they are currently displayed or not. You can also create a new test object map, either by pasing it on an existing map or by adding objects as required. The object map provides a quick way to add objects to a script. Since the test object map contains recognition properties for each object, you can easily update the recognition information in one central location. Any scripts that use this test object map also share the updated information.

Verification points
During recording you can insert verification points into the script to confirm the state of an object across builds of the application-under-test. The verification point captures object information (based on the type of verification point) and stores it in a baseline data file. The information in this file becomes the baseline of the expected state of the object during subsequent builds. Functional Tester has an object properties verification point and five data verification points (menu hierarchy, table, text, tree hierarchy, and list). You can use the Verification Point Comparator to analyze differences across builds and update the baseline file.

Functional Tester features platform-independent and browser-independent test playback. For example, you can record a script on Windows and play it back on Linux®. You can record a script using Firefox, Mozilla, Internet Explorer or Netscape. Because the script contains no references to the browser used during recording, you can play back the script using any of the supported versions of Firefox, Mozilla, Internet Explorer or Netscape.

Integrated with Rational TestManager
Functional Tester is integrated with Rational TestManager, which enables you to record and play back a Functional Tester script from TestManager and make use of TestManager features, such as the Log. If you have TestManager installed, you can use these integrated features. See Understanding Functional Tester integrations for information.

Integrated with Rational ClearQuest
Functional Tester is also integrated with Rational ClearQuest® Test Manager, which enables you to play back a functional test script from ClearQuest TestManager, generate logs, and track defects. If you have ClearQuest Test Manager installed, you can use these integrated features.

Tagged : / / / / / / / / / / / / / / /

Advance Features of Smart Build Tools


Table of Contents
Agile Development Challenges
Deployment Challenges
Build Acceleration Challenges
Integration with Elastic and Cloud Computing
Workflow Management


Agile Development Challenges

Two of the core principles of agile development are: “deliver working code frequently” and “working software is the primary measure of progress.” More and more teams, from ISVs to enterprise IT groups, are recognizing the quality and productivity benefits of integrating early and often. Whether you want to just build and test more frequently or implement a comprehensive agile process, you’ll need to ensure that your build and test process is:

  • fast
  • automated (not requiring manual intervention)
  • reliable (broken builds are the enemy of an agile approach)

Addressing the build-test-deploy process is one of the best first steps toward an agile development model.

Agile Development  Challenge




http://electric-cloud.com/images/common/spacer.gif http://electric-cloud.com/images/common/spacer.gif http://electric-cloud.com/images/common/spacer.gif
Builds require manual intervention http://electric-cloud.com/images/common/spacer.gif http://electric-cloud.com/images/common/spacer.gif Integrating often will overwhelm a manual build process http://electric-cloud.com/images/common/spacer.gif http://electric-cloud.com/images/common/spacer.gif http://electric-cloud.com/images/common/spacer.gif
Slow build cycle (whether long individual builds or a large number of build targets) http://electric-cloud.com/images/common/spacer.gif http://electric-cloud.com/images/common/spacer.gif Long builds limit the number of iterations possible in a day
Builds longer than ~30 minutes rule out Continuous Integration
http://electric-cloud.com/images/common/spacer.gif http://electric-cloud.com/images/common/spacer.gif http://electric-cloud.com/images/common/spacer.gif
Developers introducing errors during integration or production builds http://electric-cloud.com/images/common/spacer.gif http://electric-cloud.com/images/common/spacer.gif If developers can’t do preflight builds and tests on all targets/platforms prior to check-in, Continuous Integration can turn into Continuously Broken Builds http://electric-cloud.com/images/common/spacer.gif http://electric-cloud.com/images/common/spacer.gif http://electric-cloud.com/images/common/spacer.gif

Deployment Challenges

Deployment of a real world application is a complex, and all-too-often, a manual process. The complexity comes from the fact that the application may need to be deployed to any number of environments: Development (DEV), Quality Assurance (QA), User Acceptance Testing (UAT), Pre-production (STAGE), and Production (PROD). Each of these environments is typically slightly different requiring different accounts, password, and setting and thus it may seem like manual intervention is required.
Complicating matters is the fact that today’s business applications comprise multiple moving parts that all need to be synchronized and deployed together. For example, a typical J2EE application can be made up of an EAR file, database changes, some static content, and environment changes (such as JDBC connection pools, Message Queues, etc.). Making sure that all these pieces get deployed on the correct machines and in the correct order can feel like a daunting task, especially if you need to repeat it for each environment. Keep in mind that each environment may have a different number of database servers, application server, HTTP server, etc.

Build Acceleration Challenges

Slow software build cycles are more than just an annoyance. Whether you have long monolithic builds or a large number of smaller builds that take a long time, they are having a real impact on your development organization.

  • Wasted time, frustration waiting for builds
  • Fixing broken builds delays testing
  • Fewer bugs fixed, fewer features added
  • Developers avoid builds
  • QA may skip tests to meet deadlines

A recent survey of more than 350 development professionals found that 68% reported broken builds at least a few times per month (and often weekly), and fixing those typically wasted 2 weeks per year. The majority said their builds were each more than 1 hour long, with 24% reporting builds of 2-4 hours, which translates to time not spent creating great software.

Integration with Elastic and Cloud Computing

In a large infrastructure with many projects, the CI server often experiences variable task loads with unpredictable load peaks (such as during releases). In an environment with fixed resources, this leads to build queue growths, increased build times, and poor build scheduling control.
Computing clouds such as Amazon EC2 provide a nice and efficient way to scale resources to fulfill variable demands with random load spikes. Such rapid demand growths is exactly what happens in Build Server during CI “rush hours,” when everyone starts personal builds before going home, and also during pre-release days, when every new fix needs another round of unit tests, and build feedback time becomes mission-critical.
Build Server utilizes EC2 via virtual build agents. Virtual build agents are similar to standard ones, except that they run on virtual instances on the Amazon EC2. This means that Build Server is able to dynamically start as many instances of such agents as needed, in order to keep the build queue under control under high loads. Additionally, Build Server can shut down virtual build agents when they are not needed anymore, to minimize EC2 instances uptime.
While being a great solution for mitigating peak loads and maintaining constant build feedback time, Amazon EC2 integration also provides great cost optimization opportunities, as each resource accumulates costs only while in use.

Workflow Management

In recent years, build management solutions have provided even more relief when it comes to automating the build process. Both commercial and open source solutions are available to perform more automated build and workflow processing. Some solutions focus on automating the pre and post steps around the calling of the build scripts, while others go beyond the pre and post build script processing and drive down into streamlining the actual compile and linker calls without much manual scripting.

Tools Comparison


  OpenMake Bamboo AnthillPro TeamCity Electric Cloud
Deployment YES NO YES No YES
Cloud – Elastic NO YES No YES YES
WorkFlow Mgmt YES YES – Limited YES YES – Limited YES, Limited



Tagged : / / / / / / / / / / / / / / / / / / / /

Installation and Configuration Guide: Bamboo


Bamboo is available in two ‘distributions’ — Standalone or EAR-WAR. The Standalone distribution is recommended (even for organisations with an existing application server environment).
Standalone Installation Guide — Windows

Download and Install Bamboo Standalone for Windows (Windows Installer)

·  Download Bamboo Standalone for Windows. Bamboo Standalone for Windows is available for download from the Bamboo Download Center. Choose the Windows Installer (.exe) download.
·  Launch the Bamboo Windows installer (atlassian-bamboo-x.x-standalone.exe) to begin the installation wizard.
·  The installer requires you to specify two directories:
Bamboo installation directory — This is the directory where Bamboo’s application files will be installed. The default is:
C:/Program Files/Bamboo
Bamboo home directory — This is the directory where Bamboo will store its configuration data. If the directory you specify doesn’t exist, Bamboo will create the directory when it launches. The default is:
C:/Documents and Settings//Bamboo-home
Note: You must use forward-slashes in your directory path. Backslashes are not recognised by Bamboo. Please ensure that the Bamboo home directory is not located inside the Bamboo installation directory

Download and Install Bamboo Standalone for Windows (ZIP Archive)

·  Download Bamboo Standalone for Windows. Bamboo Standalone for Windows is available for download from the Bamboo Download Center. Choose the ZIP Archive (.zip) download (click the ‘Show all‘ link to show the ‘ZIP Archive‘ download link).
·  Extract the files from the ZIP Archive (atlassian-bamboo-x.x-standalone.zip) to a Bamboo installation directory of your choice. By default, the root directory in your zip file is named “Bamboo”.
·  Set up your Bamboo home directory — this is the directory where Bamboo will store its root configuration data. To do this, edit the file named bamboo-init.properties in the Bamboo/webapp/WEB-INF/classes directory. In this file, insert the property “bamboo.home”, with an absolute path to your Bamboo home directory. Your file should look something like this:


Alternatively, you can specify an environment variable ‘BAMBOO_HOME’ which specifies the absolute path to your {BAMBOO_HOME} directory. Bamboo will check if an environment variable is defined.
·  If you are going to use Bamboo remote agents, set the following in the bamboo-init.properties file in the /webapp/WEB-INF/classes directory:

  • Replace ‘localhost’ with the real host name or IP address of your Bamboo server.
  • If port number 54663 is already in use, specify a different port number.

Launch Bamboo

Launch via the Start Menu
If you have used the ‘Windows Installer’ to install Bamboo, you can start Bamboo via the Start Menu in Windows (generally under the ‘Bamboo’ folder by default). The following options will be available in your Start Menu:

  • Bamboo Continuous Integration Server Uninstaller‘ — uninstalls Bamboo from your computer
  • Install Service‘ — installs Bamboo as a Windows service (note, this will not start Bamboo)
  • Remove Service‘ — removes the Bamboo Windows service, if you have previously installed it (note, Bamboo will not be uninstalled from your computer)
  • Start in Console‘ — starts Bamboo in a Windows console
  • Start Service‘ — starts your installed Bamboo Windows service
  • Stop Service‘ — stops your installed Bamboo Windows service

You can run Bamboo in two modes, either in a Windows console or as a Windows service:

  • To run Bamboo in a Windows console, click the ‘Start in Console‘ option.
  • To run Bamboo as a Windows service, click the ‘Install service‘ option. After the service is installed, click ‘Start Service‘. Once you have installed Bamboo as a service, Bamboo will start up automatically every time Windows restarts.

Launch via batch file
You can start Bamboo via the batch files that are shipped with Bamboo. If you have installed Bamboo via the ZIP Archive, you will need to use the batch files to start Bamboo. You can find the following batch files in your installation directory:

  • BambooConsole.bat‘ — this starts Bamboo in a Windows console.
  • InstallAsService.bat‘ — this installs Bamboo as a Windows service. Note that this will not start Bamboo.
  • StartBamboo.bat‘ — this starts your installed Bamboo Windows service.
  • StopBamboo.bat‘ — this stops your installed Bamboo Windows service
  • UninstallService.bat‘ — this un-installs the Bamboo Windows service from your machine. Note that your Bamboo installation still remains.

You can run Bamboo in two modes, either in a Windows console or as a Windows service:

  • To run Bamboo in a Windows console, run ‘BambooConsole.bat
  • To run Bamboo as a Windows service, run ‘InstallAsService.bat‘. After the service is installed, run ‘StartBamboo.bat‘. Once you have installed Bamboo as a service, Bamboo will start up automatically every time Windows restarts.

Configure Bamboo

  1. Access your running Bamboo instance by going to your web browser and entering the address: http://localhost:8085/.
  2. Configure Bamboo via the Setup Wizard which will display. Read Running the Setup Wizard for further instructions.

For more details on Installation and Configuration, please review following links

Tagged : / / / / / / / / / / / / / / / / / / / / /

Disadvantages of Bamboo – Bamboo Expert Review


Bamboo Disappointment
Being a big fan of Atlassian’s Confluence and Jira, it was with much anticipation that installed Bamboo, the continuous integration (CI) engine they’ve released. Perhaps these high expectations led to my ultimate disappointment with Bamboo, but truly the features I’ve come to expect in a commercial CI product are nowhere to be found.

No concept of inherited project structure.
If you have 20 modules you would like to build, defining behavior and properties for each is a daunting task. QuickBuild and AntHillPro both allow for a hierarchal organization of modules, so that a child may inherit properties (like environmental variables, build targets, etc) of its parent. In Bamboo, when creating a “Plan”, I can clone an existing module, but that’s it. Should I have the need to change a property for all plans, I’ll be forced to configure each through the web GUI. A tedious process — even with Cruisecontrol I could search & replace config.xml in a text editor to make wholesale changes.

Alien nomenclature
In Bamboo, you have top-level “projects”, and beneath them you have “plans”, which represent the modules being built. I’ve never used the word “plan” before when describing a module’s build, and frankly the limited options offered by Bamboo to govern build behavior makes it a dubious word choice.

No passing of properties
It is sometimes desirable to direct a CI engine to pass arbitrary properties to one’s build process, and vice versa. I don’t mean “static” environmental variables, rather I refer to dynamic properties like “version number”. No such functionality is present in Bamboo. Luntbuild and Quickbuild both allow for this using OGNL expressions.

No concept of build promotion
Most commercial CI products have evolved to include “Application Lifecycle Management”, so you may describe how a build can go from being development-status to gold. Implicit in this is a workflow allowing QA to promote and release builds. None of this is even hinted at in Bamboo — it does not even tag your build.


Tagged : / / / / / / / / / / / / /

Bamboo Vs TeamCity Vs CruiseControl – Continuous Integration Expert Review


Difference between Bamboo Vs TeamCity Vs CruiseControl

  • TC pre-tested commit is good.
  • TC integrates to Visual Studio which is our main IDE.
  • JetBrains are more focused on supporting .NET builds than Atlassian is, since JetBrains actually has .NET products so they use it internally.
  • Support for .Net projects, as well as Java, in the same product (nice if you need it).
  • Server-side code coverage analysis (you could get the same results by running EMMA from the Ant build.xml)
  • Server-side static code analysis using IDEA inspections (nice but relies on using IDEA for development – Checkstyle and FindBugs could do something similar from Ant).
  • Pre-tested commits. Sends your changes to the CI server for building before committing to version control. Your changes are only checked-in if the build succeeds and all tests pass.


  • Bamboo JIRA integration is awesome. I wish TeamCity provides that kind of integration.
  • Bamboo on the other hand looks like a great tool too. It has so many plugins (just like JIRA). It looks nice as well. I can live without VSTD integration, but I really wanted pre-tested commit. Just a note: I did create a feature request ticket to Atlassian telling them about TC’s pre-tested commit feature.


  • “CruiseControl is a framework for a continuous build process.”
  • “Bamboo is a continuous integration build server that offers heaps of insight on build processes and patterns via solid reporting metrics.”
  • “TeamCity is an innovative, IDE independent, integrated team environment targeted for .NET and Java software developers and their managers.”
  • “AnthillPro3 is a third generation Build Management Server.”

Links and Reference:

Tagged : / / / / / / / / / / / / / / / / / / / / / / / / / / /

Bamboo – A Continuous Integration Server – Complete Guide


Bamboo – A Continues Integration Server

Continuous integration (CI) brings faster feedback to your development process, preventing bugs from piling up and reducing the risk of project delays.

Bamboo enables development teams of any size to adopt CI in minutes, easily integrate it with their work day and scale their build farm using elastic resources in the Amazon EC2 cloud.

Continuous integration (CI) brings faster feedback to your development process, preventing bugs from piling up and reducing the risk of project delays.

Bamboo enables development teams of any size to adopt CI in minutes, easily integrate it with their work day and scale their build farm using elastic resources in the Amazon EC2 cloud.

Bamboo makes every stage of continuous integration adoption easy, intuitive and pain-free.

Set up your first CI build in minutes
Integrate/ Collaboration CI with your current tools and workflow
Scale your build farm on-premises or in the cloud!
Analyse and improve your build performance
Extend Bamboo with plugins and the REST API
Full feature list and system requirements

Integrate/ Collaboration

Bamboo lets you pick how and when you’re notified about builds and integrates easily with tools you’re already using, so your team will be able to work together to keep your builds green!

Notifications via email, RSS, IM or IDE pop-up:
With Bamboo each team member can choose how and when to be notified:

Email, RSS, IM or IDE pop-up notifications
Customised email templates (HTML or plain-text)

Choose which builds to be notified about:

All builds for a project
Specific build plans
Every time a build finishes, only when it fails X times, only when it hangs, or only when it times out

Priorities your build queue
When your build agents are busy, Bamboo builds go into a queue.

Need to see the results of a build ASAP? You can:

Escalate builds to the front of the queue with one click.
Stop in-progress builds.
Move lower-priority builds to the back of the line.

Apply labels and comments to build results
Why did a build fail? What did you fix to turn it green again? Which builds have been tested by your QA team? What builds are approved for release to customers? Bamboo let’s you provide content to your builds results using labels and comments.

  • Apply labels and comments via your Web browser, IDE, or Bamboo’s unique 2-way IM system
  • Subscribe to an RSS feed of all build results with certain labels (e.g. “QA_FAILED”, “PATCH”,etc.)

Run and fix builds from Eclipse and IntelliJ
Bamboo integrates with Eclipse and IntelliJ IDEA to bring build management and notification into the IDE:

  • Run, label and comment builds
  • Receive pop-up notifications for builds you care about
  • Quickly identify failing tests and re-run them locally with just one click

Link builds to JIRA issues
Bamboo integrates with JIRA and allows you to easily:

  • View all builds related to an issue
  • View all issues related to a build, and mark them resolved
  • Embed build status and summary gadgets into your JIRA project dashboards

View changes that triggered builds with FishEye
By integrating Bamboo with FishEye, you can quickly see what files were changed to trigger a build and what JIRA issue the changes were made for. Want to see exactly what changed? FishEye diffs are just a click away!

Run Clover Test Optimization and code coverage
Integrate Clover for Java Test Optimization and code coverage, and you’ll instantly get faster builds and better code quality insights!

  • Clover Test Optimization can make your Java unit and functional tests run several times faster
  • View method, branch and statement coverage
  • See when and where coverage drops over time

Display results in Confluence dashboard portlets
Bamboo provides portlets that can easily be embedded on any Confluence page, so you can keep every project stakeholder up to date on project status.

  • See pass/fail status, duration, and number of failed tests for recent runs of a build plan.
  • View the latest status for all builds in a project.

Embed JavaScript widgets in any HTML page
Bamboo provides JavaScript widgets that can be embedded into any HTML page. With just a few lines of code, create custom pages that include:

  • Latest build results
  • Latest changes
  • Last result of all builds in a project
  • Plan summary graphs

Scale Your Build System

As your team runs more and more CI builds, you’ll want to add more computing power to maintain fast feedback on your build and test results.

Bamboo makes scaling your build system a snap with:

  • Remote agents that run on-premises
  • Elastic agents in the Amazon EC2 cloud.

Remote agents

Your Bamboo server can manage dozens of remote agents simultaneously, taking advantage of available computing power to provide the fastest feedback possible. With remote agents you can:

  • Run multiple builds at once to reduce feedback times
  • Test on different platform configurations

Elastic agents

Elastic agents are remote agents that run in the Amazon Elastic Compute Cloud (EC2). By using the cloud, you can instantly scale your build environment as your development cycles ebb and flow and build queues become longer. Bamboo makes it easy to customize and manage your elastic agents:

  • Schedule agents to start and stop based on known peaks and valleys in your need for CI builds.
  • Cut operational costs by taking advantage of EC2’s reserved instance pricing and availability zones.
  • Customise agent images with different operating systems, installed software, and computing power to create the most flexible building and testing system possible.
  • Reduce data transfer and startup times by using Amazon Elastic Block Storage (EBS) for persistence.

Every build agent (remote or local) has specific capabilities that are used to match the requirements of queued builds.

Bamboo’s web interface makes it easy to manage all your agents and view a log of recent activity for each agent.

Analyse and Improve Your Builds

Your team is running builds on every commit, comprehensive performance and functional tests are running every night, and your build farm has been scaled out. Wondering where and how you can make improvements? Bamboo makes it easy to see the performance of your builds and identify trouble spots and possible improvements.

  • Find out why a build failed
  • View build plan performance across time
  • See what’s breaking most so you can investigate
  • Compare several plans
  • Compare team performance and drill into author details

What happened?
When your builds turn red, you want to fix them as fast as possible! Bamboo provides information to your team that makes root-cause analysis easier, so you can turn the build green again ASAP.

  • Full stack traces for compilation failures
  • Full stack traces for test failures
  • Highlighting of newly failed tests
  • Click-through to the failing code from within the IDE

Build plan summaries at a glance
Bamboo’s plan summary view presents a wealth of information about each build plan including:

  • Results of the latest build
  • Historical pass percentage and average build time
  • Result, duration, and number of failed tests for recent builds
  • Duration and failure trends across time

Find your trouble spots
Bamboo identifies problem areas within each build based on its performance history including:

  • Most common failures
  • Tests that take longest to fix
  • Long-running tests

Compare your build plans
Which builds are turning red the most often? Which builds are taking longest to run? Bamboo reports provide useful information within a few clicks, for the exact set of plans you care about. Reports include:

  • Success percentage
  • Duration
  • Activity
  • of tests
  • of failed tests
  • Time to fix failures
  • Clover code coverage

View the CI scorecard
Who’s submitting bullet-proof code? Who’s going to buy beer for breaking the most builds? Bamboo provides insightful reports for:

  • Full Teams: # of builds triggered / failed / fixed
  • Individuals: build history, last 10 triggered / failed / fixed
  • Groups: Success percentage, # of failed / fixed builds

Extend Bamboo

Bamboo works great right out of the box, and it can be extended to fit your exact needs:

  • Install 3rd party plugins from the Atlassian Plugin Exchange to add support for additional SCMs, test tools and more.
  • Create your own Bamboo plugins. Get help from Atlassian and other Bamboo developers in the Bamboo Development Forum and then share your plugins on the Atlassian Plugin Exchange
  • Use Bamboo’s comprehensive REST API to integrate Bamboo with other tools or automate common tasks.

System requirements and supported development tools

CI server and agent operating systems Windows, Linux, Mac OS X

Cloud platforms

Amazon EC2 (Linux, Windows)

SCM repositories

Built-in support: Subversion, CVS, Perforce
Supported via plugin: Git, Github, Mercurial, Clearcase, Accurev, Dimension

Programming languages

All languages supported — Java, C/C++, C#, VB.net, PHP, Ruby, Python, perl, …


Ant, Maven, Maven2, make, NAnt, Visual Studio (devenv, MSBuild), custom command line, shell scripts

Test tools

JUnit, any tool with JUnit XML output including: Selenium, TestNG, NUnit, CppUnit, PHPUnit, PyUnit (plugin), PMD (plugin)

Code coverage tools

Atlassian Clover, Corbertura (Plugin), RCov (Plugin)

Build and agent management

Build configuration
  • Plan to agent capability matching
  • Build artifact management
  • Build notification configuration
  • Bulk editing of multiple plans
  • Build result and artifact expiration

Build triggers

  • Commit-triggered builds
  • Manual builds
  • Scheduled builds
  • Dependency-triggered builds

Build queue management

  • Build-queue re-ordering
  • Hung-build detection
  • Configurable queued build timeouts
  • Elastic agent startup

Build result management

  • Label build results via Web browser, IDE, or 2-way IM
  • Comment build results via Web browser, IDE, or 2-way IM
  • Create a Mylyn task to fix failed builds
  • View the most popular labels, all build results with a label, or all labels applied to a build plan.

Agent configuration

  • local, remote and elastic agents
  • Builder, JDK and custom capabilities

Agent management

  • Agent status monitoring

Build result notifications

RSS feed
  • All builds or all failed builds across all plans
  • All builds or all failed builds of a specific plan
  • All builds with a specific label


  • Customized email templates
  • All results or all failed results for a build plan

Instant message

  • Google Talk, Jabber, other XMPP-based clients
  • All results or all failed for a build plan
  • Commment on build results via IM
  • Label build results via IM

IDE notification

  • Pop-up notifiers
  • Pass/fail icons in status bar

External tool integrations

IDE connectors Eclipse, IntelliJ IDEA


  • View and manage issues related to a build result
  • View all builds related to an issue
  • View builds related to a JIRA project
  • Display JIRA dashboard gadgets for latest build status and build plan summaries


  • View latest result of a build plan
  • View recent results for projects, plans, or authors
  • Charts for recent build duration and test failure count
  • Charts for average build duration and test failure % over time


  • View committed changes that triggered a build
  • One-click diff and change history from Bamboo build results

Other tools

  • JavaScript widgets including latest builds, plan status, and summary graphs

Elastic Bamboo

Elastic agent configuration
  • Amazon Machine Image (AMI) customisation
  • Elastic Block Storage (EBS) persistence

Elastic Agent Management

  • Web browser and SSH management
  • Start agents from build queue
  • Agent scheduling
  • Agent usage tracking

Build analysis and reporting

Build plan reports
  • Duration, failed tests for recent builds
  • % Successful builds, average build duration over time
  • Test statistics per plan
  • Individual test history
  • Clover — code coverage per plan
  • Clover — lines of code per plan
  • Avg. time to fix builds

Author reports

  • Build statistics per author
  • Build results per author
  • Activity, failures, fixes per author

Security and user management

  • Single sign-on with Atlassian Crowd
  • LDAP integration

Permissions and access control

  • User and group definitions and permissions
  • Anonymous user permissions
  • Plan-level permissions

Extending Bamboo

  • Bamboo plugin framework
  • Dozens of 3rd party plugins available for download




Bamboo: getting Started
Jira and Bamboo

Tagged : / / / / / / / / / / / / / / / / / / / / / /