This topic describes a typical Jazz™ Team
Build setup
and illustrates the relationships between builds and roles.
Jazz Team
Build setup
example
The following steps describe how to set up and run
a typical
Jazz Team
Build:
- The team's release engineer installs the Jazz Build Engine and
Ant toolkit on the build machine. The engine and toolkit are clients
of the Jazz Team Server.
No service needs to run on the build machine.
- The release engineer creates a corresponding build engine in the Jazz repository.
The engineer specifies which build definitions are supported by the
build engine.
- The release engineer creates build definitions in the Jazz repository and
a build script for each build definition. Typically, a build script
is a versioned artifact under Rational Team Concert™ source
control.
A
build definition can use a schedule to run a build. For example, you
can set up a build to run at a continuous time interval and, optionally,
choose to build or not based on source code changes in the Jazz repository.
You can also set up a build to run at a specific time each day. Build
tasks vary among projects. In addition to compiling source code and
packaging the corresponding content into an appropriate executable
form, a build can include other steps, such as running automated tests
or running code quality tools over the code base.
- The release engineer starts the Jazz Build Engine on
the build machine. The build engine polls the Jazz Team Server for
build requests.
- The build engine retrieves a request to run a build. The build
request identifies the build definition and can include property settings
that override the default settings. The build definition communicates
to the build engine which script to run. Each build definition has
an associated build script, which is typically a versioned artifact
under Rational Team Concert source
control.
- The build engine runs the build script.
- The build script runs Ant tasks that communicate with the Jazz Team Server to
fetch source files to compile from a stream or workspace, report progress,
and create the build output, including artifacts, logs, and links.
The build outputs are stored in the repository, so that developers
can view the logs and download the build artifacts.
Builds and roles
The following figure illustrates
the relationships between builds and two roles:
- Release engineer, who creates build engines and build definitions
- Developer, who runs the defined builds, monitors build progress,
and examines build results

The figure illustrates the primary roles
and facilities involved in setting up and running builds. The table
below describes the roles and facilities.
Release Engineer
|
- Sets up the build engine and build definitions for developers
to use
- Sets up build engines on build machines that access the Jazz Team Server
- Creates build engine objects in the repository to correspond to
the physical build machines
- Creates build definitions in the repository
- During operations, monitors build engines and build execution
|
Developer
|
- Runs and monitors builds that are set up in the repository
- Requests a build
- Monitors build status
- Views build results
|
Jazz Team Server and
repository
|
- Collects build requests, hands requests out to build machines
that poll for requests, and manages results
- Receives and stores build requests from developers
- Receives status reports from build engines during build execution
- Stores build execution results returned from the build engines
|
Build engines
|
- Perform builds dispatched from the Jazz Team Server
- Poll Jazz Team Server for
build requests
- Run build scripts
- Report build status and results to the Jazz Team Server
|