5.2 Invocando guix package

O comando guix package é a ferramenta que permite aos usuários instalar, atualizar e remover pacotes, bem como reverter para configurações anteriores. Essas operações funcionam no perfil de um usuário—um diretório de pacotes instalados. Cada usuário tem um perfil padrão em $HOME/.guix-profile. O comando opera apenas no próprio perfil do usuário e funciona com privilégios de usuário normais (veja Recursos). Sua sintaxe é:

guix package opções

Principalmente, opções especifica as operações a serem executadas durante a transação. Após a conclusão, um novo perfil é criado, mas as gerações anteriores do perfil permanecem disponíveis, caso o usuário queira reverter.

Por exemplo, para remover lua e instalar guile e guile-cairo em uma única transação:

guix package -r lua -i guile guile-cairo

Para sua conveniência, também fornecemos os seguintes aliases:

• guix search é um alias para guix package -s,
• guix install é um alias para guix package -i,
• guix remove é um alias para guix package -r,
• guix upgrade é um alias para guix package -u,
• e guix show é um alias para guix package --show=.

Esses aliases são menos expressivos que guix package e oferecem menos opções, então em alguns casos você provavelmente desejará usar guix package diretamente.

guix package também suporta uma abordagem declarativa em que o usuário especifica o conjunto exato de pacotes que estarão disponíveis e passa a ele via a opção --manifest (veja --manifest).

Para cada usuário, uma ligação simbólica para o perfil padrão do usuário é criado automaticamente em $HOME/.guix-profile. Esta ligação simbólico sempre aponta para a geração atual do perfil padrão do usuário. Assim, os usuários podem adicionar $HOME/.guix-profile/bin à sua variável de ambiente PATH e assim por diante. Se você não estiver usando o sistema Guix, considere adicionar as seguintes linhas ao seu ~/.bash_profile (veja Bash Startup Files em Manual de referência do GNU Bash) para que os shells recém-gerados obtenham todos as definições corretas de variáveis de ambiente:

GUIX_PROFILE="$HOME/.guix-profile" ; \
source "$GUIX_PROFILE/etc/profile"

Em uma configuração multiusuário, os perfis de usuário são armazenados em um local registrado como raiz do coletor de lixo, para o qual $HOME/.guix-profile aponta (veja Invocando guix gc). Esse diretório geralmente é localstatedir/guix/profiles/per-user/usuário, onde localstatedir é o valor passado para configure como -- localstatedir e usuário é o nome do usuário. O diretório per-user é criado quando guix-daemon é iniciado, e o subdiretório usuário é criado por guix package.

As seguintes opções podem ser usadas:

--install=pacote …

-i pacote …

Instale os pacotes especificados.

Cada pacote pode especificar um nome de pacote simples como guile, opcionalmente seguido por uma arroba e número de versão, como guile@3.0.7 ou simplesmente guile@3.0. Neste último caso, a versão mais recente prefixada por 3.0 é selecionada.

Se nenhum número de versão for especificado, a versão mais recente disponível será selecionada. Além disso, tal especificação pacote pode conter dois pontos, seguido pelo nome de uma das saídas do pacote, como em gcc:doc ou binutils@2.22:lib (veja Pacotes com múltiplas saídas).

Pacotes com um nome correspondente (e opcionalmente versão) são procurados entre os módulos de distribuição GNU (veja Módulos de pacote).

Alternativamente, um pacote pode especificar diretamente um nome de arquivo de armazém como /gnu/store/...-guile-3.0.7, conforme produzido por, por exemplo, guix build.

Às vezes, os pacotes têm propagated-inputs: são dependências que são instaladas automaticamente junto com o pacote necessário (veja propagated-inputs em package objetos, para obter informações sobre entradas propagadas em definições de pacote).

Um exemplo é a biblioteca GNU MPC: seus arquivos de cabeçalho C referem-se aos da biblioteca GNU MPFR, que por sua vez se refere aos da biblioteca GMP. Assim, ao instalar o MPC, as bibliotecas MPFR e GMP também são instaladas no perfil; a remoção do MPC também remove o MPFR e o GMP — a menos que eles também tenham sido explicitamente instalados pelo usuário.

