[ precedente ] [ Contenuti ] [ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 7 ] [ 8 ] [ 9 ] [ successivo ]


Guida per il nuovo Maintainer
Capitolo 2 - Primi passi


Proviamo a creare un pacchetto (o, meglio ancora, adottarne uno già esistente).


2.1 Scegliamo il programma

La prima cosa da fare, dopo quella di scegliere il programma per cui creare il pacchetto, è controllare se il pacchetto è già presente negli archivi della distribuzione, utilizzando aptitude.

Si possono controllare le informazioni sui pacchetti anche nella pagina di ricerca dei pacchetti e nel sistema di tracciamento dei bug di Debian.

Se il pacchetto esiste già, bene, basta installarlo! :-) Se dovesse essere orfano e il mantainer è Debian QA Group, lo si può prendere in carico (verificandone il possessore su Debian Bug report logs: Bugs in package wnpp in unstable). Si può adottare anche un pacchetto per il quale il suo manutentore ha presentato una "richiesta di adozione" (RFA).

Alcune risorse sui pacchetti orfani o RFA sono disponibili su:

Come nota a margine, è importante sottolineare che Debian ha già i pacchetti per la maggior parte dei programmi e che il numero di pacchetti presenti nell'archivio Debian è molto più grande di quello dei contribuenti con permessi di caricamento. Pertanto, i contributi sui pacchetti già presenti in archivio sono molto più apprezzati dagli altri sviluppatori (ed è molto più probabile che si ottenga una sponsorizzazione). [3]. Si può farlo in diversi modi.

Appena ci si sente in grado di adottare un pacchetto, bisogna scaricare i sorgenti (con qualcosa tipo "apt-get source pacchetto") ed esaminarli. Questo documento purtroppo non include tutte le informazioni che riguardano l'adozione dei pacchetti. Fortunatamente non sarà difficile capire come funziona il pacchetto dal momento che qualcuno avrà già effettuato la configurazione iniziale. Continua a leggere comunque, molti dei suggerimenti qui di seguito saranno ancora utili al caso.

Se il pacchetto è nuovo, e si pensa che sarebbe bello entrare a far parte di Debian, ecco come procedere:

Ovviamente queste sono solo misure di sicurezza, fatte per salvare il futuro maintainer dall'ira degli utenti se si commette qualche errore in qualche daemon setuid... Una volta acquisita esperienza nella pacchettizzazione, si riuscirà a creare pure quel tipo di pacchetti, ma anche lo sviluppatore più esperto consulta la mailing list debian-mentors@lists.debian quando ha qualche dubbio. E i partecipanti saranno lieti di dare una mano.

Per maggiori informazioni, consulta la Guida di riferimento per lo sviluppatore.


2.2 Prendere il programma e provarlo

La prima cosa da fare è trovare e scaricare il codice sorgente del programma. Supponendo che si è recuperato il file dal sito web dell'autore. Generalmente il codice sorgente di programmi liberi per Unix e derivati sono in formato tar+gzip con estensione .tar.gz, oppure in formato tar+bzip2 con estensione .tar.bz2. Di solito, questi file, contengono la sottodirectory dal nome programma-versione con tutti i sorgenti.

Se è presente un sistema di controllo di versione (VCS) come Git, Subversion o CVS, è possibile scaricare l'ultima versione del codice sorgente con "git clone", "svn co", o "cvs co" e comprimerlo in formato tar+gzip utilizzando l'opzione "--exclude-vcs".

Se il codice sorgente è in qualche altro formato di archiviazione (per esempio, con estensione .Z o .zip[4]), scompattarlo con i programmi appropriati, e comprimerlo di nuovo.

A titolo di esempio, verrà utilizzato il programma gentoo, un gestore file per X basato su GTK+.[5]

È buona regola creare una sottodirectory nella directory home e nominarla debian o deb o qualsiasi altro nome appropriato (ad es. in questo caso ~/gentoo andrebbe più che bene). Scaricare l'archivio e scompattarlo (con il comando "tar xzf gentoo-0.9.12.tar.gz"). Bisogna assicurarsi che non ci siano errori, per quanto in apparenza irrilevanti, perché potrebbero causare problemi nell'estrazione dell'archivio sul sistema di altre persone, alcuni strumenti di estrazione a volte ignorano queste anomalie. Nella console dovrebbe esserci quanto segue.

     $ mkdir ~/gentoo ; cd ~/gentoo
     $ wget http://www.example.org/gentoo-0.9.12.tar.gz
     $ tar xvzf gentoo-0.9.12.tar.gz
     $ ls -F
     gentoo-0.9.12/                                                                                                                       
     gentoo-0.9.12.tar.gz

