AutoQA Release Process

This page describes the process for tagging, building and deploying a new version of autoqa. This page assumes a basic understanding of rpm spec file syntax and commands such as git, mock and yum.

Numbering scheme

Each release has X.Y.Z identification denoting a major, a minor and a revision number:

• Major number is increased when AutoQA makes incompatible changes in its test API. (Not used currently, since no stable public API has been offered yet.)
• Minor number is increased when AutoQA adds new features.
• Revision number is increased when AutoQA adds new hotfixes, but no new features.

Pre-requisites

You must have AutoQA source code checked out with write access (ssh:// protocol, requires gitautoqa membership):

git clone ssh://git.fedorahosted.org/git/autoqa.git
cd autoqa

Switch Git branch

All the changes must be done in a correct git branch.

• If you want to create a new X.Y.0 major or minor release, create a new release branch:

  git checkout -b release-X.Y master

• If you want to create a new revision release X.Y.Z, switch to a corresponding existing release branch:

  git checkout release-X.Y

  and apply all hotfixes you have prepared.

Update autoqa.spec

Every new release must be mentioned in the rpm spec file.

1. Edit autoqa.spec by incrementing the Version and updating the %changelog
2. Locally commit the changes

   git commit autoqa.spec

Tag the release

The last commit (changing the autoqa.spec file) must be tagged to mark the release.

1. Tag the commit:

   git tag vX.Y.Z

2. Check that the tag was applied to the correct commit by inspecting:

   git log --decorate=full

Cherry-pick to master

After you tag the release on the release branch, you will want to cherry-pick the autoqa.spec change (now tagged with vX.Y.Z tag) into the master branch.

1. Change to the master branch

   git checkout master

2. Cherry-pick the updated autoqa.spec change

   git cherry-pick vX.Y.Z

Push changes to remote repository

It's time now to push all the changes to the shared remote origin repository.

1. Push the release branch changes:

   git push --tags origin release-X.Y

2. If you modified the master branch (i.e. for major or minor releases), push it too:

   git push --tags origin master

Upload tarball

Like many projects, the appropriate method to release a new version is by tarball. Once you have tagged the release, upload a new tarball using the following commands.

1. Check-out the correct tag

   git checkout vX.Y.Z

2. Upload a new release tarball

   make upload

Build a source RPM

With the tarball uploaded, it's time to package the new release as an RPM.

1. Check-out the correct tag

   git checkout vX.Y.Z

2. Build a source package

   make srpm

Build for applicable releases

With a source RPM created, it's time to build updated packages for any existing stable repositories. This includes Fedora 40, Fedora 39 and, depending on the time of release, potentially Fedora 38. Traditionally, this step would be handled by running the koji build --tag dist-f40-updates path/to/src.rpm command. However, since autoqa is not yet packaged and available in Fedora repositories, updates are built locally using mock.

Update your mock configuration
You will need to update the mock configuration files in /etc/mock so that the autoqa package repositories are included. Information on autoqa package repositories is available at Install_and_configure_AutoQA.

1. Build packages using mock for Fedora, specify version using RELEASEVER variable

   make mock-fedora RELEASEVER=40 

2. Repeat the build procedure for all desired releases

Building for EPEL-5?
Due to changes in the filedigest algorithm, extra care is required when creating packages for EPEL-5. Be sure to set the _source_filedigest_algorithm and _binary_filedigest_algorithm for any packages used when building for EPEL-5. For convenience, a Makefile target is available to create EPEL-5 compatible packages.

make mock-epel RELEASEVER=5

Create updates

With packages built, it's time to submit them as updates. Traditionally, this step would be handled by using the bodhi update tool. However, since autoqa is not yet packaged and available in official Fedora repositories, a custom package repository is used to deliver updates.

1. Mirror the autoqa package repository locally

   rsync -avz fedorapeople.org:/srv/repos/fedora-qa/autoqa ~/public_html/ ; cd autoqa/

2. Add locally built packages to the desired repositories

   ./move-pkgs.sh path/to/autoqa.git/rpm-build/MOCK/*/*.rpm

   

   Simulating the updates-testing repository
   For pre-release or testing packages an alternative repository is available to mimic the official updates-testing Fedora repository. To submit packages into the fedora-autoqa-testing repository, add the command-line option -r testing. A complete example is included below.

   ./move-pkgs.sh -r testing path/to/autoqa.git/rpm-build/MOCK/*/*.rpm

3. Update the yum repo metadata

   ./update-repos.sh

4. Update remote repository with changes

    rsync -avz ~/public_html/autoqa fedorapeople.org:/srv/repos/fedora-qa/

Cleanup tasks

Purging old release branches

If we are sure we will no longer work on older releases (e.g. before X.Y), we can also delete older release branches. If W < Y, then we can delete release-X.W:

1. Make sure there's a tag at the tip of the branch and therefore no work is lost:

   git tag --contains release-X.W

   This must output some tag (like vX.W.3). Otherwise the branch contains commits which are not part of any tag.
2. Delete the local branch:

   git branch -D release-X.W

3. Delete the remote branch:

   git push origin :release-X.W

The same goes for deleting older major branches (branches release-Q.Y where Q < X).