Como criar pacotes para o Arch Linux

Muita gente me pergunta como fazer para criar um pacote para o Arch Linux e, por causa disso, resolvi escrever este artigo. Graças às ferramentas, e a filosofia da distribuição, criar pacotes para o Arch é bem mais fácil do que parece (e do que nas outras distribuições). Antes de colocar a mão na massa, porém, você precisa saber duas coisas:

1) Como é o fomato dos pacotes no Arch

Um pacote no Arch tem o seguinte formato:

nomedopacote-versão-release-arquitetura.pkg.tar.gz

Por exemplo:

firefox-2.0.0.14-1-i686.pkg.tar.gz

• O primeiro campo é referente ao nome do pacote que, no caso, é firefox;
• O segundo é a versão do software. No exemplo acima a versão do firefox deste pacote é a 2.0.0.14;
• O terceiro campo é o release do pacote. Ele serve para indicar qual a “versão” do pacote (e não do software). Se o pacote, por exemplo, apresentar algum problema o responsável por ele pode liberar uma nova versão do pacote para a mesma versão do software. Para isto ele deve fazer as alterações no pacote e incrementar o valor deste terceiro campo em 1. O pacote gerado seria, então, firefox-2.0.0.14-2-i686.pkg.tar.gz;
• O quarto quanto é o da arquitetura para qual o pacote foi criado. Oficialmente o Arch está disponível para as arquiteturas i686 e x86_64, mas ports para i586 e ppc estão a caminho;
• .pkg.tar.gz é a extensão dos pacotes do arch;

2) Para qual software você deseja criar um pacote.

Não adianta nada querer fazer um pacote se você não tem um programa para empacotar, né?

Agora que você já sabe isso podemos começar.

Durante este artigo eu usarei o billremider como exemplo para mostrar a criação de um pacote. Eu escolhi o billreminder porque ele é um ótimo programa que costumo usar, foi criado pelo amigo Og Maciel e a criação do pacote dele é bem simples.

Para criar um pacote você vai precisar de duas coisas. Um PKGBUILD e o makepkg. O PKGBUILD é um arquivo texto que contém todas as informações necessárias para se criar o pacote. Lá você vai ter o nome do mesmo, a versão, a url do source, a licensa, as intruções de compilação etc.

O makepkg é o responsável por pegar todas essas instruções do PKGBUILD e transformá-las no seu pacote.

A estrutura do PKGBUILD é a seguinte:

# Contributor: Seu nome

pkgname=nome-do-pacote
pkgver=versão
pkgrel=release
pkgdesc="Descrição do pacote"
arch=('arquitetura')
url="url do software"
depends=('dependencias')
license=('Licensa')
source=(url do source)
md5sums=('md5sum do source')

build() {
intruções de compilação
}

O arquivo é bem simples e de fácil entendimento. É basicamente atribuição de variável. De qualquer forma vou fazer uma melhor descrição de cada campo.

# Contributor: Esta primeira linha do PKGBUILD não é obrigatória. Ela é usada apenas para mostrar quem criou o PKGBUILD e seu email (que será utilizado para troca de informações, sugestões, dúvidas etc). Apesar de não ser obrigatório, este campo é praticamente um padrão entre os empacotadores. Exemplo:

# Contributor: Hugo Doria <hugodoria at archlinux-br.org>

pkgname: É aqui que você coloca o nome do pacote. Exemplo:

pkgname=billreminder

pkgver: Aqui fica a versão do programa que está sendo empacotado. Se você estiver criando um pacote para versão 0.3.1 do billreminder, então esta viariável ficará assim:

pkgver=0.3.1

pkgrel: Aqui fica o release do pacote.

Pkgrel=1

pkgdesc: Aqui é a descrição do software. Exemplo do billreminder:

pkgdesc=“small and quick accounting application designed to allow for easy tracking of bills”

Só duas observações:

• A descrição tem que ser em inglês.
• E você não deve colocar o nome do pacote na descrição também. Seria errado colocar a descrição desta forma:

pkgdesc=“Billreminder is a small and quick accounting application designed to allow for easy tracking of bills”.

Foi decidido que o nome do pacote não entraria na descrição do mesmo para facilitar a visualização no pacman e não causar duplicidade.

arch: aqui é a arquitetura para a qual o software está disponível. Você pode por quantas quiser (desde que seja verdade) e deve por cada uma entre aspas simples. Exemplo:

arch=('i686' 'x86_64')

url: Aqui você coloca o endereço da página do programa que você está empacotando.

url="http://billreminder.sourceforge.net/"

depends: Esta é uma das partes mais importantes do PKGBUILD. É aqui que você vai colocar todas as dependências necessárias para que o programa funcione. Cada dependência deve ficar entre aspas simples e você pode adicionar quantas dependências forem necessárias.

Supondo que você esteja criando um pacote para um programa que dependa do python, firefox, e thunderbird a variável ficaria assim:

depends=('python' 'firefox' 'thunderbird')

E no caso do billreminder:

