Durante este artigo usarei o
billreminder 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 licença, as instruçõ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=("dependências")
license=("Licença")
source=(url do source)
md5sums=("md5sum do source")
build() {
instruçõ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 variá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 licença 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. =)