Linux-Praxisbuch/ RPM-Pakete mit GNU Make

Aus Wikibooks
Zur Navigation springen Zur Suche springen

Einleitung[Bearbeiten]

Das Kapitel 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, dass es keine Maintainer gibt, die sich um den Paketbau kümmern. Oder wenn In-House-Lösungen in das RPM-Deployment gebracht werden sollen.

Vorbereitung[Bearbeiten]

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[Bearbeiten]

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 Loginnamen 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 dass unsere Struktur (bisher) so aussieht:

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

Warum ein Makefile?[Bearbeiten]

In aller Regel wird in Unix- und Linux-Umgebungen gern und viel mit Makefiles gearbeitet. Das ist sinnvoll! 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, dass 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, dass der Benutzer erwarten darf, dass es mindestens zwei Befehle gibt, die ihm zur Verfügung stehen:

 make

und

 make install

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

Darüber hinaus kann man GNU Make so einrichten, dass 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, indem 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 Konventionen, die darüber abgebildet werden. Sollte also ein Maintainer sich dieses Paketes annehmen, wird er höchstwahrscheinlich das Thema völlig anders angehen. Das nur als Randbemerkung.

Makefile erstellen[Bearbeiten]

Unser Ausgangspunkt ist gnu make. Also legen wir zunächst eine neues Makefile in unserem Projektordner an, sodass 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=/usr/bin/
DESTDIR=
VERSION=1
PROGNAME=rpm-uebung
ARCHIV=$(PROGNAME)-$(VERSION).tar.gz

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

install:
	[ -d $(DESTDIR)$(prefix) ] || mkdir -p $(DESTDIR)$(prefix)
	cp ./src/$(PROGNAME).sh $(DESTDIR)$(prefix)
	chmod uoa+x $(DESTDIR)$(prefix)$(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 Werte 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 bei GNU 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 wir make ohne Parameter aufrufen, springt es automatisch in "all:". Bei einem Programm, das 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 an die richtige Stelle in das System. Die Variable $(DESTDIR) kommt hier ins Spiel. Die ist für uns wichtig, damit wir später das rpm ohne root-Rechte bauen können. Oder damit der Benutzer das Skript an einer Stelle installieren kann, wo er es lieber hat. Das macht er dann so...

 make DESTDIR=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)[Bearbeiten]

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

Zunächst das Spec-File in der Übersicht 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 DESTDIR=$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 Wert.

 %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 ersparen, 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 DESTDIR=$RPM_BUILD_ROOT install

Wird dem make nicht DESTDIR ü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.