7. Building It
7.1. The Source Directory Tree
The first thing you need is a properly configured build tree. This is configurable using the /usr/lib/rpm/rpmrc file. Most people will just use /usr/src.
You may need to create the following directories to make a build tree:
BUILD is the directory where all building occurs by RPM. You don't have to do your test building anywhere in particular, but this is where RPM will do it's building.
SOURCES is the directory where you should put your original source tar files and your patches. This is where RPM will look by default.
SPECS is the directory where all spec files should go.
RPMS is where RPM will put all binary RPMs when built.
SRPMS is where all source RPMs will be put.
7.2. Test Building
The first thing you'll probably want to to is get the source to build cleanly without using RPM. To do this, unpack the sources, and change the directory name to $NAME.orig. Then unpack the source again. Use this source to build from. Go into the source directory and follow the instructions to build it. If you have to edit things, you'll need a patch. Once you get it to build, clean the source directory. Make sure and remove any files that get made from a configure
script. Then cd
back out of the source directory to its parent. Then you'll do something like:
|diff -Nru dir-name/filename.c dir-name/filenamec.c.new > ../SOURCES/filename.c.patch
This will create a patch for you that you can use in your spec file. Note that the "linux" that you see in the patch name is just an identifier. You might want to use something more descriptive like "config" or "bugs" to describe why
you had to make a patch. It's also a good idea to look at the patch file you are creating before using it to make sure no binaries were included by accident.
7.3. Generating the File List
Now that you have source that will build and you know how to do it, build it and install it. Look at the output of the install sequence and build your file list from that to use in the spec file. We usually build the spec file in parallel with all of these steps. You can create the initial one and fill in the easy parts, and then fill in the other steps as you go.
7.4. Building the Package with RPM
Once you have a spec file, you are ready to try and build your package. The most useful way to do it is with a command like the following:
There are other options useful with the -b
switch as well:
p means just run the prep section of the specfile.
l is a list check that does some checks on %files.
c do a prep and compile. This is useful when you are unsure of whether your source will build at all. It seems useless because you might want to just keep playing with the source itself until it builds and then start using RPM, but once you become accustomed to using RPM you will find instances when you will use it.
i do a prep, compile, and install.
b prep, compile, install, and build a binary package only.
a build it all (both source and binary packages).
There are several modifiers to the -b
switch. They are as follows:
--short-circuit will skip straight to a specified stage (can be used with c,i, and a,b).
--clean removes the build tree when done.
--keep-temps will keep all the temp files and scripts that were made in /tmp. You can actually see what files were created in /tmp using the -v option.
--test does not execute any real stages, but does keep-temp.
7.5. Testing It
Once you have a source and binary rpm for your package, you need to test it. The easiest and best way is to use a totally different machine from the one you are building on to test. After all, you've just done a lot of make install's on your own machine, so it should be installed fairly well.
You can do an rpm -e packagename on the package to test, but that can be deceiving because in building the package, you did a make install. If you left something out of your file list, it will not get uninstalled. You'll then reinstall the binary package and your system will be complete again, but your rpm still isn't. Make sure and keep in mind that just because you do a rpm -ba package, most people installing your package will just be doing the rpm -i package. Make sure you don't do anything in the buildor install sections that will need to be done when the binaries are installed by themselves.
7.6. What to do with your new RPMs
Once you've made your own RPM of something (assuming its something that hasn't already been RPM'ed), you can contribute your work to others (also assuming you RPM'ed something freely distributable). To do so, you'll want to send it to aLinux™
7.7. What Now?
Please see the above sections on Testing and What to do with new RPMs. We want all the RPMs available we can get, and we want them to be good RPMs. Please take the time to test them well, and then take the time to upload them for everyone's benefit. Also, please make sure you are only uploading freely available software. Commercial software and shareware should not be uploaded unless they have a copyright expressly stating that this is allowed. This includes ssh, pgp, etc.