Por que sempre ./configure; faço; make install; como 3 etapas separadas?

Cada vez que você compila algo da fonte, você segue as mesmas 3 etapas:

$ ./configure
$ make
$ make install

Eu entendo que faz sentido dividir o processo de instalação em etapas diferentes, mas não entendo por que cada programador neste planeta tem que escrever os mesmos três comandos repetidamente apenas para realizar um único trabalho. Do meu ponto de vista, faria todo o sentido ter um ./install.shscript entregue automaticamente com o código-fonte que contém o seguinte texto:

#!/bin/sh
./configure
make
make install

por que as pessoas fariam as 3 etapas separadamente?

Porque cada etapa faz coisas diferentes

Prepare (configure) o ambiente para a construção

./configure

Este script possui muitas opções que você deve alterar. Gostar --prefixou --with-dir=/foo. Isso significa que cada sistema possui uma configuração diferente. Também ./configureverifica se há bibliotecas ausentes que devem ser instaladas. Qualquer coisa errada aqui faz com que não construa seu aplicativo . É por isso que as distros têm pacotes que são instalados em locais diferentes, porque toda distro pensa que é melhor instalar certas bibliotecas e arquivos em certos diretórios. Diz-se que corre./configure , mas na verdade você deve alterá-lo sempre.

Por exemplo, dê uma olhada no site de pacotes do Arch Linux . Aqui você verá que qualquer pacote usa um parâmetro de configuração diferente (suponha que eles estejam usando autotools para o sistema de compilação).

Construindo o sistema

make

Isso é na verdade make all por padrão. E cada marca tem diferentes ações a realizar. Alguns fazem a construção, alguns fazem testes após a construção, alguns fazem check-out de repositórios SCM externos. Normalmente você não precisa fornecer nenhum parâmetro, mas, novamente, alguns pacotes os executam de maneira diferente.

Instale no sistema

make install

Isso instala o pacote no local especificado com configure. Se desejar, você pode especificar ./configurepara apontar para seu diretório inicial. No entanto, muitas opções de configuração estão apontando para /usrou /usr/local. Isso significa que você terá que usar de fato sudo make installporque apenas o root pode copiar arquivos para / usr e / usr / local.

Agora você vê que cada etapa é um pré-requisito para a próxima etapa. Cada etapa é uma preparação para fazer as coisas funcionarem em um fluxo sem problemas. As distros usam essa metáfora para construir pacotes (como RPM, deb, etc.).

Aqui você verá que cada etapa é, na verdade, um estado diferente. É por isso que os gerenciadores de pacotes têm wrappers diferentes. Abaixo está um exemplo de um invólucro que permite construir todo o pacote em uma etapa. Mas lembre-se de que cada aplicativo tem um wrapper diferente (na verdade, esses wrappers têm um nome como spec, PKGBUILD, etc.):

def setup:
... #use ./configure if autotools is used

def build:
... #use make if autotools is used

def install:
... #use make all if autotools is used

Aqui pode-se usar autotools, ou seja ./configure, makee make install. Mas outro pode usar SCons, configuração relacionada ao Python ou algo diferente.

Como você pode ver, a divisão de cada estado torna as coisas muito mais fáceis de manutenção e implantação, especialmente para mantenedores de pacotes e distribuições.

Primeiro, deve ser, ./configure && make && make installjá que cada um depende do sucesso do primeiro. Parte do motivo é a evolução e parte do motivo é a conveniência para o fluxo de trabalho de desenvolvimento.

Originalmente, a maioria dos Makefiles conteria apenas os comandos para compilar um programa e a instalação era deixada para o usuário. Uma regra extra permitemake install colocar a saída compilada em um local que possa ser correto; ainda existem muitos bons motivos pelos quais você pode não querer fazer isso, incluindo não ser o administrador do sistema, nem querer instalá-lo. Além disso, se estou desenvolvendo o software, provavelmente não quero instalá-lo. Quero fazer algumas alterações e testar a versão que está em meu diretório. Isso se torna ainda mais evidente se eu tiver várias versões por aí.

./configurevai e detecta o que está disponível no ambiente e / ou é desejado pelo usuário para determinar como construir o software. Isso não é algo que precise mudar com muita frequência e pode levar algum tempo. Novamente, se eu sou um desenvolvedor, não vale a pena reconfigurar constantemente. Mais importante, uma vez que makeusa timestamps para reconstruir módulos, se eu executar novamente, configurehá uma possibilidade de que os sinalizadores mudem e agora alguns dos componentes em minha construção serão compilados com um conjunto de sinalizadores e outros com um conjunto diferente de sinalizadores que podem levar a comportamento diferente e incompatível. Contanto que eu não execute novamente configure, eu sei que meu ambiente de compilação permanece o mesmo, mesmo se eu mudar minhas fontes. Se eu repetir configure, eu deveriamake clean primeiro, para remover quaisquer fontes criadas para garantir que as coisas sejam criadas de maneira uniforme.

O único caso onde os três comandos são executados em uma linha é quando os usuários instalam o programa ou um pacote é compilado (por exemplo, debuild do Debian ou rpmbuild do RedHat). E isso pressupõe que o pacote pode receber um simplesconfigure , o que normalmente não é o caso da embalagem, onde, pelo menos, --prefix=/usré desejado. E os pacakgers precisam lidar com raízes falsas ao fazer o make installpapel. Como há muitas exceções, fazer ./configure && make && make installa regra seria inconveniente para muitas pessoas que o fazem com muito mais frequência!

Em primeiro lugar, ./configure nem sempre encontra tudo o que precisa ou, em outros casos, encontra tudo o que precisa, mas nem tudo que poderia usar. Nesse caso, você gostaria de saber sobre isso (e seu script ./install.sh iria falhar de qualquer maneira!) O exemplo clássico de não falha com consequências indesejadas, do meu ponto de vista, é compilar grandes aplicativos como ffmpeg ou mplayer. Eles usarão bibliotecas se estiverem disponíveis, mas serão compilados de qualquer maneira se não estiverem, deixando algumas opções desabilitadas. O problema é que você descobre mais tarde que ele foi compilado sem suporte para um formato ou outro, sendo necessário voltar atrás e refazê-lo.

Outra coisa que ./configure faz de forma interativa é dar a você a opção de personalizar onde o aplicativo será instalado no sistema. Distribuições / ambientes diferentes têm convenções diferentes, e você provavelmente gostaria de seguir a convenção em seu sistema. Além disso, você pode querer instalá-lo localmente (somente para você). Tradicionalmente, os passos ./configure e make não são executados como root, enquanto make install (a menos que seja instalado exclusivamente para você) deve ser executado como root.

Distribuições específicas geralmente fornecem scripts que executam esta funcionalidade ./install.sh de uma maneira sensível à distribuição - por exemplo, RPMs de origem + arquivo de especificações + rpmbuild ou slackbuilds .

(Nota de rodapé: dito isso, concordo que ./configure; make; make install; pode ser extremamente tedioso.)

configure pode falhar se descobrir que faltam dependências.

makeexecuta um destino padrão, o primeiro listado no Makefile. Muitas vezes, esse alvo é all, mas nem sempre. Então você só poderia make all installse soubesse que esse era o alvo.

Assim ...

#!/bin/sh

if ./configure $*; then
  if make; then
    make install
  fi
fi

ou:

./configure $* && ./make && ./make install

O $*está incluído porque muitas vezes é necessário fornecer opções paraconfigure .

Mas por que não deixar que as pessoas façam isso sozinhas? Esta é realmente uma grande vitória?