Além disso, os pacotes às vezes dependem da definição de variáveis de ambiente para seus caminhos de pesquisa (veja a explicação de --search-paths abaixo). Quaisquer definições de variáveis ambientais ausentes ou possivelmente incorretas são relatadas aqui.

--install-from-expression=exp

-e exp

Instale o pacote avaliado por exp.

exp deve ser uma expressão de Scheme avaliada como um objeto <package>. Esta opção é particularmente útil para desambiguar variantes de um pacote com o mesmo nome, com expressões como (@(gnu packages commencement) guile-final).

Observe que esta opção instala a primeira saída do pacote especificado, o que pode ser insuficiente quando for necessária uma saída específica de um pacote de múltiplas saídas.

--install-from-file=arquivo

-f arquivo

Instale o pacote avaliado pelo código em arquivo.

Por exemplo, arquivo pode conter uma definição como esta (veja Definindo pacotes):

(use-modules (guix)
             (guix build-system gnu)
             (guix licenses))

(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)
  (synopsis "Hello, GNU world: An example GNU package")
  (description "Guess what GNU Hello prints!")
  (home-page "http://www.gnu.org/software/hello/")
  (license gpl3+))

Os desenvolvedores podem achar útil incluir um arquivo guix.scm na raiz da árvore de origem do projeto que pode ser usado para testar instantâneos de desenvolvimento e criar ambientes de desenvolvimento reproduzíveis (veja Invocando guix shell).

O arquivo também pode conter uma representação JSON de uma ou mais definições de pacote. Executar guix package -f em hello.json com o seguinte conteúdo resultaria na instalação do pacote greeter após construir myhello:

[
  {
    "name": "myhello",
    "version": "2.10",
    "source": "mirror://gnu/hello/hello-2.10.tar.gz",
    "build-system": "gnu",
    "arguments": {
      "tests?": false
    },
    "home-page": "https://www.gnu.org/software/hello/",
    "synopsis": "Hello, GNU world: An example GNU package",
    "description": "GNU Hello prints a greeting.",
    "license": "GPL-3.0+",
    "native-inputs": ["gettext"]
  },
  {
    "name": "greeter",
    "version": "1.0",
    "source": "mirror://gnu/hello/hello-2.10.tar.gz",
    "build-system": "gnu",
    "arguments": {
      "test-target": "foo",
      "parallel-build?": false
    },
    "home-page": "https://example.com/",
    "synopsis": "Greeter using GNU Hello",
    "description": "This is a wrapper around GNU Hello.",
    "license": "GPL-3.0+",
    "inputs": ["myhello", "hello"]
  }
]

--remove=pacote …

-r pacote …

Remova os pacotes especificados.

Quanto a --install, cada pacote pode especificar um número de versão e/ou nome de saída além do nome do pacote. Por exemplo, ‘-r glibc:debug’ removeria a saída de glibc.

--upgrade[=regexp …] ¶

-u [regexp …]

Atualize todos os pacotes instalados. Se um ou mais regexps forem especificados, atualize apenas os pacotes instalados cujo nome corresponda a um regexp. Veja também a opção --do-not-upgrade abaixo.

Note que isso atualiza o pacote para a versão mais recente dos pacotes encontrados na distribuição atualmente instalada. Para atualizar sua distribuição, você deve executar regularmente guix pull (veja Invocando guix pull).

Ao atualizar, as transformações de pacote que foram aplicadas originalmente ao criar o perfil são automaticamente reaplicadas (veja Opções de transformação de pacote). Por exemplo, suponha que você instalou o Emacs pela ponta do seu branch de desenvolvimento com:

guix install emacs-next --with-branch=emacs-next=master

Na próxima vez que você executar guix upgrade, o Guix puxará novamente a ponta do branch de desenvolvimento do Emacs e compilará emacs-next a partir desse checkout.

Observe que opções de transformação como --with-branch e --with-source dependem do estado externo; cabe a você garantir que elas funcionem conforme o esperado. Você também pode descartar transformações que se aplicam a um pacote executando:

guix install pacote

--do-not-upgrade[=regexp …]

Quando usado junto com a opção --upgrade, não atualize nenhum pacote cujo nome corresponda a um regexp. Por exemplo, para atualizar todos os pacotes no perfil atual, exceto aqueles que contêm a substring "emacs”:

$ guix package --upgrade . --do-not-upgrade emacs

--manifest=arquivo ¶

-m arquivo

Crie uma nova geração do perfil a partir do objeto manifest retornado pelo código Scheme em arquivo. Esta opção pode ser repetida várias vezes, em cujo caso os manifestos são concatenados.

Isso permite que você declarando o conteúdo do perfil em vez de construí-lo por meio de uma sequência de --install e comandos similares. A vantagem é que arquivo pode ser colocado sob controle de versão, copiado para máquinas diferentes para reproduzir o mesmo perfil, e assim por diante.

arquivo deve retornar um objeto manifest, que é aproximadamente uma lista de pacotes:

(use-package-modules guile emacs)

(packages->manifest
 (list emacs
       guile-2.0
       ;; Usa uma saída de pacote específica.
       (list guile-2.0 "debug")))

Veja Escrevendo manifestos, para obter informações sobre como escrever um manifesto. Veja --export-manifest, para aprender como obter um arquivo de manifesto de um perfil existente.

--roll-back ¶

Reverta para a geração anterior do perfil, ou seja, desfaça a última transação.

Quando combinado com opções como --install, a reversão ocorre antes de qualquer outra ação.

Ao reverter da primeira geração que realmente contém pacotes instalados, o perfil é feito para apontar para a geração zero, que não contém arquivos além de seus próprios metadados.

Após ter revertido, instalar, remover ou atualizar pacotes sobrescreve gerações futuras anteriores. Assim, o histórico das gerações em um perfil é sempre linear.

--switch-generation=padrão ¶

-S padrão

Mude para uma geração específica definida por padrão.

padrão pode ser um número de geração ou um número prefixado com "+” ou "-”. O último significa: mover para frente/para trás por um número especificado de gerações. Por exemplo, se você quiser retornar para a última geração após --roll-back, use --switch-generation=+1.

A diferença entre --roll-back e --switch-generation=-1 é que --switch-generation não fará uma geração zero, então se uma geração especificada não existir, a geração atual não será alterada.

--search-paths[=tipo] ¶

Relata definições de variáveis de ambiente, na sintaxe Bash, que podem ser necessárias para usar o conjunto de pacotes instalados. Essas variáveis de ambiente são usadas para especificar caminhos de busca para arquivos usados por alguns dos pacotes instalados.

Por exemplo, o GCC precisa que as variáveis de ambiente CPATH e LIBRARY_PATH sejam definidas para que ele possa procurar cabeçalhos e bibliotecas no perfil do usuário (veja Environment Variables em Usando o GNU Compiler Collection (GCC)). Se o GCC e, digamos, a biblioteca C estiverem instalados no perfil, então --search-paths sugerirá definir essas variáveis como perfil/include e perfil/lib, respectivamente (veja Caminhos de pesquisa, para obter informações sobre especificações de caminho de pesquisa associadas a pacotes.)

O caso de uso típico é definir essas variáveis de ambiente no shell:

$ eval $(guix package --search-paths)

tipo pode ser um dos seguintes: exact, prefix ou suffix, o que significa que as definições de variáveis de ambiente retornadas serão configurações exatas ou prefixos ou sufixos do valor atual dessas variáveis. Quando omitido, tipo assume como padrão exact.

Esta opção também pode ser usada para calcular os caminhos de busca combinados de vários perfis. Considere este exemplo:

$ guix package -p foo -i guile
$ guix package -p bar -i guile-json
$ guix package -p foo -p bar --search-paths

O último comando acima relata sobre a variável GUILE_LOAD_PATH, embora, considerados individualmente, nem foo nem bar levariam a essa recomendação.

--profile=perfil

-p perfil

Use perfil em vez do perfil padrão do usuário.