depends=('python-pysqlite' 'python-notify' 'dbus-python' 'setuptools' 'desktop-file-utils' 'pygobject' 'pygtk' 'pil' 'perlxml')

Para descobrir quais dependências um determinado programa tem você pode visitar o site do mesmo, usar o comando ldd ou o namcap (uma ferramenta própria do Arch para isso).

License: Aqui você coloca licensa do programa. O Arch se preocupe bastante com isso e você deve prestar muita atenção aqui. Exemplos:

license=('MIT')

ou

license=('GPL')

source: aqui fica o caminho para o source do pacote. Exemplo:

source=(http://billreminder.googlecode.com/files/billreminder-0.3.1.tar.bz2)

md5sums: Aqui fica o md5sum do source acima. Geralmente o próprio desenvolvedor disponibiliza esta soma. Se não, você pode usar o comando abaixo, por exemplo:

$ md5sum arquivo.tar.gz

Exemplo:

md5sums=('d2ee06635ae8fc1f5746634c28e48858')

build(): Aqui dentro você vai colocar todos os comandos necessários para se compilar o pacote. Geralmente você coloca os mesmos comandos que usaria para compilar o pacote normalmente.

Se você iriar ./configure; make; make install então é isso que você vai colocar dentro da função build(). Se você usa ./arquivo.sh –install-and-do-it-now, então é isso que você deve colocar.

O billreminder, por exemplo, usa o famoso configure, make, make install. A função no final ficou assim:

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

Se você prestar atenção, existem algumas informações a mais e, por isso, vou destrinchar um pouco este passo.

• A primeira linha serve para que você entre no diretório onde o source (geralmente em .tar.gz ou .tar.bz2) foi descompactado. ${startdir}, ${pkgname} e {pkgver} são variáveis que são trocadas pelo valor do diretório inicial (onde está o PKGBUILD), o nome do pacote e a versão dele, respectivamente.
• A segunda linha é o ./configure normal e o –prefix=/usr serve para indicar o caminho de instalação. O padrão é /usr/local, mas o Arch usa o /usr mesmo.
• Em seguida o make é rodado normalmente (o return serve para indicar se houve, ou não erro durante o make).
• A última linha talvez seja a mais diferente. Ela deveria ser um puro e simples make install, mas tem um DESTDIR de intruso ali. Esse DESTDIR=$startdir/pkg faz com que toda a compilação/instalação/criação do pacote seja feita dentro do sub-diretório pkg. Isso é ótimo pois evita que você danifique seu sistema enquanto está construindo milhões de pacotes. =)

O PKGBUILD final do billreminder ficou:

# Contributor: Hugo Doria <hugodoria at archlinux-br.org>

pkgname=billreminder
pkgver=0.3.1
pkgrel=1
pkgdesc="small and quick accounting application designed to allow for easy tracking of bills"
arch=('i686' 'x86_64')
url="http://billreminder.sourceforge.net/"
depends=('python-pysqlite' 'python-notify' 'dbus-python' 'setuptools' 'desktop-file-utils' 'pygobject' 'pygtk' 'pil' 'perlxml')
license=('MIT')
source=(http://billreminder.googlecode.com/files/${pkgname}-${pkgver}.tar.bz2)
md5sums=('d2ee06635ae8fc1f5746634c28e48858')

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

Agora que você tem um PKGBUILD pronto, basta entrar no diretório onde ele está e digitar:

$ makepkg

Deixe-o trabalhar e se tudo estiver certo depois de algum tempo você verá uma mensagem como essa:

==> Finished making: billreminder (Thu May 8 20:34:57 BRT 2008)

Isso significa que seu pacote foi criado com sucesso e está pronto para uso. É só distribuir pros amigos ou instalá-lo com:

# pacman -U pacote.pkg.tar.gz

Pronto. É isso. Pode parecer assustador de início, mas depois de uns três pacotes você vai pegar o jeito e ver que tudo é muito, muito simples. Depois de alguma pratica você vai estar criando pacotes em 5 minutos. Pode apostar. :P

Existem, claro, pacotes que são mais complexos de serem criados (é o caso do kernel), mas a maioria é bem simples mesmo. Eu ainda farei um artigo mostrando algumas dicas e alguns usos mais complexos do PKGBUILD. Por enquanto você pode ir lendo a manpage do PKGBUILD (man PKGBUILD) e os artigos abaixo:

• http://wiki.archlinux.org/index.php/Arch_Packaging_Standards
• http://wiki.archlinux.org/index.php/The_Arch_package_making_HOW-TO_-_with_guidelines
• http://wiki.archlinux.org/index.php/ABS_PKGBUILD_Explained

Recomendo que você crie alguns pacotes para os programas que mais gosta e depois coloque-os no AUR (uma outra coisa bem legal do Arch). Se os pacotes forem legais e o pessoal gostar, eles vão votar e há uma boa chance de seu pacote entrar nos repositórios oficiais do Arch e, dependendo das suas contribuições, você virar um Trusted User. Eu falarei mais sobre o AUR e os Trusted Users em outro artigo. Por hoje chega. #)