RPMBUILD

Nozioni Base di RPMBUILD

Rpmbuild è uno strumento per la creazione di pacchetti .rpm, tali pacchetti possono contenere programmi, documenti, file di configurazione.
Per generare il pacchetto rpm, RPMBUILD utilizza delle DIRECTORY proprie:

SOURCES:            può contenere sorgente e patch
SPECS:                  file .spec
SRPMS:                 nuovo file sorgente
RPMS:                   file rpm
BUILD:                  build_dir, usata dal sistema per elaborare i file
BUILDROOT:      (non sempre presente di default): è la directory sulla quale andrò a costruire la root del sistema dove l’rpm finale installerà i file.

La finalità delle varie operazioni che il sistema esegue sarà quella di ricreare tutta la struttura di file e directory del pacchetto da installare all’interno di una directory propria del sistema chiamata BuildRoot.
In sostanza BUILDROOT/nome-pacchetto rappresenta per l’rpmbuild quello che sarà la ROOT nel server dove andremo ad installare l’rpm che vogliamo creare.

Esempio:
Devo creare un pacchetto rpm: pippo.rpm
In fase di creazione del pacchetto mi ritrovo la seguente situazione sulla BUILDROOT:

/BUILDROOT/pippo-0.1/etc/pippo.conf
/BUILDROOT/ pippo-0.1/var/pippo.log
/BUILDROOT/ pippo-0.1/usr/bin/pippo
/BUILDROOT/ pippo-0.1/usr/lib/cosedipippo

