sabato 23 aprile 2011

Come attribuire priorità ad un pacchetto in Debian, dipendenze e stratificazione degli strumenti di gestione.

Maria Susana Diaz | 12:09 |
I pacchetti della distribuzione GNU/Linux Debian sono archiviati in modo differente, a seconda che si tratti di pacchetti binari o di pacchetti sorgenti. I pacchetti binari, cioè tutto quello che può essere usato così come si trova (compresa la documentazione), è archiviato nel formato Debian (.deb), mentre i sorgenti sono composti da terne di file: una descrizione contenuta in un file con estensione .dsc, l'archivio dei sorgenti originali in un file con estensione .orig.tar.gz e un file di differenze da applicare ai sorgenti originali, in questo caso con l'estensione .diff.gz.

Il nome di un archivio contenente un pacchetto binario Debian ha una struttura riassumibile nello schema seguente:
nome_pacchetto_versione-revisione.deb
Un pacchetto Debian binario, oltre ai file che compongono il pacchetto e che vengono installati, contiene:
  • un file di «controllo» (control), con quasi tutte le informazioni relative al pacchetto, in particolare le sue dipendenze;
  • un file contenente l'elenco dei file di configurazione, per i quali occorre avere un occhio di riguardo (conffiles);
  • due coppie di script che controllano la fase di installazione e quella di disinstallazione del pacchetto (preinst, postinst, prerm, postrm).

 

Priorità di un pacchetto.

A ogni pacchetto Debian viene attribuita una priorità, rappresentata da una definizione standard. Questa permette di facilitare la scelta dei pacchetti da installare. Si usano le parole chiave seguenti:

Parola chiave Significato Descrizione
required
richiesto indica un pacchetto necessario per il funzionamento elementare del sistema;
important
importante indica un pacchetto importante per il buon funzionamento del sistema;
standard
standard indica un pacchetto che fa parte di software comune in un sistema GNU/Linux, senza richiedere la presenza del sistema grafico X;
optional
opzionale indica un pacchetto opzionale;
extra
extra indica un pacchetto destinato a un uso specializzato, o che va in conflitto con altri pacchetti di livello precedente.

È interessante osservare che il livello di priorità è un'informazione che normalmente non è contenuta nei pacchetti, ma viene attribuita all'esterno di questi. La si ritrova nei file Packages e Packages.cd, la cui descrizione viene fatta in seguito.

 

Dipendenze secondo i pacchetti Debian.

Come accennato, il file di controllo contiene in particolare le informazioni sulle dipendenze del pacchetto. Secondo la logica di Debian, le dipendenze avvengono sempre in relazione a «pacchetti»: quando si tratta di una dipendenza da una funzionalità, questa viene identificata attraverso un «pacchetto virtuale». L'esempio seguente è un estratto delle informazioni relative al pacchetto apache-ssl, dove si vede l'uso delle definizioni di quasi tutti i tipi di dipendenza e di incompatibilità:

Depends: libc6 (>= 2.0.7u-6), libssl09, mime-support, perl, ...
Suggests: apache-doc, lynx
Conflicts: apache-modules, php3 (<= 3.0.3-1), libapache-mod-perl (<= 1.15-2.1)
Replaces: apache-modules
Provides: httpd
Le varie parole chiave hanno il significato seguente:
Parola chiave Significato Descrizione
depends
dipende indica un elenco di pacchetti indispensabili, eventualmente con il livello di versione richiesto, che devono essere presenti perché questo possa funzionare;
recommends
raccomanda indica un elenco di pacchetti raccomandati, anche se non indispensabili, perché il pacchetto che si installa possa essere utilizzato opportunamente;
suggests
suggerisce indica un elenco di pacchetti suggeriti, che starebbero bene assieme a quello che si installa;
conflicts
contrasta indica un elenco di pacchetti che non possono convivere assieme a questo;
replaces
sostituisce indica un elenco di pacchetti che vengono rimpiazzati da questo;
provides
fornisce indica un elenco di pacchetti che rappresentano le funzionalità offerte da questo.

Le parole chiave utilizzate sono verbi posti alla terza persona singolare, come dire che «il pacchetto A: dipende da... raccomanda... suggerisce... va in conflitto con... sostituisce... fornisce le funzionalità...». Osservando l'esempio, il pacchetto in questione fornisce le funzionalità httpd (in questo caso un pacchetto virtuale), ovvero quelle di un servente HTTP, è incompatibile con il pacchetto apache-modules e con altri se hanno una versione troppo vecchia, inoltre va a sostituire lo stesso pacchetto apache-modules.

 

Stato di un pacchetto.

Secondo la logica del sistema di gestione dei pacchetti Debian, lo stato di un pacchetto può avere tre gruppi di caratteristiche: lo stato in relazione a ciò che è installato nel sistema, lo stato di selezione e alcune caratteristiche speciali. Rispetto al sistema, un pacchetto può essere:

