RPM Building Hints

PM is a popular tool for software distribution and installation on Linux (or GNU/Linux as Richard Stallman prefers it, with some justification). It took me a while (and help from others) to understand how to create an rpm without becoming root (superuser). So I wrote up this simple example of use of rpmbuild in case some other software developer might find it of interest as an introduction to the topic. I found existing documents on rpmbuild were helpful but inadequate.

So the following is a simple example

This is documented here in terms of a mythical product zzz, version 6.2.

Corrections and suggests for improvement of this page are always welcome. Created Sep 21, 2004.

• Build Goals
• The Files
• Spec
• Rpmmacros
• Shell Script
• References

Build Goals

I wanted the simplest rpmbuild I could manage and did not want to be root during creation of the RPMs. The non-rootness is very easy to accomplish, but it was difficult to figure out how to do that. Finally someone helped me, so now I'm helping you! I hope.

The Files

You need to write a .spec file. Here I'll use zzz-6.2.spec as the example. You need to write ~HOME/.rpmmacros. You need a buildable source tree. A simple shell script can then do the work. That's all you really need. rpmbuild creates three rpm's when rpmbuild succeeds.

The three rpm's a successful build will create are under SRPMS (the source rpm) and under RPMS (the installable binary and a debuginfo rpm). For this example, if one were building on ia64 Linux (an SGI Altix, for example) one would find SRPMS/zzz-6.2-2.src.rpm, RPMS/ia64/zzz-6.2-2.ia64.rpm, RPMS/ia64/zzz-debuginfo-6.2-2.ia64.rpm

The src.rpm is the buildable source, with source code and configure and Makefile present. The debuginfo rpm is source without build stuff, usable with a debugger: installed by default in /usr/src/debug/zzz. The zzz-6.2-2.ia64.rpm is the executable tool (zzz in this case), the rpm folks simply wanting to use the tool would install.

If you have a package from the internet and wish to build RPM's you must sometimes apply patches. I won't describe that part here, I assume no patching is needed. See the References below for more info.

To make the example concrete, I'll use $HOME/.rpmmacros, $HOME/zzz-6.2.spec as the spec file, and $HOME/zzz as the location of my original source file. I'm assuming that the package builds like most packages, in that one does

	sh configure
	make

to build the product.

spec file

Summary: An example tool. To show a simple rpm build of the tool.
Name: zzz
Version: 6.2
Release: 2
Copyright: GPL
Source:%{name}-%{version}.tar.gz
Group: Development/Debuggers
BuildRoot:/var/tmp/davea/%{name}-root
%description
zzz is not a real tool, it's an example showing one way
to build an rpm.

%prep

%setup -q

%build
sh configure
make

%install
make 
install -D zzz/zzz  $RPM_BUILD_ROOT/usr/bin/zzz

%clean
rm -rf $RPM_BUILD_ROOT

%files
%defattr(-,root,root)

/usr/bin/zzz

%changelog
* Tue Sep  22 2004  David Anderson 
- Removed debug printf's that were accidentally left in.
* Tue Sep  21 2004  David Anderson 
- Initial example

There is a lot one can say about spec files, and the references give lots of useful info, most of which I won't repeat here. The sections, briefly are as follows.

• Summary Give a one line summary of the tool's purpose.
• Name: Give the name of the tool.
• Version: The version. '6.2' in this case, but use whatever is appropriate.
• Release: This is the rpm release number. It appears in the rpm file name. Used if you make multiple rpm's of the same product (say for example you had build problems and needed to redo the release). Start at 1, normally, for a given Name: and Version: .
• Copyright: Here use one of the standard strings, such as GPL. See the rpm documentation for alternative strings.
• Source: This is the name of the tar'd gzipped source file tree. For this example, zzz-6.2.tar.gz would be the correct name.
• Group: Here use one of the standard names (see the rpm documentation). This is a sort of category, not a string you invent.
• BuildRoot: A location for temporary files (for the build install target).
• %description A nice description of the package goes here. It should be a paragraph you write to to tell folks what the package is for.
• %prep Shell commands for the 'prep' phase of the package go here. In this example there is no prep.
• %setup -q This is normal boilerplate for shell commands in the preparation phase, in this example we need nothing further here.
• %build Here put shell commands that build the zzz binary. This example uses configure/make so that's what commands I show in the example.
• %install Some packages use 'make install' as the shell commands here to install the package, but here I use the install command. The two file names are the built-executable and the installed-executable name. The names not be identical.
• %clean A shell command to clean up after a build.
• %files First here would be the '%defattr' line, and following that, the line naming the binary which is the executable this package prepares.
• %defattr(-,root,root) Boiler plate, determines how installed.
• /usr/bin/zzz The file name the install rule installs to. This line causes this file to be what is in one generated rpm (the rpm with the executable 'zzz').
• %changelog Here insert a log of versions of the rpm. Note that the entries must be most-recent-first. The '*' lines should closely follow the date format here. The - lines are comments.

rpmmacros file

This is the key to enabling safe rpm building as yourself. The file $HOME/.rpmmacros should contain the line:

%_topdir /var/tmp/davea/rpm

This line overrides the default _topdir of /usr/src/redhat and enables the build to work in the directory of your choice (/var/tmp/davea/rpm for this example).

The "Maximum RPM" document writes about 'topdir' in .rpmrc, but that simply does not work in current rpmbuild.

Shell Script

Given the spec file, .rpmmacros, and the application source tree, this file pulls it all together and builds the RPMs.

#!/bin/sh
# Build a zzz rpm set. 
# Uses temp space here, does not touch the source.
# Runnable as myself, does not use root permission at all.
set -x
# Relies on ~/.rpmmacros setting _topdir to what is here ($r, see below)
d=/var/tmp/davea
if [ ! -d $d ] 
then
        mkdir $d
fi

# clean out  /var/tmp/davea/rpm
# and then recreates the basic redhat dirs, like SOURCES SPECS there.
cd $d
r=$d/rpm
o=zzz-6.2
s=$r/SOURCES
spec=${o}.spec
rm -rf $r
mkdir rpm
mkdir rpm/SOURCES
mkdir rpm/SRPMS
mkdir rpm/SPECS
mkdir rpm/BUILD
mkdir rpm/RPMS

# First setup and copy the source.
cd  $s
rm -rf $o
mkdir $o
cp -r $HOME/zzz/* $o

# ensure no old junk present. (overkill)
rm  -f $o.tar
rm  -f $o.tar.gz
tar -cf $o.tar $o
ls -l $o.tar
gzip  $o.tar
ls -l
cp $HOME/$spec $r/SPECS
#rm -rf $o
# Now build the binaries and the rpms.
rpmbuild -ba $r/SPECS/$spec

References

• Maximum RPM (rpm.org) The best source for information on the spec file generally, though the references here to 'topdir' don't work (see _topdir as I describe it above in $HOME/.rpmmacros).
• Tips on building (rpm.org) Useful hints.
• Cambridge University slides on building rpm. Good simple overview, but mentions nothing about avoiding root permissions.

http://reality.sgiweb.org/davea/rpmbuild.html