Zuul jobs are implemented as Ansible playbooks. Zuul prepares the
repositories used for a job, installs any required Ansible roles, and
then executes the job’s playbooks. Any setup or artifact collection
required is the responsibility of the job itself. While this flexible
arrangement allows for almost any kind of job to be run by Zuul,
batteries are included. Zuul has a standard library of jobs upon
which to build.

Before starting each job, the Zuul executor creates a directory to
hold all of the content related to the job. This includes some
directories which are used by Zuul to configure and run Ansible and
may not be accessible, as well as a directory tree, under work/,
that is readable and writable by the job. The hierarchy is:

work/

The working directory of the job.

work/src/

Contains the prepared git repositories for the job.

work/logs/

Where the Ansible log for the job is written; your job
may place other logs here as well.

The git repositories in work/src contain the repositories for all
of the projects specified in the required-projects section of the
job, plus the project associated with the queue item if it isn’t
already in that list. In the case of a proposed change, that change
and all of the changes ahead of it in the pipeline queue will already
be merged into their respective repositories and target branches. The
change’s project will have the change’s branch checked out, as will
all of the other projects, if that branch exists (otherwise, a
fallback or default branch will be used). If your job needs to
operate on multiple branches, simply checkout the appropriate branches
of these git repos to ensure that the job results reflect the proposed
future state that Zuul is testing, and all dependencies are present.
Do not use any git remotes; the local repositories are guaranteed to
be up to date.

The repositories will be placed on the filesystem in directories
corresponding with the canonical hostname of their source connection.
For example:

work/src/git.example.com/project1work/src/github.com/project2

Is the layout that would be present for a job which included project1
from the connection associated to git.example.com and project2 from
GitHub. This helps avoid collisions between projects with the same
name, and some language environments, such as Go, expect repositories
in this format.

Note that these git repositories are located on the executor; in order
to be useful to most kinds of jobs, they will need to be present on
the test nodes. The base job in the standard library (see
zuul-base-jobs documentation for details) contains a
pre-playbook which copies the repositories to all of the job’s nodes.
It is recommended to always inherit from this base job to ensure that
behavior.

There are several sources of variables which are available to Ansible:
variables defined in jobs, secrets, and site-wide variables. The
order of precedence is:

Site-wide variables

Secrets

Job variables

Parent job results

Meaning that a site-wide variable with the same name as any other will
override its value, and similarly, secrets override job variables of
the same name which override data returned from parent jobs. Each of
the sources is described below.

Any variables specified in the job definition (using the
job.vars attribute) are available as Ansible host variables.
They are added to the vars section of the inventory file under the
all hosts group, so they are available to all hosts. Simply refer
to them by the name specified in the job’s vars section.

Secrets also appear as variables available to Ansible.
Unlike job variables, these are not added to the inventory file (so
that the inventory file may be kept for debugging purposes without
revealing secrets). But they are still available to Ansible as normal
variables. Because secrets are groups of variables, they will appear
as a dictionary structure in templates, with the dictionary itself
being the name of the secret, and its members the individual items in
the secret. For example, a secret defined as:

-secret:name:credentialsdata:username:foopassword:bar

Might be used in a template as:

{{credentials.username}}{{credentials.password}}

Secrets are only available to playbooks associated with the job
definition which uses the secret; they are not available to playbooks
associated with child jobs or job variants.

Zuul supplies not only the variables specified by the job definition
to Ansible, but also some variables from Zuul itself.

When a pipeline is triggered by an action, it enqueues items which may
vary based on the pipeline’s configuration. For example, when a new
change is created, that change may be enqueued into the pipeline,
while a tag may be enqueued into the pipeline when it is pushed.

Information about these items is available to jobs. All of the items
enqueued in a pipeline are git references, and therefore share some
attributes in common. But other attributes may vary based on the type
of item.

The UUID of the build. A build is a single execution of a job.
When an item is enqueued into a pipeline, this usually results
in one build of each job configured for that item’s project.
However, items may be re-enqueued in which case another build
may run. In dependent pipelines, the same job may run multiple
times for the same item as circumstances change ahead in the
queue. Each time a job is run, for whatever reason, it is
acompanied with a new unique id.

The build set UUID. When Zuul runs jobs for an item, the
collection of those jobs is known as a buildset. If the
configuration of items ahead in a dependent pipeline changes,
Zuul creates a new buildset and restarts all of the jobs.

A dictionary of all projects prepared by Zuul for the item. It
includes, at least, the item’s own project. It also includes
the projects of any items this item depends on, as well as the
projects that appear in job.required-projects.

This is a dictionary of dictionaries. Each value has a key of
the canonical_name, then each entry consists of:

A change to the repository. Most often, this will be a git reference
which has not yet been merged into the repository (e.g., a gerrit
change or a GitHub pull request). The following additional variables
are available:

This represents a branch tip. This item may have been enqueued
because the branch was updated (via a change having merged, or a
direct push). Or it may have been enqueued by a timer for the purpose
of verifying the current condition of the branch. The following
additional variables are available:

This represents a git reference that is neither a change, branch, or
tag. Note that all items include a ref attribute which may be used
to identify the ref. The following additional variables are
available:

zuul.oldrev

If the item was enqueued as the result of a ref being deleted,
the previous git sha of the ref will be included here. If the
ref was created, this variable will be undefined.

zuul.newrev

If the item was enqueued as the result of a ref being created,
the new git sha of the ref will be included here. If the ref
was deleted, this variable will be undefined.

The Zuul administrator may define variables which will be available to
all jobs running in the system. These are statically defined and may
not be altered by jobs. See the Administrator’s Guide for information on how a site
administrator may define these variables.

Zuul starts each job with an SSH agent running and the key used to
access the job’s nodes added to that agent. Generally you won’t need
to be aware of this since Ansible will use this when performing any
tasks on remote nodes. However, under some circumstances you may want
to interact with the agent. For example, you may wish to add a key
provided as a secret to the job in order to access a specific host, or
you may want to, in a pre-playbook, replace the key used to log into
the assigned nodes in order to further protect it from being abused by
untrusted job content.

A job may return some values to Zuul to affect its behavior and for
use by other jobs.. To return a value, use the zuul_return
Ansible module in a job playbook running on the executor ‘localhost’ node.
For example:

tasks:-zuul_return:data:foo:bar

Will return the dictionary {'foo':'bar'} to Zuul.

To set the log URL for a build, use zuul_return to set the
zuul.log_url value. For example:

Any values other than those in the zuul hierarchy will be supplied
as Ansible variables to child jobs. These variables have less
precedence than any other type of variable in Zuul, so be sure their
names are not shared by any job variables. If more than one parent
job returns the same variable, the value from the later job in the job
graph will take precedence.