Arch Build System: Unterschied zwischen den Versionen

Aus wiki.archlinux.de
(47 dazwischenliegende Versionen von 12 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
[[Kategorie:Paketverwaltung]]
==== Einführung ====
Das Arch Build System (ABS) wird genutzt um:
Das Arch Build System (ABS) wird genutzt um:


* Neue Pakete für Software zu erstellen, für die noch keine Pakete vorhanden sind
* Neue Pakete für Software zu erstellen
* Vorhande Pakete an die eigenen Bedürfnisse anzupassen
* Vorhande Pakete an die eigenen Bedürfnisse anzupassen
* Das komplette System mit eigenen Compiler-flags neuzubauen, "a la gentoo" (Und so Kernel Module mit eigenem Kernel nutzbar machen!)
ABS ist nicht notwendig um Arch Linux zu nutzen, aber es ist nützlich.


Dieses How-To versucht dir eine Übersicht über ABS und Arch Pakete zu geben, es ist keine komplette Referenz! Wenn du mehr willst, solltest du einen Blick in die man-pages werfen.
Das Arch Build System besteht aus [[Abs#Der_ABS-Verzeichnisbaum|abs]], [[Abs#Erstellung_von_Paketen|makepkg]] und [[pacman]].
Dieser Artikel versucht nun eine Übersicht über das Erstellen von Paketen unter Archlinux zu geben. Detailreichere Informationen finden sich in den jeweiligen [[Manpages]].


==== Vorbereitung ====
== Vorbereitung ==


Um ABS zu nutzen, musst du zuerst die Programme "cvsup" oder "csup" und "wget" installieren:
Das Paket "abs" installieren:


<pre>
pacman -S abs
pacman -S cvsup wget</pre>


oder
Alle sonstigen Pakete, die zur Erstellung von Paketen notwendig sind, befinden sich in der Gruppe base-devel:
<pre>
pacman -S csup wget</pre>


Oder, wenn du die Pakete z.B. im Verzeichnis 'foo' gespeichert hast:
pacman -S base-devel
<pre>
cd foo
pacman -U  cvsup-*.pkg.tar.gz  wget-*.pkg.tar.gz</pre>


==== Was ist ein Paket ?====
== Das Paket ==


Ein Paket ist eine Datei, die meist ''foo''.pkg.tar.gz genannt ist.
Ein Paket ist eine Datei, die meist ''foo''.pkg.tar.gz bzw. ''foo''.pkg.tar.xz genannt ist.


Es ist nicht mehr, als ein gz komprimiertes tar-Archiv, das folgendes enthält:
Es ist nicht mehr, als ein gz bzw. xz komprimiertes tar-Archiv, das folgendes enthält:


* Die zu installierenden Dateien
* Die zu installierenden Dateien
Zeile 38: Zeile 27:
*.PKGINFO : enthält alle Metadaten, die pacman für den Umgang mit Paketen, Abhängigkeiten etc. benötigt.
*.PKGINFO : enthält alle Metadaten, die pacman für den Umgang mit Paketen, Abhängigkeiten etc. benötigt.


*.FILELIST : enthält alle Dateien des Archives. Nötig um ein Paket zu deinstallieren oder um ggf. Abhängigkeitskonflikte festzustellen (ab Pacman 3.1 sind filelisten nicht mehr nötig und werden vom entsprechenden makepkg auch nicht mehr erzeugt)
*.INSTALL : enthält Befehle, die nach dem Installieren/Aktualisieren/Deinstallieren ausgeführt werden. (Nur vorhanden, wenn es in PKGBUILD definiert wurde)
 
*.INSTALL : enthält Befehle, die nach dem Installieren/Upgraden/Deinstallieren ausgeführt werden. (Nur vorhanden, wenn es in PKGBUILD definiert wurde)
 
==== Was ist PKGBUILD und was enthält es? ====


Wie schon gesagt, enthält PKGBUILD die Metadaten über ein Paket. Es ist eine einfache Textdatei, die z.B. so aussehen könnte:
== Das PKGBUILD ==


<pre>
PKGBUILD enthält die Metadaten über ein Paket, die von [[pacman]] benötigt werden, um die Pakete verwalten zu können. Es stellt die Grundlage für Pakete in Archlinux dar. Ein PKGBUILD ist eine einfache Textdatei, die beispielsweise so aussehen kann:
# $Id: PKGBUILD,v 1.12 2003/11/06 08:26:13 dorphell Exp $
# Maintainer: judd <jvinet@zeroflux.org>
# Contributor: Judd Vinet <jvinet@zeroflux.org>
pkgname=foo
pkgver=0.99 # note: if the pkgver had been '0.99-10' then use an underscore. like '0.99_10'
pkgrel=1
pkgdesc="short description of foo"
arch=(i686 x86_64)
url="http://www.foo.org"
license=('GPL')
groups=
provides=
depends=('qt' 'python')
makedepends=('guile')
conflicts=('yafoo')
replaces=('mffoo')
backup=('etc/foo/foo.conf')
install=('foo.install')
source=(http://www.foo.org/download/$pkgname-$pkgver.tar.gz)
md5sums=('2c0cca3ef6330a187c6ef4fe41ecaa4d35175bee593a7cc7d6205584a94d8625')


build() {
# $Id: PKGBUILD,v 1.12 2003/11/06 08:26:13 dorphell Exp $
  cd $startdir/src/$pkgname-$pkgver
# Maintainer: judd <jvinet@zeroflux.org>
  ./configure --prefix=/usr
# Contributor: Judd Vinet <jvinet@zeroflux.org>
  make || return 1
pkgname=foo
  make prefix=$startdir/pkg/usr install
pkgver=0.99 # note: if the pkgver had been '0.99-10' then use an underscore. like '0.99_10'
}
pkgrel=1
</pre>
pkgdesc="short description of foo"
arch=(i686 x86_64)
url="http://www.foo.org"
license=('GPL')
groups=
provides=
depends=('qt' 'python')
makedepends=('guile')
conflicts=('yafoo')
replaces=('mffoo')
backup=('etc/foo/foo.conf')
install='foo.install'
source=(http://www.foo.org/download/$pkgname-$pkgver.tar.gz)
md5sums=('2c0cca3ef6330a187c6ef4fe41eca')
build() {
  cd $srcdir/$pkgname-$pkgver
  ./configure --prefix=/usr
  make
}
package() {
  cd $srcdir/$pkgname-$pkgver
  make DESTDIR=$pkgdir install
}


Erklärung für jede Zeile:
Erklärung:


* '''# text''' : Kommentare
* '''# text''' : Kommentare
* '''# $Id: PKGBUILD,v ...''' : Das CVS-Tag für dieses Paket (Vom Archlinux-CVS System erstellt).
* '''# $Id: PKGBUILD,v ...''' : Das SVN-Tag für dieses Paket (automatisch vom Archlinux-SVN System erstellt). Dies sollte bei Paketen, die für das [[AUR]] gedacht sind, stets weggelassen werden.
* '''# Maintainer''' :  Der Verantwortliche für dieses Paket in den offiziellen Repo's.
* '''# Maintainer''' :  Der Verantwortliche für dieses Paket in den offiziellen Repositories.
* '''# Contributor''' : Der Verfasser der ersten PKGBUILD für dieses Paket.
* '''# Contributor''' : Der Verfasser der ersten PKGBUILD für dieses Paket.
* '''pkgname''' :  Der Paketname
* '''pkgname''' :  Der Paketname
* '''pkgver''' : Die Paketversion
* '''pkgver''' : Die Paketversion
* '''pkgrel''' : Die Releasenummer des Arch Paketes. Wird geändert, wenn das PKGBUILD verändert wurde, sie unterscheided sich also von der Paketversion.
* '''pkgrel''' : Die Releasenummer des Arch Paketes. Wird geändert, wenn das PKGBUILD verändert wurde, sie unterscheided sich also von der Paketversion.
* '''pkgdesc''' : Eine Kurzbeschreibung des Paketes. Du siehst sie, in der [http://archlinux.org/packages/ Paket Datenbank]
* '''pkgdesc''' : Eine Kurzbeschreibung des Paketes. Du siehst sie in der [http://www.archlinux.de/?page=Packages Paket Datenbank]
* '''arch''' : Die Architekturen, auf denen das Paket kompiliert und getestet wurde.
* '''arch''' : Die Architekturen, auf denen das Paket kompiliert und getestet wurde, oder 'any' bei plattformunabhängigen Paketen.
* '''url''' : Die Homepage des Programmes
* '''url''' : Die Homepage des Programmes
* '''license''' : Die Lizenz, unter der das Programm steht
* '''license''' : Die Lizenz, unter der das Programm steht
* '''groups''' :  Wird genutzt um Pakete zu Gruppen zusammen zu fassen. Wenn du z.B. KDE installieren willst, werden alle Pakete installiert, die zur Gruppe 'KDE' gehören
* '''groups''' :  Wird genutzt um Pakete zu Gruppen zusammen zu fassen. Wenn du z.B. KDE installieren willst, werden alle Pakete installiert, die zur Gruppe 'kde' gehören
* '''provides''' : Wird genutzt, wenn das Paket ein anderes Paket enthält. z.B. enthält 'kernel-scsi' 'kernel'
* '''provides''' : Wird genutzt, wenn das Paket ein anderes Paket bereitstellt.
* '''depends''' : Liste der Abhängigkeiten um das Programm auszuführen.
* '''depends''' : Liste der Abhängigkeiten um das Programm auszuführen.
* '''makedepends''' : Liste der Abhängigkeiten um das Programm zu kompilieren.
* '''makedepends''' : Liste der Abhängigkeiten um das Programm zu kompilieren. Pakete, die schon unter depends aufgeführt wurden, sind hier nicht noch einmal aufzuführen.
* '''conflicts''' : Pakete, die nicht zusammen mit diesem Programm installiert sein können. In unserem Fall steht  <i>foo</i> in Konflikt zu <i>yafoo (yet another foo)</i>.  
* '''conflicts''' : Pakete, die nicht zusammen mit diesem Programm installiert sein können. In unserem Fall steht  ''foo'' in Konflikt zu ''yafoo''.  
* '''replaces''' : Das neue Paket ersetzt das Alte. In unserem Fall wird <i>mffoo (my first foo)</i> nicht mehr unterstützt und wird durch <i>foo</i> ersetzt.
* '''replaces''' : Das neue Paket ersetzt das alte. In unserem Fall wird ''mffoo'' nicht mehr unterstützt und wird durch ''foo'' ersetzt.
* '''backup''' : Dateien, die gesichert werden (als .pacsave), wenn das Programm deinstalliert wird.
* '''backup''' : Dateien, die gesichert werden (als .pacsave), wenn das Programm deinstalliert wird.
* '''install''' : Spezifiziert ein Installationsskript, das im Paket enthalten ist. (Muss sich mit PKGBUILD im selben Verzeichnis befinden)
* '''install''' : Spezifiziert ein Installationsskript, das im Paket enthalten ist. (Muss sich mit PKGBUILD im selben Verzeichnis befinden)
* '''source''' : Die Bezugsquelle des Quelltextes. Kann sowohl ein lokales Paket, als auch ein remote "http" oder "ftp" Paket sein. Der Dateiname wird aus <i>pkgname</i> und <i>pkgver</i> erstellt, damit der Pfad nicht bei jeder neuen Version angepasst werden muss.
* '''source''' : Die Bezugsquelle des Quelltextes. Kann sowohl ein lokales Paket, als auch ein remote "http" oder "ftp" Paket sein. Der Dateiname wird aus ''pkgname'' und ''pkgver'' erstellt, damit der Pfad nicht bei jeder neuen Version angepasst werden muss.
* '''md5sums''' : MD5 Summen der Quelltexte um beschädigte Dateien auszuschließen.
* '''md5sums''' : MD5 Summen der Quelltexte um beschädigte Dateien auszuschließen.
* '''build()''' : Alle Schritte, die nötig sind um das Paket zu kompilieren.


Nun die Funktionen:
=== Die build-Funktion und die Package-Funktion ===
 
In der build-Funktion werden die Anweisungen ausgeführt, die nötig sind, um das Paket zu kompilieren.
* build : Alle Schritte, die nötig sind um das Paket zu kompilieren. (Darauf gehen wir später besser ein).
 
Wie du siehst, enthält PKGBUILD alle Informationen, die von der Paketverwaltung gebraucht werden könnten. Es ist das Herzstück von pacman und ABS.
 
Es sind auch Installationsdateien vorhanden. Unser PKGBUILD gibt 'foo.install' als Installationsdatei an. Es könnte z.B. folgendes enthalten:
 
<pre>
post_install() {
/bin/true
}
 
post_upgrade() {
/bin/true
}
 
pre_remove() {
/bin/true
}
 
op=$1
shift
 
$op "$@"
</pre>
 
Erklärungen:
 
* post_install : Wird nach der Installation ausgeführt. Es wird ein Argument übergeben:
** Die Paketversion
* post_upgrade : Wird ausgeführt, nachdem alle Dateien aktualisiert wurden <em> Es werden zwei Argumente übergeben</em>:
** Die neue Paketversion
** Die alte Paketversion
* pre_remove : Wird ausgeführt, bevor Dateien gelöscht werden (beendet z.B. daemonen) und übergibt ein Argument:
** Die Paketversion
 
Damit die Installationsdateien funktionieren, müssen diese letzten drei Zeilen am Ende jeder Installationsdatei vorhanden sein.
 
Schablonen sowohl für ein PKGBUILD als auch für Installationsdateien befinden sich auf deinem Rechner, z.B. unter /var/abs/core. Sie haben .proto als Suffix.
 
==== Die build Funktion====
 
Wenn du dich nicht mit dem Bauen von Paketen auskennst, solltest du wissen, dass die meisten Pakete über den 'Dreisatz' erstellt werden können:
 
* Paketdateien dekomprimieren (macht in den meisten Fällen makepkg):
 
  <pre>
  tar -xzf foo-0.99.tar.gz
  tar -xjf foo-0.99.tar.bz2</pre>
 
* In das Verzeichnis wechseln
 
  <pre>cd foo-0.99</pre>
 
* configure (1/3): normalerweise ist ein kleines Script <code>configure</code> im Quelltextverzeichniss vorhanden. Es wird genutzt um das Paket zu konfigurieren (hinzufügen von Unterstützungen, Installationsverzeichnis festlegen, ...) und sicher zu stellen, dass alle Abhängigkeiten aufgelöst sind.
 
  <pre>./configure [[option]]</pre>
 
Du solltest zuerst einen Blick in die 'help' Option werfen:
 
  <pre>./configure --help</pre>
 
* make (2/3) : Kompilieren der Quelltexte


  <pre>make</pre>
In der package-Funktion werden die zu installierenden Dateien und Verzeichnisse so abgelegt, dass makepkg daraus einen Tarball - das Paket - erstellen kann, der dann von [[pacman]] installiert werden kann. Es kann aber auch mehrere Package-Funktionen geben. Dann spricht man von [[split packages]].
----
Wenn du dich nicht mit dem Bauen von Paketen auskennst, solltest du wissen, dass die meisten Pakete über den ''Dreisatz'' erstellt werden können:


* install (3/3)
./configure --prefix=/usr
make
make install


  <pre>make install</pre>
''./configure'' überprüft zunächst, ob alle Voraussetzungen für das zu kompilierende Programm erfüllt sind. Über dieses Script lässt sich auch konfigurieren, wie und mit welchen Funktionen ein Programm
kompiliert wird. ''./configure --help'' zeigt meistens eine Übersicht über die Optionen, die verfügbar sind. ''make'' kompiliert schließlich das Paket und '' make install'' installiert die Dateien.


Du solltest immer die <code>INSTALL</code> oder die <README> Datei lesen, um zu erfahren, wie das Paket erstellt und installiert werden sollte , denn nicht alle Pakete nutzen den Dreisatz 'configure; make; make install'!
Du solltest immer die ''INSTALL'' oder die ''README'' Datei des jeweiligen Pakets lesen, um zu erfahren, wie es erstellt und installiert werden sollte, denn nicht alle Pakete nutzen diesen ''Dreisatz''!
----


Schauen wir uns eine 'standard' build Funktion an :
Eine 'Standard' build-Funktion sieht so aus:


<pre>
build() {
build() {
   cd $srcdir/$pkgname-$pkgver
   cd $startdir/src/$pkgname-$pkgver
   ./configure --prefix=/usr
   ./configure --prefix=/usr
   make || return 1
   make
  make prefix=$startdir/pkg/usr install || return 1
}
}
</pre>


Im Detail :
Erklärung:
* In das Verzeichnis der entpackten Quelltexte wechseln :


  <pre>cd $startdir/src/$pkgname-$pkgver</pre>
* In das Verzeichnis der von ''makepkg'' entpackten Quelltexte wechseln (hier treten in der Praxis oft schon Probleme auf; besser, man schaut nach ob das Verzeichnis wirklich so heißt):
cd $srcdir/$pkgname-$pkgver


* Konfigurieren des Paketes mit dem Installationsverzeichnis <code>/usr</code> :
* Konfigurieren des Paketes mit dem Installationsverzeichnis ''/usr'' und unter Umständen weiteren Optionen:
./configure --prefix=/usr --option1 --option2


  <pre>
Da die meisten Programme davon ausgehen, dass nach /usr/local installiert werden soll, wir unter Arch Linux aber  nach /usr installieren wollen, ist es wichtig, das Prefix zu setzen.
  ./configure --prefix=/usr</pre>


* compile
* kompilieren:
make


  <pre>
Eine 'Standard' package-Funktion sieht so aus:
  make || return 1</pre>


* installiere das Programm nicht in <code>/usr</code> sondern in <code>$startdir/pkg/usr</code>, sodass pacman Kontrolle über die Dateien hat :
* installieren:
make DESTDIR=$pkgdir install


  <pre>
Dabei wird das Programm nicht in ''/usr'' sondern in ''$pkgdir/usr'' installiert, so dass erst einmal [[makepkg]] und indirekt auch [[pacman]] Kontrolle über die Dateien hat!
  make prefix=$startdir/pkg/usr install</pre>
Ob ''DESTDIR'' verwendet wird, hängt vom jeweiligen Programm bzw. dessen Makefile ab. Manchmal muss z.B. auch PREFIX verwendet und entsprechend umgebogen werden.


Wir wollen das Paket erstellen, aber nicht installieren, also installieren wir es nicht standardmäßig (<code>/usr</code>), sondern nach <code>$startdir/pkg/usr</code>. So kann makepkg sehen, welche Dateien das Paket installiert und daraus ein Arch Paket erstellen.
make PREFIX=$pkgdir/usr install


'''BEACHTE''': Teilweise wird <code>prefix</code> nicht im <code>Makefile</code> genutzt; meist wird stattdessen <code>DESTDIR</code> verwendet. Wenn das Paket mit Hilfe von autofoo (autoconf/automake) erstellt wird, solltest du <code>DESTDIR</code> nutzen, denn so wird es in der [http://sources.redhat.com/automake/automake.html#Install Dokumentation] angegeben. Überprüfe, ob die generierte <code>filelist</code> um einiges kürzer ist, als sie sein sollte. Ist dies der Fall, versuche das Paket mit <code>make DESTDIR=$startdir/pkg install</code> zu erstellen.
=== Installationsdateien ===
Fall auch das nicht funktioniert, wirst du dir die Befehle, die "<code>make <...> install=</code>" ausführt genauer anschauen müssen.
Installationsdateien stellen die Möglichkeit bereit, Anweisungen zu bestimmten Punkten der Installation auszuführen. Dazu müssen sie im PKGBUILD angegeben werden. Unseres gibt 'foo.install' als Installationsdatei an. Es könnte z.B. folgendes enthalten:


Moderne Skriptsprachen kommen oft auch mit modernen Buildsystemen. Da kann die Buildfunktion auch völlig anders aussehen.
post_install() {
/bin/true
}
post_upgrade() {
/bin/true
}
pre_remove() {
/bin/true
}


==== Der ABS Verzeichnisbaum ====
Erklärungen:


Wenn du abs das erste Mal nutzt :
* '''post_install''': Wird nach der Installation ausgeführt. Es wird ein Argument übergeben:
** Die Paketversion
* '''post_upgrade''': Wird ausgeführt, nachdem alle Dateien aktualisiert wurden <em> Es werden zwei Argumente übergeben</em>:
** Die neue Paketversion
** Die alte Paketversion
* '''pre_remove''': Wird ausgeführt, bevor Dateien gelöscht werden (beendet z.B. daemonen) und übergibt ein Argument:
** Die Paketversion


<pre>
== Der ABS-Verzeichnisbaum ==
root @ localhost # abs</pre>
Bei Archlinux werden die PKGBUILDs, anhand derer die Pakete in den offiziellen Repositories gebaut sind, mit SVN verwaltet.
Sie werden mit ''abs'' auf den lokalen Rechner heruntergeladen oder aktualisiert:
abs


so synchronisierst du deinen "ABS Verzeichnisbaum" mit einem Arch Server über das CVS-System.
Der nun mit dem SVN-System synchrone Verzeichnisbaum befindet sich in '''/var/abs''' und sieht folgendermaßen aus:
Was genau ist der ABS Verzeichnisbaum? Er befindet sich in <code>/var/abs</code> und sieht so aus :


<pre>
| -- core/
|-
|    || -- acl/
| -- base/
|    ||    || -- PKGBUILD
|-
|    || -- attr/
|    ||-- autoconf/
|    ||    || -- PKGBUILD
|-
|    || -- autoconf/
|    ||-- automake/
|    ||    || -- PKGBUILD
|-
|    || -- ...
|    ||-- ...
| -- extra/
|-
|     || -- acpid/
| -- devel/
|    ||    || -- PKGBUILD
|-
|     || -- apache/
| -- ...
|     ||     || -- PKGBUILD
|-
|     || -- ...
| -- extra/
| -- community/
|-
|    || -- ...
|      || -- deamons/
|-
|     ||      || -- acpid/
|-
|     ||     ||     || -- PKGBUILD
...   ...   ...    ...
</pre>


Also ist der ABS Verzeichnisbaum genauso aufgebaut, wie die Paketdatenbank :
Jedes Repository besitzt einen eigenen Ordner in diesem Verzeichnisbaum, in dem sich dann die Ordner der jeweiligen Pakete befinden.
* erste Verzeichnisebene: Kategorien
Das Verzeichnis ''local'' dient zur Aufbewahrung selbst erstellter Pakete. Es wird im Gegensatz zu den anderen Ordnern von ''abs'' nicht verändert.
* zweite Verzeichnisebene: Paketverzeichnisse
* PKGBUILD Dateien mit Paketinformationen


Allerdings gibt es ein spezielles Verzeichnis: '''local'''. Es ist ''dein'' Verzeichnis, in dem du Pakete erstellst, du solltest niemals etwas in den restlichen Verzeichnissen ändern.
Die sich nun auf dem lokalen Rechner befindlichen PKGBUILDs lassen sich jetzt nach den eigenen Wünschen verändern und wie im nächsten Abschnitt beschrieben neu erstellen.


'''BEACHTE:''' Der erste Download des ABS Verzeichnisbaumes ist der größte, danach sind nur kleinere Updates nötig. Du brauchst auch mit kleinerer Bandbreite oder Volumentarif keine Angst haben : es sind nur Textdateien, die bei der Übertragung auch noch komprimiert sind.
== Erstellung von Paketen ==
{{achtung|Um Schäden am System zu vermeiden, sollten Pakete nie als root erstellt werden!}}
Pakete werden mit ''makepkg'' erstellt. Dazu muss in das Verzeichnis gewechselt werden, in dem sich das Paket befindet und hier ''makepkg'' ausgeführt werden. Verzeichnisse aus dem ABS-Verzeichnisbaum
sollten zuvor woandershin, zum Beispiel nach ''/var/abs/local'' oder nach ~/paketierung kopiert werden und nicht zur Erstellung des Pakets benutzt werden.


Nun weißt du, was der ABS Verzeichnisbaum ist, aber wie nutzt man ihn?
~/paketierung/foo/PKGBUILD (und ggf. noch weitere Dateien wie install-files, desktop-files, Patches u.v.m.


==== Erste Verwendung von ABS : Anpassen von Paketen ====
Sind nicht alle Abhängigkeiten zum Bau vorhanden, listet ''makepkg'' diese auf. ''makepkg -s'' würde versuchen, sie zu installieren. Das funktioniert aber nur, wenn sie in einem Repo vorhanden sind, auf das die Datei [[pacman.conf]] referenziert.


Diese Situation kann öfter erscheinen, als man meint : offizielle Pakete sind mit <code>--enable</code> oder <code>--disable</code> Optionen erstellt, die nicht deinen Anforderungen entsprechen.
cd ~/paketierung/foo
makepkg
Jetzt entstehen ein Verzeichnis namens src, und eines namens pkg. In ersterem findet der Paketbau statt in letzerem landen die Dateien, die ins fertige Paket sollen. Im PKGBUILD kann mit $srcdir bzw. $pkgdir darauf zugegriffen werden.
~/paketierung/foo/PKGBUILD
                  src
                  pkg


Nehmen wir als Beispiel : ''foo'' Das Paket ''foo'' wurde mit deaktivierte '''arts''' Unterstützung erstellt. Um '''arts''' Unterstützung zu aktivieren muss folgendes getan werden :
Das erstellte Paket (oder je nach Konfiguration der Variablen PKGDEST in der [[makepkg.conf]] ein Link darauf) befindet sich jetzt im selben Verzeichnis und kann mit [[pacman]] installiert werden:
pacman -U foo-0.99-x86_64.pkg.tar.gz


* finde heraus, wo das Paket ''foo'' liegt :
== Konfiguration ==
=== abs.conf ===
In der Datei ''/etc/abs.conf'' werden die Eigenschaften von ''abs'' festgelegt. Der wichtigste Punkt stellt die Möglichkeit der Wahl der Repositories dar, deren PKGBUILDs synchronisiert werden sollen.


suche ''foo'' in [http://archlinux.org/packages/]
=== makepkg.conf ===
{{achtung|Änderungen in makepkg.conf können Probleme und Fehler in den Paketen nachsichziehen und sollten daher nur von erfahreneren Nutzern durchgeführt werden.}}
In der Datei ''/etc/makepkg.conf'' werden die Eigenschaften von ''makepkg'' festgelegt. Dabei lassen sich die Standardeinstellungen der Programme verändern, die ''makepkg'' verwendet, um Pakete zu erstellen.
Zu nennen sind dabei die Umgebungsvariablen MAKEFLAGS, CFLAGS und CXXFLAGS, die ''gcc'' und ''make'' beeinflussen.


per ''find''  :
==Hinzufügen von Patches==
Hier wird beschrieben wie man einen Patch
den man selbst erstellt oder heruntergeladen hat, in die {{ic|prepare ()}} Funktion einer {{ic|PKGBUILD}} Datei einpflegt.


  <pre>
Als erstes fügt man einen Eintrag für den Patch in die {{ic|source}} Zeile ein. Dieser Eintrag muss durch ein Leerzeichen von dem URL zur Originalquelle getrennt sein.
  find /var/abs -name "foo"</pre>
Ist der Patch im Internet verfügbar, trägt man den vollständigen URL zum Patch ein, der Patch wird dann später beim eigentlichen Kompilieren des Paketes automatisch heruntergeladen und im src Verzeichnis abgelegt. Hat man den Patch selbst erstellt, oder bereits vorher heruntergeladen, legt man ihn im selben Verzeichnis wie die {{ic|PKGBUILD}} Datei ab. In diesem Fall trägt man lediglich den Dateinamen des Patches in die {{ic|source}} Zeile ein. Der Patch wird dann automatisch in das {{ic|source}} Verzeichnis kopiert. Sollte man die {{ic|PKGBUILD}} Datei weitergeben wollen, so muss man sie mit der Patchdatei zusammen weitergeben.
Anschließend fügt man einen Eintrag zur {{ic|md5sums}} bzw. {{ic|sha1sums}} Zeile hinzu. Die Prüfsummen erstellt man mittels {{ic|makepkg -g}}.
Nun erstellt man die {{ic|prepare()}} Funktion. Um das Patchen zu automatisieren trägt man die Anweisung in das zu patchende Verzeichnis zu wechseln ein; z.B.
cd $srcdir/$pkgname-$pkgver
oder ähnlich. {{ic|$pkname-$pkgver}} ist oftmals, aber nicht immer, der Name des beim Entpacken einer heruntergeladenen Quelldatei erstellten Verzeichnisses.
Abschließend muss man noch dafür sorgen, dass der Patch aus dem angegebenen Verzeichnis heraus appliziert werden kann. Dies geschieht, indem man
patch -p1 -i $srcdir/pkgname.patch
in die {{ic|prepare()}} Funktion einträgt. Für {{ic|pkgname.patch}} setzt man hier den zuvor in die {{ic|source}} Zeile eingetragenen Dateinamen des Patches ein.
Hier ein zur Veranschaulichung ein Beispiel für eine {{ic|prepare}} Funktion mit Patchfunktion:
prepare() {
cd "${srcdir}/${pkgname}-${pkgver}"
sed 's/file_handle/file_handle_rofl/g' -i istream.*
patch -p1 -i ../https-segfault.patch
patch -p1 -1 ../w3m-bdwgc72.diff
}


per slocate :
Das Paket kann nun in gewohnter Weise gebaut werden.


  <pre>
== Siehe auch ==
  slocate foo | grep ^/var/abs</pre>
* [[pacman]]
* [[AUR]]
* [[:en:Patching_in_ABS|Patching in ABS]] {{Sprache|en}}


In jedem Fall wirst du sehen, dass ''foo'' Bestandteil von <code>extra</code> und <code>multimedia</code> ist (Beispiel).
== Weblinks ==
* [http://www.gnu.org/software/make/manual/html_node/Options-Summary.html#Options-Summary Informationen über MAKEFLAGS] {{sprache|en}}
* [http://gcc.gnu.org/onlinedocs/gcc-4.3.3/gcc/Option-Summary.html#Option-Summary Informationen über CFLAGS und CXXFLAGS] {{sprache|en}}
* [http://en.gentoo-wiki.com/wiki/Safe_Cflags Gentoo Wiki: Safe CFLAGS] {{sprache|en}}


* kopiere das ''foo'' <code>PKGBUILD</code> in dein Arbeitsverzeichnis <code>/var/abs/local/foo</code>
{{ÜberFDL||Seite=http://wiki.archlinux.org|Name=ArchLinux.org Wiki|Original=http://wiki.archlinux.org/index.php?title=ABS_-_The_Arch_Build_System}}


  <pre>
[[Kategorie:Paketverwaltung]]
  mkdir /var/abs/local/foo
[[en:Arch Build System]]
  cp /var/abs/extra/multimedia/foo/* /var/abs/local/foo
  cd /var/abs/local/foo</pre>
 
* Anpassung des <code>PKGBUILD</code> : In unserem Fall  '''arts''' Unterstützung :
 
  <pre>
  build() {
    cd $startdir/src/$pkgname-$pkgver
    ./configure --prefix=/usr
    make || return 1
    make prefix=$startdir/pkg/usr install
  }</pre>
 
wird zu :
 
  <pre>
  build() {
    cd $startdir/src/$pkgname-$pkgver
    ./configure --enable-arts --prefix=/usr
    make || return 1
    make prefix=$startdir/pkg/usr install
  }</pre>
 
* Paket erstellen :
 
  <pre>
  makepkg</pre>
 
* Paket installieren (<code>-A</code> zum installieren, <code>-U</code> zum upgraden eines installierten Paketes):
 
  <pre>
  pacman -A foo-*.pkg.tar.gz
  pacman -U foo-*.pkg.tar.gz</pre>
 
==== Tuning: Compiler Flags und Anpassung von makepkg====
 
Die Konfigurationsdatei von <code>makepkg</code> liegt in <code>/etc/makepkg.conf</code>. Hier kannst du Umgebungsvariablen sowohl für <code>gcc</code> und <code>make</code> als auch für <code>makepkg</code> selbst  definieren. Hier eine Beispiel <code>/etc/makepkg.conf</code> :
 
<pre>
# Das FTP/HTTP download Programm, das makepkg zum laden der Quelltexte nutzt
export FTPAGENT="/usr/bin/wget --continue --passive-ftp --tries=3 --waitretry=3"
 
# Informationen für GCC über den Prozessortyp
export CARCH="i686"
export CHOST="i686-pc-linux-gnu"
 
# Flags für GCC, wenn ein Paket kompiliert wird
export CFLAGS "-march athlon-tbird -O2 -pipe"
export CXXFLAGS "-march athlon-tbird -02 -pipe"
 
# Flags für make, wenn ein Paket kompiliert wird
export MAKEFLAGS="-j 2"
 
# Aktiviere farbige Ausgabe
export USE_COLOR="y"
 
## Folgende Variablen betreffen nur makepkg
 
# Aktiviere fakeroot um Pakete als normaler User zu erstellen
export USE_FAKEROOT="y"
 
# Das Verzeichnis, in dem das erstellte Paket erstellt wird (normalerweise ./)
export PKGDEST=/home/packages
 
# Pfad zum ABS Verzeichnisbaum (normalerweise /var/abs)
export ABSROOT=/var/abs
 
# Aktiviere dies, um deinen Namen in erstellte Pakete zu schreiben
export PACKAGER="John Doe <nowhere@devnull.com>"
</pre>
 
'''BEACHTE:''' User wissen, was die Änderungen an den <code>CFLAGS, CXXFLAGS, MAKEFLAGS</code> Variablen bewirken, da sie Unstabilität oder Fehler bewirken können. Außerdem sollte der normale Arch Linux User die Werte für <code>CARCH</code> und <code>USE_FAKEROOT</code> nicht ändern.
 
Referenzen zu gcc und make flags
* [http://gcc.gnu.org/onlinedocs/gcc-3.4.3/gcc/Option-Summary.html#Option-Summary]
* [http://www.gnu.org/software/make/manual/html''chapter/make''9.html#SEC102]
 
 
<pre>
Translated Version of http://wiki.archlinux.org/index.php/ABS
Published under GNU Free Documentation License 1.2.
</pre>

Version vom 2. Juni 2014, 18:27 Uhr

Das Arch Build System (ABS) wird genutzt um:

  • Neue Pakete für Software zu erstellen
  • Vorhande Pakete an die eigenen Bedürfnisse anzupassen

Das Arch Build System besteht aus abs, makepkg und pacman. Dieser Artikel versucht nun eine Übersicht über das Erstellen von Paketen unter Archlinux zu geben. Detailreichere Informationen finden sich in den jeweiligen Manpages.

Vorbereitung

Das Paket "abs" installieren:

pacman -S abs

Alle sonstigen Pakete, die zur Erstellung von Paketen notwendig sind, befinden sich in der Gruppe base-devel:

pacman -S base-devel

Das Paket

Ein Paket ist eine Datei, die meist foo.pkg.tar.gz bzw. foo.pkg.tar.xz genannt ist.

Es ist nicht mehr, als ein gz bzw. xz komprimiertes tar-Archiv, das folgendes enthält:

  • Die zu installierenden Dateien
  • .PKGINFO : enthält alle Metadaten, die pacman für den Umgang mit Paketen, Abhängigkeiten etc. benötigt.
  • .INSTALL : enthält Befehle, die nach dem Installieren/Aktualisieren/Deinstallieren ausgeführt werden. (Nur vorhanden, wenn es in PKGBUILD definiert wurde)

Das PKGBUILD

PKGBUILD enthält die Metadaten über ein Paket, die von pacman benötigt werden, um die Pakete verwalten zu können. Es stellt die Grundlage für Pakete in Archlinux dar. Ein PKGBUILD ist eine einfache Textdatei, die beispielsweise so aussehen kann:

# $Id: PKGBUILD,v 1.12 2003/11/06 08:26:13 dorphell Exp $
# Maintainer: judd <jvinet@zeroflux.org>
# Contributor: Judd Vinet <jvinet@zeroflux.org>
pkgname=foo
pkgver=0.99 # note: if the pkgver had been '0.99-10' then use an underscore. like '0.99_10'
pkgrel=1
pkgdesc="short description of foo"
arch=(i686 x86_64)
url="http://www.foo.org"
license=('GPL')
groups=
provides=
depends=('qt' 'python')
makedepends=('guile')
conflicts=('yafoo')
replaces=('mffoo')
backup=('etc/foo/foo.conf')
install='foo.install'
source=(http://www.foo.org/download/$pkgname-$pkgver.tar.gz)
md5sums=('2c0cca3ef6330a187c6ef4fe41eca')

build() {
  cd $srcdir/$pkgname-$pkgver
  ./configure --prefix=/usr
  make
}
package() {
  cd $srcdir/$pkgname-$pkgver
  make DESTDIR=$pkgdir install
}

Erklärung:

  • # text : Kommentare
  • # $Id: PKGBUILD,v ... : Das SVN-Tag für dieses Paket (automatisch vom Archlinux-SVN System erstellt). Dies sollte bei Paketen, die für das AUR gedacht sind, stets weggelassen werden.
  • # Maintainer : Der Verantwortliche für dieses Paket in den offiziellen Repositories.
  • # Contributor : Der Verfasser der ersten PKGBUILD für dieses Paket.
  • pkgname : Der Paketname
  • pkgver : Die Paketversion
  • pkgrel : Die Releasenummer des Arch Paketes. Wird geändert, wenn das PKGBUILD verändert wurde, sie unterscheided sich also von der Paketversion.
  • pkgdesc : Eine Kurzbeschreibung des Paketes. Du siehst sie in der Paket Datenbank
  • arch : Die Architekturen, auf denen das Paket kompiliert und getestet wurde, oder 'any' bei plattformunabhängigen Paketen.
  • url : Die Homepage des Programmes
  • license : Die Lizenz, unter der das Programm steht
  • groups : Wird genutzt um Pakete zu Gruppen zusammen zu fassen. Wenn du z.B. KDE installieren willst, werden alle Pakete installiert, die zur Gruppe 'kde' gehören
  • provides : Wird genutzt, wenn das Paket ein anderes Paket bereitstellt.
  • depends : Liste der Abhängigkeiten um das Programm auszuführen.
  • makedepends : Liste der Abhängigkeiten um das Programm zu kompilieren. Pakete, die schon unter depends aufgeführt wurden, sind hier nicht noch einmal aufzuführen.
  • conflicts : Pakete, die nicht zusammen mit diesem Programm installiert sein können. In unserem Fall steht foo in Konflikt zu yafoo.
  • replaces : Das neue Paket ersetzt das alte. In unserem Fall wird mffoo nicht mehr unterstützt und wird durch foo ersetzt.
  • backup : Dateien, die gesichert werden (als .pacsave), wenn das Programm deinstalliert wird.
  • install : Spezifiziert ein Installationsskript, das im Paket enthalten ist. (Muss sich mit PKGBUILD im selben Verzeichnis befinden)
  • source : Die Bezugsquelle des Quelltextes. Kann sowohl ein lokales Paket, als auch ein remote "http" oder "ftp" Paket sein. Der Dateiname wird aus pkgname und pkgver erstellt, damit der Pfad nicht bei jeder neuen Version angepasst werden muss.
  • md5sums : MD5 Summen der Quelltexte um beschädigte Dateien auszuschließen.
  • build() : Alle Schritte, die nötig sind um das Paket zu kompilieren.

Die build-Funktion und die Package-Funktion

In der build-Funktion werden die Anweisungen ausgeführt, die nötig sind, um das Paket zu kompilieren.

In der package-Funktion werden die zu installierenden Dateien und Verzeichnisse so abgelegt, dass makepkg daraus einen Tarball - das Paket - erstellen kann, der dann von pacman installiert werden kann. Es kann aber auch mehrere Package-Funktionen geben. Dann spricht man von split packages.


Wenn du dich nicht mit dem Bauen von Paketen auskennst, solltest du wissen, dass die meisten Pakete über den Dreisatz erstellt werden können:

./configure --prefix=/usr
make
make install

./configure überprüft zunächst, ob alle Voraussetzungen für das zu kompilierende Programm erfüllt sind. Über dieses Script lässt sich auch konfigurieren, wie und mit welchen Funktionen ein Programm kompiliert wird. ./configure --help zeigt meistens eine Übersicht über die Optionen, die verfügbar sind. make kompiliert schließlich das Paket und make install installiert die Dateien.

Du solltest immer die INSTALL oder die README Datei des jeweiligen Pakets lesen, um zu erfahren, wie es erstellt und installiert werden sollte, denn nicht alle Pakete nutzen diesen Dreisatz!


Eine 'Standard' build-Funktion sieht so aus:

build() {
 cd $srcdir/$pkgname-$pkgver
 ./configure --prefix=/usr
 make
}

Erklärung:

  • In das Verzeichnis der von makepkg entpackten Quelltexte wechseln (hier treten in der Praxis oft schon Probleme auf; besser, man schaut nach ob das Verzeichnis wirklich so heißt):
cd $srcdir/$pkgname-$pkgver
  • Konfigurieren des Paketes mit dem Installationsverzeichnis /usr und unter Umständen weiteren Optionen:
./configure --prefix=/usr --option1 --option2

Da die meisten Programme davon ausgehen, dass nach /usr/local installiert werden soll, wir unter Arch Linux aber nach /usr installieren wollen, ist es wichtig, das Prefix zu setzen.

  • kompilieren:
make

Eine 'Standard' package-Funktion sieht so aus:

  • installieren:
make DESTDIR=$pkgdir install

Dabei wird das Programm nicht in /usr sondern in $pkgdir/usr installiert, so dass erst einmal makepkg und indirekt auch pacman Kontrolle über die Dateien hat! Ob DESTDIR verwendet wird, hängt vom jeweiligen Programm bzw. dessen Makefile ab. Manchmal muss z.B. auch PREFIX verwendet und entsprechend umgebogen werden.

make PREFIX=$pkgdir/usr install

Installationsdateien

Installationsdateien stellen die Möglichkeit bereit, Anweisungen zu bestimmten Punkten der Installation auszuführen. Dazu müssen sie im PKGBUILD angegeben werden. Unseres gibt 'foo.install' als Installationsdatei an. Es könnte z.B. folgendes enthalten:

post_install() {
/bin/true
}

post_upgrade() {
/bin/true
}

pre_remove() {
/bin/true
}

Erklärungen:

  • post_install: Wird nach der Installation ausgeführt. Es wird ein Argument übergeben:
    • Die Paketversion
  • post_upgrade: Wird ausgeführt, nachdem alle Dateien aktualisiert wurden Es werden zwei Argumente übergeben:
    • Die neue Paketversion
    • Die alte Paketversion
  • pre_remove: Wird ausgeführt, bevor Dateien gelöscht werden (beendet z.B. daemonen) und übergibt ein Argument:
    • Die Paketversion

Der ABS-Verzeichnisbaum

Bei Archlinux werden die PKGBUILDs, anhand derer die Pakete in den offiziellen Repositories gebaut sind, mit SVN verwaltet. Sie werden mit abs auf den lokalen Rechner heruntergeladen oder aktualisiert:

abs

Der nun mit dem SVN-System synchrone Verzeichnisbaum befindet sich in /var/abs und sieht folgendermaßen aus:

| -- core/
|     || -- acl/
|     ||     || -- PKGBUILD
|     || -- attr/
|     ||     || -- PKGBUILD
|     || -- autoconf/
|     ||     || -- PKGBUILD
|     || -- ...
| -- extra/
|     || -- acpid/
|     ||     || -- PKGBUILD
|     || -- apache/
|     ||     || -- PKGBUILD
|     || -- ...
| -- community/
|     || -- ...

Jedes Repository besitzt einen eigenen Ordner in diesem Verzeichnisbaum, in dem sich dann die Ordner der jeweiligen Pakete befinden. Das Verzeichnis local dient zur Aufbewahrung selbst erstellter Pakete. Es wird im Gegensatz zu den anderen Ordnern von abs nicht verändert.

Die sich nun auf dem lokalen Rechner befindlichen PKGBUILDs lassen sich jetzt nach den eigenen Wünschen verändern und wie im nächsten Abschnitt beschrieben neu erstellen.

Erstellung von Paketen

Achtung: Um Schäden am System zu vermeiden, sollten Pakete nie als root erstellt werden!

Pakete werden mit makepkg erstellt. Dazu muss in das Verzeichnis gewechselt werden, in dem sich das Paket befindet und hier makepkg ausgeführt werden. Verzeichnisse aus dem ABS-Verzeichnisbaum sollten zuvor woandershin, zum Beispiel nach /var/abs/local oder nach ~/paketierung kopiert werden und nicht zur Erstellung des Pakets benutzt werden.

~/paketierung/foo/PKGBUILD (und ggf. noch weitere Dateien wie install-files, desktop-files, Patches u.v.m.

Sind nicht alle Abhängigkeiten zum Bau vorhanden, listet makepkg diese auf. makepkg -s würde versuchen, sie zu installieren. Das funktioniert aber nur, wenn sie in einem Repo vorhanden sind, auf das die Datei pacman.conf referenziert.

cd ~/paketierung/foo
makepkg

Jetzt entstehen ein Verzeichnis namens src, und eines namens pkg. In ersterem findet der Paketbau statt in letzerem landen die Dateien, die ins fertige Paket sollen. Im PKGBUILD kann mit $srcdir bzw. $pkgdir darauf zugegriffen werden.

~/paketierung/foo/PKGBUILD
                  src
                  pkg

Das erstellte Paket (oder je nach Konfiguration der Variablen PKGDEST in der makepkg.conf ein Link darauf) befindet sich jetzt im selben Verzeichnis und kann mit pacman installiert werden:

pacman -U foo-0.99-x86_64.pkg.tar.gz

Konfiguration

abs.conf

In der Datei /etc/abs.conf werden die Eigenschaften von abs festgelegt. Der wichtigste Punkt stellt die Möglichkeit der Wahl der Repositories dar, deren PKGBUILDs synchronisiert werden sollen.

makepkg.conf

Achtung: Änderungen in makepkg.conf können Probleme und Fehler in den Paketen nachsichziehen und sollten daher nur von erfahreneren Nutzern durchgeführt werden.

In der Datei /etc/makepkg.conf werden die Eigenschaften von makepkg festgelegt. Dabei lassen sich die Standardeinstellungen der Programme verändern, die makepkg verwendet, um Pakete zu erstellen. Zu nennen sind dabei die Umgebungsvariablen MAKEFLAGS, CFLAGS und CXXFLAGS, die gcc und make beeinflussen.

Hinzufügen von Patches

Hier wird beschrieben wie man einen Patch den man selbst erstellt oder heruntergeladen hat, in die prepare () Funktion einer PKGBUILD Datei einpflegt.

Als erstes fügt man einen Eintrag für den Patch in die source Zeile ein. Dieser Eintrag muss durch ein Leerzeichen von dem URL zur Originalquelle getrennt sein. Ist der Patch im Internet verfügbar, trägt man den vollständigen URL zum Patch ein, der Patch wird dann später beim eigentlichen Kompilieren des Paketes automatisch heruntergeladen und im src Verzeichnis abgelegt. Hat man den Patch selbst erstellt, oder bereits vorher heruntergeladen, legt man ihn im selben Verzeichnis wie die PKGBUILD Datei ab. In diesem Fall trägt man lediglich den Dateinamen des Patches in die source Zeile ein. Der Patch wird dann automatisch in das source Verzeichnis kopiert. Sollte man die PKGBUILD Datei weitergeben wollen, so muss man sie mit der Patchdatei zusammen weitergeben. Anschließend fügt man einen Eintrag zur md5sums bzw. sha1sums Zeile hinzu. Die Prüfsummen erstellt man mittels makepkg -g. Nun erstellt man die prepare() Funktion. Um das Patchen zu automatisieren trägt man die Anweisung in das zu patchende Verzeichnis zu wechseln ein; z.B.

cd $srcdir/$pkgname-$pkgver

oder ähnlich. $pkname-$pkgver ist oftmals, aber nicht immer, der Name des beim Entpacken einer heruntergeladenen Quelldatei erstellten Verzeichnisses. Abschließend muss man noch dafür sorgen, dass der Patch aus dem angegebenen Verzeichnis heraus appliziert werden kann. Dies geschieht, indem man

patch -p1 -i $srcdir/pkgname.patch

in die prepare() Funktion einträgt. Für pkgname.patch setzt man hier den zuvor in die source Zeile eingetragenen Dateinamen des Patches ein. Hier ein zur Veranschaulichung ein Beispiel für eine prepare Funktion mit Patchfunktion:

prepare() {
cd "${srcdir}/${pkgname}-${pkgver}"
sed 's/file_handle/file_handle_rofl/g' -i istream.*
patch -p1 -i ../https-segfault.patch 
patch -p1 -1 ../w3m-bdwgc72.diff
}

Das Paket kann nun in gewohnter Weise gebaut werden.

Siehe auch

Weblinks


Dieser Artikel (oder Teile davon) steht unter GNU FDL (GNU Freie Dokumentationslizenz) und ist eine Übersetzung aus dem ArchLinux.org Wiki. Am Original-Artikel kann jeder Korrekturen und Ergänzungen vornehmen. Im ArchLinux.org Wiki ist eine Liste der Autoren verfügbar.