Translation(s): English - Italiano



Introduzione

Questa guida è basata su un Build it Event di Debian Women tenuto da Margarita Manterola (in collaborazione con il progetto OpenHatch) il 07 maggio 2011.

Questa pagina fornisce istruzioni passo-passo semplici su come prendere un pacchetto esistente, ricompilarlo, applicarvi modifiche e preparare tali modifiche in modo da poterle inviare come patch ad un bug. È pensato per essere chiaro da seguire per qualsiasi utente con una conoscenza di base della riga di comando, pur fornendo collegamenti a ulteriori approfondimenti sui molti diversi modi in cui possono essere creati i pacchetti.

Requisiti

Per questo tutorial sono richieste conoscenze pregresse molto limitate, ma nessuna paura della riga di comando :-)

Requisiti tecnici:

Per essere sicuri che questi pacchetti siano installati, eseguire:

  • sudo apt-get install build-essential fakeroot devscripts equivs lintian

Configurare apt

Una volta installati i pacchetti necessari, il prossimo passo da fare è di assicurarsi di aver configurato sul proprio computer alcuni repository per i sorgenti.

Aprire il proprio file /etc/apt/sources.list e controllare di avere una o più righe che iniziano con deb-src.

   deb-src http://http.us.debian.org/debian unstable main

Queste righe sono necessarie per poter lavorare con i pacchetti dei sorgenti.

Se non si ha alcuna riga deb-src, è necessario aggiungerne almeno una. Questo di solito viene fatto copiando una delle righe deb esistenti. Può essere fatto eseguento un editor con i privilegi di amministrazione (ad esempio, sudo gedit, sudo kate o sudo vim).

Normalmente è una buona idea usare unstable come repository, in modo da lavorare con la versione più recente del pacchetto. Però, se si vuole modificare un pacchetto come è in stable o testing, si possono usare anche quelle distribuzioni.

Configurare righe deb-src per unstable non crea problemi anche se si usa stable/testing/ecc. come distribuzione per il proprio sistema; il fatto di prendere i sorgenti da unstable non ha effetto sul sistema installato.

Una volta aggiunta la riga, è necessario eseguire

  • sudo apt-get update

per poter aggiornare l'elenco dei pacchetti disponibili per l'installazione.

Creare una directory di lavoro

Ora che si è aggiunto l'URL per i sorgenti ai propri repository di apt, si è in grado di ottenere i sorgenti di qualsiasi pacchetto Debian si desideri.

Per questo tutorial in particolare, verranno scaricati i sorgenti di un pacchetto a cui verrà fatta una piccola modifica in modo da farlo funzionare meglio.

È sempre una buona idea avere una directory da usare per lavorare con il software sorgente, distinta da altre directory usate per altri scopi. In caso non se ne abbia già una, è suggerita la creazione di una directory src con al suo interno un'altra chiamata debian:

  • mkdir -p ~/src/debian/; cd ~/src/debian

All'interno di questa directory verrano messi i sorgenti del pacchetto su cui si desidera lavorare.

Scegliere il pacchetto

In questo esempio, verrà usato un pacchetto chiamato fdupes, uno strumento per trovare file duplicati, e verrà risolto il bug Debian 585426.

