[ precedente ] [ Contenuti ] [ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 7 ] [ 8 ] [ 9 ] [ successivo ]
Proviamo a creare un pacchetto (o, meglio ancora, adottarne uno già esistente).
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.
prendendo in consegna dei pacchetti orfani, ma ancora attivamente utilizzati
entrando a far parte del packaging
teams
aiutando nella risoluzione dei bug di pacchetti molto popolari
preparazione di QA
or NMU uploads
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:
Prima di tutto bisogna capire se il programma funziona in modo corretto, e averlo provato per almeno un po' di tempo e dimostrarne l'utilità.
Bisogna controllare su lista dei pacchetti sui
quali si lavora
che nessun altro stia lavorando sullo stesso
pacchetto. Se nessuno ci sta lavorando, si può segnalare un bug di tipo ITP
(Intent To Package) allo pseudo-pacchetto wnpp
usando il programma
reportbug
. Se qualcuno ci sta lavorando e si ritiene necessario
si potrebbe contattare il maintainer. Altrimenti - si potrebbe trovare un
altro programma interessante che non manutenuto.
il programma deve avere una licenza.
I programmi nella sezione main, devono essere in accordo
con le Linee Guida per il Software Libero Debian (DFSG, Debian Free Software
Guidelines) (vedere http://www.debian.org/social_contract#guidelines
)
e non devono richiede nessun pacchetto che non sia presente nella
sezione main, per la compilazione o l'esecuzione, come
previsto dalla policy di Debian. Questo è il caso preferito.
I programmi nella sezione contrib, devono essere conformi alle DFSG, ma potrebbero richiedere, per la compilazione o l'esecuzione, un pacchetto che non è presente nella sezione main.
I programmi nella sezione non-free, possono non essere conformi alle DFSG, ma devono poter essere distribuibili.
Se non si è sicuri su quale sezione il pacchetto dovrebbe essere incluso, si
può mandare il testo della licenza alla mailing list debian-legal@lists.debian.org
e chiedere consigli.
il programma non dovrebbe girare come setuid root, o meglio, non dovrebbe richiedere di essere setuid o setgid per nessun utente.
il programma non dovrebbe essere un daemon, o qualcosa che debba essere
installato nelle directory */sbin
, o aprire una porta come root.
il programma dovrebbe essere in formato binario eseguibile, le librerie sono più difficili da gestire.
il programma dovrebbe essere ben documentato e il suo codice facilmente comprensibile (ad es. non offuscato).
Si dovrebbe contattare l'autore o gli autori del programma per verificare che siano d'accordo con la sua pacchettizzazione. È importante essere in grado di consultarsi con l'autore/i sul programma nel caso di problemi specifici del programma, per questo è meglio non provare a pacchettizzare programmi non più manutenuti.
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
.
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.
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
.
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.
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
:
Il nome del pacchetto e la versione sono separati da "_" (trattino basso).
C'è .orig
prima di .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:
pacchetti binari multipli,
pacchetti di libreria,
pacchetti di moduli del kernel,
pacchetti di patch del kernel,
pacchetti i cui sorgenti non sono in formato tar.gz. o tar.bz2, oppure
l'archivio dei sorgenti ha contenuti non distribuibili.
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 UTCjoy-mg@debian.org
kalos@nerdrug.org
jacopo.reggiani@gmail.com