Parola chiave Significato Descrizione
installed
installato il pacchetto risulta installato correttamente nel sistema e anche la configurazione è stata completata;
half-installed
semi-installato l'installazione del pacchetto non è stata completata per qualche ragione;
not-installed
non installato il pacchetto non risulta installato;
unpacked
estratto il pacchetto risulta estratto dall'archivio, ma non è stato configurato;
half-configured
semi-configurato il pacchetto risulta estratto dall'archivio e la configurazione non è stata completata per qualche ragione;
config-files
file di configurazione del pacchetto sono presenti solo i file di configurazione.

Il sistema di installazione e disinstallazione dei pacchetti Debian è in realtà una procedura, con la quale si «prenotano» delle operazioni che poi vengono eseguite in sequenza. Sotto questo aspetto, un pacchetto che in qualche modo sia «conosciuto» da questa procedura ha anche uno stato di selezione (come già accennato), che può essere:

Parola chiave Significato Descrizione
unknown
sconosciuto quando non è mai stata richiesta la sua installazione (e di conseguenza non è nemmeno installato);
install
da installare quando è stata richiesta la sua installazione, o il suo aggiornamento;
remove

deinstall
da togliere quando è stata richiesta la sua disinstallazione normale, cioè senza cancellare i file di configurazione;
purge
da eliminare completamente quando è stata richiesta la sua eliminazione totale, compresi i file di configurazione.
Infine, un pacchetto può essere stato marcato in modo che non venga aggiornato o sostituito con un'altra versione, hold, oppure può essere stato marcato dal sistema di gestione dei pacchetti perché risulta danneggiato in qualche modo e in tal senso viene indicato come candidato alla reinstallazione, reinst-required.

Per conoscere lo stato di un pacchetto si può usare dpkg richiedendo l'azione -l. L'esempio seguente mostra l'elenco di alcuni pacchetti con l'indicazione del loro stato:

dpkg -l[Invio]

Desired=Unknown/Install/Remove/Purge
| Status=Not/Installed/Config-files/Unpacked/Failed-config/Half-installed
|/ Err?=(none)/Hold/Reinst-required/X=both-problems (Status,Err: uppercase=bad)
||/ Name            Version        Description
+++-===============-==============-============================================
ii  gnome-admin     1.0.1-1        Gnome Admin Utilities (gulp and logview)
ii  gnome-bin       1.0.3-1        Miscellaneous binaries used by Gnome
rc  gnome-card-game 1.0.1-4        Gnome card games - Solitaire games (FreeCell
rc  gnome-control-c 0.30-2         The Gnome Control Center
ii  gnome-core      1.0.1-0.3      Common files for Gnome core apps and help br
ii  gnome-dev-doc   1.0.3-1        Gnome developers documentation
pn  gnome-games     <none>         (no description available)
ii  gnome-games-loc 1.0.1-4        The locale databases for the gnome-games pa
rc  gnome-gnibbles  1.0.1-4        A cute little game that has no description
rc  gnome-gnobots   1.0.1-4        Gnome version of text based robots game for 
pn  gnome-guile     <none>         (no description available)
un  gnome-gxnsnmp   <none>         (no description available)
pn  gnome-gxsnmp    <none>         (no description available)
ii  gnome-terminal  1.0.1-0.3      The Gnome terminal emulator application

Significato delle lettere utilizzate nelle prime tre colonne del rapporto generato con dpkg -l

Colonna Sigla Significato
1 u Pacchetto sconosciuto.
1 i Pacchetto da installare.
1 r Pacchetto da rimuovere (lasciando la configurazione).
1 p Pacchetto da eliminare completamente.
Colonna Sigla Significato
2 n Pacchetto non installato.
2 i Pacchetto installato.
2 c Sono presenti solo i file di configurazione.
2 u Pacchetto estratto dall'archivio, ma non configurato.
2 f Configurazione interrotta.
2 h Installazione interrotta.
Colonna Sigla Significato
3 Nessuno stato particolare.
3 h Segnato per la conservazione alla versione attuale.
3 r Si richiede la reinstallazione.
3 x Equivalente a «h» e a «r» messi assieme.

 

Disponibilità di un pacchetto.

La gestione dei pacchetti Debian, richiede che i programmi che ne consentono l'installazione, siano in grado di sapere quali sono i pacchetti effettivamente disponibili. I pacchetti disponibili sono quelli che si trovano in una distribuzione su CD-ROM, DVD-ROM, in una copia locale nel file system (eventualmente condiviso in rete), in un sito Internet,... In ogni caso, tali informazioni sono contenute in un file che accompagna i pacchetti (uno per ogni raggruppamento principale) e si tratta di Packages, o Packages.cd nel caso di distribuzioni suddivise su più dischi (CD-ROM, DVD-ROM o unità di memorizzazione di altro tipo che possono essere sostituite durante l'installazione).