Prima di procedere si deve installare il pacchetto (o controllare di averlo già installato e aggiornato all'ultima versione), dato che sarà necessario avere le dipendenze appropriate quando si dovrà installare quello modificato.

Se fdupes non è installato, lo si può installare usando:

  • sudo apt-get install fdupes

Poi si può controllare che il bug sia sempre presente eseguendo:

  • fdupes --help

e verificando che la seconda riga di informazioni per l'opzione --debug continui a non avere alcun senso.

Il flusso di lavoro della pacchettizzazione

Ottenere il pacchetto sorgente

Allo scopo di ottenere i sorgenti di fdupes, ciò che è necessario fare è andare nella directory prescelta (in questo esempio src/debian) ed eseguire (come utente normale):

  • apt-get source fdupes

Si sono così scaricati 3 file (.dsc, .tar.gz, .diff.gz), che costituiscono il pacchetto sorgente Debian. 1

Una volta scaricato il pacchetto, si può controllare la directory in cui si è (digitando ls) e si può vedere che, oltre ai 3 file che sono stati scaricati, c'è anche una directory chiamata fdupes-1.50-PR2. Questo è il sorgente spacchettato del pacchetto Debian.

Per spostarsi in tale directory digitare:

  • cd fdupes-1.50-PR2/

Se si controlla il contenuto di questa directory (digitando ancora ls), si possono vedere parecchi file di diverso tipo e una directory debian.

Ogni pacchetto Debian (o di una derivata da Debian) include una directory debian, dove vengono archiviate tutte le informazioni relative al pacchetto Debian. Tutto ciò che è al di fuori di tale directory è il codice a monte, cioè il codice originale rilasciato da chiunque abbia programmato il software.

Andare nella directory debian, digitando

  • cd debian

Questa è la directory che il manutentore del pacchetto ha aggiunto al codice sorgente per compilare il pacchetto.

In questa directory di solito si trovano molti file correlati con la versione Debian del programma, patch specifiche per Debian, pagine man, documentazione e così via. In questo documento non verrà spiegato più in dettaglio cosa siano questi file. Guardare il suo contenuto usando ls.

Ricordarsi solamente che

Spostarsi indietro di una directory, usando

  • cd ..

Ci si dovrebbe trovare nuovamente nella directory fdupes-1.50-PR2, la directory principale del codice sorgente.

Ottenere le dipendenze di compilazione

Per poter compilare quasi qualsiasi programma, è necessario avere installate alcune dipendenze.

Le dipendenze sono i programmi o le librerie necessari per compilare il programma. Normalmente si tratta di svariati pacchetti il cui nome termina in -dev, ma potrebbero esserci anche altre cose, come automake o gcc, a seconda di quanti strumenti di sviluppo si sono già installati nel tempo sulla macchina.

Il comando mk-build-deps da devscripts fornisce un modo per installare facilmente tutte le dipendenze necessarie:

  • sudo mk-build-deps -i -r fdupes

Una volta scaricati questi strumenti, si è pronti per compilare il pacchetto.

Ricompilare senza modifiche

Prima di fare qualsiasi modifica al codice, si provi a compilare il pacchetto così come è adesso, solo per assicurarsi che venga compilato e installato in maniera corretta. Eseguire:

  • fakeroot debian/rules binary

Questo è il comando, quasi come per make, che compila il pacchetto.

L'esecuzione di questo comando probabilmente richiede un po' di tempo, dato che di solito prima deve eseguire ./configure, poi deve compilare il codice sorgente e poi creare i pacchetti. Di fatto, esegue i comandi che sono elencati nel file debian/rules e, si spera, termina con una messaggio nella lingua dell'utente simile a:

   dpkg-deb: generazione del pacchetto `fdupes' in `../fdupes_1.50-PR2-3_<propria_arch>.deb'

<propria_arch> può essere i386, amd64 o un altro nome, a secondo da quale architettura è in esecuzione sulla macchina.

Una volta che il pacchetto è stato generato correttamente, il passo successivo è quello di installare tale file con:

  • sudo dpkg -i ../fdupes_1.50-PR2-3_<propria_arch>.deb

Dopo di ciò, controllare che il bug sia ancora presente, eseguendo

  • fdupes --help

Modificare il codice sorgente

Ora, risolviamo questo bug per davvero.

Arriva la parte divertente. Quando si cerca di risolvere un bug di un pacchetto, a volte questo è presente nei sorgenti a monte, a volte è correlato al modo in cui il programma è stato impacchettato per Debian. Perciò è necessario modificare file diversi a seconda dell'origine del problema.

Gestire le patch con dpatch

In questo caso particolare, il pacchetto usa lo strumento dpatch, uno strumento per gestire patch per il pacchetto, perciò viene usato quello.

Per creare una nuova patch, è necessario fare quanto segue. Digitare:

  • dpatch-edit-patch 80_bts585426_fix_help 70_bts537138_disambiguate_recurse.dpatch

Questo avvia una nuova shell all'interno di un ambiente speciale, in cui si possono modificare i propri file e dpatch successivamente si occuperà di vedere le differenze con l'originale.

Il nome della patch è stato scelto in modo da farlo corrispondere al modello già stabilito dal manutentore (cioè, in base ai nomi degli altri file delle patch nella directory debian/patches).

Ora è necessario modificare il file fdupes.c. Andare alla riga 1066 e cancellarla. La riga contiene:

   printf("                  \teach set of duplicates without prompting the user\n");

Si può modificare il file con il proprio editor preferito (vi fdupes.c, gedit fdupes.c, kate fdupes.c, ecc.).

Una volta fatto, si deve digitare nella console:

  • exit

Questo termina l'ambiente speciale che è stato creato da dpatch e nella directory debian/patches/ c'è ora una nuova patch. Controllarla con:

  • cat debian/patches/80_bts585426_fix_help.dpatch

Per poter applicare questa patch è necessario modificare il file debian/patches/00list aggiungendo dopo l'ultima riga:

   80_bts585426_fix_help

Il file 00list è il file di dpatch che elenca tutte le patch che saranno applicate. Sono applicate nell'ordine, a partire da quella nella prima riga, fino a quella nell'ultima.

Gestire le patch con quilt

Alcuni pacchetti usano uno strumento differente, chiamato quilt per gestire le patch; di seguito sono descritti le azioni da compiere quando si usa quilt. Dato che fdupes non usa quilt, queste azioni non funzioneranno in modo corretto per fdupes.

Per creare una nuova patch, è necessario fare quanto segue; digitare:

  • quilt push -a

Questo assicura che tutte le patch siano state applicate all'albero dei sorgenti. Dopo digitare:

  • quilt new 80_bts585426_fix_help

Questo crea una nuova patch chiamata 80_bts585426_fix_help. Quindi digitare:

  • quilt edit fdupes.c

Questo avvia un editor in modo da poter modificare fdupes.c. Andare alla riga 1066 e cancellarla. La riga contiene:

   printf(" \teach set of duplicates without prompting the user\n");

Una volta fatto, salvare il lavoro e uscire dall'editor; sarà stata registrata una nuova patch. Se ci sono altri file da modificare, si può ripetere questo passo con altri nomi di file. Questi cambiamenti verranno registrati nella stessa patch.

Il nome della patch è stato scelto in modo da seguire il modello già stabilito dal manutentore (cioè i nome degli altri file patch nella directory debian/patches).

Aggiornare il changelog

Prima di rigenerare il pacchetto con questa patch, si deve rendere il pacchetto diverso da quello originale, in modo che sia successivamente possibile estrarre le modifiche per poterle inviare come patch per il bug. Per farlo, digitare:

  • dch -n

Questo

Si sta adesso perciò modificando il file changelog. Ciò che va inserito in questo file è una qualche descrizione delle modifiche fatte. Ad esempio:

   Added a patch to fix the --help issue with the --debug option. Closes: #585426.

Aggiungerlo nella riga con l'elemento vuoto *.

Generare il pacchetto modificato

Una volta fatto quanto descritto sopra, si deve prima ripulire la directory di compilazione, in modo che tutto sia come all'inizio, con:

  • fakeroot debian/rules clean

e poi si può generare il pacchetto nuovamente nello stesso modo usato in precedenza:

  • fakeroot debian/rules binary

Nel caso sia necessario fare il debug del pacchetto compilato, particolarmente se si sta cercando di risolvere un Segmentation Fault, è meglio compilarlo in quest'altro modo, in maniera che il codice non sia ottimizzato e non siano stati rimossi i simboli di debug e sia perciò più facile farne il debug:

  • DEB_BUILD_OPTIONS=nostrip,noopt fakeroot debian/rules binary

Si vede a schermo l'output del compilatore. Di solito non è molto interessante, a meno che non si stia analizzando un bug che è correlato con la compilazione stessa del pacchetto. Di solito l'autore lascia che proceda mentre fa qualcos'altro (prendere qualche biscotto per il caffè, ad esempio).

Questa volta, il pacchetto creato dovrebbe essere ../fdupes_1.50-PR2-3.1_<propria_arch.deb: la versione è cambiata perché dch la ha modificata per conto dell'utente nel changelog (-3.1 invece di -3).

Installare e testare il pacchetto modificato

Installarlo con:

  • sudo dpkg -i ../fdupes_1.50-PR2-3.1_<propria_arch>.deb

e testare il fatto che l'aiuto sia adesso corretto. :)

Se per caso, è stato fatto qualcosa che ha peggiorato la situazione, si può sempre tornare alla versione Debian con:

  • apt-get install --reinstall fdupes=<versione_precedente>

Generare il pacchetto sorgente

Una volta risolto un bug, si può volere anche generare il pacchetto sorgente. Ciò significa non solo il file .deb, ma anche gli altri file che sono stati scaricati all'inizio. Ciò viene fatto con:

  • debuild -us -uc

I parametri aggiuntivi servono ad evitare che il pacchetto venga firmato, dato che al momento non è necessario.

Una volta generato con successo il pacchetto sorgente, andare nella directory precedente:

  • cd ..

e controllare i file presenti con ls. Si può vedere che adesso ci sono più file, inclusi due file dsc: uno per il pacchetto originale e uno per quello che è stato appena creato.

Inviare le modifiche al BTS

Una volta generato un qualsiasi pacchetto sorgente, è possibile trovare le differenze tra il proprio pacchetto e quello originale, usando debdiff:

  • debdiff fdupes_1.50-PR2-3.dsc fdupes_1.50-PR2-3.1.dsc > mio_primo_debdiff.diff

In questo caso particolare, dato che è stato usato lo strumento dpatch, quello che andrebbe inviato al BTS come patch è il file dpatch che è già stao creato, dato che contiene le modifiche fatte.

Se invece non è stato usato dpatch, si può usare l'output di quel comando debdiff e inviare quello al BTS.

Per informazioni su come segnalare un bug vedere questa pagina.

Conclusioni

Questo è tutto, prepararsi al prossimo pacchetto

Le modifiche a questo pacchetto sono terminate e si può adesso continuare a risolvere i bug in altri pacchetti Debian! Questi sono i comandi importanti che devono essere tenuti a mente:

   apt-get source il-pacchetto
   sudo mk-build-deps -i -r
   (...)
   fakeroot debian/rules binary
   dpkg -i il-pacchetto-blabla.deb
   debuild -us -uc
   debdiff pacchetto-blabla.dsc pacchetto-blabla.1.dsc > altro_debdiff.diff

Vedere anche


  1. Approfondimento: Se si scarica fdupes con apt-get source si viene anche informati che quel pacchetto è mantenuto usando Git. Se un pacchetto è mantenuto in un VCS, può essere utile scaricare il pacchetto dal VCS per collaborare in modo più efficiente con il manutentore. Tuttavia è sempre possibile usare apt-get source, perciò per il momento ci si limiterà a quello. Si possono leggere ulteriori informazioni sui pacchetti sorgenti nei VCS qui. (1)