Automating Slackware's Package Management

psionl0 — Wed, 20 Feb 2013 07:45:35 GMT

In my previous blog, I explained how even if you are only installing a couple of files on the system, there were advantages to creating a Slackware package to do so. The example I gave was the files I needed to disable nouveau and use nvidia instead.

This policy paid dividends when I upgraded to Slackware 14.0. The nvidia drivers wouldn't work and I faced the task of upgrading them for 14.0 (which meant remembering stuff I had done 18 months ago). Before doing that, it seemed prudent to just remove the files I had installed for nvidia (where/what were they again?) and see if the new kernel was up to the task. All I had to do was enter the command: "removepkg nvidiaenabled-1.0-noarch-1_gs.tgz" and it was done. The new kernel proved to be up to task so hours of work had been spared.

The problem is that creating a Slackware package by hand can be an involved process (as shown by the steps in my previous blog). I had previously created a package called "moreicons" which added a couple of icons somewhere for use in wbar or idesk. It installed and worked but it wouldn't copy the "slack-desc" so pkgtools had no information to reveal about it (apart from the files). It turns out that "makepkg" is rather fussy about both the structure of the directory you are making a package out of and the name of the package. I couldn't see where I was going wrong so, since it was a minor package, I just left things as they were.

Since that time, I have gained some experience in writing SlackBuild scripts so I decided it was time to make a proper "moreicons" package by writing a script to do so. Slackwiki has a good tutorial on writing SlackBuild scripts to convert a source to a package and SlackBuilds.org has a number of templates you can use to make your own script. Of course, since the main reason for writing a SlackBuild script is that src2pkg has failed to create the package for you, it is not really a task for n00bs. However, for just installing a few files, writing a script is well within the realm of anybody who can use an editor and Slackware's package management tools.

This is a breakdown of the script I wrote for moreicons. The first part just sets up some variables that the script will use. This makes it easy to use the script as a template for installing other files. The usual SlackBuild script uses the /tmp or /tmp/SBo directories to do its work but I saw no advantage of this for such a minor task and kept everything in the current working directory. Note that the build is 2 because it is fixing up build 1.

Code:

#!/bin/sh

# Slackware build script for moreicons


PRGNAM=moreicons
VERSION=${VERSION:-1.0}
ARCH=noarch
BUILD=${BUILD:-2}
TAG=${TAG:-_gs}
CWD=$(pwd)
PKG=$CWD/package-$PRGNAM

set -e # Exit on most errors

The next section is the main part of the script. It deletes the old package directory and creates a new directory structure where the files I want installed will be placed. Note that this script assumes that the icons are present in the current working directory.

Code:

rm -rf $PKG
mkdir -p $PKG

# Create the subdirectories and copy the icons into the $PKG directory
mkdir -p $PKG/usr/share/pixmaps
cp -a $CWD/home.png $PKG/usr/share/pixmaps
cp -a $CWD/sw.png $PKG/usr/share/pixmaps

DOCUMENTATION: Since this package is only installing a couple of files, there is strictly no need for any documentation other than the slack-desc. If you are creating the package by hand it is tempting to skip the documentation altogether. However, it is no extra work for the script and by creating a directory for documentation, you avoid the need to hang on to the files you used when creating the script/package. It is usual to keep a copy of the SlackBuild in the documents folder and it is also a good idea to add a README file there too. The README file is basically just the slack-desc without the "moreicons:" bits but I also have the option of adding some extra instructions for my future self. The README is actually created within the script itself so no extra files are involved.

Code:

# Copy program documentation into the package
mkdir -p $PKG/usr/doc/$PRGNAM-$VERSION
cat $CWD/$PRGNAM.SlackBuild > $PKG/usr/doc/$PRGNAM-$VERSION/$PRGNAM.SlackBuild

# Create a README file
cat > $PKG/usr/doc/$PRGNAM-$VERSION/README << _EOG
moreicons (extra icons) 

Puts a couple of extra icons into
/usr/share/pixmaps directory
sw.png, home.png 

Used in wbar, idesk etc.

SlackBuild created 19 Feb 2013
_EOG

Just as the script creates a README file, it also creates the slack-desc. The use of the generic $PRGNAM variable makes this more useful as a template.

Code:

