Using the Koji build system
Using Koji in Fedora
The Koji Build System is Fedora’s RPM buildsystem.
Packagers use the koji client to request package builds
and get information about the buildsystem.
Koji runs on top of Mock to build RPM packages for specific architectures
and ensure that they build correctly.
You can use the koji command directly, or use fedpkg,
a script that interacts with the RPM Packaging system and other subsystems,
like git and koji itself.
Installing Koji
Follow Installing Packager Tools.
Koji Config
The global-local client configuration file for koji is /etc/koji.conf.
You should not need to change this from the defaults
for building Fedora packages.
These allow you to use the primary build system
as well as secondary arch build systems.
Building with fedpkg targets
When building with fedpkg within a git repository,
every push is automatically tagged via git.
All you have to do to build the package is to run fedpkg build.
This triggers a build request for the branch.
Easy!
It is also possible to target a specific koji tag:
fedpkg build --target TARGET
For example,
if building on rawhide
against a side-tag for updating API for many packages,
such as f43-python,
use the following:
fedpkg build --target 'f43-python'
Chained builds
Sometimes you want to make sure
that one build has succeeded before launching the next one,
for example when you want to rebuild a package
against a dependency that has just been rebuilt.
fedpkg provides a chain-build command to help with this.
As explained in the Package Update Guide,
multi-build chains like this should be created on a side tag,
and you can use fedpkg chain-build to do the builds on the side tag.
To do a chained build to a side tag, first create the side tag, as explained in the Package Update Guide. In the simplest case, just do:
fedpkg request-side-tag
This will print a command you can use to wait for the side tag to be created. Run that command, and when it exits, do:
fedpkg chain-build --target=side-tag-name libwidget libgizmo
replacing side-tag-name with the actual name of your side tag.
The current package is added to the end of the CHAIN list.
Colons (:) can be used in the CHAIN parameter to define groups of packages.
Packages in any single group will be built in parallel
and all packages in a group must build successfully
and populate the repository
before the next group will begin building.
For example:
fedpkg chain-build --target=side-tag-name libwidget libaselib : libgizmo :
causes libwidget and libaselib to be built in parallel,
followed by libgizmo,
and then the package in your current directory.
If no groups are defined,
packages will be built sequentially.
If a build fails, following builds are canceled, but the builds that already succeeded are pushed to the repository.
Note: It is possible to do a chained build directly to the default build target for Rawhide, but this is no longer recommended or reliable. Building for the default Rawhide target immediately auto-creates an update, and some Rawhide updates are now subject to gating tests. If any package in the chain is subject to gating tests, and one fails, that package will never reach stable and the rest of the chain will not be able to build. This is quite likely to happen to chains containing critical path packages. When using a side tag, no updates will be automatically created, and each build is immediately available in the side tag’s buildroot without having to pass tests first. You can manually create the update once all the builds are done, and the tests will not encounter dependency issues if you rebuilt all the dependent packages correctly.
Scratch Builds
Sometimes it is useful to be able to build a package against the buildroot without actually including it in the release. This is called a scratch build.
The following section covers using koji directly, as well as the fedpkg tool, to do scratch builds.
To create a scratch build from changes you haven’t committed, do the following:
fedpkg scratch-build --srpm
From the latest git commit:
koji build --scratch rawhide 'git url'
If you have committed the changes to git
and you are in the current branch,
you can do a scratch build with fedpkg,
which wraps the koji command line tool with the appropriate options:
fedpkg scratch-build
To run a scratch build for a specific architecture:
fedpkg scratch-build --arches <archs>
<archs> can be a comma separated list of several architectures.
Finally, it is possible to combine the scratch-build command with a specific koji tag in the form:
fedpkg scratch-build --target TARGET
Run fedpkg scratch-build --help or koji build --help for more information.
Build Failures
If your package fails to build, you get an error, for example:
420066 buildArch kernel-2.6.18-1.2739.10.9.el9.jjf.215394.2.src.rpm, ia64): open (build-1.example.com) -> FAILED: BuildrootError: error building package (arch ia64), mock exited with status 10
Investigate why the build failed by looking at the log files.
If there is a build.log, start there.
Otherwise, look at init.log.
Each job you successfully start gets a unique task ID, which is listed in its output.
Logs can be found in the web interface,
in the Task pages for the failed task.
Alternatively, use koji watch-log, along with the task ID,
to view the logs.
See the help output for more details.
Advanced use of Koji
We’ve tried to make Koji self-documenting wherever possible.
The command line tool prints a list of valid commands,
and each command supports --help. For example:
$ koji help Koji commands are: build Build a package from source cancel-task Cancel a task help List available commands latest-build Print the latest rpms for a tag latest-pkg Print the latest builds for a tag [...]
$ koji build --help usage: koji build [options] tag URL (Specify the --help global option for a list of other help options) options: -h, --help show this help message and exit --skip-tag Do not attempt to tag package --scratch Perform a scratch build --nowait Don't wait on the build [...]
Using koji to generate a mock config to replicate a buildroot
koji can be used to replicate a build root for local debugging.
koji mock-config --help
Usage: koji mock-config [options] name
(Specify the --help global option for a list of other help options)
Options:
-h, --help show this help message and exit
--arch=ARCH Specify the arch
--tag=TAG Create a mock config for a tag
--task=TASK Duplicate the mock config of a previous task
--buildroot=BUILDROOT
Duplicate the mock config for the specified buildroot
id
--mockdir=DIR Specify mockdir
--topdir=DIR Specify topdir
--topurl=URL url under which Koji files are accessible
--distribution=DISTRIBUTION
Change the distribution macro
-o FILE Output to a file
For example to get the latest buildroot for f42-build run:
koji mock-config --tag f42-build --arch=x86_64 --topurl=https://kojipkgs.fedoraproject.org/ f42
You must pass --topurl=https://kojipkgs.fedoraproject.org/ to any mock-config command
to get a working mock-config from Fedora’s koji.
Using Koji to control tasks
List tasks:
koji list-tasks
List only tasks requested by you:
koji list-tasks --mine
requeue an already-processed task (general syntax is: koji resubmit [options] taskID):
koji resubmit 3
Building a Package with the command-line tool
Instead of using the fedpkg target,
you can also directly use the command line tool, koji.
To build a package, the syntax is:
koji build <build target> <git URL>
For example:
koji build f42-candidate 'git url'
The koji build command creates a build task in Koji.
By default, the tool will wait and print status updates until the build completes.
You can override this with the --nowait option.
| For fedora koji, the git url MUST be based on pkgs.fedoraproject.org. Other arbitrary git repos cannot be used for builds. |
Koji tags and packages organization
Terminology
In Koji, it is sometimes necessary to distinguish between a package in general, a specific build of a package, and the various rpm files created by a build. When precision is needed, these terms should be interpreted as follows:
-
Package: The name of a source rpm. This refers to the package in general and not any particular build or subpackage. For example: kernel, glibc, etc.
-
Build: A particular build of a package. This refers to the entire build: all arches and subpackages. For example: kernel-2.6.9-34.EL, glibc-2.3.4-2.19.
-
RPM: A particular rpm. A specific arch and subpackage of a build. For example: kernel-2.6.9-34.EL.x86_64, kernel-devel-2.6.9-34.EL.s390, glibc-2.3.4-2.19.i686, glibc-common-2.3.4-2.19.ia64
Tags and targets
Koji organizes packages using tags. In Koji a tag is roughly a collection of packages:
-
Tags support inheritance
-
Each tag has its own list of valid packages (inheritable)
-
Package ownership can be set per-tag (inheritable)
-
When you build you specify a target rather than a tag
A build target specifies where a package should be built and how it should be tagged afterward. This allows target names to remain fixed as tags change through releases.
Koji commands for tags
Targets
You can get a full list of build targets with the following command:
$ koji list-targets
You can see just a single target with the --name option:
$ koji list-targets --name f42 Name Buildroot Destination --------------------------------------------------------------------------------------------- f42 f42-build f42-updates-candidate
This tells you a build for target f42
will use a buildroot with packages from the f42-build tag
and tag the resulting packages as f42-updates-candidate.
You probably do not want to build against rawhide.
If Fedora N is the latest one out,
to build to the next one, choose f\{N+1}.
Packages
As mentioned above,
each tag has its own list of packages that may be placed in the tag.
To see that list for a tag, use the list-pkgs command:
$ koji list-pkgs --tag f42
The first column is the name of the package, the second tells you which tag the package entry has been inherited from, and the third tells you the owner of the package.
Want to help? Learn how to contribute to Fedora Docs ›