Stratificazione degli strumenti di gestione dei pacchetti Debian.

Gli strumenti per la gestione dei pacchetti Debian sono molti e sono fatti per intervenire a livelli diversi. La figura seguente mostra la piramide, alla base della quale si trovano gli strumenti fondamentali.

Gerarchia semplificata tra gli strumenti di gestione dei pacchetti Debian.
piramide

In breve:
  • dpkg-deb interviene solo al livello di archivi Debian, consentendo l'estrazione e l'archiviazione in questo formato;
  • dpkg-split è uno strumento aggiuntivo in grado di suddividere e riassemblare assieme gli archivi Debian, in modo da poterli gestire in file più piccoli, soprattutto quando questi devono essere trasportati su dischetti;
  • Dpkg (l'eseguibile dpkg) interviene nei pacchetti Debian, a livello elementare, consentendone l'installazione e la loro disinstallazione, avvalendosi eventualmente di dpkg-deb quando necessario;
  • apt-get interviene nei pacchetti Debian, a livello più evoluto di Dpkg, essendo in grado di risolvere da solo molti problemi di dipendenze;
  • Dselect si trova al livello più alto per la gestione dei pacchetti (assieme a APT) e si avvale di tutti gli strumenti inferiori;
  • APT è un sistema di strumenti paralleli a Dselect, composto da diversi programmi frontali alternativi che poi si avvalgono di apt-get per lo svolgimento dei loro compiti.

 

Gestione elementare attraverso gli strumenti fondamentali.

Per l'installazione e la disinstallazione dei pacchetti Debian, lo strumento più banale è dato da Dpkg, composto dall'eseguibile dpkg. Questo è in grado di utilizzare a sua volta anche dpkg-deb, quando si vuole intervenire a livello di archivio Debian.

dpkg [opzioni] azione
Alla fine della riga di comando dell'eseguibile dpkg deve apparire l'indicazione di un'azione, che può essere preceduta da alcune opzioni. Come si intuisce, l'azione stabilisce cosa debba essere fatto, mentre le opzioni ne alterano l'ambito. Qui viene mostrato solo l'uso di alcune azioni, perché per le altre conviene agire attraverso strumenti di livello superiore. Non viene mostrato l'uso delle opzioni, comunque si può approfondire l'uso di Dpkg consultando la pagina di manuale dpkg(8).

Alcune opzioni.
Opzione Descrizione
-c archivio_debian...
--contents archivio_debian...
Questa azione richiama l'utilizzo di dpkg-deb allo scopo di mostrare l'elenco dei file contenuti nell'archivio Debian indicato come argomento.
-f archivio_debian...
--field archivio_debian...
Questa azione richiama l'utilizzo di dpkg-deb allo scopo di mostrare le informazioni di controllo sui pacchetti contenuti negli archivi elencati.
-I archivio_debian...
--info archivio_debian...
Questa azione richiama l'utilizzo di dpkg-deb allo scopo di mostrare tutte le informazioni disponibili sui pacchetti contenuti negli archivi elencati.
-i archivio_debian...
--install archivio_debian...
Installa o aggiorna i pacchetti contenuti negli archivi indicati come argomento. Questa azione può essere abbinata all'opzione -R, o --recursive, allo scopo di installare tutti i pacchetti i cui archivi si trovano in una directory, che diventerebbe quindi l'argomento di questa azione.
L'installazione del pacchetto include anche la configurazione dello stesso.
--configure pacchetto...
Richiede espressamente di eseguire la configurazione dei pacchetti indicati (ammesso che questi non risultino già installati e configurati correttamente).
-r pacchetto...
--remove pacchetto...
Rimuove i pacchetti indicati, senza eliminare i file di configurazione.
--purge pacchetto...
Elimina completamente i pacchetti indicati, compresi i file di configurazione.
-l [modello_pacchetti...]
--list [modello_pacchetti...]
Mostra l'elenco dei pacchetti corrispondenti ai modelli indicati (si usano i caratteri jolly comuni, proteggendoli in modo che la shell non li interpreti direttamente). Se vengono indicati dei modelli, vengono fornite informazioni su tutti i pacchetti conosciuti, non solo quelli installati, mentre utilizzando l'azione senza argomenti, si ottengono informazioni solo sui pacchetti installati, o che comunque hanno mantenuto i file di configurazione.
-s pacchetto...
--status pacchetto...
Mostra le informazioni sullo stato dei pacchetti indicati, aggiungendo anche la descrizione se il pacchetto risulta installato. In questo caso non si possono più utilizzare i caratteri jolly.
-L pacchetto...
--listfiles pacchetto...
Elenca i file che appartengono a un pacchetto, in base a quanto contenuto nell'archivio originale. Tuttavia, non è possibile conoscere in questo modo quali file sono stati creati dagli script di installazione del pacchetto stesso.
-S modello_file...
--search modello_file...
Permette di fare una ricerca per trovare a quali pacchetti appartengono i file indicati come argomento, con o senza l'ausilio di caratteri jolly. In particolare, se si indica un nome o un modello senza l'indicazione di un percorso, si ottengono tutti i pacchetti che hanno file o directory con quel nome.
-C
--audit
Controlla i pacchetti installati per determinare quali sono stati installati solo parzialmente.
--compare-versions versione_1 \
  \operatore versione_2
Si tratta di una richiesta particolare con la quale si ottiene il confronto tra due stringhe che rappresentano una versione (completa di revisione). Ciò può essere molto utile nella realizzazione di script. Se il confronto dà un risultato Vero, l'eseguibile dpkg restituisce zero, mentre negli altri casi restituisce un valore maggiore. Gli operatori che possono essere utilizzati sono elencati nella tabella seguente.

Espressioni per il confronto tra le versioni attraverso l'uso dell'azione --compare-versions con dpkg

Espressione Descrizione
ver_1 eq ver_2
Vero se le versioni sono uguali.
ver_1 ne ver_2
Vero se le versioni sono differenti.
ver_1 lt ver_2
Vero se la prima versione è minore della seconda.
ver_1 le ver_2
Vero se la prima versione è minore o uguale alla seconda.
ver_1 gt ver_2
Vero se la prima versione è maggiore della seconda.
ver_1 ge ver_2
Vero se la prima versione è maggiore o uguale alla seconda.


Segue la descrizione di alcuni esempi.
  • dpkg -c zsh_3.1.2-10.deb[Invio]
    Mostra l'elenco dei file che compongono il pacchetto zsh, contenuti nell'archivio indicato, esclusi i file che vengono creati dagli script del pacchetto stesso.
  • dpkg -I zsh_3.1.2-10.deb[Invio]
    Mostra tutte le informazioni disponibili sull'archivio indicato.
  • dpkg -i zsh_3.1.2-10.deb[Invio]
    Installa, o aggiorna, il pacchetto contenuto nell'archivio indicato, ammesso che ciò sia possibile in relazione alle dipendenze di questo.
  • dpkg -r zsh[Invio]
    Rimuove il pacchetto indicato, senza eliminare i file di configurazione.
  • dpkg --purge zsh[Invio]
    Elimina completamente il pacchetto indicato, compresi i file di configurazione.
  • dpkg -l[Invio]
    Elenca lo stato di tutti i pacchetti installati, o dei quali rimangono i file di configurazione.
  • dpkg -l z\*[Invio]
    Elenca lo stato di tutti i pacchetti conosciuti che iniziano con la lettera «z». Si osservi l'uso della barra obliqua inversa per proteggere l'asterisco contro l'interpretazione da parte della shell.
  • dpkg -s zsh[Invio]
    Mostra le informazioni sullo stato del pacchetto indicato, in modo più dettagliato.
  • dpkg -L zsh[Invio]
    Elenca i file che appartengono al pacchetto zsh.
  • dpkg -S /bin/cat[Invio]
    Cerca di scoprire a chi appartiene il file /bin/cat (scoprendo che appartiene al pacchetto textutils).

Gestione più evoluta dei pacchetti: organizzazione di una copia della distribuzione .

Per una gestione più evoluta dei pacchetti, occorre definire la fonte di questi, dalla quale deve essere ottenibile il file Packages. Per comprendere la cosa, è necessario prima di tutto conoscere in che modo dovrebbe essere organizzato un CD-ROM o una copia nel file system della distribuzione. Lo schema seguente rappresenta l'essenziale (la metavariabile arch viene sostituita dalla sigla dell'architettura per cui sono fatti i pacchetti):