# Create a slack-desc file and put it in the install directory
mkdir -p $PKG/install
cat > $PKG/install/slack-desc <<_EOF
$PRGNAM: moreicons (extra icons) 
$PRGNAM:
$PRGNAM: Puts a couple of extra icons into
$PRGNAM: /usr/share/pixmaps directory
$PRGNAM: sw.png, home.png
$PRGNAM:
$PRGNAM: Used in wbar, idesk etc.
$PRGNAM:
$PRGNAM:
$PRGNAM: SlackBuild created 19 Feb 2013
$PRGNAM:
_EOF

Finally, we build the package.

Code:

# Make the package
cd $PKG
/sbin/makepkg -l y -c n $CWD/$PRGNAM-$VERSION-$ARCH-$BUILD$TAG.${PKGTYPE:-tgz}

I have included the moreicons.SlackBuild.txt as an attachment in case anybody would like to use it as a template.

Attached Files

moreicons.SlackBuild.txt (1.2 KB, 3 views)

Using Slackware's Package Management

psionl0 — Fri, 19 Aug 2011 13:50:10 GMT

Slackware's package management system is very simple and effective. Run installpkg and all the files in the package get installed in the right place, installation scripts get run and a record of the installation gets stored in /var/log/packages. The time stamp on the file in /var/log/packages also tells you when the package was installed (very handy sometimes).

Of course, if you no longer need the package then you can run removepkg and all of the package's files (not shared by other packages) get removed and a record of the removal is stored in /var/log/removed-packages. The lack of automatic dependency resolution is an advantage here because you can be sure that removing the package won't clobber another package.

But what about those times where you only need to install one or two files, create symlinks in the system directories or create a script or two? You can do these things without using the package management system but you lose the advantage of having a record of the system changes. In the long run, such files are likely to be forgotten and remain in the system taking up disk space long after they have served any useful purpose.

I recently needed to install nvidia on my PC because the noveau drivers would not work correctly on this mode. This wasn't hard. src2pkg made Slackware packages out of the nvidia-kernels and nvidia-drivers and both installed without incident.

In order to replace noveau with nvidia I needed to create two files: one was /etc/X11/xorg.conf (generated by running nvidia-xconfig) and the other was /etc/modprobe.d/disable-nouveau.conf which (you guessed it) prevents noveau from being loaded at boot time. When these two files are present then the PC boots up with nvidia. With the files removed, the PC boots up with noveau.

Although the installation was straight forward, the performance was not. This was the start of a lot of messing around and included such measures as changing the kernel from 2.6.37.6 to 2.6.38.4 (noveau actually works with the upgraded kernel). As part of this tomfoolery, I had to switch between nvidia and noveau many times. This meant removing then reinstalling the two files as mentioned above.

There is no problem with remembering where the two files are supposed to go - on the day. However, there is no guarantee that I would remember the precise location of the files a week later (unless I made very good notes). I could have gotten around this difficulty by creating two scripts - one to install the files and one to remove them. However, that does not help much with the documentation side of things and it also ignores the fact that Slackware's package management system can do the same thing and also take care of the documentation.

To make a package out of these two files is surprisingly easy (as is often the case when you do things the Slackware way). The first step is to create a directory for the packages files: I called mine nvidiaenabled-1.0-noarch-1_gs. Then I cd'd into it. I had to recreate parts of the root directory tree where the files are and I also needed an install directory for the "slack-desc" (the easiest way to create slack-desc is to copy one and edit it). Once the files are in place, you run makepkg to create the package and installpkg to install the files.

After creating the "slack-desc" in the root directory, these are the commands I used to make the package:

Code:

# mkdir nvidiaenabled-1.0-noarch-1_gs
# cd nvidiaenabled-1.0-noarch-1_gs
# mkdir install
# mkdir etc
# mkdir etc/X11
# mkdir etc/modprobe.d
# cp /root/slack-desc install/
# cp /etc/X11/xorg.conf etc/X11/
# cp /etc/modprobe.d/disable-nouveau.conf etc/modprobe.d/
# makepkg ../nvidiaenabled-1.0-noarch-1_gs.tgz (answer "n" to changing permissions)

Although the files were initially present, I ran "installpkg nvidiaenabled-1.0-noarch-1_gs.tgz" (after cd'ing to the /root directory) to ensure that a record was now present in /var/log/packages.

Now I have a simple way of switching between nvidia and noveau (just run installpkg or removepkg). I don't have to remember which files are involved nor when or even whether nvidia is enabled or not because Slackware has documented this for me. Since I have more work before either driver is working satisfactorily (but not until I know what else to do), this package is going to make life a lot easier for me.

LinuxQuestions.org - Blogs - psionl0

Automating Slackware's Package Management

Using Slackware's Package Management