All the release management for packages is done with the LCFG
release tool - lcfg-reltool
. This tool supports a number
of sub-commands each with different specific options.
To get the list of supported commands you can run the tool with no command-line options:
[finlaggan]squinney: lcfg-reltool lcfg-reltool helpAvailable commands: commands: list the application's commands help: display a command's help screen checkmacros: Check for correct macro usage devosxpkg: Build MacOSX packages from the development source tree devpack: Package the development source tree devrpm: Build binary RPMS from the development source tree majorversion: Tag the source tree as a particular major release microversion: Tag the source tree as a particular release minorversion: Tag the source tree as a particular minor release osxpkg: Build MacOSX packages from the tagged source tree pack: Package the tagged source tree rpm: Build binary RPMS from the tagged source tree srpm: Build binary RPMS from the tagged source tree
To get help regarding the options for a particular command you just need to use the help command, for example:
$ lcfg-reltool help major lcfg-reltoollcfg-reltool majorversion [long options...] --checkcommitted Check for uncommitted changes --logname The VCS log file name --genchangelog Generate the change log from the VCS log --quiet Less output to the screen --dryrun Simulate operation --dir Project working directory
For convenience, you can always use the shortest unique name to refer to a command. So you can use "major" instead of "majorversion", in fact you could even use "ma"
All commands support the following three options:
As with the commands you can use the shortest unique name for each
option. So, "dryrun" could become "dry". Note
though that single-dash versions of the options (e.g. -q
for --quiet
) are NOT currently supported.
There are three ways in which you can tag a new release of your code. Which you use depends on the significance of the changes you have made, particularly whether any APIs have been modified. The three commands are: majorversion, minorversion and microversion.
LCFG projects always have a version string composed of 3 parts which are joined with periods, e.g. 1.2.3. The first part (the 1) is the major version, the second part (the 2) is the minor version and the third part (the 3) is the micro version (sometimes referred to as the release but that is confusing as it is not related to the RPM release field).
It is entirely up to you how you alter the version of a package when you make a new release. Each tool works in the same way though by incrementing the associated field and resetting any smaller fields back to zero. For example, after a minor release the version string 1.2.3 would become 1.3.0 and after a major release the same initial version string would be 2.0.0. After an update of the micro part (using the microversion command) 1.2.3 would become 1.2.4
All three commands support the same options:
The checkcommitted and genchangelog options can
also be negated to temporarily turn-off settings in the LCFG build
metadata. This is done by using --no-checkcommitted
and
--no-genchangelog
on the command line.
lcfg-reltool micro lcfg-reltool major --dir ~/dice/lcfg-foo
Traditionally LCFG software authors did not want to explicitly pack the source for a project as this will happen anyway as a by-product of generating binary RPMs. The aim of the new build tools is to generate source tar files and SRPMs which are platform-independent. From these source packages we can then generate the binary packages on any target platform. Most likely this building of binary packages will happen inside a chroot (using something like mock or koji on Fedora and RHEL/SL).
If you want to just generate a tar file of the source you can use
the commands devpack and pack. If you also want to
generate an SRPM you can use the srpm command. Alternatively,
another way in which to generate just the SRPM is to pass the
--sourceonly
option to the devrpm or
rpm commands, see below for full details of those two
commands.
Source packaging can be carried out in two ways. The first works on the current "devel" tree which can contain changes which have not yet been tagged as a new release. This is done with the devpack command. The files may have been committed into the version-control system or they may contain uncommitted changes (depending on the setting of the checkcommitted option, of course). However, you MUST have actually added the file or directory to the version-control system for it to be put into the source package. When creating a devel package the version gets the string "_dev" appended if it is not already present.
The second approach generates the source package from the tagged release which matches the version in the LCFG build metadata. This is done with the pack or srpm commands. It exports the tagged version of the source tree from the version-control system repository. In the case of the srpm command you will get an SRPM, which contains the tar file and RPM spec file as well as the source tar file separately.
The following options are supported:
$HOME/lcfgbuild
The gencmake and translate options can be negated
to turn off the settings from the LCFG build metadata. For example,
--no-gencmake
stops the system generating CMake files.
Inside the results directory (which is usually
$HOME/lcfgbuild
) the release tools will create a
sub-directory for the specific version of the package being
built. Within this sub-directory the various generated products (the
source tar file, the specfile, the SRPM, etc.) will be stored. For
example, using the following command:
lcfg-reltool pack --dir dice/lcfg-file
produces a directory named
$HOME/lcfgbuild/lcfg-file-1.1.16/
which contains:
$ ls lcfgbuild/lcfg-file-1.1.16/ lcfg-file-1.1.16.spec lcfg-file-1.1.16.tar.gz
If you had used the srpm command it would have also
contained lcfg-file-1.1.16-1.src.rpm
.
The generated products are put into a directory like this rather
than using the same tree as the rpmbuild
command because
the intention is to produce build files (and output) for many
different platforms.
Currently it is only possible to build binary RPMs, the aim is to also provide support for generating MacOSX packages and Solaris packages. Primarily these commands are intended as a convenient option for authors who want to install and test a package after they have just made some changes. The idea is that on whichever platform an author chooses to develop software the LCFG release tools will be used to generate source packages and a set of files for each supported platform which control the actual build process. The design is very much geared towards the process of going from a tagged release to a binary package become two-stages. This encourages good separation of concerns and should result in higher quality software which can be easily ported to other platforms.
There are currently two commands for building binary packages. These are rpm and devrpm, they inherit from pack and devpack respectively. These commands support all the options used in the source packaging process. They also support the following additional options:
Note that if you need to generate an SRPM from a development tree
then currently the only way to do this is using the devrpm
command along with the --sourceonly
option.
Sometimes when you are building a package quickly just to test the
installation you know that not all build dependencies are
satisfied. If you are certain this will not affect the successful
building of the application (maybe they are just for some tests which
are actually optional) you can override the dependency checking with
--no-deps
.
As with the source packaging stage, the results from these commands
will be put into $HOME/lcfgbuild
in a directory for the
version of the package built. If you have built RPMs they will also be
in the directory hierarchy used by rpmbuild
, this is a
side-effect of using that tool to build binary packages.
lcfg-reltool devrpm --no-deps lcfg-reltool rpm --dir ~/lcfg/lcfg-foo --resultsdir /tmp/squinney