You may want to trigger a Plan build when another Plan's build has successfully completed. This ensures that changes to any Job's source code associated with one Plan does not break the build of another dependent Plan (known in this context as a 'child' Plan). For example, there could be two Plans in Bamboo: Acme – Core — which contains the core code for an application. Acme – Plugin — which contains code for a plugin to the application. In this scenario, the Acme – Plugin Plan is a child of Acme – Core. Any changes to source code associated with the Acme – Core Plan should trigger a build of Acme – Plugin. In turn, every time a Acme – Plugin Plan build completes successfully, you may want to run builds for some additional Plans (e.g Acme – Functional Tests and Acme – Unit Tests). In this case, Acme – Plugin is a parent of the Acme – Functional Tests and Acme – Unit Tests Plans, as well as being a child of the Acme – Core Plan. On this page:

Build Dependencies

To trigger a build when another build finishes:

1. Click 'Home' to go to the Dashboard.
2. Click the 'All Plans' tab.
3. Locate the plan in the list and click the 'Edit' icon to display the Plan's Configuration pages.
4. Click the 'Dependencies' tab. Any dependencies that currently exist for this Plan are displayed on this page, as follows:
   • Automatic Dependency Management section — Select the Automatic Dependency Management check box if you want Bamboo to automatically establish this Plan's build dependencies based on the dependencies defined in the pom.xml file of one of its Jobs. Please see the Notes below.
     • In the Dependency provider field, select the appropriate Job of this Plan whose pom.xml you want Bamboo to base the Plan's build dependencies on. Only Jobs which use a Maven 2 builder are displayed in this field.
   • Manual Dependency Management section — All Plans in your Bamboo system (other than the one you are configuring) are listed in two 'Parent plans' and 'Child plans' sections (see screenshot below). Select the check boxes of the Plans in the following subsections:
     • Child plans — Plans whose builds you want triggered as a result of successful completion of the Plan you are configuring.
     • Parent plans — Plans whose successful completion will trigger a build of the Plan you are configuring. Any other Plans in your Bamboo system that specify build dependencies, with the Plan you are configuring, will have their check boxes selected.
   • Dependency Blocking Strategy section — Select the dependency blocking strategy that you want to apply to this build. For more information, see Dependency Blocking Strategies. Please note, dependency blocking only works when the Plan uses a build strategy based on source code updates.
5. Click the 'Save' button.

Screenshot above: Plan Configuration — Dependencies

Notes

• If you choose 'Automatic Dependency Management', please note:
  • Maven 2 will parse your pom.xml after the Job's initial build and generate the dependencies.
  • You may not need to specify any further build dependency options in the Manual Dependency Management section.
  • This feature is not applicable, nor available if you are using Maven 1.
• Build Dependencies and Build Strategies —

  Build dependencies work together with the build strategies of Plans to trigger builds of these Plans. For example, you can set up Plan A to poll its repository for changes as well as configure a build dependency on a parent Plan (Plan B). In such a case, builds of Plan A will be triggered when code changes are detected in its repository as well as when builds of Plan B complete successfully. If you want your builds to only be triggered by successful parent builds from your build dependencies, you can do this by specifying Manual & dependent builds only as the build strategy for your plan. See Triggering a Plan Build Manually.

• Tips for Setting Up Dependent Builds — Please take note of the following information when setting up dependent builds:
  • Take care not to create circular dependencies, where your child build triggers one of its parent builds. Otherwise your plans may build continuously.
  • See Triggering a Plan Build Manually.
  • If the child build uses the same source as the parent build (e.g. the Subversion URL is the same), the child build will be forced to check out the same revision of source code as the parent build. This ensures that builds are consistent when triggering one build from another.