Creazione di un PKGBUILD per creare pacchetti per Arch Linux

I file PKGBUILD sono il modo in cui i pacchetti vengono creati e creati per Arch Linux e i suoi derivati ​​come Manjaro.

Potresti anche averli incontrati un po' tu stesso se hai mai usato AUR, il repository di PKGBUILD curato dagli utenti di Arch Linux.

Ma come si passa esattamente da un PKGBUILD a un pacchetto installabile? Cosa sta succedendo esattamente tra i due e come puoi crearli per i tuoi pacchetti? Li imparerai in questo articolo.

Nozioni di base su PKGBUILD

Per coloro che hanno familiarità con Bash o altre shell, sarai felice di sapere, se non l'hai già fatto, che un PKGBUILD è praticamente solo uno script di shell con alcune variabili.

I file PKGBUILD sono costituiti da variabili e funzioni, tutte utilizzate per definire il pacchetto stesso e come costruirlo.

Per creare un pacchetto da un PKGBUILD, viene utilizzata l'utilità della riga di comando makepkg. Dopo aver ottenuto un PKGBUILD, esegui semplicemente makepkg all'interno della directory contenente PKGBUILD, e voilà, hai un pacchetto installabile!

In questo tutorial, esaminerai il pacchetto che ho appena creato, che stampa "Hello World!" quando eseguito:

Preparazione

Per seguire questo tutorial, devi creare un paio di file.

Innanzitutto, devi creare un file chiamato PKGBUILD . Se non è già stato chiarito, questa servirà come "ricetta" per creare il tuo pacchetto.

L'altro file che devi creare è un file chiamato hello-world.sh . Spiegherò il suo scopo un po' più tardi.

Puoi creare entrambi questi file anche con un singolo comando.

touch PKGBUILD hello-world.sh

Puoi verificare che i file siano stati creati con il comando ls:

E sei pronto per partire!

Configurazione del file PKGBUILD

Invece di dover copiare e incollare l'intero file, andrò oltre inserendo ogni riga con te, così puoi capire meglio lo scopo di tutto ciò che sta accadendo. Se non preferisci farlo impara in questo modo, ti consiglio vivamente il Articolo di Arch Wiki sulla creazione di pacchetti per Arch Linux.

Questo articolo, inoltre, non esamina ogni singola opzione che puoi impostare in un PKGBUILD, ma piuttosto alcune di quelle comunemente utilizzate in modo da poter iniziare il più rapidamente possibile.

Detto questo, apri il tuo editor di testo e iniziamo subito!

nomepkg

Per prima cosa, la variabile pkgname. Questo è ciò che definisce il nome del tuo pacchetto durante l'installazione e come pacman, il gestore di pacchetti di Arch Linux, tiene traccia del pacchetto.

Il formato di questa variabile (e di alcune altre) assume la forma di variabile=valore, con il nome della variabile a sinistra, il valore della variabile a destra, separati da un segno di uguale.

Per impostare il nome del pacchetto, inserisci quanto segue in PKGBUILD:

pkgname="hello-world"

• Per impostare un nome di pacchetto diverso, sostituisci hello-world con il nome del pacchetto.
• Questo non imposta il comando utilizzato per eseguire il programma. Questo è gestito un po' di seguito nel package() sezione.

pkgver

Come indicato nel nome della variabile stessa, questo imposta la versione del tuo pacchetto (cioè 1.0.0). Ciò è utile quando un utente aggiorna il proprio sistema, poiché l'impostazione di una versione superiore comporterà la richiesta di aggiornamento all'utente.

Per impostare, inserisci quanto segue in PKGBUILD (dopo la riga precedente):

pkgver="1.0.0"

pacchetto

Questo è correlato alla variabile pkgver e normalmente non è importante conoscerlo. Come la variabile pkgver, tuttavia, avviserà gli utenti per gli aggiornamenti se viene spostata a un numero più alto.

Serve per tutte le modifiche che richiedono che il pkgver rimanga lo stesso, come le modifiche allo stesso PKGBUILD. Ciò sarebbe utile se hai creato un PKGBUILD per un programma che usi (e desideri mantenere la versione uguale a quella del pacchetto) e devi correggere un bug nel PKGBUILD stesso.

Per impostare la variabile, inserisci quanto segue in PKGBUILD:

pkgver="1"

Questa variabile dovrebbe sempre inizia da 1, quindi sali uno alla volta. Quando il pkgver si sposta verso l'alto, questo può (e dovrebbe) essere reimpostato su 1, poiché lo stesso pkgver notificherà agli utenti che sono disponibili aggiornamenti.

pkgdesc

Questo imposterà la descrizione del pacchetto, che viene utilizzata per identificare meglio il pacchetto.

Per impostarlo, metti la descrizione tra virgolette:

pkgdesc="Hello world in your terminal!"

arco

Questa variabile imposta l'architettura con cui il pacchetto è compatibile. Va bene se non capisci cos'è un'architettura, poiché nella maggior parte dei casi è praticamente inutile.

Indipendentemente da ciò, makepkg deve ancora essere impostato in modo che sappia che il pacchetto è compatibile con il nostro sistema.

Questa variabile supporta l'impostazione di più valori, quindi makepkg richiede una sintassi diversa come mostrato di seguito.

Per impostarlo, inserisci quanto segue in PKGBUILD:

arch=("x86_64")