Quando rpmbuild avrà creato il pacchetto pippo.rpm ed io vado ad installarlo su un qualunque server della mia rete, mi ritroverò in tale server i seguenti file (in realtà possiamo anche decidere quali fare installare e quali no:

/etc/pippo.conf
/var/pippo.log
/usr/bin/pippo
/usr/lib/cosedipippo

Quindi BUILDROOT/pippo-0.1 mi rappresenta la ROOT del server dove andrò ad installare il pacchetto rpm che ora voglio creare
Tutte le operazioni che l’rpmbuild deve compiere per creare il file rpm sono contenute in un file .spec , presente nella cartella SPECS.
Quindi per realizzare un rpm, il passo principale è editare in modo opportuno il file spec.

Installazione

yum install rpm-build rpmdevtools

opzionalmente e preferibilmente si può installare anche: rpmdevtools

Creare ed editare il file spec

Al momento dell’installazione rpmbuild crea le directory:

/root/rpmbuild/BUILD
/root/rpmbuild/RPMS
/root/rpmbuild/SOURCES
/root/rpmbuild/SPECS
/root/rpmbuild/SRPMS

creiamo noi la seguente
/root/rpmbuild/BUILDROOT

Se non dovesse crearle, possono essere create manualmente.
Nel caso si sia installato rpmdevtools  le cartelle si possono creare tramite il comando

rpmdev-setuptree

Se tale comando non viene eseguito dall’utente root ma un altro utente, le directory verranno create nella home dell’utente che ha eseguito il comando.
Possiamo creare un file .spec nella directory SPECS tramite l’uso di VIM (o VI).
Se abbiamo installato gli rpmdevtools possiamo creare un file .spec con valori di default tramite il comando:

rpmdev-newspec nomefile.spec

Il file SPEC conterrà tutte le informazioni del pacchetto che vogliamo installare e tutte le operazioni e modifiche che vorremo applicare sul pacchetto sorgente (se esiste) affiché queste facciano parte del nuovo pacchetto rpm che vogliamo creare.

Le sezioni del file spec.

(prima parte)

Name:
Version:
Release:
Summary:
Group:
License:
URL:
Source0:
Source1:
Patch0:
Patch1:
BuildRoot:
BuildRequires:
Requires:
%description

Name: nome del pacchetto
Version: versione del pacchetto
Release: numero di volte che è stato creata questa versione del pacchetto
Summary: breve descrizione del Pacchetto
Group: indica la tipologia del pacchetto. L’elenco delle tipologie si trova in /usr/share/doc/rpm/GROUPS
Licence: indica la licenza del pacchetto
URL: indica l’url, se esiste, della documentazione del pacchetto o del produttore
Source0: indica il nome del file sorgente del nostro pacchetto, solitamente un file .tar che comprende tutti i file del pacchetto di cui vogliamo realizzare l’rpm. Possono esistere più file Source, in tal caso vengono indicato successivamente come Source1, Source2…
Patch0: comprende i file delle patch da applicare ai file sorgenti se si vuole modificarli. Possono esserci più file di patch, in questo caso vengono indicati come Patch1, Patch2…
BuildRoot: questa directory è la ROOT per il sistema che installerà il pacchetto rpm che andremo a creare.
Il path dovrebbe essere di default: /root/rpmbuild/BUILDROOT/nomepacchetto-versione/ oppure ne possiamo indicare uno in questa variabile. In questa cartella dobbiamo “ricostruire” i file del nostro pacchetto esattamente come saranno installati nel server che installerà il pacchetto finito.
ATTENZIONE: in alcune versioni di rpmbuild questo valore può essere ignorato se risulta settato di default nei file di configurazione (vedi fine documento). Il valore resta sempre quello di default anche se si prova a settarne uno diverso in questa variabile.
BuildRequires: pacchetti che è necessario avere installati nel proprio sistema affinchè rpmbuild possa creare il file rpm.
Requires: pacchetti che sono necessari nel server che dovrà installare il nostro pacchetto rpm affinchè questo possa funzionare (le dipendenze).
%description:  descrizione lunga di quello che è e che fa il nostro pacchetto

IMPORTANTE:
quella che sarà la BuildRoot (che non è BUILDROOT ma è di default BUILDROOT/nomepacchetto-ver) può essere indicata nello spec file tramite l’uso di due variabili:

%{buildroot}
$RPM_BUILD_ROOT

Mentre la directory /root/rpmbuild/BUILD può essere indicate tramite la variabile:

%{_builddir}

(seconda parte)

%prep
%setup -q
%patch
%build

%configure
make %{?_smp_mflags}

%install
rm -rf $RPM_BUILD_ROOT
make install DESTDIR=$RPM_BUILD_ROOT

%clean
rm -rf $RPM_BUILD_ROOT

%files
%defattr(-,root,root,-)
%doc
%changelog

Le fasi che andiamo ora a descrivere sono quelle che elaborano i file in modo tale che siano pronti ad essere inseriti nel pacchetto finale.
Ognuna di queste fasi può essere indirizzata tramite l’unione di MACRO proprie di rpmbuild a cui possiamo aggiungere comandi bash.

La fase %PREP

Scompatta il file sorgente e lo copia sulla directory /root/rpmbuild/BUILD
Questa directory è quella che rpmbuild utilizza per svolgere tutte le operazioni sui file (che poi andranno spostati in modo opportuno su BuildRoot prima di generare il pacchetto rpm).
le macro che eseguono questa funzione sono:

%setup –> cancella tutto quello che c’è dentro BUILD e scompatta il source (opzione -c per creare una cartella dentro BUILD)

%patch –> applica le patch elencate

Opzioni di %Setup (da documentazione):

   -a number
 Only unpack the source directive of the given number, such as –a 0 for source0:, after changing to the  directory.

  -b number
 Only unpack the source directive of the given number, such as –b 0 for source0:, before changing to the  directory.

  -c
 Create directory before unpacking, used if your sources will not create the directory as part of unpacking. (dir:name-ver)

  -D
 Do not delete the directory before unpacking.

 -n name
 Name the directory as name.

 -q
 Run quietly with minimal output.

 -T
 Disable the automatic unpacking of the archives.

Se non abbiamo un file sorgente da scompattare o se vogliamo lavorare su tale file in modo differente, possiamo non inserire la macro %setup ed eseguire noi l’elenco dei  comandi che riteniamo opportuni.
Stesso discorso se non abbiamo patch da applicare.

Nota: applicare una patch significa che rpmbuild confronta il file di patch con l’analogo del pacchetto source e lo corregge secondo le indicazioni trovate su patch.
Se ad esempio abbiamo un file prova.txt e abbiamo un file prova_new.txt, la patch che ci porta da prova a prova_new si ottiene da: diff –u prova.txt prova_new.txt > prova.patch
Prova.patch sarà il file da inserire nella cartella SOURCE e in fase di %prep verrà applicata al file prova.txt
(se ricevete errori verificate che nel file .patch i percorsi dei file siano corretti).

La fase %BUILD

In questa fase si prepara il pacchetto all’installazione; di default:

%configure –> macro che esegue ./configure (file solitamente presente nei pacchetti di installazione)

make –> si prepara all’installazione

in generale si possono cancellare questi due passaggi e inserire dei passaggi in funzione delle proprie esigenze.

La fase INSTALL

make install –> di default installa il pacchetto

anche in questo caso si può procedere inserendo comandi relativi al proprio progetto e non i comandi di default di rpmbuild.

ATTENZIONE: col termine “installazione” non si intende di istallare il pacchetto sorgente nel server ma in questo caso rpmbuild installa la sorgente dentro la cartella BuildRoot. Cioè ricrea su BuildRoot la stessa struttura (file e cartelle) che il pacchetto .rpm dovrà avere nel server dove lo dovremmo installare (una volta realizzato)

La Sezione %FILE

Include l’elenco di file che desideriamo includere nell’rpm.
Senza questo elenco non viene creato nessun RPM.
Quando andremo ad installare il pacchetto rpm appena realizzato, i file qui presenti saranno installati nel percorso qui indicato (mentre nella creazione del pacchetto questi file saranno collocati, nel giusto path, dentro BuildRoot).

Es: il file nella cartella BuildRoot /cartella/test.txt nell’elenco di %file andrà indicato semplicemente come /cartella/test.txt e non BuildRoot /cartella/test.txt

Questo tag prevede alcune macro, vediamo le principali:

%configure —> precede i file di configurazione (es: /etc/mioprogetto.cfg)

%doc —–> precede i file di documentazione (es: /usr/share/doc/README)

%defattr —-> definisce gli attributi generali di tutti i file. La sua sintassi è:

defattr (permessifile, utente, gruppo, permessicartella). Es: defattr (775, root, root, 660).

I valori posso essere sostituiti da un segno “-” in tal caso le proprietà restano le stesse presenti nel file sorgente.

%attr —> precede i file e ne definisce gli attributi specifici seguendo le stesse regole di defattr (usato per file singoli).

%dir —> aggiunge una directory

%{_localstatedir} —-> equivale alla cartella /var

%{_sysconfdir} —–> equivale a /etc

L’elenco completo di tutte le macro/variabili si trova nella documentazione ufficiale.

 Fase %clean

In questa fase dobbiamo (se vogliamo) inserire i comandi per cancellare i file utilizzati per la creazione del pacchetto rpm.

 Fase %changelog

Indica data e modifica del pacchetto. Segue un formato particolare. Ecco un esempio:

%changelog

*Sun Jul 13 2012 1

–Initial Build.

–Added setup.py file.

–Fixed bin/vpd, src/vpd.py.

Le fasi %PRE, %POST e %PREUN e %POSTUN

Sono fasi facoltative. Tali fasi vengono eseguite prima o dopo l’installazione o la disinstallazione del pacchetto rpm (quindi non durante la realizzazione del pacchetto, ma quando il pacchetto, una volta realizzato, viene installato o disinstallato da un server).

Definire Variabili

Nella creazione di un pacchetto rpm è possibile anche definire delle variabili proprie, tramite il comando:

%define

 Es:

%define mia_dir /home/mia/

Definiamo la variabile mia_dir col valore /home/mia
Possiamo richiamare tale variabile tramite: %{mia_dir}

File di configurazione

Dentro i seguenti file possiamo trovare informazioni utili come ad esempio i valori di default delle variabili:

/usr/lib/rpm/macros
/usr/lib/rpm/rpmrc

Realizzare il file rpm dal file spec

Una volta editato il file .spec dobbiamo creare il file RPM.
E’ importante ricorda che la documentazione ufficiale sconsiglia di creare un pacchetto rpm come utente root.
Per creare l’rpm dal file .spec si usa il comando:

rpm -ba nomefile.spec

 Al fine di testing è possibile eseguire parzialmente le varie fasi della creazione di un rpm con i seguenti comandi:

rpmbuild -ba nomefilespec.spce
rpmbuild -bp —> prep
rpmbuild -bc —> prep + build
rpmbuild -bi —> prep + build + install
rpmbuild -bb —> prep + build + install + Package (bin), no src (per quello -ba)
rpmbuild -bl —> Check file list

Una volta creato, potremmo trovare il nostro pacchetto rpm pronto per essere installato nella directory:

/root/rpmbuild/RPMS

Mentre troveremo il suo NUOVO file sorgente in:

/rpm/rpmbuild/ SRPMS

Note

Piccolo esempio per chiarire.
La creazione di un pacchetto RPM sembra dipendere dalla presenza di un file sorgente.
In realtà questo non è necessario.

Se volessimo realizzare un rpm da ZERO senza una sorgente già pronta, l’unica cosa che dovremmo fare è copiare manualmente i file che vogliamo inserire nel pacchetto dentro la BuildRoot e successivamente elencarli in modo opportuno nella fase %file lasciando VUOTE tutte le altre fasi (al massimo potremmo editare la fase %clean per eliminare i file una volta generato il pacchetto).

Il file sorgente potrebbe non essere un file .tar o potrebbero essere dei file in un server remoto. In questo caso le fasi %PREP, %BUILD e %INSTALL devono essere usate per prendere questi file, editarli (se serve) e posizionarli nei path corretti dentro la BuildRoot. Ovviamente andranno elencati in %file

Web-bibilografia

http://www.rpm.org/max-rpm/index.html
http://rpmbuildtut.wordpress.com/getting-started/
https://fedoraproject.org/wiki/How_to_create_an_RPM_package/it
http://stereochro.me/ideas/rpm-for-the-unwilling
http://www.tldp.org/HOWTO/RPM-HOWTO/build.html#SPEC-FILE

CREARE PATCH

http://wiki.networksecuritytoolkit.org/nstwiki/index.php/HowTo_Create_A_Patch_File_For_A_RPM

crea qualsiasi cosa

crea qualsiasi cosa

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.