How to create a GNU Hello RPM package/de

In other languages: English (en) [edit]

Einleitung

Der Artikel beschreibt exemplarisch an Hand eines "Hallo-Welt"-Projekts, wie eine Minimallösung aussehen kann, um eine Makefile ein rpm-Paket bauen zu lassen.

Typische Szenarien sind: Kleinere Projekte mit wenigen Anwendern die das Problem haben, das es keine Maintainer gibt, die sich um den Paketbau kümmert. Oder wenn In-House-Lösungen in das RPM-Deployment gebracht werden sollen.

Vorbereitung

Für die folgenden Schritte werden folgende Tools benötigt.

• GNU Make
• rpmbuild
• Ein Editor

Wie die die Software-Pakte der oben genannten Tools genau heißen ist von der Distribution abhängig.

Erstellen des eigentlichen Programms

Zunächst das (Beispiel-)Programm. Es handelt sich in unserem Falle um ein Bash-Skript das aus einer einzigen Zeile Code besteht (Die erste Zeile bestimmt nur den Interpreter):

 #!/bin/bash
 echo "Hallo whoami";

Was tut dieses Programm? Beim Aufruf Gibt es einfach nur "Hallo" aus, gefolgt von dem Loginnahmen, der Person, die es aufruft. Das ist - zugegeben - wenig sinnstiftend aber für unseren Zweck reicht es.

Das Skript speichern wir in die Datei "rpm-uebung.sh". Diese Datei speichern wir - der Ordnung halber in das Verzeichnis "/src". "src" steht für Source-Code. Diesen Ordner, speichern wir in einem Projektordner. So das unsere Struktur (bisher) so aussieht:

• rpm-uebung
  • src
    • rpm-uebung.sh

Warum ein Makefile?

In aller Regel wird in Unix- und Linux-Umgebungen gern und viel mit Makefiles gearbeitet. Das macht Sinn! Denn es abstrahiert den Umgang mit dem Programm. In der Regel ist Derjenige, der das Programm installiert nicht der selbe der das Programm programmiert. Die Idee hinter Makefiles ist, das der User nicht viel wissen muss über das Programm um es installieren zu können. Makefiles sind auch nur Skripte die etwas automatisch tun. Die Konvention ist, das der Benutzer erwarten darf, das es mindestens zwei Befehle gibt, die ihm zur Verfügung stehen:

 make

und

 make install

Der Benutzer erwartet, das der erste Befehl das Programm zusammenbaut und zweite, es auf seinem System installiert.

Darüber hinaus kann man GNU Make so einrichten das es Beliebige Parameter akzeptiert und dann definierte Aktionen ausführt. Zum Beispiel ein RPM erstellt. Und das ist der Grund, warum wir rpmbuild (das Tool zum erstellen von rpms) nicht direkt aufrufen, sondern über GNU Make. Wir versuchen die Komplexität vor dem User zu verstecken, in dem wir ihm eine definierte Schnittstellen geben. So muss er die Feinheiten von rpmbuild nicht verstehen.

Für Fedora-Maintainer sieht die Situation anders aus. Er will die volle Kontrolle über den RPM-Bau. Es gibt Distributionsweite einheitliche Konvention, die darüber abgebildet werden. Sollte sich also ein Maintainer sich dieses Paketes annehmen, wird er höchstwahrscheinlich das Thema völlig anders angehen. Das nur als Randbemerkung.

Makefile erstellen

Unser Ausgangspunkt ist gnu make. Also legen wir zunächst eine neues Makefile in unserem Projektordner an. So das Unsere Struktur so aussieht:

• rpm-uebung
  • src
    • rpm-uebung.sh
  • Makefile

Hier der Komplette Inhalt als Übersicht und zum kopieren (Ganz wichtig! Die Einrückungen müssen Tabs sein und dürfen keine Leerzeichen sein. Sonst wird GNU Make die Arbeit verweigern):

PREFIX=
VERSION=1
PROGNAME=rpm-uebung
ARCHIV=$(PROGNAME)-$(VERSION).tar.gz

all:
       echo "Es gibt nichts zu tun..."

install:
       [ -d $(PREFIX)/usr/bin/ ] || mkdir -p $(PREFIX)/usr/bin/
       cp ./src/$(PROGNAME).sh $(PREFIX)/usr/bin/
       chmod uoa+x $(PREFIX)/usr/bin/$(PROGNAME).sh

dist-tar:
       [ -d ./$(PROGNAME)-$(VERSION) ] ||  mkdir ./$(PROGNAME)-$(VERSION) 
       cp -r ./src ./$(PROGNAME)-$(VERSION)/
       cp ./Makefile ./$(PROGNAME)-$(VERSION)
       cp $(PROGNAME).spec ./$(PROGNAME)-$(VERSION)/$(PROGNAME)-$(VERSION).spec
       tar -cvzf $(ARCHIV) $(PROGNAME)-$(VERSION)
       rm -rvf ./rpm-uebung-$(VERSION)

dist-rpm: 
       rpmbuild -ta $(ARCHIV)

.PHONY: dist-rpm dist-tar install

Jetzt noch mal zur Struktur. Im ersten Teil werden verschiedene Variablen gesetzt. Variablen aus zwei Gründen:

• Zum einen, muss man deren Werde nur an einer Stelle ändern, falls sie geändert werden müssen. Und es ist zu erwarten, das sie sich ändern. So zum Beispiel die Versionsnummer.
• Zum anderen kann man beiGNU Make über Parameter die Variablen setzen. Diese Eigenschaft werden wir später im Wechselspiel mit dem rpmbuild-tool brauchen.