A questo punto si avrà un'altra sottodirectory, dal nome gentoo-0.9.12. Spostarsi in questa directory e leggere attentamente la documentazione fornita. Di solito si avranno dei file come README*, INSTALL*, *.lsm o *.html. È necessario trovare istruzioni su come compilare e installare correttamente il programma (si potrebbe supporre di installare il programma nella directory /usr/local/bin, ma questo non è il comportamento corretto, tratteremo l'argomento più avanti Installazione in una sotto-directory, Sezione 3.3).

I programmi più semplici sono dotati di un file Makefile, e possono essere compilati semplicemente con il comando "make". Alcuni supportano "make check", che esegue dei controlli automatici. Per installare il programma nella directory di destinazione, di solito basta eseguire "make install".

Adesso si provi a compilare ed eseguire il programma, assicurandosi che funzioni correttamente e che niente sia andato storto durante l'installazione o l'esecuzione.

Di solito, per ripulire la directory di compilazione, si usa il comando "make clean" (o meglio ancora "make distclean"). Talvolta c'è anche il comando "make uninstall" che serve a rimuovere tutti i file installati.


2.3 Programmi portabili liberi

Molti programmi liberi sono scritti utilizzando i linguaggi di programmazione C e C++. Molti di questi utilizzano Autotools o CMake per essere portabili su diverse piattaforme. Questi strumenti vengono utilizzati per generare il Makefile e altri file sorgenti necessari. Dopo di questo, i programmi vengono compilati utilizzando il solito "make; make install".

Autotools è il sistema di compilazione della GNU, che compendre Autoconf, Automake, Libtool, e gettext. Per capire meglio ciò che avviene, si possono leggere i seguenti file sorgenti: configure.ac, Makefile.am, e Makefile.in. [6]

Il primo passo del processo di lavorazione degli Autotools consiste solitamente nell'esecuzione del comando "autoreconf -i -f" per i sorgenti che verranno successivamente distribuiti insieme ai file generati.

     configure.ac-----+-> autoreconf -+-> configure
     Makefile.am -----+        |      +-> Makefile.in
     src/Makefile.am -+        |      +-> src/Makefile.in
                               |      +-> config.h.in
                           automake
                           aclocal
                           aclocal.m4
                           autoheader

La modifica dei file configure.ac e Makefile.am richiede una minima conoscenza di autoconf e automake. Vedere"info autoconf" e "info automake".

Il passo successivo da compiere con Autotools, di solito, consiste nel procurarsi il sorgente del programma e nel compilarlo nella directory binary tramite l'esecuzione dei comandi "./configure && make" all'interno della directory dei sorgenti stessi.

     Makefile.in -----+                +-> Makefile -----+-> make -> binary
     src/Makefile.in -+-> ./configure -+-> src/Makefile -+
     config.h.in -----+                +-> config.h -----+
                               |
                config.status -+
                config.guess --+

Si possono modificare molte cose nel file Makefile, come la posizione predefinita di installazione dei file utilizzando l'opzione, ad es. "./configure --prefix=/usr".

Nonostante non sia richiesto, l'aggiornamento di configure e degli altri file con "autoreconf -i -f" come utente può migliorare la compatibilità del sorgente.

CMake è un sistema di compilazione alternativo. Per capire meglio ciò che avviene, si può leggere il file CMakeLists.txt.


2.4 Nome e versione del pacchetto

Si dovrebbe iniziare la fase di pacchettizzazione con la directory dei sorgenti completamente ripulita, o semplicemente partendo da una nuova estrazione dall'archivio dei sorgenti.

Per costruire correttamente il pacchetto, si deve convertire in minuscolo il nome del programma originale (se non lo fosse), e rinominare la directory dei sorgenti in pacchetto-versione.

Se il nome del programma è formato da più di una parola, si deve contrarlo in una sola parola, o abbreviarlo. Per esempio, il pacchetto del programma "John's little editor for X" potrebbe essere chiamato johnledx, o jle4x, o qualsiasi altra cosa attinente, che riesca a stare sotto un numero ragionevole di caratteri, ad esempio 20.

