Con questa guida accenno al python e come compilare i suoi sorgenti per creare un pacchetto deb “automaticamente”. Successivamente vedremo come invece lo si può creare in maniera “manuale”.

Per l’esempio useremo emesene. Cominciamo!

La prima cosa da fare (ovviamente) è decomprimere l’archivio (lo potete fare o cliccando col destro sul pacchetto e facendo “Estrai qui” oppure da terminale):

$ tar zxf emesene-rc.tar.gz

Ora entriamo nella cartella e avviamo la “compilazione” per la creazione del pacchetto:

$ cd emesene-rc.tar.gz

$ python setup.py bdist_dumb

Ora verrà creata una cartella di nome dist che conterrà un archivio. Decomprimiamolo.

$ cd dist

$ tar zxf emesene-1.0.linux-i686

Fattò ciò avremo una cartella che a sua volta conterrà una struttura /usr/… Ora non ci resta altro che fare che convertire tale struttura in deb, però prima dobbiamo creare il control. Per creare dobbiamo creare una cartella chiamata DEBIAN e metterci all’interno il control.

$ cd emesene-1.0.linux-i686
$ mkdir DEBIAN
$ cd DEBIAN
$ gedit control

Ora come abbiamo visto per la parte 3, dobbiamo creare il control. Attenzione alle dipendenze: leggere la parte 2 per risolvere tutte le dipendenze di cui ha bisogno il programma. Finito con la modifica, salviamolo e usciamo. Ora non ci resta che dare il comando per creare il deb. Posizioniamoci dove stava la cartella dist e diamo comando:

$ dpkg-deb --build emesene-1.0.linux-i686

Finito! Ora avremo il nostro deb con il programma pronto all’installazione!

La creazione di pacchetti con cheinstall discosta di poco rispetto alla creazione della parte 3. Come al solito consiglio di leggere la parte 2.

Iniziamo con l’installare il pacchetto:

$ sudo apt-get install checkinstall

Dopo l’installazione entriamo nella catella scompattata dei sorgenti e diamo i seguenti comandi:

$ ./configure
$ make
$ sudo checkinstall

Adesso partità un wizard a linea di comando per la creazione del deb. La lingua usata è l’italiano. Il difetto di questo programma (purtroppo) è che non risolve le dipendenze. Ne consegue che una volta creato il deb non lo si può distribuire perchè appunto non risolve le dipendenze, installerebbe un programma inutilizzabile, se vengono a mancare i pacchetti necessari.
Si può usare questo programma più per un uso didattico, ma non si consiglia l’uso e la distribuzione.

Questa guida si basa sulla parte 2: Risolvere le dipendenze con apt-get o con apt-cache o manualmente.

Quello che io definisco “metodo tradizionale” è il più noto sicuramente e “facilmente trovabile su internet”. Vediamo di cosa tratta.

Per prima cosa bisogna installare alcuni pacchetti:

$ sudo apt-get install devscripts dh-make make build-essential

Ora si decomprime il pacchetto sorgente con:

$ tar -xvfz sorgete.tar.gz

Con questo comando creiamo una cartella con dentro i sorgenti decompressi. Ora entriamo nella cartella e diamo il via alla compilazione e alla creazione del deb.

$ cd sorgente
$ ./configure VAR
$ make
$ dh_make -s -e tua@email.it -c gpl

Ora andiamo in debian e apriamo il file control con un editor.

$ gedit ./debian/control

Ora qui modifichiamo le varie linee.

• Source: Il nome del pacchetto
• Version: La versione del pacchetto
• Section: Il nome della sezione dove comparirà il pacchetto
• Priority: La priorità del pacchetto
• Maintainer: E’ il proprio nome con indirizzo email
• Package: Il nome pacchetto
• Architecture: L’archietttura. Per esempio: i386
• Build-Depends: Sono i pacchetti Debian/Ubuntu necessari per costruire questo pacchetto.
• Depends: I pacchetti necessari per l’installazione. E’ consigliato rimuovere tutti i ‘${***}’ dove al posto di *** c’è qualcosa tipo shlibs:Depends. Invece mettere il nome del pacchetto necessario e magari il numero di versione necessario tra parentesi. Per esempio (>=2.0.1). Esempio 2: libaudio (>=9.1). Separare più pacchetti con una virgola.
• Recommends: Pacchetti consigliati, con la stessa politica di Depends
• Conflicts: Pacchetti che va in conflitto e quindi vanno disinstallati, con la stessa politica di Depends
• Description: Descrizione del pacchetto. Per usare su più righe, le righe successive farle iniziare o con il tab o con uno spazio.

