Arch Linux
 

ABS

De Wiki do Arch Linux Brasil


Tabela de conteúdo

O que é o ABS?

ABS é a sigla para Arch Build System. É um sistema parecido com o ports, usado para instalar programas a partir do código-fonte.

O que é um sistema 'ports-like'?

'Ports' é o sistema utilizado pelo FreeBSD, que permite que pacotes de código-fonte sejam baixados, desempacotados, compilados e instalados, tudo automaticamente. Um 'port' é um pequeno diretório no computador do usuário, identificado pelo software a ser instalado, e que contém alguns arquivos com instruções de como baixar e instalar o programa a partir de seu código-fonte. Navegar até o diretório desejado e digitar 'make; make install' é o suficiente para que o sistema baixe e compile o código-fonte, e instale o programa. O usuário desse sistema só teria que se preocupar em baixar a árvore de diretórios do ports, onde cada sub-diretório representa um programa que pode ser instalado.

ABS é um conceito similar

O ABS é feito de uma árvore de diretórios (árvore ABS), encontrada em /var/abs, e que contém vários sub-diretórios, cada um dentro de uma categoria e identificado pelo nome do respectivo pacote. Você pode se referir a cada sub-diretório (pacote) como um 'ABS', do mesmo modo que alguém se referiria a um 'port'. Esse ABS, ou sub-diretório, não contém o pacote do programa, nem seu código-fonte, e sim, um arquivo PKGBUILD, (e algumas vezes outros arquivos). Um PKGBUILD é simplesmente um arquivo-texto contendo instruções de compilação e empacotamento assim como o endereço URL do código-fonte a ser baixado. O componente mais importante do ABS é o PKGBUILD.

Se por exemplo você quisesse instalar o nano a partir do código-fonte, teria que copiar o diretório /var/abs/core/base/nano para um diretório de compilação temporário, navegar até ele e digitar makepkg. Simples! Então o makepkg irá ler e seguir as instruções contidas no PKGBUILD. O código-fonte será baixado automaticamente, descompactado e compilado, e então será empacotado num arquivo com extensão .pkg.tar.gz, de acordo com as informações presentes no PKGBUILD. Esse pacote resultante é o programa já compilado, pronto para ser instalado com um simples pacman -U nano.pkg.tar.gz, ou se preferir tudo em um único comando; makepkg -i. A remoção do pacote também é feita através do pacman.

Os arquivos PKGBUILD podem também ser customizados para atender às suas necessidades e você pode inclusive escolher usar a função makepkg do ABS para construir seus próprios pacotes de fontes externas à árvore do ABS. (Veja o protótipo PKGBUILD e arquivos de instalação em /var/abs/core)

Com a árvore ABS, um usuário Arch tem à sua disposição todos os pacotes Arch, para compilar a partir do fonte. As ferramentas do ABS podem também ser usadas para criar pacotes customizados para seu sistema, e/ou compartilhados com a comunidade Arch através do AUR.

Como sempre, man makepkg para mais informações.

TODO: breve explicação do makeworld

O makeworld não tem manual, então faça um makeworld --help.

Por que usar o ABS?

O Arch Build System (ou simplesmente ABS) é usado para:

  • Criar novos pacotes a partir dos fontes, de programas que não possuem ainda um pacote binário disponível;
  • Customizar pacotes existentes para se adequarem às suas necessidades (ativando ou desativando opções);
  • Recriar seu sistema inteiro usando flags de compilação, "a la FreeBSD";
  • Fazer com que módulos do kernel funcionem com seu kernel customizado.

Ao usar Arch Linux, não é necessário utilizar o ABS. O ABS é simplesmente uma ferramenta adicional para aqueles que querem um pouco mais de controle sobre os pacotes instalados em seu sistema.

Esse how-to tenta te dar uma idéia geral do funcionamento do ABS e dos pacotes Arch; não é um guia de referência completo! Se quiser mais informações, leia as páginas do manual.