debian/
 |-- .disk/
 |    `-- info
 |
 `-- dists/
      |-- stable/
      |    |-- main/
      |    |    `-- binary-arch/
      |    |         |-- Packages
      |    |         |-- Packages.gz
      |    |         |-- Packages.cd
      |    |         |-- Packages.cd.gz
      |    |         `-- *.deb
      |    |
      |    |-- contrib/
      |    |    `-- binary-arch/
      |    |         |-- Packages
      |    |         |-- Packages.gz
      |    |         |-- Packages.cd
      |    |         |-- Packages.cd.gz
      |    |         `-- *.deb
      |    |
      |    |-- non-free/
      |    |    `-- binary-arch/
      |    |         |-- Packages
      |    |         |-- Packages.gz
      |    |         |-- Packages.cd
      |    |         |-- Packages.cd.gz
      |    |         `-- *.deb
      |    |
      |    |-- non-US/
      |    |    `-- binary-arch/
      |    |         |-- Packages
      |    |         |-- Packages.gz
      |    |         |-- Packages.cd
      |    |         |-- Packages.cd.gz
      |    |         `-- *.deb
      |    |
      |    `-- local/
      |         `-- binary-arch/
      |              |-- Packages
      |              |-- Packages.gz
      |              |-- Packages.cd
      |              |-- Packages.cd.gz
      |              `-- *.deb
      |
      `--local/
          `-- local --> ../stable/local
Il file debian/.disk/info è indispensabile quando la distribuzione è suddivisa su più dischi. Questo file contiene una riga che serve a identificare l'unità di memorizzazione. I file debian/dists/stable/*/binary-arch/Packages, assieme alle loro versioni compresse con gzip, contengono le informazioni sui pacchetti contenuti negli archivi che si trovano nella stessa directory, o in quelle successive, mentre i file debian/dists/stable/*/binary-arch/Packages.cd contengono le informazioni di tutti i file Packages delle stesse directory per tutti i dischi in cui si articola la distribuzione.

Di tutta questa struttura, la directory debian/ è la radice, o l'inizio, e questa è la posizione che viene richiesta dai programmi per la gestione dei pacchetti quando devono attingere le informazioni sulla disponibilità dei pacchetti.
Come si vede dalla struttura mostrata, una distribuzione Debian si articola anche in componenti, a causa di possibili limitazioni nell'uso e nella distribuzione del software relativo. In generale, gli archivi che si trovano a partire da debian/dists/stable/main/ sono quelli principali che non contengono limitazioni particolari, mentre per gli altri valgono considerazioni differenti. Le varie componenti in cui si articola una distribuzione sono identificate dai nomi delle directory che si diramano da debian/dists/stable/.

 APT a livello essenziale .

Il sistema APT si basa sul programma di servizio apt-get, che a sua volta si avvale di dpkg.

Per funzionare, apt-get richiede la presenza di un file di configurazione, /etc/apt/sources.list, all'interno del quale vanno elencate le fonti da cui si possono ottenere delle distribuzioni Debian. Questo file può contenere commenti, preceduti dal simbolo #, righe vuote che vengono ignorate come i commenti e righe contenenti ognuna l'indicazione di un'origine, espressa secondo la sintassi seguente:

deb uri_inizio_distribuzione distribuzione componente...
Per esempio, per indicare l'utilizzo della distribuzione stable (come mostrato fino a questo punto negli esempi) contenuta a partire da /home/pippo/debian/, della quale si vogliono tutte le componenti normali, si può utilizzare la direttiva seguente:

deb file:/home/pippo/debian/ stable main contrib non-free non-US local
Nello stesso modo si potrebbero indicare degli URI riferiti a siti FTP o HTTP. Inoltre, è importante tenere presente che si possono indicare molte fonti differenti, come si vede dall'esempio seguente:

deb file:/home/pippo/1/debian/ stable main contrib non-free non-US local
deb file:/home/pippo/2/debian/ stable main contrib non-free non-US local
deb http://ftp.us.debian.org/debian stable main contrib non-free
deb http://non-us.debian.org/debian-non-US stable non-US
Dopo la configurazione, apt-get richiede espressamente che gli sia ordinato di leggere le sorgenti per aggiornare l'elenco locale dei pacchetti disponibili, in modo da disporre di una visione di ciò che esiste e delle dipendenze relative. Si osservi lo schema sintattico per l'utilizzo di apt-get:

apt-get [opzioni] [comando] [pacchetto...]
Da quello che si vede, nella riga di comando di apt-get non si fa mai riferimento direttamente ad archivi Debian, ma sempre solo a pacchetti.
Per comprendere il funzionamento di apt-get è bene cominciare da alcuni esempi. Normalmente si inizia aggiornando l'elenco locale dei pacchetti
disponibili:

apt-get update[Invio]

Quindi potrebbe essere conveniente chiedere l'aggiornamento dei pacchetti, riferiti alla stessa versione della distribuzione che si sta utilizzando:

apt-get upgrade[Invio]

Per installare o aggiornare un pacchetto specifico, soddisfacendo le dipendenze necessarie, si può intervenire come nell'esempio seguente, dove si mostra in che modo installare o aggiornare il pacchetto zsh, rispettando le dipendenze:

apt-get install zsh[Invio]

Infine, per aggiornare il proprio sistema a una nuova versione della distribuzione, si utilizza il comando seguente:

apt-get -f dist-upgrade[Invio]

Questo è seguito generalmente da una richiesta esplicita di configurazione dei pacchetti che ne avessero bisogno, per mezzo di dpkg:

dpkg --configure --pending[Invio]

Alcuni comandi.
Opzione Descrizione
update
Risincronizza l'elenco locale dei pacchetti rispetto alle origini dichiarate nel file di configurazione. In generale, prima di un comando upgrade o dist-upgrade, occorrerebbe eseguire un comando update.
upgrade
Aggiorna tutti i pacchetti che risultano già installati, per i quali è disponibile un aggiornamento. L'aggiornamento non viene fatto se questo può provocare degli inconvenienti.
dist-upgrade
Aggiorna tutti i pacchetti che risultano già installati, per i quali è disponibile un aggiornamento. L'aggiornamento viene fatto tenendo conto delle dipendenze, che nel frattempo potrebbero essere cambiate (di solito quando si tratta di un aggiornamento che coinvolge l'intera distribuzione).
Di solito, dopo questo tipo di operazione, si avvia il comando dpkg --configure --pending allo scopo di procedere con la configurazione di ciò che richiede tale passaggio.
install pacchetto...
Installa i pacchetti indicati come argomento, provvedendo a sistemare anche le dipendenze. È bene sottolineare che vanno indicati i nomi dei pacchetti e non i nomi degli archivi che li contengono.
check
Esegue un controllo, anche sui pacchetti che sono stati installati in modo errato.
clean
APT utilizza un deposito transitorio per gli archivi utilizzati per l'installazione o l'aggiornamento. Si tratta della directory /var/cache/apt/archives/, che va ripulita periodicamente attraverso il comando clean.

Alcune opzioni.
Opzione Descrizione
-f
--fix-broken
Con l'uso di questa opzione si fa in modo che apt-get cerchi di sistemare i problemi legati alle dipendenze. Questa opzione può essere usata da sola, senza l'indicazione di un comando, oppure con un comando, di solito dist-upgrade, per richiedere espressamente la sistemazione dei problemi che si possono generare con lo stesso.
-s
--simulate
Simula l'esecuzione del comando, in modo da mostrare cosa si otterrebbe.

 

Ricerca dei file che apparentemente non appartengono ad alcun pacchetto.

Con l'aiuto di Dpkg è possibile cercare di individuare a quale pacchetto appartiene questo o quel file. Precisamente si usa l'opzione -S, come nell'esempio seguente:

dpkg -S /etc/timezone[Invio]

In questo caso si fa riferimento al file /etc/timezone e si dovrebbe ottenere una segnalazione simile a quella seguente, da cui si comprende che il file è abbinato al pacchetto timezones:

timezones: /etc/timezone
Per avere una visione di insieme dei file che potrebbero essere stati abbandonati inavvertitamente, si può usare Cruft,(2) che scandisce il file system e genera un rapporto. Naturalmente, non tutto ciò che viene indicato è necessariamente un file superfluo, ma è comunque il punto di partenza per la propria ricerca.

cruft [opzioni]
L'eseguibile cruft può essere usato solo dall'utente root e l'elenco che genera, di file sospetti, viene emesso attraverso lo standard output, a meno che siano usate delle opzioni particolari.

 Ricerca dei pacchetti che possono essere disinstallati senza problemi di dipendenze.

L'individuazione dei pacchetti che possono essere eliminati senza problemi di dipendenze, è un compito piuttosto complesso senza l'utilizzo di uno strumento apposito. Per questo si può usare Deborphanche, se usato senza argomenti, si limita a elencare i pacchetti delle librerie che, apparentemente, non servono:
deborphan [opzioni] [pacchetto]...
Alcune opzioni significative per l'utilizzo di Deborphan.
Opzione Descrizione
-d
--show-deps
Mostra le dipendenze dei pacchetti indicati alla fine della riga di comando.
-n
--nice-mode
Elenca anche i pacchetti che non sono indispensabili, pur essendo suggeriti o raccomandati da altri.
-a
--all-packages
Elenca tutti i pacchetti che risultano dall'interrogazione richiesta, senza limitare il risultato alle sole librerie.
-P
--show-priority
Mostra la priorità dei pacchetti che risultano dall'interrogazione.
-s
--show-section
Mostra la sezione a cui appartengono i pacchetti ottenuti dall'interrogazione.
Eventualmente, si può controllare il funzionamento di Deborphan tramite Orphaner,che viene distribuito assieme a Deborphan stesso, il quale si comporta da programma frontale interattivo:

orphaner [--purge] [opzioni_deborphan]
Con l'opzione --purge si specifica di voler eliminare completamente i pacchetti che devono essere selezionati successivamente (eliminando anche i file di configurazione), mentre ogni opzione successiva viene passata tale e quale al programma deborphan, allo scopo di cambiare l'elenco dei pacchetti selezionabili.

L'aspetto di orphaner durante il suo funzionamento. In questo caso non sono state indicate opzioni di alcun tipo, pertanto vengono elencati soltanto i nomi delle librerie inutili.
Orphaner V1.1

.--------------------------Orphaner V1.1-----------------------------.
| Select Packages for removal or cancel to quit:                     |
| .----------------------------------------------------------------. |
| |                   [ ] fftw2     main/libs                      | |
| |                   [ ] ldso      main/oldlibs                   | |
| |                   [ ] libdb4.1  main/libs                      | |
| |                   [ ] libpng3   main/libs                      | |
| |                                                                | |
| |                                                                | |
| |                                                                | |
| |                                                                | |
| |                                                                | |
| |                                                                | |
| |                                                                | |
| `----------------------------------------------------------------' |
|--------------------------------------------------------------------|
|       <   OK   >    <Simulate>    < Cancel >    <  Help  >         |
`--------------------------------------------------------------------'

Riconfigurazione.

L'installazione di un pacchetto prevede anche una fase di configurazione, che in molti casi è determinata in modo automatico, mentre il resto delle volte richiede un'interazione con un programma. Questa comunicazione tra utente e programma di installazione serve a creare al volo i file di configurazione necessari al funzionamento dei programmi che compongono il pacchetto; di solito, dopo tale operazione è possibile intervenire a mano in questi file, ma spesso ciò non è conveniente. Per ripetere la configurazione di un pacchetto già installato, si può usare dpkg-reconfigure, che fa parte del pacchetto Debconf:
dpkg-reconfigure [opzioni] pacchetto
Per esempio, si può usare il comando seguente per riconfigurare il pacchetto debconf:

dpkg-reconfigure debconf[Invio]

L'esempio mostra una situazione abbastanza comune, dal momento che il pacchetto debconf serve proprio a definire il comportamento della distribuzione in fase di configurazione dei pacchetti:

Debian Configuration                                                           
.-------------------------[?] Configuring Debconf----------------------------.
| Packages that use debconf for configuration share a common look and        |
| feel. You can select the type of user interface they use.                  |
|                                                                            |
| The dialog frontend is a full-screen, character based interface, while     |
| the readline frontend uses a more traditional plain text interface, and    |
| the gnome frontend is a modern X interface. The editor frontend lets       |
| you configure things using your favorite text editor. The                  |
| noninteractive frontend never asks you any questions.                      |
|                                                                            |
| What interface should be used for configuring packages?                    |
| .------------------------------------------------------------------------. |
| |                            Dialog                                      | |
| |                            Readline                                    | |
| |                            Gnome                                       | |
| |                            Editor                                      | |
| |                            Noninteractive                              | |
| `------------------------------------------------------------------------' |
|----------------------------------------------------------------------------|
|                       <  OK  >            <Cancel>                         |
`----------------------------------------------------------------------------'
Selezionando la voce {Dialog} si passa a un'altra richiesta, in cui si specifica il livello di attenzione che si vuole dare alla configurazione:
.-------------------------[?] Configuring Debconf----------------------------.
| Debconf prioritizes the questions it asks you. Pick the lowest priority    |
| of question you want to see:                                               |
|   - 'critical' only prompts you if the system might break.                 |
|     Pick it if you are a newbie, or in a hurry.                            |
|   - 'high' is for rather important questions                               |
|   - 'medium' is for normal questions                                       |
|   - 'low' is for control freaks who want to see everything                 |
|                                                                            |
|                                                                            |
| Note that no matter what level you pick here, you will be able to see      |
| every question if you reconfigure a package with dpkg-reconfigure.         |
|                                                                            |
| See only questions that are of what priority and higher?                   |
| .------------------------------------------------------------------------. |
| |                               medium                                   | |
| |                               critical                                 | |
| |                               high                                     | |
| |                               low                                      | |
| `------------------------------------------------------------------------' |
|----------------------------------------------------------------------------|
|                       <  OK  >            <Cancel>                         |
`----------------------------------------------------------------------------'
È disponibile anche un programma frontale per accedere alla configurazione dei pacchetti, partendo dalla classificazione a cui questi appartengono, con Configure-debian:


configure-debian [opzioni]
Le opzioni che si possono indicare nella riga di comando vengono passate tali e quali al programma dpkg-reconfigure, nel momento in cui questo viene avviato. Segue un esempio di utilizzo del programma:

configure-debian[Invio]

Debian Configuration
.-------Configure Packages---------.
|                                  |
|                                  |
| Which subsection do you want?    |
| .------------------------------. |
| |         admin                | |
| |         base                 | |
| |         comm                 | |
| |         devel                | |
| |         doc                  | |
| |         editors              | |
| |         libs                 | |
| |         misc                 | |
| |         net                  | |
| |         otherosfs            | |
| |         shells               | |
| |         sound                | |
| `---------.(+)-----------------' |
|----------------------------------|
|      <  OK  >    <Cancel>        |
`----------------------------------'
Scorrendo l'elenco viene scelta la voce tex:
Debian Configuration
.------------Configure Packages--------------.
|                                            |
|                                            |
| Which program do you want to configure?    |
| .----------------------------------------. |
| |              tetex-base                | |
| |              tetex-bin                 | |
| `----------------------------------------' |
|--------------------------------------------|
|          <  OK  >      <Cancel>            |
`--------------------------------------------'
Viene selezionata la voce tetex-base, che così viene configurato. Al termine viene proposto di configurare un altro pacchetto:
Debian Configuration
.--------------Configure Packages-----------------.
|                                                 |
|                                                 |
| Would you like to configure another program?    |
|                                                 |
|                                                 |
|-------------------------------------------------|
|             <  Yes  >       <  No  >            |
`-------------------------------------------------'