Se dovessi impostare più valori per questo, separeresti ogni valore con uno spazio e virgolette in questo modo:arch=(“x86_x64” “arm”)

dipende

Questo elenca tutti i pacchetti di cui il nostro pacchetto ha bisogno per funzionare. Come arco , può anche contenere più valori e quindi deve utilizzare la sintassi delle parentesi.

Poiché il nostro pacchetto non avrà alcuna dipendenza, non dobbiamo inserire questo campo in PKGBUILD. Se il nostro pacchetto avesse dipendenze, tuttavia, useremmo semplicemente la stessa sintassi di arch .

optdipende

Questo elenca i pacchetti che non sono necessari per funzionare, ma che sono necessari per funzionalità extra.

Questo segue la stessa sintassi di dipende .

conflitti

Questo dice a pacman quali pacchetti farebbero agire il nostro pacchetto o si comporterebbero in un modo che non vorremmo.

Qualsiasi pacchetto elencato qui verrebbe disinstallato prima dell'installazione del nostro.

Questo segue la stessa sintassi di dipende anche.

licenza

Definisce la licenza software con cui è concesso in licenza il programma. Arch Wiki ha alcune informazioni se hai bisogno di aiuto per scegliere una licenza. Impostandolo su custom funzionerà se non sai su cosa impostarlo.

Questo richiede la stessa sintassi di arch e dipende :

license=("custom")

fonte

Questo è il modo in cui makepkg sa quali file usare per costruire il nostro pacchetto. Questo può contenere una varietà di diversi tipi di fonti, inclusi file locali e URL.

Quando aggiungi file locali, inserisci il nome del file relativo a PKGBUILD, ovvero considera il seguente layout di directory:

PKGBUILD
file.txt
src/file.sh

Se desideri includere file.sh nella nostra PKGBUILD, inseriresti src/file.sh come il suo nome.

Quando si inseriscono gli URL, è sufficiente inserire l'URL completo, ad esempio https://mirrors.creativecommons.org/presskit/logos/cc.logo.large.png.

Il tuo pacchetto ha bisogno solo del file hello-world.sh e, poiché si trova nella stessa directory di PKGBUILD, devi semplicemente digitarne il nome come valore per source .

Questa variabile utilizza anche la stessa sintassi di arch e dipende :

source=("hello-world.sh")

sha512somma

Viene utilizzato per verificare che i file in sorgente non sono stati modificati o scaricati in modo errato. Informazioni su come ottenere i valori per questo possono essere trovate nell'articolo Arch Wiki su PKGBUILDs.

Se preferisci semplicemente non impostarlo (o semplicemente non è necessario, ad esempio per i file locali), puoi semplicemente inserire SKIP per ogni file nella sorgente variabile:

sha512sums=("SKIP")

pacchetto()

Questa è l'ultima e più importante parte per realizzare effettivamente il nostro pacchetto. È importante conoscere due variabili quando si lavora con questo:

• ${srcdir} :Qui è dove makepkg mette i file nel sorgente variabile. Questa è la directory in cui puoi interagire con i file e apportare qualsiasi altra modifica necessaria ai file.

• ${pkgdir}:Qui è dove posizioniamo i file che verranno installati sul nostro sistema.
  La struttura delle cartelle per ${pkgdir} è impostata come se fosse su un sistema reale (cioè ${pkgdir}/usr/bin/hello-world creerebbe il file /usr/bin/hello-world durante l'installazione con pacman.

package() contiene un elenco di comandi utilizzati per creare un pacchetto.

Quindi, se (ipoteticamente) dovessi avere un file che legge Linux è superiore a Windows in /usr/share/motto.txt, eseguiresti qualcosa del genere:

package() {
  mkdir -p "${pkgdir}/usr/share"
  echo "Linux is superior to Windows" | tee "${pkgdir}/usr/share/motto.txt"
}

Alcune note sul comando precedente:

• ${pkgdir} contiene nessun all'inizio le directory al suo interno. Se hai saltato il comando mkdir, tee visualizzerebbe un errore dicendo che la directory non esiste.

• Quando si specificano le directory, sempre anteponili con ${pkgdir} o ${srcdir} variabile. L'inserimento di qualcosa come /usr/share/motto.txt senza tale indicherebbe la directory letterale /usr/share/motto.txt sul tuo sistema attualmente in esecuzione.

Per il tuo PKGBUILD, collocherai il file hello-world.sh in /usr/bin/hello-world sul tuo sistema di destinazione. Farai anche in modo che il file dica "Ciao a te!" quando eseguito.

Per farlo, inserisci quanto segue nella tua PKGBUILD:

package() {
  echo 'Hello to you!' > "${srcdir}/hello-world.sh"
  mkdir -p "${pkgdir}/usr/bin"
  cp "${srcdir}/hello-world.sh" "${pkgdir}/usr/bin/hello-world"
  chmod +x "${pkgdir}/usr/bin/hello-world"
}

E hai finito! Il file risultante ora dovrebbe essere simile a questo:

Ora compila e installa il pacchetto con makepkg -si comando, quindi esegui hello-world nel tuo terminale per vederne l'output.

Conclusione

E proprio così, hai creato il tuo primo PKGBUILD! Stai per creare dei veri e propri pacchetti per te stesso, e forse anche per l'AUR.

Hai qualche domanda o qualcosa semplicemente non funziona bene? Sentiti libero di pubblicarlo nella sezione commenti qui sotto.