Instalando pacotes

Para usar o abs, você antes precisar instalar o cvsup e o wget: 

# pacman -Sy cvsup wget

Como alternativa ao cvsup, você pode usar o csup, uma versão do cvsup escrita em C: 

# pacman -Sy csup

/etc/abs/abs.conf

Modifique o arquivo /etc/abs/abs.conf, incluindo os repositórios desejados: 

# nano /etc/abs/abs.conf

Remova o ! da frente dos repositórios que deseja utilizar, por exemplo: 

SUPFILES=(core extra !unstable community !testing)

Criando a árvore ABS

Como root, execute: 

# abs

Sua árvore ABS será criada em /var/abs. Note que as pastas logo abaixo da raiz da árvore correspondem às categorias especificadas em /etc/abs/abs.conf.

O comando abs deve também ser usado periodicamente para sincronizar e atualizar sua árvore ABS.

A árvore ABS

Quando você executar abs pela primeira vez, ele sincronizará a árvore ABS com o servidor Arch utilizando o sistema cvs. Então, o que é exatamente a árvore ABS? Ela está localizada em /var/abs e se parece com isso: 

|-
| -- core/
|-
|     ||-- autoconf/
|-
|     ||-- automake/
|-
|     ||-- ...
|-
| -- devel/
|-
| -- ...
|-
| -- extra/
|-
|      || -- daemons/
|-
|      ||      || -- acpid/
|-
|      ||      ||      || -- PKGBUILD
...    ...    ...    ...

A árvore ABS possui exatamente a mesma estrutura que o banco de dados dos pacotes:

  • os diretórios de primeiro nível representam as categorias;
  • os diretórios de segundo nível representam os próprios ABS, cujos nomes correspondem aos pacotes que podem ser instalados;
  • os arquivos PKGBUILD contém toda a informação necessária em relação ao respectivo pacote;
  • um diretório ABS pode ainda conter pacthes e/ou outros arquivos necessário para criar o pacote.

É importante entender que o atual código-fonte do software a ser instalado não está presente no diretório ABS do programa. Ao invés disso, o arquivo PKGBUILD possui o endereço de onde encontrar o(s) arquivos(s) necessários para assim o ABS baixá-lo(s).

/var/abs/local

Dentro da árvore ABS, existe um diretório especial chamado: local. Esse é o seu diretório, é onde você fará tudo; você não deve modificar os diretórios restantes. Copie o ABS desejado (var/abs/[branch]/[categoria]/[nomedopacote]) para o diretório de compilação (/var/abs/local).

Crie seu diretório de compilação /var/abs/local: 

# mkdir /var/abs/local

Altere usuário e grupo do diretório local para o seu usuário específico, pois é aconselhável rodar o makepkg como usuário comum: 

# chwon -R seuusuario.users /var/abs/local


ATENÇÃO: O primeiro download da árvore ABS é o maior, e então somente atualizações menores são necessárias (a não ser que você passe um bom tempo sem atualizá-la), portanto não se preocupe com o tamanho do download se você usa uma conexão de 56k; são somente arquivos-texto e é tudo comprimido durante a transferência.

Agora que você sabe o que é a árvore de diretórios ABS, como a usamos?

Como compilar, método tradicional

Se você não está familiarizado a compilar software, saiba que a maioria dos pacotes (não todos) podem ser compilados desta forma tradicional:

  • Baixe o código-fonte compactado do servidor, usando um navegador web, ftp, wget ou método alternativo.
  • descompacte o arquivo: 
# tar -xzf foo-0.99.tar.gz
# tar -xjf foo-0.99.tar.bz2
  • entre no diretório: 
# cd foo-0.99
  • configure o pacote: geralmente existe um pequeno script chamado configure no diretório descompactado que é usado para configurar o pacote (adicionar ou remover suporte para determinadas funções, escolher o destino da instalação etc.) e checar se seu sistema tem todo o software requerido pelo pacote. Ele pode ser executado da seguinte maneira: 