perfil deve ser o nome de um arquivo que será criado após a conclusão. Concretamente, perfil será uma mera ligação simbólica ("symlink”) apontanda para o perfil real onde os pacotes estão instalados:

$ guix install hello -p ~/code/my-profile
…
$ ~/code/my-profile/bin/hello
Olá, mundo!

Tudo o que é preciso para se livrar do perfil é remover este link simbólico e seus irmãos que apontam para gerações específicas:

$ rm ~/code/my-profile ~/code/my-profile-*-link

--list-profiles

Liste todos os perfis dos usuários:

$ guix package --list-profiles
/home/charlie/.guix-profile
/home/charlie/code/my-profile
/home/charlie/code/devel-profile
/home/charlie/tmp/test

Ao executar como root, liste todos os perfis de todos os usuários.

--allow-collisions

Permitir pacotes de colisão no novo perfil. Use por sua conta e risco!

Por padrão, guix package relata como um erro collisions no perfil. Colisões acontecem quando duas ou mais versões ou variantes diferentes de um determinado pacote acabam no perfil.

--bootstrap

Use o bootstrap Guile para construir o perfil. Esta opção é útil somente para desenvolvedores de distribuição.

Além dessas ações, guix package suporta as seguintes opções para consultar o estado atual de um perfil ou a disponibilidade de pacotes:

--search=regexp

-s regexp

Liste os pacotes disponíveis cujo nome, sinopse ou descrição correspondem a regexp (sem distinção entre maiúsculas e minúsculas), classificados por relevância. Imprima todos os metadados dos pacotes correspondentes no formato recutils (veja bancos de dados GNU recutils em manual GNU recutils).

Isso permite que campos específicos sejam extraídos usando o comando recsel, por exemplo:

$ guix package -s malloc | recsel -p name,version,relevance
name: jemalloc
version: 4.5.0
relevance: 6

name: glibc
version: 2.25
relevance: 1

name: libgc
version: 7.6.0
relevance: 1

Da mesma forma, para mostrar o nome de todos os pacotes disponíveis sob os termos da GNU LGPL versão 3:

$ guix package -s "" | recsel -p name -e 'license ~ "LGPL 3"'
name: elfutils

name: gmp
…

Também é possível refinar os resultados da pesquisa usando vários sinalizadores -s para guix package, ou vários argumentos para guix search. Por exemplo, o comando a seguir retorna uma lista de jogos de tabuleiro (desta vez usando o alias guix search):

$ guix search '\<board\>' game | recsel -p name
name: gnubg
…

Se omitissemos -s game, também teríamos pacotes de software que lidam com placas de circuito impresso; remover os colchetes angulares em torno de board adicionaria ainda mais pacotes relacionados a teclados.

E agora um exemplo mais elaborado. O comando a seguir procura bibliotecas criptográficas, filtra as bibliotecas Haskell, Perl, Python e Ruby e imprime o nome e a sinopse dos pacotes correspondentes:

$ guix search crypto library | \
    recsel -e '! (name ~ "^(ghc|perl|python|ruby)")' -p name,synopsis

Veja Selection Expressions em manual GNU recutils, para obter mais informações sobre expressões de seleção para recsel -e.

--show=pacote

Exibe detalhes sobre pacote, retirados da lista de pacotes disponíveis, no formato recutils (veja GNU Recutils Databases em GNU Recutils Manual).

$ guix package --show=guile | recsel -p name,version
name: guile
version: 3.0.5

name: guile
version: 3.0.2

name: guile
version: 2.2.7
…

Você também pode especificar o nome completo de um pacote para obter detalhes apenas sobre uma versão específica dele (desta vez usando o alias guix show):

$ guix show guile@3.0.5 | recsel -p name,version
name: guile
version: 3.0.5

--list-installed[=regexp]

-I [regexp]

Lista os pacotes instalados mais recentemente no perfil especificado, com os pacotes instalados mais recentemente mostrados por último. Quando regexp for especificado, liste apenas os pacotes instalados cujo nome corresponda a regexp.

Para cada pacote instalado, imprima os seguintes itens, separados por tabulações: o nome do pacote, sua string de versão e a parte do pacote que está instalada (por exemplo, out para a saída predefinida, include para os seus cabeçalhos, etc.) e o caminho deste pacote no armazém.

--list-available[=regexp]

-A [regexp]

Lista de pacotes atualmente disponíveis na distribuição para este sistema (veja Distribuição GNU). Quando regexp for especificado, liste apenas os pacotes disponíveis cujo nome corresponda a regexp.

Para cada pacote, imprima os seguintes itens separados por tabulações: seu nome, sua string de versão, as partes do pacote (veja Pacotes com múltiplas saídas) e o local de origem de sua definição.

--list-generations[=padrão] ¶

-l [padrão]

Retorne uma lista de gerações junto com suas datas de criação; para cada geração, exiba os pacotes instalados, com os pacotes instalados mais recentemente mostrados por último. Observe que a geração zero nunca é mostrada.

Para cada pacote instalado, mostre os seguintes itens, separados por tabulações: o nome de um pacote, sua string de versão, a parte do pacote que está instalada (veja Pacotes com múltiplas saídas) e a localização deste pacote em o armazém.

Quando padrão é usado, o comando retorna apenas gerações correspondentes. Os padrões válidos incluem:

• Inteiros e números inteiros separados por vírgula. Ambos os padrões denotam números de geração. Por exemplo, --list-generations=1 retorna o primeiro.

  E --list-generations=1,8,2 gera três gerações na ordem especificada. Não são permitidos espaços nem vírgulas finais.

• Intervalos. --list-generations=2..9 mostra o gerações especificadas e tudo mais. Observe que o início de um intervalo deve ser menor que o seu final.

  Também é possível omitir o ponto final. Por exemplo, --list-generations=2.. retorna todas as gerações começando pela segunda.

• Duração. Você também pode visitar os últimos N dias, semanas, ou meses passando um número inteiro junto com a primeira letra da duração. Por exemplo, --list-generations=20d lista gerações com até 20 dias.

--delete-generations[=padrão]

-d [padrão]

Quando padrão for omitido, exclua todas as gerações, exceto a atual.

Este comando aceita os mesmos padrões de --list-Generations. Quando pattern for especificado, exclua as gerações correspondentes. Quando padrão especifica uma duração, as gerações mais antigas que a duração especificada correspondem. Por exemplo, --delete-generations=1m exclui gerações com mais de um mês.

Se a geração atual corresponder, ela será não excluída. Além disso, a geração zero nunca é excluída.

Observe que a exclusão de gerações impede a reversão para elas. Conseqüentemente, este comando deve ser usado com cuidado.

--export-manifest

Escreva na saída padrão um manifesto adequado para --manifest correspondente ao(s) perfil(s) selecionado(s).

Esta opção destina-se a ajudá-lo a migrar do modo operacional "imperativo” — executando guix install, guix upgrade, etc.—para o modo declarativo que --manifest ofertas.

Observe que o manifesto resultante aproxima o que seu perfil realmente contém; por exemplo, dependendo de como seu perfil foi criado, ele pode se referir a pacotes ou versões de pacotes que não são exatamente o que você especificou.

Tenha em mente que um manifesto é puramente simbólico: ele contém apenas nomes de pacotes e possivelmente versões, e seu significado varia com o tempo. Se você quiser “fixar” canais nas revisões que foram usadas para construir o(s) perfil(es), veja --export-channels abaixo.

--export-channels

Escreva na saída padrão a lista de canais usados pelo(s) perfil(s) selecionado(s), em um formato adequado para guix pull --channels ou guix time-machine --channels (veja Canais) . .

Juntamente com --export-manifest, esta opção fornece informações que permitem replicar o perfil atual (veja Replicando Guix).

No entanto, observe que a saída deste comando aproxima o que foi realmente usado para construir este perfil. Em particular, um único perfil pode ter sido construído a partir de diversas revisões diferentes do mesmo canal. Nesse caso, --export-manifest escolhe a última e escreve a lista de outras revisões em um comentário. Se você realmente precisa escolher pacotes de análises de canais diferentes, você pode usar inferiores em seu manifesto para fazer isso (veja Inferiores).

Juntamente com --export-manifest, este é um bom ponto de partida se você estiver disposto a migrar do modelo "imperativo" para o modelo totalmente declarativo que consiste em um arquivo de manifesto junto com um arquivo de canais fixando o canal exato revisão(ões) que você deseja.

Finalmente, como guix package pode realmente iniciar processos de construção, ele suporta todas as opções de construção comuns (veja Opções de compilação comuns). Ele também oferece suporte a opções de transformação de pacotes, como --with-source, e as preserva em atualizações (veja Opções de transformação de pacote).