Pacchetti Debian sorgenti.

I pacchetti sorgenti messi a disposizione dalla distribuzione GNU/Linux Debian sono composti generalmente da tre file:

nome_pacchetto_versione-revisione.dsc
nome_pacchetto_versione-revisione.orig.tar.gz
nome_pacchetto_versione-revisione.diff.gz
Il file con estensione .dsc contiene informazioni essenziali sul pacchetto, con le firme eventuali, per garantire la sua integrità. Il file con estensione .orig.tar.gz contiene i sorgenti originali, archiviati attraverso tar+gz. Il file con estensione .diff.gz è un file di differenze da applicare per l'adattamento alla distribuzione; eventualmente questo file potrebbe mancare se il pacchetto nasce espressamente per la distribuzione Debian.

Per compilare un pacchetto occorre prima estrarlo, applicandogli le modifiche previste. Per farlo nel modo corretto, si usa il comando seguente, dove si suppone che nella directory corrente siano disponibili i tre file del pacchetto che interessa:

dpkg-source -x nome_pacchetto_versione-revisione.dsc[Invio]

In questo modo si ottiene la directory nome_pacchetto-versione/, all'interno della quale bisogna entrare per avviare uno script che viene creato proprio con l'applicazione delle modifiche:

cd nome_pacchetto-versione[Invio]
su[Invio]
debian/rules binary[Invio]

