Criando um PKGBUILD para gerar pacotes para o Arch Linux

Os arquivos PKGBUILD são como os pacotes são construídos e criados para o Arch Linux e seus derivados, como Manjaro.

Você pode até mesmo se deparar com eles um pouco se você já usou o AUR, o repositório de usuário do Arch Linux de PKGBUILDS.

Mas como exatamente você vai de um PKGBUILD para um pacote instalável? O que exatamente está acontecendo entre os dois e como você pode fazê-los para seus próprios pacotes? Você vai aprender nele neste artigo.

O básico do PKGBUILD

Para aqueles que estão familiarizados com Bash ou outros shells, você vai gostar de saber, se não sabe ainda, que um PKGBUILD é praticamente apenas um script de shell com algumas variáveis.

Os arquivos PKGBUILD consistem em variáveis e funções, todas as quais são usadas para definir o próprio pacote e como compilá-lo.

Para criar um pacote de um PKGBUILD, o utilitário de linha de comando do makepkg é usado. Depois de obter um PKGBUILD, você simplesmente executa makepkg dentro do diretório contendo o PKGBUILD, e pronto, você tem um pacote instalável!

Pkgbuild

Neste tutorial, você estará passando pelo pacote que acabei de fazer, que imprime "Olá mundo!" ao executar:

PKGBuild Exemplo

Configurando

Para seguir junto com este tutorial, você precisa criar alguns arquivos.

Primeiro, você precisa fazer um arquivo chamado PKGBUILD. Se já não fosse claro, isso servirá como "receita" para construir seu pacote.

O outro arquivo que você precisa fazer é um arquivo chamado Hello-World.sh. Eu vou explicar seu propósito um pouco mais tarde.

Você pode criar esses dois arquivos com um único comando também.

Comandos para usar no terminal

touch PKGBUILD hello-world.sh

Você pode verificar se os arquivos foram criados com o comando ls:

Pkgbuild Basic Guide

E está pronto!

Configurando seu arquivo PKGBUILD

Em vez de ter você copiar a colar todo o arquivo, eu estarei guiando você em adicionar cada linha, para que você possa entender melhor o propósito de tudo que está acontecendo. Se você não quiser aprender dessa maneira, eu recomendo o artigo da Arch Wiki sobre criação de pacotes para Arch Linux.

Este artigo também não cobre todas as opções que você pode definir em um PKGBUILD, mas sim alguns comumente usados para que você possa começar o mais rápido possível.

Com isso fora do caminho, abra seu editor de texto e vamos em frente!

pkgname

Antes de mais nada, a variável pkgname. É isso que define o nome do seu pacote ao instalar e como o gerenciador de pacotes do Arch Linux pacman registra o pacote.

O formato dessa variável (e alguns outros) assume a forma de variável=valor, com o nome da variável à esquerda, o valor da variável à direita, separado por um sinal de igual.

Para definir o nome do pacote, insira o seguinte para o PKGBUILD:

pkgname="hello-world"

Para definir um nome de pacote diferente, substitua hello-world com o nome do pacote.
Isso não define o comando usado para executar o programa. Isso é tratado um pouco abaixo na seção package().

pkgver

Como é indicado no próprio nome da variável, isso define a versão do seu pacote (i.e. 1.0.0). Isso é útil quando um usuário atualiza seu sistema, conforme configurar uma versão mais alta resultará no usuário perceber que há uma atualização.

Para definir, digite o seguinte para o PKGBUILD (após a linha anterior):

pkgver="1.0.0"

pkgrel

Isso está relacionado à variável pkgver e normalmente não é importante saber. Como a variável pkgver, ela notificará os usuários para upgrades se for movido para um número maior.

Ele serve para quaisquer alterações que exijam que o PKGVER permaneça o mesmo, como quaisquer alterações no próprio PKGBUILD. Isso seria útil se você criou um PKGBUILD para um programa que você usa (e deseja manter a versão do mesmo que o pacote), e você precisa consertar um bug no próprio PKGBUILD.

Para definir a variável, insira o seguinte no PKGBUILD:

pkgver="1"

Essa variável deve sempre começar em 1 e, em seguida, suba uma de cada vez. Quando o pkgver se move para cima, isso pode (e deve) ser redefinido para 1, pois o próprio PKGVER notificará os usuários que os upgrades estão disponíveis.

pkgdesc

Isso definirá a descrição do pacote, que é usada para ajudar a identificar melhor o pacote.

Para defini-lo, basta colocar a descrição dentro de aspas:

pkgdesc="Hello world in your terminal!"

arch

Esta variável define a arquitetura em que pacote é compatível. Tudo bem se você não entender o que é uma arquitetura, como é praticamente inútil na maioria dos casos.

Independentemente disso, o makepkg ainda precisa ser definido para que o pacote seja compatível com nosso sistema.