Ok modificato il file, salviamolo e creiamo il pacchetto:

$ debuild binary

Ed ecco creato il pacchetto.deb, pronto per l’installazione.

Il problema più difficile per la compilazione è risolvere le dipendenze! Se non vengono risolte quelle si complica la compilazione e molto probabbilmente si rischia di non riuscire a compilare. Vediamo come risolverle con pochi comandi.

Risolvere con apt-get
Partiamo da una verità: Per usare questo procedimento è necessario (come già visto nella parte 1) che siano abilitati quanti più repository possibili. Oltre a questo, è necessario che il pacchetto che vogliamo compilare abbia una versione nei repository. Per esempio se voglio compilare compiz, c’è bisogno che il compiz sia presente in almeno un repository con i suoi sorgenti. Per questo motivo in /etc/apt/sources.list si fa distinzione tra deb e deb-src. Il primo contiene i deb quindi i pacchetti belli e pronti da scaricare e installare, tramite apt-get o synaptic o altro gestore di pacchetti; mentre il secondo ha i sorgenti.
Ok detto ciò, procediamo con l’auto ricerca dei pacchetti necessari per la compilazione.
Diamo il seguente comando:

$ sudo apt-get build-dep pacchetto

Ora apt-get ci dirrà che c’è bisogno di installare alcuni pacchetti. Noi rispondiamo affermativamente. Al termine avremo tutti i pacchetti necessari per la compilazione.

Risolvere con apt-cache
In caso che apt-get non riesce a risolvere le dipendenze (raramente, ma può succedere, specialmente se la versione è più aggiornata di quella dei repository), si può procedere con un altro comando simile: apt-cache. Diciamo che questa procedura è semi-manuale (almeno ci vengono detti con un colpo tutti i pacchetti necessari):

$ sudo apt-cache showsrc pacchetto | grep Build-Depends

Ora ci verranno forniti i nomi dei pacchetti che servono. Uno ad uno installiamoli e siamo pronti.

Risolvere manualmente.. In caso che nessun procedimento funziona
E se tutto fallisce? Beh non ci rimane che leggere il README o LEGGIMI o andare sul sito del pacchetto alla ricerca dei pacchetti di cui dipende il nostro programma. Appena trovati, bisogna sperare che stanno nei repository tutti, altrimenti bisogna cercarli su internet. Consiglio di cercare prima i deb, almeno vi risparmiate un’altra compilazione e comunque avete un sistema “ordinato”. A volte capita anche che questo pacchetto a sua volta dipende da altri pacchetti, che a loro volta possono tranqullamente dipendere da altri. Così ci ritroviamo ad installare/compilare decine di pacchetti prima di arrivare al nostro pacchetto. Purtroppo succede anche questo…

Con questa guida voglio insegnare a tutti come creare i pacchetti deb da sorgenti. Il pacchetto deb è stata (a mio avviso) una grande invenzione per l’installazione nel mondo del pinguino. Questo per un motivo molto semplice: si possono installare e disinstallare pacchetti(->programmi) in pochi click, senza dovessi più preoccupare di dover cercare le dipendenze, in quanto è stesso il programma che le cerca e le installa (se presenti in uno dei repository nella lista di /etc/apt/sources.list).

Il mio suggerimento per affrontare questa mini-guida è di modificare il file sorgente dei repository (/etc/apt/sources.list) e di togliere tutti i “cancelletto” (#) che sta come primo carattere da tutte le linee che iniziano o per deb o per deb-src. In questo modo abilitiamo tutti i repository e come vederemo più avanti questo servirà ad apt per cercare le relative dipendenze, quindi più ce ne stanno e meglio è..

Ok! E’ bene sapere che non c’è un solo modo per creare un pacchetto deb. In questa guida tratteremo vari metodi.

Bene! Ora iniziamo con la guida vera e propria!

Mini leggenda
sorgente.tar.gz => pacchetto sorgente
./configure VAR => comando preliminare per avviare la configurazione del pacchetto. VAR sono i parametri che si possono passare. Per vederli basta dare $ ./configure –help
pacchetto.deb => E’ il pacchetto deb creato dal sorgente.

(Attenzione: Questa guida è in continuo miglioramento, quindi le pagine possono cambiare anche dopo la pubblicazione)