Come si vede, è stato necessario acquisire i privilegi dell'utente root per procedere alla compilazione.

In alternativa, se manca il file con estensione .dsc, si può rimediare nel modo seguente:

tar xzvf nome_pacchetto_versione-revisione.orig.tar.gz[Invio]
cd nome_pacchetto-versione[Invio]
cat ../nome_pacchetto_versione-revisione.diff.gz | gunzip | patch -p1[Invio]
chmod a+x debian/rules[Invio]
su[Invio]
debian/rules binary[Invio]

Come si vede, si devono applicare le modifiche manualmente, quindi occorre attribuire al file debian/rules i permessi di esecuzione. Il resto funziona regolarmente.

Al termine si ottiene il file nome_pacchetto_versione-revisione_arch.deb, contenente il pacchetto binario pronto per l'installazione.

È evidente che, se si vogliono apportare delle modifiche ulteriori al sorgente, queste vanno fatte dopo l'estrazione e dopo l'applicazione delle modifiche già previste per la distribuzione Debian. Volendo ricostruire un pacchetto sorgente corretto, si interviene secondo la sequenza seguente.
  1. Si estrae l'archivio originale e si applicano le modifiche già previste:
    tar xzvf nome_pacchetto_versione-revisione.orig.tar.gz[Invio]
    cd nome_pacchetto-versione[Invio]
    cat ../nome_pacchetto_versione-revisione.diff.gz | gunzip | patch -p1[Invio]
    cd ..[Invio]
  2. Si fanno le modifiche aggiuntive che si ritengono necessarie.
  3. Si cancella il file con estensione .diff.gz e .dsc:
    rm nome_pacchetto_versione-revisione.diff.gz[Invio]
    rm nome_pacchetto_versione-revisione.dsc[Invio]
  4. Si ricostruisce tutto con dpkg-source:
    dpkg-source -b nome_pacchetto-versione[Invio]
    In pratica, l'argomento dell'opzione -b è il nome della directory contenente i sorgenti modificati.
Al termine si ottiene un file nome_pacchetto_versione-revisione.diff.gz nuovo, assieme al file nome_pacchetto_versione-revisione.dsc appropriato.

 fonte: a2pluto



Ricerca personalizzata




Se ti è piaciuto l'articolo, iscriviti al feed per tenerti sempre aggiornato sui nuovi contenuti del blog:






GOOGLE+

LINKEDIN

Xtreme Download Manager, XDMAN Ubuntu, audio, Linux opera mini, browser internet Chromium Linux, Chrome, browsers tux collection, mascote Linux LibreCAD, Grafica, Disegno vim, editor, linux, ubuntu Ardour, audio, Ubuntu Unity, deskyop, Gnome, Ubuntu grafica 3d, Linux, Blender