Abordagem Fakeroot

O primeiro passo é você entender como funciona um software compilado da fonte.

Vamos utilizar o método Fakeroot, que significa Raiz Falsa. Para entendermos o conceito, precisamos saber como é instalado um programa por de trás dos panos.

Para esta abordagem, vamos usar um software criado com autotools, que possui ferramentas como "./configure", "makefile", etc.

A grosso modo, ao instalar um programa, ele possui toda a estrutura dos diretórios, como usr/{bin,share,man,doc}, etc/, /lib64, /lib ... Esta estrutura, se instalado com "make install", é solta diretamente na raiz (/) do sistema, logo podemos saber que a instalação será feita e você já pode executar o seu software.

Isso, se tratando de softwares convencionais, os opcionais como Firefox, Telegram... etc, normalmente ficam em um diretório a parte em opt/ e normalmente já são pré-compilados.

Quando compilamos e fizemos um "make install", é feito o passo que falamos acima, é solto basicamente toda a estrutura do programa pré compilado na raiz (/). Este processo é válido e se o desenvolvedor ter boa vontade, ele pode ter inserido a opção de desinstalação do software "make desinstall".

Caso não houve boa vontade, você terá que remover toda hierarquia instalado pelo software manualmente! Isto te dá um controle, é claro, mas o tempo que você perde... Hmm, é complicado.

É ai que entra o Fakeroot, vamos enganar o sistema dizendo que um diretório especifico, ao invés de instalar na raiz (/). Este diretório falso é essencial, pois podemos manipular todo o programa pre-compilado antes da instalação. Isto,se tratando de software compilados, se forem scripts, podemos usar a mesma abordagem do Fakeroot. :)

Assim, fizemos os nossos enfeites que vamos abordar mais adiante.

Para um exemplo, supondo que rodei toda a base "./configure && make" e ao invés de por "make install", somente botaria em "make install DESTDIR=/Um/Diretorio".

Vamos usar um software como base para compilar da fonte. Assim você terá mais visão do que abordamos acima. Vamos utilizar o editor de texto nano para iniciar a brincadeira.

Primeiramente, crie um diretório em /tmp/ chamado "source" e dentro deste diretório, aonde vamos armazenar o código fonte do nano. Dentro de /tmp/source crie o diretório "nano".

mkdir -vp /tmp/source/nano

E adquira o fonte do editor nano e baixe com "wget" em "/tmp/source/nano/". Após feito o download, descompacte o mesmo:

cd /tmp/source/nano
wget https://www.nano-editor.org/dist/v4/nano-4.7.tar.xz
tar xvf nano-4.7.tar.xz

Após feito este processo, vamos entrar dentro do diretório que foi criado. É lá que está todo o fonte do editor nano:

ls
nano-4.7  nano-4.7.tar.xz

cd nano-4-7

Como dito, este artigo está trabalhando com abordagem do autotools. Execute agora o script "configure", com ele podemos fazer pré-configurações como: a raiz aonde será solto o software, desabilitar/habilitar funcionalidades em geral do software etc, etc...

NOTA: você pode usar o "./configure --help" para saber todas opções disponíveis que você pode habilitar/desabilitar.

Como o objetivo deste artigo não é "como compilar um software" e sim "Como escrever o seu gerenciador de pacotes", vamos usar configurações genéricas neste para não ter excesso de informações para você neste momento. Saiba que se você não sabe como funciona a compilação de programas, provavelmente você não está apto a criar o seu gerenciador ainda.

./configure \
--prefix=/usr        \
--sysconfdir=/etc    \
--mandir=/usr/man    \
--libdir=/usr/lib64  \
--enable-utf8

Entendendo as configurações usadas no "configure":

• --prefix :: A hierarquia de "usr" deve ficar em /usr, e não em /usr/local. Normalmente esta hierarquia é em /usr/local/, o que pode ter muitos conflitos com o sistema, então pedimos para ser apenas /usr.
• --sysconfdir :: Toda arquivos de configuração do software devem ficar em /etc.
• --mandir :: Aonde será instalado o manual do software /usr/man.
• --libdir :: Bibliotecas devem ficar em /usr/lib64.
• --enable-utf8 :: Ativa suporte UTF-8.

Lembre-se, isto não é uma receita de bolo, cada programa tem suas próprias configurações! O básico e pontapé inicial que você pode utilizar seria: (--prefix, --sysconfdir, --mandir, --libdir).

Feita isto, vamos compilar o software em si! Para isto, utilizamos o "make". Se o seu processador tem vários núcleos, você pode especificar com "-j Número_de_Núcleos", assim a compilação será mais rápida.

Exemplo aqui, possuo 6 núcleos:

make -j 6

Tudo certo até aqui? Não houve erros? Então vamos fazer a instalação na raiz falsa! A abordagem do Fakeroot inicia aqui, para isto, vamos precisar criar agora um diretório em "/tmp" chamado "build/nome-do-programa.versão". É lá que será a "raiz" falsa do editor nano.

Crie o diretório em /tmp/build/nano-versao:

mkdir -vp /tmp/build/nano-4.7
mkdir: created directory '/tmp/build'
mkdir: created directory '/tmp/build/nano-4.7'

Feito isto, vamos realizar a instalação com "make install", passando a variável DESTDIR. Assim enganamos o sistema dizendo que a raiz é em /tmp/build/nano-versao:

make install DESTDIR='/tmp/build/nano-4.7/'

Vamos agora entrar no diretório /tmp/build/nano-versao e ver que toda estrutura de diretórios estão lá!

cd /tmp/build/nano-4.7
ls
usr

tree --filelimit 10
.
└── usr
    ├── bin
    │   ├── nano
    │   └── rnano -> nano
    ├── man
    │   ├── man1
    │   │   ├── nano.1
    │   │   └── rnano.1
    │   └── man5
    │       └── nanorc.5
    └── share
        ├── doc
        │   └── nano
        │       ├── faq.html
        │       ├── nano.1.html
        │       ├── nano.html
        │       ├── nanorc.5.html
        │       └── rnano.1.html
        ├── info
        │   ├── dir
        │   └── nano.info
        ├── locale [35 entries exceeds filelimit, not opening dir]
        └── nano [44 entries exceeds filelimit, not opening dir]

Perceba que toda hierarquia que seria solta na raiz do sistema, agora está aqui neste diretório!

Com isto, podemos fazer o que quiser com o software, usar um compressor, por exemplo como gzip, e passar para um amigo o software compilado. O seu amigo poderia extrair o software na raiz do sistema e teria o software pronto! Você poderia também, a partir daqui, copiar todo a estrutura para a raiz do sistema.

Mas isto seria um problema, pois como dito no inicio, teríamos que rastrear toda a estrutura que foi solta na raiz do sistema e excluir uma por uma, arquivo por arquivo, diretório por diretório, link simbólico por link simbólico.

A grosso modo, é isso que os gerenciadores de baixo nível fazem! Eles fazem o rastreamento do software, gerando um pacote agrupando tudo em um "arquivo", assim facilitando para usuário de ter que fazer tudo isso manual.

Entendeu a mágica do Fakeroot/raiz falsa. Então, a partir daqui, vamos começar a criar nosso gerenciador de pacotes.