A magia por trás do configure, make, make install


A magia por trás do configure, make, make install
Se você usou algum sabor do Unix para o desenvolvimento, provavelmente você instalou o software da fonte com esse encantamento mágico:
./configure
make
make install

Eu sei que eu escrevi muito, mas, nos meus primeiros dias, usando o Linux, eu realmente não entendi o que isso significava, eu simplesmente sabia que, se eu queria instalar o software, esse era o feitiço para recitar.
Recentemente, criei minhas próprias ferramentas do Unix e queria tocar nesse processo de instalação padrão; não só é familiar para muitos usuários do Unix, também é um ótimo ponto de partida para a construção de um pacote para o Homebrew e os vários gerenciadores de pacotes Linux e BSD. Era hora de cavar no Grimoire de Unix e descobrir o que o encantamento faz.

O que tudo isso faz

Existem três etapas distintas nesse processo:
1. Configure o software
configurescript é responsável por se preparar para construir o software em seu sistema específico. Ele garante que todas as dependências para o resto do processo de instalação e instalação estão disponíveis e descobre o que precisa saber para usar essas dependências.
Os programas Unix são muitas vezes escritos em C, portanto, geralmente precisaremos de um compilador C para construí-los. Nesses casos, o configurescript estabelecerá que seu sistema possui realmente um compilador C, e descubra o que é chamado e onde encontrá-lo.
2. Criar o software
Uma vez configureque fez seu trabalho, podemos invocar makepara construir o software. Isso executa uma série de tarefas definidas em a Makefilepara criar o programa concluído a partir do seu código-fonte.
O tarball que você faz o download geralmente não inclui um acabado MakefileEm vez disso, ele vem com um modelo chamado Makefile.ine o configurescript produz um personalizado Makefileespecífico para o seu sistema.
3. Instale o software
Agora que o software foi construído e pronto para ser executado, os arquivos podem ser copiados para seus destinos finais. make installcomando copiará o programa construído, e suas bibliotecas e documentação, para os locais corretos.
Isso geralmente significa que o binário do programa será copiado para um diretório no seu PATH, a página do manual do programa será copiada para um diretório no seu MANPATH, e qualquer outro arquivo de que dependa será armazenado com segurança no lugar apropriado.
Uma vez que o passo de instalação também é definido no Makefile, onde o software está instalado pode mudar com base nas opções passadas para o configurescript, ou coisas que o configurescript descobriu sobre o seu sistema.
Dependendo de onde o software está sendo instalado, você pode precisar de permissões escalonadas para esta etapa para que você possa copiar arquivos para diretórios do sistema. O uso sudomuitas vezes faz o truque.

De onde são esses scripts

Tudo isso funciona porque um configurescript examina seu sistema e usa a informação que encontra para converter um Makefile.inmodelo em um Makefile, mas de onde o configurescript e o Makefile.inmodelo vêm?
Se você já abriu um configurescript ou associado Makefile.in, você verá que eles são milhares de linhas de script de shell denso. Às vezes, esses scripts de suporte são maiores do que o código-fonte do programa que eles instalam.
Mesmo a partir de um configurescript existente , seria muito assustador construí-lo manualmente. Não se preocupe, porém: esses scripts não são construídos à mão.
Os programas que foram construídos desta forma geralmente foram empacotados usando um conjunto de programas coletivamente referidos como autotools . Esta suíte inclui autoconfautomakee muitos outros programas, todos os quais funcionam juntos para tornar a vida útil de um software significativamente mais fácil. O usuário final não vê essas ferramentas, mas eles sofrem com a instalação de um processo de instalação que funcionará de forma consistente em vários tipos diferentes de Unix.

Olá Mundo


Vamos fazer um simples programa "Hello world" C e ver o que seria necessário para empacotá-lo com autotools.
Aqui está a fonte do programa, em um arquivo chamado main.c:
#include <stdio.h>

int
main(int argc, char* argv[])
{
    printf("Hello world\n");
    return 0;
}

Criando o script de configuração

Em vez de escrever o script de configuração à mão, precisamos criar umconfigure.acarquivo escrito em m4sh - uma combinação de macros m4 e script de shell POSIX - para descrever o que o script de configuração precisa fazer.
A primeira macro m4 que precisamos chamar é AC_INIT, que inicializará o autoconf e configurará algumas informações básicas sobre o programa que estamos empacotando. O programa é chamado helloworld, a versão é 0.1, e o mantenedor é george@thoughtbot.com:
AC_INIT([helloworld], [0.1], [george@thoughtbot.com])
Nós vamos usar automakepara este projeto, então precisamos inicializar isso com a AM_INIT_AUTOMAKEmacro:
AM_INIT_AUTOMAKE
Em seguida, precisamos dizer autoconf sobre as dependências que nosso script de configuração precisa procurar. Nesse caso, o script de configuração só precisa procurar um compilador C. Podemos configurar isso usando a AC_PROG_CCmacro:
AC_PROG_CC
Se houvesse outras dependências, então usaríamos outras macas m4 para descobri-las; Por exemplo, a AC_PATH_PROGmacro procura um determinado programa no usuário PATH.
Agora que listámos nossas dependências, podemos usá-las. Nós vimos anteriormente que um configurescript típico usará as informações que ele tem sobre o sistema do usuário para construir um Makefilede um Makefile.inmodelo.
A próxima linha usou a AC_CONFIG_FILESmacro para dizer ao autoconf que o script de configuração deve fazer exatamente isso: deve encontrar um arquivo chamado Makefile.in, substituir espaços reservados, como @PACKAGE_VERSION@valores como 0.1, e escrever os resultados Makefile.
AC_CONFIG_FILES([Makefile])