# ./configure [[option]]

Você deve antes tentar o help para melhor entender o que ele faz: 

# ./configure --help

Se uma opção --prefix não é passada ao script, grande parte deles usará /usr/local como destino da instalação, porém outros usarão /usr. Para manter uma consistência, é geralmente recomendado passar ao script a opção --prefix=/usr/local. É boa prática instalar programas pessoais em /usr/local, e deixar os outros gerenciados pela distribuição, em /usr. Isso assegura que versões de programas pessoais possam coexistir com aqueles administrados pelo gerenciador de pacotes da distribuição - no caso do Arch, o pacman. 

# ./configure --prefix=/usr/local
  • compile os fontes: 
make
  • instale: 
make install
  • Para desinstalar, teríamos de ir ao diretório onde se encontra o código-fonte e executar: 
# make uninstall

Como compilar, método ABS

O ABS é uma elegante ferramenta que fornece uma poderosa assistência ao processo de compilação, e cria um pacote para instalação. O método ABS envolve copiar um ABS da árvore original para o diretório de compilação e fazer um makepkg. No nosso exemplo, instalaremos o pacote slim, um gerenciador de sessões.

  • 1. Copie o ABS slim da árvore para o diretório de compilação; 
cp -r /var/abs/extra/slim /var/abs/local
  • 2. Vá até o diretório anteriormente copiado; 
cd /var/abs/local/slim
  • 3. Rode makepkg, que vai automaticamente baixar o arquivo com os fontes, descompactá-lo e criar um slim.pkg.tar.gz. A opção -i faz com que o pacman instale o pacote criado logo após empacotá-lo. 
makepkg -i

É isso, você acabou de compilar o slim a partir do código-fonte e o instalou no seu sistema através do pacman. A remoção também é feita através do pacman, como para os pacotes normais - (pacman -R slim).

Como alternativa, você pode rodar o makepkg sem a opção -i, e manualmente instalar com o pacman, fazendo: 

# pacman -U slim.pkg.tar.gz

Opções úteis

Algumas opções úteis do makepkg, diretamente do manual dele: 

-c, --clean
             Clean up leftover work files and directories after a successful build.

-f, --force
             makepkg will not build a package if a built package already exists in the PKGDEST (set in makepkg.conf) directory,
             which may default to the current directory. This allows the built package to be overwritten.

-i, --install
             Install or upgrade the package after a successful build using pacman.

-s, --syncdeps
             Install missing dependencies using pacman. When missing build-time or run-time dependencies are found, pacman will
             try to resolve them. If successful, the missing packages will be downloaded and installed.

Resumindo, makepkg -csi irá baixar todas as dependências (se existirem), instalá-las com o pacman e limpar todos os resíduos gerados pela compilação.

Novamente, consulte man makepkg para mais informações.

TODO: Explicar a função makeworld para reconstruir o sistema etc.

O que é um pacote?

Lembre-se, o ABS automaticamente baixar o código-fonte do programa especificado. Então ele descompacta, compila os fontes e empacota o binário resultante da compilação em um pacote instalável.

Tipicamente, o pacote resultante é um arquivo chamado foo.pkg.tar.gz.

Na verdade, o pacote nada mais é que um arquivo tar compactado com o gzip, e que contém:

  • Os arquivos a serem instalados;
  • .PKGINFO: contém todos os metadados necessários ao pacman para lidar com os pacotes, dependências etc.;
  • .FILELIST: lista todos os arquivos do pacote. É utilizado para desinstalar o software ou checar possíveis conflitos entre arquivos do sistema;
  • .INSTALL: um arquivo usado para executar comandos depois de instalações/atualizações/remoções. (Só está presente se especificado no PKGBUILD).

Como o pacman gerencia pacotes tar.gz, foo.pkg.tar.gz agora pode ser facilmente instalado/removido.

O que é um PKGBUILD e o que ele contém?

