, tags: arch, github, linux, continuous integration

3 min read

Automatisiert AUR Packages mithilfe von Github Actions veröffentlichen

Vor einiger Zeit habe ich ein (für mich) ziemlich interessantes Software Projekt von m0ngr31 (@Github) entdeckt: Jellyamp, eine freie Software vergleichbar mit Plexamp, jedoch für den Medienserver Jellyfin. Da es noch kein AUR Paket gab, las ich mich ein, wie man diese erstellt. Schließlich galt es das ganze zu automatisieren, so dass ich die Schritte nicht bei jedem Release manuell durchführen muss.

AUR PKGBUILD

Zuerst habe ich mir angeschaut, wie eine PKGBUILD Datei für Arch aufgebaut ist, und wie diese funktionieren. Da das für ein Appimage relativ einfach ist, kam ich, dank dem Blog Beitrag von Dave Parrish recht schnell zu einem fertigen PKGBUILD. Dieses besteht aus Variablen, die den Paketnamen, die Version, in Konflikt stehende Pakete, die Architektur, die Lizenz, Abhängigkeiten, usw. enthalten:

# Maintainer: Peter Gerhards <mail@peterge.de>

_pkgname=Jellyamp
pkgname=jellyamp-appimage
pkgver=0.9.8
pkgrel=1
pkgdesc="A stylish, cross-platform desktop client for listening to music from a Jellyfin server. Inspired by Plexamp."
provides=('jellyamp')
conflicts=('jellyamp')
arch=('x86_64')
url="https://github.com/m0ngr31/jellyamp"
license=("MIT")
depends=('zlib' 'hicolor-icon-theme')
options=(!strip)
_appimage="${pkgname}-${pkgver}.AppImage"
source=("${_appimage}::https://github.com/m0ngr31/jellyamp/releases/download/v${pkgver}/${_pkgname}-${pkgver}-${arch}.AppImage"
               "https://raw.githubusercontent.com/m0ngr31/jellyamp/v${pkgver}/LICENSE"
       )
noextract=("${_appimage}")

Danach folgen drei Funktionen, die zunächst die Appimage Datei ausführbar machen und extrahieren, danach eine .dekstop Datei erstellen, sowie die Berechtigungen anpassen und schließlich die Datei und die Lizenz verschieben, die .desktop Datei und Icons kopieren, und die korrekten Symlinks anlegen:

prepare() {
    chmod +x "${_appimage}"
    ./"${_appimage}" --appimage-extract
}

build() {
    # Adjust .desktop so it will work outside of AppImage container
    sed -i -E "s|Exec=AppRun|Exec=env DESKTOPINTEGRATION=false /usr/bin/${_pkgname}|"\
        "squashfs-root/${_pkgname}.desktop"
    # Fix permissions; .AppImage permissions are 700 for all directories
    chmod -R a-x+rX squashfs-root/usr
}

package() {
    # AppImage
    install -Dm755 "${srcdir}/${_appimage}" "${pkgdir}/opt/${pkgname}/${pkgname}.AppImage"
    install -Dm644 "${srcdir}/LICENSE" "${pkgdir}/opt/${pkgname}/LICENSE"

    # Desktop file
    install -Dm644 "${srcdir}/squashfs-root/${_pkgname}.desktop"\
            "${pkgdir}/usr/share/applications/${_pkgname}.desktop"

    # Icon images
    install -dm755 "${pkgdir}/usr/share/"
    cp -a "${srcdir}/squashfs-root/usr/share/icons" "${pkgdir}/usr/share/"

    # Symlink executable
    install -dm755 "${pkgdir}/usr/bin"
    ln -s "/opt/${pkgname}/${pkgname}.AppImage" "${pkgdir}/usr/bin/${_pkgname}"

    # Symlink license
    install -dm755 "${pkgdir}/usr/share/licenses/${pkgname}/"
    ln -s "/opt/$pkgname/LICENSE" "$pkgdir/usr/share/licenses/$pkgname"
}

Zum Schluss ist noch eine Liste mit den Hashsummen der einzelnen Dateien angegeben (makepkg -g >> PKGBUILD):

md5sums=('6413a08ea61f23b03fb6d44e0e9e137a'
         'f320c21f36aa4854c516c2393ba9de69')

Mit dieser Datei lässt sich dann mit makepkg -si das korrekte Paket herunterladen, extrahieren, und installieren.

Automatische Aktualisierung mithilfe von Github Actions

Um nun den manuellen Aufwand zu ersparen, verwende ich Github Actions, die bei einem neuen Release innerhalb der nächsten 3 Stunden die korrekte PKGBUILD Datei ins AUR hochladen. Dazu habe ich 2 Workflows angelegt.
Der erste prüft alle 3 Stunden auf einen neuen Release im Repo der Software, und updatet in diesem Fall die Datei release-versions/jellyamp-latest.txt, und commited & pusht die Änderungen dann wieder ins Repo.
Im zweiten Workflow ist die Startbedingung ein push, der eine Datei in release-versions verändert. Daraufhin startet die Action einen Docker Container mit dem Dockerfile aus dem jellyamp-appimge Verzeichnis. Dieses gibt als Basisimage die aktuellste Version des archlinux Containers an, installiert notwendige Pakete wie base-devel und git, fügt einen User hinzu, mit dem wir später die Arbeit durchführen, und kopiert und führt das Script entrypoint.sh aus.
Dieses klont zunächst das Github Repo mit dem PKGBUILD Template und das AUR Repo der Software. Nun überschreibe ich die Software Version mit dem aktuellsten Stand den ich von der Github API geliefert bekomme, lade alle Dateien runter und erstelle die Hashsumme aller Dateien und erzeuge schließlich die .SRCINFO Datei für AUR. Diese schiebe ich dann nach /github/workspace, ein Verzeichnis dass auch außerhalb des Docker Containers verfügbar ist.
Nun folgt als letzter Schritt das hochladen von PKGBUILD und .SRCINFO aus /github/workspace ins AUR. Dies erledige ich mithilfe der Action KSXGitHub/github-actions-deploy-aur, hierzu habe ich im Repo Secrets angelegt und einen zusätzlichen User als Maintainer auf das AUR Projekt berechtigt. Über diesen erfolgt dann das commiten & pushen der beiden Dateien. Die aktuellsten Änderung im AUR Repo können hier eingesehen werden.

Update 04/2021: Die Action funktioniert! (Ich hab natürlich nie daran gezweifelt xD) Aber es kann sein das Github den Workflow auf inaktiv stellt. Dann muss man dies in der Webgui nach 60 Tagen bestätigen. Alternativ kann man auch mit

on:
 workflow_dispatch:

in der Action diese von der Webgui aus starten.

Author: peterge