Bisogna controllare inoltre l'esatta versione del programma (che deve essere inclusa nella versione del pacchetto). Se il programma non usa una numerazione delle versioni tipo X.Y.Z, ma qualche tipo di data, si può utilizzare tale data come numero di versione, a condizione che la numerazione vada ad aumentare. Anche se è meglio utilizzare lo stesso numero di versione usato dal programma, se il formato è 09Oct23 potrebbe essere necessario convertirlo nel formato YYYYMMDD, la data di prima quindi diventerebbe 20091023, questo è utile per garantire il corretto ordine di aggiornamento con il programma dpkg. [7]

Alcuni programmi non usano alcun tipo di numerazione, in questo caso si dovrebbe contattare l'autore del programma, per controllare se viene usato qualche altro metodo di revisione.


2.5 Il primo pacchetto Debian

Una delle prime cose da fare è impostare le variabili d'ambiente della shell $DEBEMAIL e $DEBFULLNAME visto che molti strumenti di gestione di Debian usano queste variabili per recuperare il nome e l'email da utilizzare nei pacchetti, come viene mostrato di seguito.[8].

     $ cat >>~/.bashrc <<EOF
     DEBEMAIL=il.vostro.indirizzo.email@example.org
     DEBFULLNAME="Nome Cognome"
     export DEBEMAIL DEBFULLNAME
     EOF

Adesso si può iniziare la costruzione del pacchetto Debian eseguendo il programma dh_make come segue:

     $ . ~/.bashrc
     $ cd ~/gentoo/gentoo-0.9.12
     $ dh_make -f ../gentoo-0.9.12.tar.gz

Ovviamente, si deve sostituire il nome del file con il nome dell'archivio dei sorgenti originali. [9] Vedere dh_make(1) per i dettagli.

Verranno visualizzate alcune informazioni. Verrà chiesto che tipo di pacchetto creare. Gentoo è un singolo pacchetto binario - crea un solo binario, e quindi un solo file .deb - per cui si dovrà selezionare la prima opzione con il tasto "s", controllare le informazioni sullo schermo e confermare la scelta con "ENTER". [10]

Dopo l'esecuzione di dh_make, verrà eseguita una copia dell'archivio originale del programma, come nome gentoo_0.9.12.orig.tar.gz, nella directory superiore, per consentire, più avanti, la creazione di un pacchetto Debian sorgente non-nativo con il debian.tar.gz.

     $ cd ~/gentoo ; ls -F
     gentoo-0.9.12/
     gentoo-0.9.12.tar.gz
     gentoo_0.9.12.orig.tar.gz

Si presti attenzione a due caratteristiche chiave presenti nel nome del file gentoo_0.9.12.orig.tar.gz:

Si dovrebbe aver notato che nella sottodirectory dei sorgenti debian sono stati creati molti modelli di file. Questo verrà trattato in File richiesti nella directory debian, Capitolo 4 e Altri file nella directory debian, Capitolo 5. Dovreste aver capito che la pacchettizzazione non è un processo automatico. È necessario modificare il sorgente originale per Debian come descritto in Modificare i sorgenti, Capitolo 3. Dopo tutti questi passaggi, è necessario creare i pacchetti Debian in maniera appropriata come descritto in Costruzione del pacchetto, Capitolo 6, controllarli come descritto in Controllare il pacchetto per errori, Capitolo 7, e caricarli come descritto in Caricamento del pacchetto, Capitolo 8. Verranno approfonditi tutti questi passaggi.

Ancora una volta, visto che si è alle prime armi come maintainer non è consigliato creare pacchetti complessi, ad esempio:

Non è difficile, ma richiede un po' più di conoscenze, per cui non ne parleremo in questo documento.

Se accidentalmente viene cancellato qualche modello di file mentre ci si lavora, è possibile recuperarlo eseguendo dh_make con l'opzione --addmissing nella directory dei sorgenti del pacchetto Debian.

L'aggiornamento di un pacchetto già esistente può diventare complicato, perché è possibile che si siano usate vecchie tecniche di pacchettizzazione. Per adesso, è consigliabile, concentrarsi sulla creazione di nuovi pacchetti per imparare le basi. Si tornerà ad approfondire l'argomento più avanti su Aggiornamento del pacchetto, Capitolo 9.


[ precedente ] [ Contenuti ] [ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 7 ] [ 8 ] [ 9 ] [ successivo ]


Guida per il nuovo Maintainer

version 1.2.25, 2010-12-21 14:06:56 UTC

Josip Rodin joy-mg@debian.org
Traduzione: Calogero Lo Leggio kalos@nerdrug.org
Traduzione: Jacopo Reggiani jacopo.reggiani@gmail.com
Traduzione: Francesco P. Lovergine