Essa variável suporta a configuração de vários valores, portanto, o makepkg requer uma sintaxe diferente conforme mostrado abaixo.

Para configurá-lo, digite o seguinte no PKGBUILD:

arch=("x86_64")

Se você fosse para definir vários valores, você separaria cada valor com um espaço e aspas, assim: arch = ("x86_x64" "arm")

depends

Isso lista todos os pacotes que nosso pacote precisa para funcionar. Como arch, ele também pode conter vários valores e, portanto, deve usar a sintaxe de parênteses.

Como nosso pacote não terá nenhuma dependência, não precisamos entrar neste campo no PKGBUILD. Se o nosso pacote tiverem dependências, basta usarmos a mesma sintaxe como arch.

optdepends

Isso lista os pacotes que não são necessários para funcionar, mas que são necessários para a funcionalidades extra.

Isso segue a mesma sintaxe que depends.

conflicts

Isso diz ao Pacman que pacotes fariam com que nosso pacote a agisse ou se comportasse de uma maneira que não queríamos.

Qualquer pacote listado aqui seria desinstalado antes que o nosso esteja instalado.

Isso segue a mesma sintaxe que depends também.

license

Isso define a Licença de Software que seu programa é licenciado. O Arch Wiki tem algumas informações se precisar de ajuda para escolher uma licença. Definir isso para custom funcionará se você não souber o que definir aqui.

Isso segue a mesma sintaxe que arch e depends:

license=("custom")

source

É assim que o makepkg sabe quais arquivos usar para construir nosso pacote. Isso pode conter uma variedade de tipos diferentes de fontes, incluindo arquivos e URLs locais.

Ao adicionar arquivos locais, insira o nome do arquivo em relação ao PKGBUILD, ou seja, considere o seguinte layout de diretório:

PKGBUILD

file.txt

src/file.sh

Se você quisesse incluir file.sh em nosso PKGBUILD, você digitaria src/file.sh como nome.

Ao inserir URLs, você simplesmente entra com um URL completo, isto é, https://mirrors.creativecommons.org/presskit/logos/cc.logo.large.png.

Seu pacote só precisa do arquivo hello-world.sh, e, como está no mesmo diretório que o PKGBUILD, basta digitar seu nome como o valor para source.

Esta variável também usa a mesma sintaxe de arch e depends:

source=("hello-world.sh")

sha512sums

Isso é usado para verificar se os arquivos em source não foram modificados ou baixados incorretamente. As informações sobre como obter os valores para isso podem ser encontradas no artigo sobre PKGBUILD no Arch Wiki.

Se você preferir não definir isso (ou simplesmente não precisar, isto é, para arquivos locais), você pode simplesmente digitar SKIP para cada arquivo na variável source:

sha512sums=("SKIP")

package()

Esta é a última e mais importante parte para realmente gerar o nosso pacote. É importante saber duas variáveis ao trabalhar com isso:

${srcdir}: é aí que makepkg coloca os arquivos na variável source. Este é o diretório onde você pode interagir com os arquivos e fazer qualquer outra modificação necessária para os arquivos.
${pkgdir}: É aqui que colocamos os arquivos que serão instalados em nosso sistema. A estrutura da pasta para ${pkgdir} é configurada como se estivesse em um sistema real (i.e. ${pkgdir}/usr/bin/hello-world criaria o arquivo em /usr/bin/hello-world ao instalar com Pacman.

package() contém uma lista de comandos usados criar um pacote.

Então, se (hipoteticamente) que você precisasse de um arquivo que tivesse "Linux é superior ao Windows" em /usr/share/motto.txt, você executaria algo assim:

package() {
 mkdir -p "${pkgdir}/usr/share"
 echo "Linux é superior ao Windows" | tee "${pkgdir}/usr/share/motto.txt"
}

Algumas notas no comando acima:

${pkgdir} não tem diretórios dentro dele no início. Se você pulou o comando mkdir, tee produziria um erro dizendo que o diretório não existe.
Ao especificar diretórios, sempre prepare-os com o ${pkgdir} ou ${srcdir} variável. Colocar algo como /usr/share/motto.txt sem isso apontaria para o diretório literal /usr/share/motto.txt no seu sistema atualmente em execução.

Para o seu PKGBuild, você vai colocar o arquivo hello-world.sh em /usr/bin/hello-world em seu sistema de destino. Você também estará fazendo o arquivo dizer "Hello to you!" quando rodar.

Para fazer isso, digite o seguinte em seu PKGBUILD:

package() {
 echo \'Hello to you!\' > "${srcdir}/hello-world.sh"
 mkdir -p "${pkgdir}/usr/bin"
 cp "${srcdir}/hello-world.sh" "${pkgdir}/usr/bin/hello-world"
 chmod +x "${pkgdir}/usr/bin/hello-world"
}

E está pronto! Construa e instale o pacote com makepkg -si e execute o hello-world em seu terminal para ver sua saída.