Der zweite Teil sind die Definitionen der Kommandos die GNU Make kennen und ausführen können soll. Der Kommando-Name (bzw. "Ziel") steht immer links, am Anfang der Zeile und Endet mit einem Doppelpunkt. Alle darauf folgenden Zeilen, die mit einem Tab eingerückt werden, sind dann die Schritte die bei dem Befehlsaufruf abgearbeitet werden.

Die letzte Zeile definiert, welche Funktionen/Befehle immer ausgeführt werden sollen. Normalerweise überprüft make nämlich ob die Quelle - die Source-Datei - neuer als das Ziel - die Binär-Datei - ist um zu entscheiden, ob ein Neubau nötig ist.

Unser make-Skript ist nun fertig benutzbar. Wenn wir jetzt den Befehl...

make

...aufrufen, bekommen wir die Meldung:

"Es gibt nichts zu tun..."

...Zurück. Wenn make ohne Parameter aufrufen, springt es automatisch in "all:". Bei einem Programm was kompiliert werden muss, würde das hier gemacht werden. Bei einem Bash-Skript ist das aber nicht nötig.

Anders sieht es mit dem Befehl...

 make install

...aus. Hier kopieren wir unser Skript die richtige stelle in das System. Die Variable $(PREFIX) kommt hier in Spiel. Die ist für uns wichtig, mit wir später das rpm ohne root-Rechte bauen können. Oder mit der Benutzer, das Skript an eine Stelle installieren kann, wo er es lieber hat. Das macht er dann so...

 make PREFIX=opt install 

...in diesem Fall würde das Skript nach /opt/usr/bin/ installiert werden. Soweit erst mal. Auf die anderen Teile kommen wir noch zu sprechen.

Der RPM-Bau (Spec-File)

Jetzt kommen wir zum eigentlich RPM-Bau. Das wird ein Zusammenspiel zwischen GNU Make und rpmbuild.

Zunächst das Spec-Fiel in der Übersicht zum zum kopieren:

Summary: Eine rpm uebung
License: GPL
Name: rpm-uebung
Version: 1
Release: 1
Source: rpm-uebung-1.tar.gz
Group:  Development/Tools
BuildArch: noarch
BuildRoot: /var/tmp/%{name}-buildroot 

%description
Kleine Programm, das den Benutzer mit seinem Loginnamen begruesst.

%prep
%setup

%build

%install
make PREFIX=$RPM_BUILD_ROOT install

%files
%defattr(0755,root,root)
/usr/bin/rpm-uebung.sh

...Der Aufbau ist syntaktisch völlig anders als beim Makefile. Am Anfang stehen wieder die Definition von Variablen. Hier ist das ":" eine Zuweisung und keine Bedingung wie bei GNU Make.

Bevor ich ins Detail gehe, speichern wir die Datei als "rpm-uebung.spec". Wichtig ist, das dass File wie das Projekt heißt. Unser Verzeichnis sollte nun so aussehen:

• rpm-uebung
  • src
    • rpm-uebung.sh
  • Makefiles
  • rpm-uebung.spec

Noch mal ins Detail...

 Summary: Eine rpm uebung

Kurze Zusammenfassung was das für ein Programm ist.

 License: GPL

Klar, die Lizenz.

 Name: rpm-uebung

Der Name unseres Programms.

 Version: 1
 Release: 1

Die Versions- und Release-Nummer

 Group:  Development/Tools

Die Software-Gruppe. Gut, für unseren Fall gibt es hier kein wirklich sinnvollen Wehr.

 %description
 Kleine Programm, das den Benutzer mit seinem Loginnamen begruesst.

Hier kommt die etwas ausführliche Beschreibung (die bei uns aber nicht sehr ausführlich ist). Dann folgen die Regeln für den Build und die Installation, auf die wir gleich im Detail eingehen.

%files %defattr(0755,root,root) /usr/bin/rpm-uebung.sh

In den letzten Zeilen wird festgehalten, welche Dateien bei der Installation angelegt werden. Und (mit %defattr(0755,root,root)) wird festgelegt, welche Rechte die Dateien bekommen. Da es sich um eine Ausführbare Datei handelt, muss es 0755 sein.

Erläuterung/Benutzung:

Der User ruft zunächst den Befehl "dist-tar" auf. Das erstellt ein Tar-Archiv unseres Programmst. Dann ruft der Benutzer Befehl "make dist-rpm" auf. In unserem Makefile wird nun der rpmbuild-Befehl parametisiert aufgerufen...

dist-rpm: 
       rpmbuild -ta $(ARCHIV)

Will man den ersten Befehl implezieren um dem User ein Schritt zu erspahren, kann man die Zeile wie Folgt abwandeln.

dist-rpm: dist-tar
       rpmbuild -ta $(ARCHIV)

...Nun weiß make von alleine, das es vorher "dist-tar:" ausführen muss.

Das rpmbuild wird nun seinerseits das Makefile bzw make aufrufen um sich den Installationsprozess anzusehen. Mit dies nicht im root-Verzeichnis geschieht, wird das wieder parametrisiert. Deshalb haben wir auch oben Variablen im Makefile benutzt...

 make PREFIX=$RPM_BUILD_ROOT install

Wird dem make nicht der Prefix übergeben, würde das Skript versuchen tatsächlich das Programm im System zu installieren. Das schlägt ohme root-Rechte fehl.

Wenn nichts schief gelaufen ist, sollte jetzt ein installierbares rpm-Paket da sein und zwar im Verzeichnis /RPMS unterhalb der rpm-Build-Umgebung, die auf jedem System in aller Regel im Verzeichnis /home/USERNAME/rpmbuild/ liegt.