Como explicado anteriormente, o arquivo PKGBUILD contém metadados sobre um pacote. É um arquivo-texto. Aqui está um exemplo: 

# $Id: PKGBUILD,v 1.12 2003/11/06 08:26:13 dorphell Exp $
# Maintainer: judd <jvinet@zeroflux.org>
# Contributor: Judd Vinet <jvinet@zeroflux.org>
pkgname=foo
pkgver=0.99 # note: if the pkgver had been '0.99-10' then use an underscore, i.e. '0.99_10'
pkgrel=1
pkgdesc="short description of foo"
arch=(i686 x86_64)
url="http://www.foo.org"
license=('GPL')
groups=
provides=
depends=('qt' 'python')
makedepends=('guile')
conflicts=('yafoo')
replaces=('mffoo')
backup=('etc/foo/foo.conf')
install=('foo.install')
source=(http://www.foo.org/download/$pkgname-$pkgver.tar.gz)
md5sums=('2c0cca3ef6330a187c6ef4fe41ecaa4d35175bee593a7cc7d6205584a94d8625')

build() {
  cd $startdir/src/$pkgname-$pkgver
  ./configure --prefix=/usr
  make || return 1
  make prefix=$startdir/pkg/usr install
}

Vejamos o que significa cada campo:

  • # text : comentários;
  • # $Id: PKGBUILD,v ...: a cvs-tag para esse pkg (do sistema archlinux-cvs criado);
  • # Maintainer: o mantenedor responsável por esse pkg nos repositórios oficiais;
  • # Contributor: a pessoa que escreveu a primeira versão do PKGBUILD deste pacote;
  • pkgname: o nome do pacote;
  • pkgver: a versão do pacote;
  • pkgrel: o número do 'release' do pacote. Ele difere da versão do pacote e é modificado quando o PKGBUILD é editado. Isso pode acontecer por várias razões, por exemplo se você habilitar suporte para alguma coisa na hora da compilação;
  • pkgdesc: uma breve descrição do pacote. Isso é o que você vê quando navega pelo banco de dados de pacotes;
  • arch: mostra em que arquiteturas é sabido que o pacote compila e funciona - veja Arch64_FAQ para detalhes sobre ports;
  • url: a página web do software (que aparece quando você clica em um pacote no banco de dados de pacotes);
  • license: a licença a qual o software distribuido está submetido;
  • provides: isso é usado se um pacote fornece um outro pacote, por exemplo, kernel-scsi fornece kernel;
  • depends: as dependências de execução do pacote (o que ele precisa para funcionar);
  • makedepends: as dependências necessárias para compilar o pacote, mas que não não mais usadas depois do pacote já pronto;
  • conflicts: esses pacotes não podem estar instalados ao mesmo tempo. Aqui, foo conflita com yafoo (yet another foo). They cannot be installed at the same time;
  • replaces: o novo pacote substitui o antigo. Aqui, mffoo (my first foo) não é mais suportado e está sendo substituido por foo;
  • backup: que arquivos fazer back up (como arquivo.pacsave) quando o pacote é removido;
  • install: especifica um script especial de instalação que está incluído no pacote (ele deve estar no mesmo diretório do PKGBUILD);
  • source: especifica de onde o código-fonte do pacote deve ser baixado. Pode ser um pacote local bem como de um endereço "http" ou "ftp". É identificado usando o pkgver a fim de evitar mudanças no endereço cada vez que a versão do pacote mudar;
  • md5sums: somas md5 do pacote para checar sua integridade.

Agora, vamos explicar a função:

  • build(): todas as ações necessárias para compilar o pacote (será explicado com detalhes mais a frente nesse documento)

Você vê que o PKGBUILD contém todas as informações que o gerenciador de pacotes pode precisar. Ele é o coração do pacman e do abs.

Existem também os arquivos de instalação. Esse PKGBUILD especifica 'foo.install' como o arquivo de instalação do pacote. Aqui está um exemplo de um arquivo desses: 

post_install() {
/bin/true
}

post_upgrade() {
/bin/true
}

pre_remove() {
/bin/true
}

op=$1
shift

$op "$@"

E aqui as explicações de cada função:

  • post_install(): esse script é executado logo depois de os arquivos serem instalados; requer um argumento:
    • a versão do pacote
  • post_upgrade(): esse script é executado após os arquivos terem sido atualizados; requer dois argumentos:
    • a nova versão do pacote
    • a versão antiga do pacote
  • pre_remove(): esse script é executado antes de os arquivos serem removidos (parar um processo daemon, por exemplo) e recebe um argumento:
    • a versão do pacote

As três linhas ao fim são necessárias em todo arquivo de instalação para que eles funcionem apropriadamente.

Função build() em detalhes

Vamos dar uma olhada na função build() mencionada no exemplo de PKGBUILD mostrado acima. Repare na seção build(): 

build() {
  cd $startdir/src/$pkgname-$pkgver
  ./configure --prefix=/usr
  make || return 1
  make prefix=$startdir/pkg/usr install
}

O que significa cada linha:

  • dirija-se ao diretório onde os fontes foram descompactados: 
# cd $startdir/src/$pkgname-$pkgver
  • configure o pacote, e o informe o diretório /usr para instalação: 
# ./configure --prefix=/usr
  • compile: 
# make || return 1
  • instale o software não em /usr, mas sim em $startdir/pkg/usr para que então o pacman tenha controle sobre os arquivos. 
# make prefix=$startdir/pkg/usr install

O que nós queremos fazer é compilar o pacote, não instalá-lo. Então, ao invés de instalar no lugar padrão (/usr), nós dizemos ao make para colocar os arquivos em um diretório especial: $startdir/pkg/usr. Desse modo, o makepkg pode identificar quais arquivos o pacote instala, e então compactar tudo em um pacote Arch.

ATENÇÃO: Algumas vezes ocorre do prefix não ser usado no Makefile e DESTDIR ser usado no lugar. Se o pacote é compilado com autoconf/automake, use DESTDIR; é isso o que aparece documentado nos manuais. Cheque se o filelist gerado é muito menor do que ele deveria ser, e se for o caso, tente compilar com make DESTDIR=$startdir/pkg install. Se ainda assim não funcionar, você terá de investigar mais a fundo os comandos de instalação executados pelo "make <...> install=".

Primeiro uso do ABS: customizando um pacote

A situação a seguir pode acontecer mais frequentemente do que você pode imaginar: pacotes oficiais são compilados com um certo número de opções --enable ou --disable escolhidas, e essas não são necessariamente as opções que você teria escolhido.

Para ilustrar, usarei um exemplo: foo. O pacote foo é compilado com suporte a arts desativado. Imagine que queremos habilitar o suporte a arts. Faríamos assim:

  • procure onde o pacote foo está localizado. Você pode fazer assim:
    • procurando por foo em [1]
    • usando o comando find: 
      # find /var/abs -name "foo"
    • usando o comando locate: 
      # locate foo | grep ^/var/abs

De qualquer maneira, você verá que foo é parte do extra e do multimedia (por exemplo).

  • copie o ABS foo para /var/abs/local/foo: 
# cp -r /var/abs/extra/multimedia/foo /var/abs/local
# cd /var/abs/local/foo
  • modifique o arquivo PKGBUILD; adicionaremos o suporte para arts: 
build() {
  cd $startdir/src/$pkgname-$pkgver
  ./configure --prefix=/usr
  make || return 1
  make prefix=$startdir/pkg/usr install
}

se torna: 

build() {
  cd $startdir/src/$pkgname-$pkgver
  ./configure --enable-arts --prefix=/usr
  make || return 1
  make prefix=$startdir/pkg/usr install
}
  • rode makepkg: 
# makepkg -c

(A opção -c limpa os arquivos que restaram ao fim da compilação.)

  • instale o novo pacote usando o seguinte comando (-U to upgrade or install package): 
# pacman -U foo-*.pkg.tar.gz

Flags de compilação e Customização do makepkg

O arquivo de configuração do makepkg é o /etc/makepkg.conf. Nele você pode especificar variáveis de ambiente para o gcc e para o make, assim como algumas para o próprio makepkg. A seguir temos um exemplo de um /etc/makepkg.conf. 

#
# /etc/makepkg.conf
#

#########################################################################
# SOURCE ACQUISITION
#########################################################################
#
#-- The FTP/HTTP download utility that makepkg should use to acquire sources
FTPAGENT="/usr/bin/wget --continue --passive-ftp --tries=3 --waitretry=3 --no-check-certificate"
#FTPAGENT="/usr/bin/snarf"
#FTPAGENT="/usr/bin/lftpget -c"

#########################################################################
# ARCHITECTURE, COMPILE FLAGS
#########################################################################
#
CARCH="i686"
CHOST="i686-pc-linux-gnu"

#-- Exclusive: will only run on i686
# -mtune builds exclusively for an architecture
# -mcpu optimizes for an architecture, but builds for the whole processor family
CFLAGS="-march=i686 -O2 -pipe"
CXXFLAGS="-march=i686 -O2 -pipe"
#-- Make Flags: change this for DistCC/SMP systems
MAKEFLAGS="-j2"

#########################################################################
# BUILD ENVIRONMENT
#########################################################################
#
# Defaults: BUILDENV=(!fakeroot !distcc color !ccache)
#
#-- fakeroot: Allow building packages as a non-root user
#-- distcc:   Use the Distributed C/C++/ObjC compiler
#-- color:    Colorize output messages
#-- ccache:   Use ccache to cache compilation
#
BUILDENV=(fakeroot !distcc color !ccache)
#
#-- If using DistCC, your MAKEFLAGS will also need modification. In addition,
#-- specify a space-delimited list of hosts running in the DistCC cluster.
#DISTCC_HOSTS=""

#########################################################################
# GLOBAL PACKAGE OPTIONS
#   These are default values for the options=() settings
#########################################################################
#
# Default: OPTIONS=(strip !docs !libtool emptydirs)
#
#-- strip:     Strip symbols from binaries/libraries
#-- docs:      Save doc and info directories
#-- libtool:   Leave libtool (.la) files in packages
#-- emptydirs: Leave empty directories in packages
#
OPTIONS=(strip !docs libtool emptydirs)

#-- File integrity checks to use. Valid: md5, sha1, sha256, sha384, sha512
INTEGRITY_CHECK=(md5)
#-- Info and doc directories to remove (if option set correctly above)
DOC_DIRS=(usr/{,share/}{info,doc,gtk-doc} opt/gnome/{,share/}{info,doc,gtk-doc})

#########################################################################
# PACKAGE OUTPUT
#########################################################################
#
# Default: put built package and cached source in build directory
#
#-- Destination: specify a fixed directory where all packages will be placed
PKGDEST=/home/packages
#-- Source cache: specify a fixed directory where source files will be cached
SRCDEST=/home/sources
#-- Packager: name/email of the person or organization building packages
PACKAGER="John Doe <john@doe.com>"

# vim: set ft=sh ts=2 sw=2 et:

ATENÇÃO: Os usuários devem ter atenção redobrada ao alterar as variáveis CFLAGS, CXXFLAGS, e MAKEFLAGS, pois elas podem fazer com que os pacotes compilados tornem-se instáveis ou até impedir a compilação dos mesmos. O usuário mediano do Arch Linux muito provavelmente não precisará mudar os valores de CARCH, CHOST, e USE_FAKEROOT.

Referências sobre flags para o gcc e para o make

Obtido em "http://wiki.archlinux-br.org/ABS"
Ferramentas pessoais
TOOLBOX
LANGUAGES