Avete mai scaricato il codice sorgente di un popolare progetto software che richiedeva di digitare il quasi rituale ./configure; fai &&fai installa sequenza di comandi per compilarlo e installarlo? In tal caso, hai utilizzato GNU Autotools. Se hai mai esaminato alcuni dei file che accompagnano un progetto del genere, probabilmente sei stato anche terrorizzato dall'apparente complessità di un tale sistema di compilazione.
Buone notizie! GNU Autotools è molto più semplice da configurare di quanto pensi, ed è GNU Autotools stesso che genera quei file di configurazione da 1.000 righe per te. Sì, puoi scrivere 20 o 30 righe di codice di installazione e ricevere le altre 4.000 gratuitamente.
Autotools al lavoro
Il terminale Linux
- I 7 migliori emulatori di terminale per Linux
- 10 strumenti da riga di comando per l'analisi dei dati in Linux
- Scarica ora:cheat sheet SSH
- Cheat sheet sui comandi avanzati di Linux
- Esercitazioni sulla riga di comando di Linux
Se sei un utente nuovo di Linux alla ricerca di informazioni su come installare le applicazioni, non devi leggere questo articolo! Puoi leggerlo se vuoi ricercare come viene creato il software, ma se stai solo installando una nuova applicazione, leggi il mio articolo sull'installazione di app su Linux.
Per gli sviluppatori, Autotools è un modo semplice e veloce per gestire e creare pacchetti di codice sorgente in modo che gli utenti possano compilare e installare il software. Autotools è anche ben supportato dai principali formati di packaging, come DEB e RPM, quindi i gestori di repository software possono facilmente preparare un progetto creato con Autotools.
Autotools lavora in più fasi:
- In primo luogo, durante il ./configure passo, Autotools esegue la scansione del sistema host (il computer su cui viene eseguito) per rilevare le impostazioni predefinite. Le impostazioni predefinite includono dove si trovano le librerie di supporto e dove deve essere posizionato il nuovo software nel sistema.
- Successivamente, durante il make passo, Autotools costruisce l'applicazione, di solito convertendo il codice sorgente leggibile dall'uomo in linguaggio macchina.
- Infine, durante il make install passaggio, Autotools copia i file creati nelle posizioni appropriate (rilevate durante la fase di configurazione) sul tuo computer.
Questo processo sembra semplice e lo è, purché utilizzi Autotools.
Il vantaggio di Autotools
GNU Autotools è un software grande e importante che la maggior parte di noi dà per scontato. Insieme a GCC (GNU Compiler Collection), Autotools è l'impalcatura che consente di costruire e installare il software libero su un sistema in esecuzione. Se stai utilizzando un sistema POSIX, non è un eufemismo dire che la maggior parte del tuo sistema operativo esiste come software eseguibile sul tuo computer a causa di questi progetti.
Nel probabile caso in cui il tuo progetto domestico non sia un sistema operativo, potresti presumere che Autotools sia eccessivo per le tue esigenze. Ma, nonostante la sua reputazione, Autotools ha molte piccole funzionalità che potrebbero avvantaggiarti, anche se il tuo progetto è un'applicazione relativamente semplice o una serie di script.
Portabilità
Prima di tutto, Autotools ha in mente la portabilità. Sebbene non possa far funzionare il tuo progetto su tutte le piattaforme POSIX (sta a te, come programmatore), Autotools può garantire che i file che hai contrassegnato per l'installazione vengano installati nelle posizioni più ragionevoli su una piattaforma nota. E grazie ad Autotools, è banale per un utente esperto personalizzare e sovrascrivere qualsiasi valore non ottimale, in base al proprio sistema.
Con Autotools, tutto ciò che devi sapere è quali file devono essere installati in quale posizione generale. Si occupa di tutto il resto. Niente più script di installazione personalizzati che si interrompono su qualsiasi sistema operativo non testato.
Imballaggio
Anche Autotools è ben supportato. Consegna un progetto con Autotools a un packager di distro, sia che stia impacchettando un RPM, DEB, TGZ o qualsiasi altra cosa, e il loro lavoro è semplice. Gli strumenti di packaging conoscono Autotools, quindi è probabile che non siano necessarie patch, hacking o aggiustamenti. In molti casi, l'integrazione di un progetto Autotools in una pipeline può anche essere automatizzata.
Come usare Autotools
Per utilizzare Autotools, devi prima aver installato Autotools. La tua distribuzione potrebbe fornire un pacchetto pensato per aiutare gli sviluppatori a creare progetti, oppure potrebbe fornire pacchetti separati per ciascun componente, quindi potresti dover fare qualche ricerca sulla tua piattaforma per scoprire quali pacchetti devi installare.
I componenti principali di Autotools sono:
- produzione automobilistica
- autoconf
- fare
Anche se probabilmente devi installare il compilatore (GCC, per esempio) richiesto dal tuo progetto, Autotools funziona perfettamente con script o risorse binarie che non devono essere compilate. In effetti, Autotools può essere utile per tali progetti perché fornisce una disinstallazione make script per una facile rimozione.
Una volta installati tutti i componenti, è il momento di esaminare la struttura dei file del tuo progetto.
Struttura del progetto Autotools
GNU Autotools ha aspettative molto specifiche e la maggior parte di esse è probabilmente familiare se scarichi e costruisci spesso codice sorgente. Innanzitutto, il codice sorgente stesso dovrebbe trovarsi in una sottodirectory chiamata src .
Il tuo progetto non deve seguire tutte queste aspettative, ma se metti i file in posizioni non standard (dal punto di vista di Autotools), dovrai apportare modifiche in seguito nel tuo Makefile.
Inoltre, sono necessari questi file:
- NOTIZIE
- LEGGIMI
- AUTORI
- Registro delle modifiche
Non è necessario utilizzare attivamente i file e possono essere collegamenti simbolici a un documento monolitico (come README.md ) che racchiude tutte queste informazioni, ma devono essere presenti.
Configurazione di Autotools
Crea un file chiamato configure.ac nella directory principale del tuo progetto. Questo file è utilizzato da autoconf per creare la configurazione script di shell che gli utenti eseguono prima della creazione. Il file deve contenere almeno AC_INIT e AC_OUTPUT Macro M4. Non è necessario sapere nulla del linguaggio M4 per utilizzare queste macro; sono già scritti per te e tutti quelli relativi ad Autotools sono definiti nella documentazione.
Apri il file nel tuo editor di testo preferito. AC_INIT la macro può essere costituita dal nome del pacchetto, dalla versione, da un indirizzo e-mail per le segnalazioni di bug, dall'URL del progetto e, facoltativamente, dal nome del file TAR di origine.
L'AC_OUTPUT macro è molto più semplice e non accetta argomenti.
AC_INIT([penguin], [2019.3.6], [[email protected]])
AC_OUTPUT
Se dovessi eseguire autoconf a questo punto, una configurazione lo script verrebbe generato dal tuo configure.ac file e verrebbe eseguito correttamente. Questo è tutto ciò che farebbe, però, perché tutto ciò che hai fatto finora è definire i metadati del tuo progetto e richiedere la creazione di uno script di configurazione.
Le prossime macro che devi richiamare nel tuo configure.ac file sono funzioni per creare un Makefile. Un Makefile dice al make comando cosa fare (di solito, come compilare e collegare un programma).
Le macro per creare un Makefile sono AM_INIT_AUTOMAKE , che non accetta argomenti e AC_CONFIG_FILES , che accetta il nome che vuoi chiamare il tuo file di output.
Infine, devi aggiungere una macro per tenere conto del compilatore di cui il tuo progetto ha bisogno. La macro che usi dipende ovviamente dal tuo progetto. Se il tuo progetto è scritto in C++, la macro appropriata è AC_PROG_CXX , mentre un progetto scritto in C richiede AC_PROG_CC , e così via, come dettagliato nella sezione Creazione di programmi e librerie nella documentazione di Autoconf.
Ad esempio, potrei aggiungere quanto segue per il mio programma C++:
AC_INIT([penguin], [2019.3.6], [[email protected]])
AC_OUTPUT
AM_INIT_AUTOMAKE
AC_CONFIG_FILES([Makefile])
AC_PROG_CXX
Salva il file. È ora di passare al Makefile.
Generazione di Makefile di Autotools
I makefile non sono difficili da scrivere manualmente, ma Autotools può scriverne uno per te e quello che genera utilizzerà le opzioni di configurazione rilevate durante il ./configure passo, e conterrà molte più opzioni di quelle che penseresti di includere o di voler scrivere tu stesso. Tuttavia, Autotools non è in grado di rilevare tutto ciò che il tuo progetto richiede per la creazione, quindi devi aggiungere alcuni dettagli nel file Makefile.am , che a sua volta viene utilizzato da automake durante la costruzione di un Makefile.
Creafile.am utilizza la stessa sintassi di un Makefile, quindi se hai mai scritto un Makefile da zero, questo processo sarà familiare e semplice. Spesso, un Makefile.am file richiede solo poche definizioni di variabili per indicare quali file devono essere creati e dove devono essere installati.
Variabili che terminano con _PROGRAMS identificare il codice che deve essere compilato (questo è generalmente considerato il primario bersaglio; è il motivo principale per cui esiste il Makefile). Automake riconosce altri primari, come _SCRIPTS , _DATI , _LIBRERIE e altre parti comuni che costituiscono un progetto software.
Se la tua applicazione viene letteralmente compilata durante il processo di compilazione, la identifichi come un programma binario con bin_PROGRAMS variabile, quindi fare riferimento a qualsiasi parte del codice sorgente richiesta per compilarlo (queste parti possono essere uno o più file da compilare e collegare insieme) utilizzando il nome del programma come prefisso della variabile:
bin_PROGRAMS = penguin
penguin_SOURCES = penguin.cpp
L'obiettivo di bin_PROGRAMS è installato nel bindir , che è configurabile dall'utente durante la compilazione.
Se la tua applicazione non è effettivamente compilata, il tuo progetto non ha bisogno di un bin_PROGRAMS affatto variabile. Ad esempio, se il tuo progetto è uno script scritto in Bash, Perl o un linguaggio interpretato simile, definisci un _SCRIPTS variabile invece:
bin_SCRIPTS = bin/penguin
Automake prevede che le sorgenti si trovino in una directory chiamata src , quindi se il tuo progetto utilizza una struttura di directory alternativa per il suo layout, devi dire ad Automake di accettare codice da fonti esterne:
AUTOMAKE_OPTIONS = foreign subdir-objects
Infine, puoi creare qualsiasi regola Makefile personalizzata in Makefile.am e verranno copiati alla lettera nel Makefile generato. Ad esempio, se sai che un valore temporaneo deve essere sostituito nel codice sorgente prima che l'installazione proceda, puoi creare una regola personalizzata per quel processo:
all-am: penguin
touch bin/penguin.sh
penguin: bin/penguin.sh
@sed "s|__datadir__|@datadir@|" $< >bin/$@
Un trucco particolarmente utile consiste nell'estendere il clean esistente obiettivo, almeno durante lo sviluppo. Il pulisci Il comando generalmente rimuove tutti i file di build generati ad eccezione dell'infrastruttura di Automake. È progettato in questo modo perché la maggior parte degli utenti raramente desidera rendere pulito per cancellare i file che facilitano la creazione del loro codice.
Tuttavia, durante lo sviluppo, potresti volere un metodo per riportare in modo affidabile il tuo progetto a uno stato relativamente inalterato da Autotools. In tal caso, potresti voler aggiungere questo:
clean-local:
@rm config.status configure config.log
@rm Makefile
@rm -r autom4te.cache/
@rm aclocal.m4
@rm compile install-sh missing Makefile.in
C'è molta flessibilità qui e, se non hai già familiarità con Makefiles, può essere difficile sapere quale sia il tuo Makefile.am necessità. La necessità più assoluta è un obiettivo primario, che si tratti di un programma binario o di uno script, e un'indicazione di dove si trova il codice sorgente (se questo avviene tramite un _SOURCES variabile o utilizzando AUTOMAKE_OPTIONS per dire ad Automake dove cercare il codice sorgente).
Una volta che hai definito queste variabili e impostazioni, puoi provare a generare i tuoi script di build come vedi nella prossima sezione e aggiustare per tutto ciò che manca.
Autotools crea script per la generazione
Hai costruito l'infrastruttura, ora è il momento di lasciare che Autotools faccia ciò che sa fare meglio:automatizzare gli strumenti del tuo progetto. Il modo in cui lo sviluppatore (tu) si interfaccia con Autotools è diverso da come fanno gli utenti che creano il tuo codice.
I costruttori utilizzano generalmente questa sequenza ben nota:
$ ./configure
$ make
$ sudo make install
Affinché quell'incantesimo funzioni, tuttavia, tu come sviluppatore devi avviare l'infrastruttura di build. Innanzitutto, esegui autoreconf per generare lo script di configurazione che gli utenti invocano prima di eseguire make . Usa –Installa opzione per inserire file ausiliari, come un collegamento simbolico a depcomp , uno script per generare dipendenze durante il processo di compilazione e una copia della compilazione script, un wrapper per i compilatori per tenere conto della varianza della sintassi e così via.
$ autoreconf --install
configure.ac:3: installing './compile'
configure.ac:2: installing './install-sh'
configure.ac:2: installing './missing'
Con questo ambiente di sviluppo, puoi quindi creare un pacchetto per la distribuzione del codice sorgente:
$ make dist
La distanza target è una regola che ottieni "gratuitamente" da Autotools.
È una funzionalità incorporata nel Makefile generato dal tuo umile Makefile.am configurazione. Questo target produce un tar.gz archivio contenente tutto il codice sorgente e tutta l'infrastruttura essenziale di Autotools in modo che le persone che scaricano il pacchetto possano creare il progetto.
A questo punto, dovresti rivedere attentamente il contenuto dell'archivio per assicurarti che contenga tutto ciò che intendi spedire ai tuoi utenti. Dovresti anche, ovviamente, provare a costruirlo tu stesso:
$ tar --extract --file penguin-0.0.1.tar.gz
$ cd penguin-0.0.1
$ ./configure
$ make
$ DESTDIR=/tmp/penguin-test-build make install
Se la tua build ha esito positivo, trovi una copia locale della tua applicazione compilata specificata da DESTDIR (nel caso di questo esempio, /tmp/penguin-test-build ).
$ /tmp/example-test-build/usr/local/bin/example
hello world from GNU Autotools
È ora di utilizzare Autotools
Autotools è una grande raccolta di script per un processo di rilascio prevedibile e automatizzato. Questo set di strumenti potrebbe essere nuovo per te se sei abituato ai builder Python o Bash, ma probabilmente vale la pena imparare per la struttura e l'adattabilità che fornisce al tuo progetto.
E anche Autotools non è solo per il codice. Autotools può essere utilizzato per creare progetti Docbook, per mantenere i media organizzati (uso Autotools per le mie uscite musicali), progetti di documentazione e qualsiasi altra cosa che possa trarre vantaggio da destinazioni di installazione personalizzabili.