Finalmente, tendo dito ao autoconf tudo o que nosso script de configuração precisa fazer, podemos chamar a AC_OUTPUTmacro para exibir o script:
AC_OUTPUT
Aqui está tudo. Nada mal, em comparação com o configurescript de linha 4.737 que vai produzir!
AC_INIT([helloworld], [0.1], [george@thoughtbot.com])
AM_INIT_AUTOMAKE
AC_PROG_CC
AC_CONFIG_FILES([Makefile])
AC_OUTPUT
Estamos quase prontos para empacotar e distribuir o nosso programa, mas ainda estamos perdendo alguma coisa. Nosso configurescript esperará um Makefile.inarquivo que possa substituir todas essas variáveis ​​específicas do sistema, mas, até agora, não criamos esse arquivo.

Criando o Makefile

Tal como acontece com o configurescript, o Makefile.inmodelo é muito longo e complexo. Então, em vez de escrevê-lo à mão, nós escrevemos um Makefile.am arquivo mais curto , que automakeusará para gerar o Makefile.innosso para nós.
Primeiro, precisamos definir algumas opções para informar o automake sobre o layout do projeto. Uma vez que não estamos seguindo o layout padrão de um projeto GNU, avisamos o automake que este é um foreignprojeto:
AUTOMAKE_OPTIONS = foreign
Em seguida, dizemos ao automake que queremos o Makefile para construir um programa chamado helloworld:
bin_PROGRAMS = helloworld
Há muita informação acumulada nesta linha, graças ao esquema de nomeação uniforme de automake .
PROGRAMSsufixo é chamado de primário . Ele diz ao automake quais propriedades o helloworldarquivo possui. Por exemplo, PROGRAMSprecisam ser construídos, enquanto SCRIPTSDATAarquivos não precisam ser construídas.
binprefixo diz ao automake que o arquivo listado aqui deve ser instalado no diretório definido pela variável bindirExistem vários diretórios definidos para nós por autotools-inclusive bindirlibdirpkglibdir-mas também podemos definir a nossa própria.
Se quisermos instalar alguns scripts Ruby como parte de nosso programa, poderíamos definir uma rubydirvariável e informar o automake para instalar os nossos arquivos Ruby lá:
rubydir = $(datadir)/ruby
ruby_DATA = my_script.rb my_other_script.rb
Podem ser adicionados prefixos adicionais antes do diretório de instalação para melhorar o comportamento do automake.
Uma vez que definimos um PROGRAM, precisamos dizer ao automake onde encontrar seus arquivos de origem. Nesse caso, o prefixo é o nome do programa que esses arquivos de origem são compilados, e não o local onde eles serão instalados:
helloworld_SOURCES = main.c
Aqui está o Makefile.amarquivo inteiro para o nosso helloworldprograma. Tal como acontece com o script configure.ace o configurescript, é muito mais curto que oMakefile.inque ele gera:
AUTOMAKE_OPTIONS = foreign
bin_PROGRAMS = helloworld
helloworld_SOURCES = main.c

Colocando tudo junto

Agora escrevemos nossos arquivos de configuração, podemos executar autotools e gerar o configurescript e o Makefile.inmodelo finalizados .
Primeiro, precisamos gerar um ambiente m4 para autotools para usar:
aclocal
Agora podemos correr autoconfpara transformar o nosso configure.acem um configurescript, e automaketransformar o nosso Makefile.amem um Makefile.in:
autoconf
automake --add-missing

Distribuindo o programa

O usuário final não precisa ver nossa configuração de autotools, para que possamos distribuir oconfigurescript e Makefile.insem todos os arquivos que usamos para gerá-los.
Felizmente, os autotools também nos ajudarão com a distribuição. O Makefile contém todos os tipos de objetivos interessantes, incluindo um para construir um tarball do projeto contendo todos os arquivos que precisamos distribuir:
./configure
make dist
Você pode até testar que o tarball de distribuição pode ser instalado sob uma variedade de condições:
make distcheck

Comentários :

Postar um comentário

Interested to get more of our Update !