Definindo pacotes (Manual de referência do GNU Guix)

8.2 Definindo pacotes

A interface de alto nível para definições de pacotes é implementada nos módulos (guix packages) e (guix build-system). Como exemplo, a definição de pacote, ou receita, para o pacote GNU Hello se parece com isto:

(define-module (gnu packages hello)
  #:use-module (guix packages)
  #:use-module (guix download)
  #:use-module (guix build-system gnu)
  #:use-module (guix licenses)
  #:use-module (gnu packages gawk))

(define-public hello
  (package
    (name "hello")
    (version "2.10")
    (source (origin
              (method url-fetch)
              (uri (string-append "mirror://gnu/hello/hello-" version
                                  ".tar.gz"))
              (sha256
               (base32
                "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))))
    (build-system gnu-build-system)
    (arguments '(#:configure-flags '("--enable-silent-rules")))
    (inputs (list gawk))
    (synopsis "Hello, GNU world: An example GNU package")
    (description "Guess what GNU Hello prints!")
    (home-page "https://www.gnu.org/software/hello/")
    (license gpl3+)))

Sem ser um especialista em Scheme, o leitor pode ter adivinhado o significado dos vários campos aqui. Esta expressão vincula a variável hello a um objeto <package>, que é essencialmente um registro (veja Scheme records em Manual de Referência do GNU Guile). Este objeto de pacote pode ser inspecionado usando procedimentos encontrados no módulo (guix packages); por exemplo, (package-name hello) retorna—surpresa!—"hello".

Com sorte, você poderá importar parte ou toda a definição do pacote de seu interesse de outro repositório, usando o comando guix import (veja Invoking guix import).

No exemplo acima, hello é definido em um módulo próprio, (gnu packages hello). Tecnicamente, isso não é estritamente necessário, mas é conveniente fazê-lo: todos os pacotes definidos em módulos sob (gnu packages …) são automaticamente conhecidos pelas ferramentas de linha de comando (veja Módulos de pacote).

Há alguns pontos que vale a pena observar na definição do pacote acima:

O campo source do pacote é um objeto <origin> (veja Referência do origin, para a referência completa). Aqui, o método url-fetch de (guix download) é usado, o que significa que a fonte é um arquivo a ser baixado por FTP ou HTTP.
O prefixo mirror://gnu instrui url-fetch a usar um dos espelhos GNU definidos em (guix download).

O campo sha256 especifica o hash SHA256 esperado do arquivo que está sendo baixado. É obrigatório e permite que o Guix verifique a integridade do arquivo. O formulário (base32 …) introduz a representação base32 do hash. Você pode obter essas informações com guix download (veja Invocando guix download) e guix hash (veja Invocando guix hash).

Quando necessário, o formulário origin também pode ter um campo patches listando os remendos a serem aplicados e um campo snippet fornecendo uma expressão Scheme para modificar o código-fonte.
O campo build-system especifica o procedimento para construir o pacote (veja Sistemas de compilação). Aqui, gnu-build-system representa o familiar GNU Build System, onde os pacotes podem ser configurados, construídos e instalados com a sequência de comando usual ./configure && make && make check && make install.
Ao começar a empacotar software não trivial, você pode precisar de ferramentas para manipular essas fases de compilação, manipular arquivos e assim por diante. Veja Construir utilitários, para mais informações sobre isso.
O campo arguments especifica opções para o sistema de compilação (veja Sistemas de compilação). Aqui, ele é interpretado por gnu-build-system como uma solicitação executada configure com o sinalizador --enable-silent-rules.
E quanto a esses caracteres de citação (')? Eles são sintaxe Scheme para introduzir uma lista literal; ' é sinônimo de quote. Às vezes, você também verá ` (uma crase, sinônimo de quasiquote) e , (uma vírgula, sinônimo de unquote). Veja quoting em Manual de referência do GNU Guile, para detalhes. Aqui, o valor do campo arguments é uma lista de argumentos passados para o sistema de construção mais adiante, como com apply (veja apply em Manual de referência do GNU Guile).

A sequência hash-dois-pontos (#:) define um palavra-chave em Scheme (veja Keywords em Manual de referência do GNU Guile) e #:configure-flags é uma palavra-chave usada para passar um argumento de palavra-chave para o sistema de compilação (veja Coding With Keywords em Manual de referência do GNU Guile).
O campo inputs especifica entradas para o processo de construção—i.e., dependências de tempo de construção ou tempo de execução do pacote. Aqui, adicionamos uma entrada, uma referência à variável gawk; gawk é ele próprio vinculado a um objeto <package>.
Note que GCC, Coreutils, Bash e outras ferramentas essenciais não precisam ser especificadas como entradas aqui. Em vez disso, gnu-build-system cuida de garantir que elas estejam presentes (veja Sistemas de compilação).

No entanto, quaisquer outras dependências precisam ser especificadas no campo inputs. Qualquer dependência não especificada aqui simplesmente ficará indisponível para o processo de build, possivelmente levando a uma falha de build.

Veja Referência do package, para uma descrição completa dos campos possíveis.

Indo além: Intimidado pela linguagem Scheme ou curioso sobre ela? O Livro de receitas tem uma seção curta para começar que recapitula algumas das coisas mostradas acima e explica os fundamentos. Veja Um curso intensivo de Scheme em Livro de receitas do GNU Guix, para mais informações.

Uma vez que uma definição de pacote esteja pronta, o pacote pode ser realmente construído usando a ferramenta de linha de comando guix build (veja Invocando guix build), solucionando problemas de quaisquer falhas de construção que você encontrar (veja Depurando falhas de compilação). Você pode facilmente voltar para a definição do pacote usando o comando guix edit (veja Invocando guix edit). Veja Diretrizes de empacotamento, para mais informações sobre como testar definições de pacote, e Invocando guix lint, para informações sobre como verificar uma definição para conformidade de estilo. Por fim, veja Canais, para obter informações sobre como estender a distribuição adicionando suas próprias definições de pacote em um “canal”.

Por fim, a atualização da definição do pacote para uma nova versão upstream pode ser parcialmente automatizada pelo comando guix refresh (veja Invocando guix refresh).

Nos bastidores, uma derivação correspondente ao objeto <package> é primeiro computada pelo procedimento package-derivation. Essa derivação é armazenada em um arquivo .drv em /gnu/store. As ações de construção que ele prescreve podem então ser realizadas usando o procedimento build-derivations (veja O armazém).

Procedimento: package-derivation armazém pacote [sistema]

Retorne o objeto <derivation> de pacote para sistema (veja Derivações).

pacote deve ser um objeto <package> válido e sistema deve ser uma string que indique o tipo de sistema de destino — por exemplo, "x86_64-linux" para um sistema GNU baseado em Linux x86_64. armazém deve ser uma conexão com o daemon, que opera no armazém (veja O armazém).

Da mesma forma, é possível calcular uma derivação que crie um pacote para algum outro sistema:

Procedimento: package-cross-derivation armazém pacote alvo [sistema]

Retorne o objeto <derivation> de pacote criado de sistema para alvo.

alvo deve ser um tripleto GNU válido que indique o hardware e o sistema operacional de destino, como "aarch64-linux-gnu" (veja Specifying Target Triplets em Autoconf).

Depois de ter as definições dos pacotes, você pode definir facilmente variantes desses pacotes. Veja Definindo variantes de pacote, para mais informações sobre isso.