Construir Manifesto (Livro de receitas do GNU Guix)

7.6 Bônus: Construir manifesto

A especificação Cuirass acima é conveniente: ela constrói todos os pacotes em nosso canal, o que inclui algumas variantes (veja Nível 3: Configurando a integração contínua). No entanto, isso pode ser insuficientemente expressivo em alguns casos: pode-se querer trabalhos específicos de compilação cruzada, transformações, imagens Docker, pacotes RPM/Deb ou até mesmo testes de sistema.

Para conseguir isso, você pode escrever um manifest (veja Escrevendo manifestos em Manual de Referência do GNU Guix). O que temos para Guile tem entradas para as variantes de pacote que definimos acima, bem como variantes adicionais e compilações cruzadas:

;; Este é ‘.guix/manifest.scm’.

(use-modules (guix)
             (guix profiles)
             (guile-package)) ;importa nosso próprio módulo de pacote

(define* (package->manifest-entry* package system
                                   #:key target)
  "Retorna uma entrada de manifesto para pacote PACKAGE no sisteme SYSTEM,
opcionalmente compilado cruzado para alvo TARGET."
  (manifest-entry
    (inherit (package->manifest-entry package))
    (name (string-append (package-name package) "." system
                         (if target
                             (string-append "." target)
                             "")))
    (item (with-parameters ((%current-system system)
                            (%current-target-system target))
            package))))

(define native-builds
  (manifest
   (append (map (lambda (system)
                  (package->manifest-entry* guile system))

                '("x86_64-linux" "i686-linux"
                  "aarch64-linux" "armhf-linux"
                  "powerpc64le-linux"))
           (map (lambda (guile)
                  (package->manifest-entry* guile "x86_64-linux"))
                (cons (package
                        (inherit (package-with-c-toolchain
                                  guile
                                  `(("clang-toolchain"
                                     ,(specification->package
                                       "clang-toolchain")))))
                        (name "guile-clang"))
                      (list guile-without-threads
                            guile-without-networking
                            guile-debug
                            guile-strict-typing))))))

(define cross-builds
  (manifest
   (map (lambda (target)
          (package->manifest-entry* guile "x86_64-linux"
                                    #:target target))
        '("i586-pc-gnu"
          "aarch64-linux-gnu"
          "riscv64-linux-gnu"
          "i686-w64-mingw32"
          "x86_64-linux-gnu"))))

(concatenate-manifests (list native-builds cross-builds))

Não entraremos em detalhes deste manifesto; basta dizer que ele fornece flexibilidade adicional. Agora precisamos dizer ao Cuirass para construir este manifesto, que é feito com uma especificação ligeiramente diferente da anterior:

;; Cuirass spec file to build all the packages of the ‘guile’ channel.
(list (specification
        (name "guile")
        (build '(manifest ".guix/manifest.scm"))
        (channels
         (append (list (channel
                         (name 'guile)
                         (url "https://git.savannah.gnu.org/git/guile.git")
                         (branch "main")))
                 %default-channels))))

Alteramos a parte (build …) da especificação para '(manifest ".guix/manifest.scm") para que ele escolhesse nosso manifesto, e pronto!