Difference between revisions of "Makepkg (Português)"

From ArchWiki
Jump to: navigation, search
m (rm extra blank line)
m (Remove translateme tag)
Line 21: Line 21:
 
{{Related2|Arch Build System (Português)|Arch Build System}}
 
{{Related2|Arch Build System (Português)|Arch Build System}}
 
{{Related articles end}}
 
{{Related articles end}}
{{Translateme (Português)|Consideravelmente desatualizado, faltando aqui informações contidas no original}}
 
  
 
Makepkg é usado para compilar e construir um pacote adequado para instalação com o [[pacman (Português)|pacman]], gerenciador de pacotes do Arch Linux. Makepkg é um script automático para a construção do pacote; podendo fazer o download e validar o arquivo, checando as dependências, configurações do tempo de compilação, compilar o código, instalar temporariamente como root, fazer a personalização, gerar informações, e por fim, fazer todo empacotamento.  
 
Makepkg é usado para compilar e construir um pacote adequado para instalação com o [[pacman (Português)|pacman]], gerenciador de pacotes do Arch Linux. Makepkg é um script automático para a construção do pacote; podendo fazer o download e validar o arquivo, checando as dependências, configurações do tempo de compilação, compilar o código, instalar temporariamente como root, fazer a personalização, gerar informações, e por fim, fazer todo empacotamento.  

Revision as of 21:24, 19 December 2017

Makepkg é usado para compilar e construir um pacote adequado para instalação com o pacman, gerenciador de pacotes do Arch Linux. Makepkg é um script automático para a construção do pacote; podendo fazer o download e validar o arquivo, checando as dependências, configurações do tempo de compilação, compilar o código, instalar temporariamente como root, fazer a personalização, gerar informações, e por fim, fazer todo empacotamento.

O Makepkg é fornecido pelos pacotes do pacman package.

Configuração

Veja makepkg.conf(5) para detalhes sobre as opções de configuração do makepkg.

A configuração do sistema está disponível em /etc/makepkg.conf, mas alterações específicas para cada usu[ario podem ser feitas em $XDG_CONFIG_HOME/pacman/makepkg.conf ou ~/.makepkg.conf. É recomendado revisar a configuração antes de compilar pacotes.

Informação do empacotador

Cada pacote é marcado com metadados identificando, entre outros, também o empacotador. Por padrão, os pacotes compilados pelo usuário são marcados com Empacotador desconhecido. Se vários usuários estiverem compilando pacotes em um sistema, ou de outra forma distribuindo seus pacotes para outros usuários, é conveniente fornecer contato real. Isso pode ser feito configurando a variável PACKAGER em makepkg.conf.

Para verificar isso em um pacote instalado:

$ pacman -Qi pacote
[...]
Empacotador       : John Doe <john@doe.com>
[...]

Para automaticamente produzir pacotes assinados, defina também a variável GPGKEY em makepkg.conf.

Saída de pacote

Por padrão, makepkg cria os tarballs de pacote no diretório atual de trabalho e baixa os dados fonte diretamente para o diretório src/. Caminhos personalizados podem ser configurados, por exemplo, para manter todos os pacotes compilados em ~/build/pacotes/ e todos os fontes em ~/build/fontes/.

Configure as seguintes variáveis do makepkg.conf, se necessário:

  • PKGDEST – diretório para armazenar pacotes resultantes
  • SRCDEST – diretório para armazenar dados fonte (links simbólicos serão colocados em src/ se ele aponta para outro lugar)
  • SRCPKGDEST – diretório para armazenar os pacotes fontes (compilado com makepkg -S)

Verificação de assinatura

Nota: A verificação de assinatura implementada no makepkg não usa o chaveiro do pacman; em vez disso, depende do chaveiro do usuário.

Se um arquivo de assinatura na forma de .sig ou .asc é parte do vetor fonte do PKGBUILD, o makepkg tenta automaticamente verificá-la. No caso do chaveiro do usuário não contém a chave pública necessária para verificação de assinatura, o makepkg vai abortar a instalação com uma mensagem de que a chave PGP não pôde ser verificada.

Se uma chave pública necessária para um pacote está faltando, o PKGBUILD muito provavelmente vai conter uma entrada validpgpkeys com os IDs de chaves necessárias. Você pode importá-la manualmente ou você pode localizá-la em um servidor de chaves e importá-la de lá.

Uso

Antes de continuar, verifique se o grupo base-devel está instalado. Os pacotes que pertencem a este grupo não são requeridos na lista de dependência nos arquivos PKGBUILD. A instalação do grupo "base-devel" é como root:

# pacman -S base-devel
Nota: Antes de reclamar sobre a falta (criar) pacotes, lembre-se sobre o grupo “base” que assume a instalação de todo o sistema do Arch Linux. O grupo "base-devel" assume toda a instação durante a construção com o makepkg.

A construção do pacote, necessita criar um primeiro PKGBUILD, ou Script, com descrição na Criando pacotes, ou obter a partir árvore do ABS, Arch User Repository, ou através de outras fontes.

Atenção: Apenas construção/instalação de pacotes com fontes confiáveis.

Com o PKGBUILD, mude para o diretório onde ele se encontra e execute o seguinte comando para construir o pacote descrito pelo PKGBUILD:

$ makepkg

Para que o makepkg limpe arquivos e pastas restantes, tais como arquivos extraídos para o $srcdir, adicione a seguinte opção. É útil para vários construções do mesmo pacote ou ao atualizar a versão do pacote, enquanto usa a mesma pasta de compilação.

$ makepkg -c

Se está faltando dependências necessárias, makepkg emitirá um aviso antes de falhar. Para construir o pacote e instalar as dependências automaticamente, basta usar o comando:

$ makepkg -s

Note que essas dependências devem estar disponíveis nos repositórios configurados, consulte pacman (Português)#Repositórios e espelhos para detalhes. Alternativa para instalação manual de dependência antes da construção (pacman -S --asdeps dep1 dep2).

Uma vez que todas as dependências estão satisfeita e os pacotes construídos, um arquivo de pacote (pkgname-pkgver.pkg.tar.xz) será criado no diretório. Para instalação, como root:

# pacman -U pkgname-pkgver.pkg.tar.xz

Alternativamente, para instalar, usando o -i é um jeito mais fácil de executar pacman -U pkgname-pkgver.pkg.tar.xz, como:

$ makepkg -i

Dicas e Truques

Criando pacotes otimizados

Uma melhoria de desempenho do software empacotado pode ser conseguida ao permitir otimizações do compilador para a máquina host. A desvantagem é que os pacotes compilados para uma arquitetura de processador específica não serão executados corretamente em outras máquinas. Nas máquinas x86_64, raramente existem ganhos de desempenho reais reais significativos que justificariam investir o tempo para reconstruir pacotes oficiais.

No entanto, é muito fácil reduzir o desempenho usando flags de compilação "não padronizadas". Muitas otimizações de compilação só são úteis em certas situações e não devem ser aplicadas indiscriminadamente em cada pacote. A menos que você possa verificar/avaliar que algo é mais rápido, há uma chance muito boa de não ser! O Guia de Otimização de Compilação e artigo wiki CFLAGS Seguras do Gentoo (ambos em inglês) fornecem mais informações detalhadas sobre a otimização do compilador.

As opções passadas para um compilador C/C++ (ex.: gcc ou clang) são controladas pelas variáveis de ambiente CFLAGS, CXXFLAGS eCPPFLAGS. Da mesma forma, o sistema de compilação make usa MAKEFLAGS. Para usar o sistema de compilação do Arch, o makepkg expõe essas variáveis de ambiente como opções de configuração no makepkg.conf. Os valores padrão são configurados para produzir pacotes genéricos que podem ser instalados em uma ampla gama de máquinas.

Nota: Tenha em mente que nem todos os sistemas de compilação usam as variáveis configuradas no makepkg.conf. Por exemplo, cmake ignora a variável de ambiente das opções de pré-processador, CPPFLAGS. Consequentemente, muitos PKGBUILD contêm soluções alternativas com opções específicas para o sistema de compilação usado pelo software empacotado.

O GCC pode detectar e habilitar automaticamente otimizações seguras específicas para cada arquitetura. Para usar esse recurso, primeiro remova os sinalizadores -march e -mtune, então adicione -march = native. Por exemplo,

CFLAGS="-march=native -O2 -pipe -fstack-protector-strong -fno-plt"
CXXFLAGS="${CFLAGS}"

Para ver quais sinalizadores isso habilita em sua máquina, execute:

$ gcc -march=native -v -Q --help=target
Note:
  • Se você especificar um valor diferente de -march=native, então -Q --help=target não vai funcionar como esperado.[1] Você precisa passar por uma fase de compilação para descobrir quais opções estão realmente habilitadas. Veja Encontre opções específicas da CPU (inglês) no wiki do Gentoo para instruções.
  • Para descobrir as opções ótimas para uma arquitetura x86 32 bit, você pode usar o script gcccpuopt.

MAKEFLAGS

A opção MAKEFLAGS pode ser usada para especificar opções adicionais para fazer. Os usuários com sistemas multi-core/multiprocessador podem especificar o número de tarefas a serem executadas simultaneamente. Isso pode ser realizado com o uso de nproc para determinar o número de processadores disponíveis, ex.: MAKEFLAGS="-j$(nproc)". Alguns PKGBUILD substituem especificamente isso com -j1, devido a condições de corrida em certas versões ou simplesmente porque não há suporte em primeiro lugar. Os pacotes que não conseguem ser compilados por causa disso devem ser relatados no rastreador de erros (ou no caso dos pacotes AUR, para o mantenedor do pacote) depois de ter certeza de que o erro está realmente sendo causado pelo seu MAKEFLAGS.

Veja make(1) para uma lista completa de opções disponíveis.

Mostrar pacotes com um empacote específico

Isso mostra todos os pacotes instalados no sistema com o empacotador chamado nome-empacotador:

$ expac "%n %p" | grep "nome-empacotador" | column -t

Isso mostra todos os pacotes instalados no sistema com o empacotador definido na variável PACKAGER do /etc/makepkg. Isso mostra apenas pacotes que estão em um repositório definido em /etc/pacman.conf.

$ . /etc/makepkg.conf; grep -xvFf <(pacman -Qqm) <(expac "%n\t%p" | grep "$PACKAGER$" | cut -f1)

Melhorando os tempos de compilação

tmpfs

Como a compilação requer muitas operações de E/S e lidar com arquivos pequenos, mover o diretório de trabalhos para um tmpfs pode trazer melhorias em tempos de compilação.

A variável BUILDDIR pode ser temporariamente exportada para makepkg para definir o diretório de compilação para um tmpfs existente. Por exemplo:

$ BUILDDIR=/tmp/makepkg makepkg
Atenção: Evite compilar pacotes grandes no tmpfs para evitar ficar sem memória.

Configuração persistente pode ser feita no makepkg.conf descomentando a opção BUILDDIR, que é encontrada no fim da seção BUILD ENVIRONMENT no arquivo padrão /etc/makepkg.conf. Definir esses valores para, por exemplo, BUILDDIR=/tmp/makepkg fará uso do /tmp tmpfs padrão do Arch.

Nota:
  • A pasta tmpfs deve ser montada sem a opção noexec; do contrário, ela vai evitar que scripts de compilação ou utilitários sejam executados.
  • Tenha em mente que qualquer pacote compilado no tmpfs não persistirá após reinicialização. Considere configurar a opção PKGDEST apropriadamente para mover o pacote compilado automaticamente para outro diretório (persistente).

ccache

O uso de ccache pode melhorar os tempos de compilação ao armazenar em cache os resultados de compilações.

Gerar novos checksums

Execute o seguinte comando no mesmo diretório que o arquivo PKGBUILD para gerar novas somas de verificação (checksums):

$ updpkgsums

Usar outros algoritmos de compressão

Para acelerar o empacotamento e a instalação, com a consequência de ter arquivos de pacotes maiores, você pode alterar PKGEXT. Por exemplo, o seguinte torna o arquivo de pacote descompactado para apenas uma invocação:

$ PKGEXT='.pkg.tar' makepkg

Um outro exemplo abaixo mostra o uso do algoritmo lzop, com o pacote lzo necessário:

$ PKGEXT='.pkg.tar.lzo' makepkg

Para fazer uma dessas configurações permanentes, configure PKGEXT em /etc/makepkg.conf.

Usando núcleos na compressão

O xz oferece suporte a multiprocessamento simétrico (SMP) por meio do sinalizador --threads para acelerar a compressão. Por exemplo, para deixar o makepkg usar quantos núcleos de CPU for possível para comprimir os pacotes, edite o vetor COMPRESSXZ em /etc/makepkg.conf:

COMPRESSXZ=(xz -c -z - --threads=0)

O pigz é uma implementação paralela para o gzip que, por padrão, usa todos os núcleos disponíveis na CPU (o sinalizador -p/--processes pode ser usado para empregar menos núcleos):

COMPRESSGZ=(pigz -c -f -n)

Compilar pacotes 32 bits em um sistema 64 bits

Atenção: Erros foram relatados ao usar esse método par compilar o pacote linux. O método de instalação é preferível e verificou-se que funciona para compilar os pacotes do kernel.

Primeiro, habilite o repositório multilib e instale multilib-devel.

Então, crie um arquivo de configuração 32 bits

~/.makepkg.i686.conf
CARCH="i686"
CHOST="i686-unknown-linux-gnu"
CFLAGS="-m32 -march=i686 -mtune=generic -O2 -pipe -fstack-protector-strong"
CXXFLAGS="${CFLAGS}"
LDFLAGS="-m32 -Wl,-O1,--sort-common,--as-needed,-z,relro"

e chame o makepkg assim

$ linux32 makepkg --config ~/.makepkg.i686.conf

Solução de problemas

Makepkg algumas vezes falha ao assinar um pacote sem perguntar pela palavra-chave de assinatura

Com o gnupg 2.1, gpg-agent agora é iniciado automaticamente pelo gpg. O problema surge no estágio do pacote de makepkg --sign. Para permitir os privilégios corretos, fakeroot executa a função package() iniciando o gpg-agent dentro do mesmo ambiente fakeroot. Na saída, o fakeroot limpa os semáforos fazendo com que a "escrita" termine o pipe para fechar para aquela instância do gpg-agent que resultará em um erro de pipe quebrado. Se o mesmo gpg-agent estiver em execução quando makepkg --sign estiver próximo de executado, então o gpg-agent retorna código de saída 2; então a seguinte saída ocorre:

==> Assinando pacote...
==> ATENÇÃO: Falha em assinar arquivo de pacote.

Esse erro está atualmente sendo rastreado: FS#49946. Uma solução temporária de contorno para esse problema é executar killall gpg-agent && makepkg --sign. Esse problema está resolvido no pacman-gitAUR, especificamento no hash de commit c6b04c04653ba9933fe978829148312e412a9ea7

CFLAGS/CXXFLAGS/CPPFLAGS no makepkg.conf não funciona para pacotes baseados no QMAKE

Qmake configura automaticamente a variável CFLAGS e CXXFLAGS de acordo com o que você pensa que deveria ser a configuração correta. Para deixar o qmake usar as variáveis definidas no arquivo de configuração do makepkg, você deve editar o PKGBUILD e passar as variáveis QMAKE_CFLAGS_RELEASE e QMAKE_CXXFLAGS_RELEASE ao qmake. Por exemplo:

PKGBUILD
...

build() {
  cd "$srcdir/$_pkgname-$pkgver-src"
  qmake-qt4 "$srcdir/$_pkgname-$pkgver-src/$_pkgname.pro" \
    PREFIX=/usr \
    QMAKE_CFLAGS_RELEASE="${CFLAGS}"\
    QMAKE_CXXFLAGS_RELEASE="${CXXFLAGS}"

  make
}

...

Alternativamente, para uma configuração para todo sistema, você pode criar seu próprio qmake.conf e configurar a variável de ambiente QMAKESPEC.

Especificando diretório de instalação para pacotes baseados em QMAKE

O makefile gerado pelo qmake usa a variável de ambiente INSTALL_ROOT para especificar onde o programa deve ser instalado. Então, essa função package deve funcionar:

PKGBUILD
...

package() {
	cd "$srcdir/${pkgname%-git}"
	make INSTALL_ROOT="$pkgdir" install
}

...

Note que o qmake também tem que ser configurado adequadamente. Por exemplo, coloque isso em seu arquivo .pro:

SeuProjeto.pro
...

target.path = /usr/local/bin
INSTALLS += target

...

AVISO: O pacote contém referência para $srcdir

De alguma forma, as strings literais $srcdir ou $pkgdir acabaram em um dos arquivos instalados no seu pacote.

Para identificar quais arquivos, execute o seguinte do diretório de compilação makepkg:

$ grep -R "$(pwd)/src" pkg/

Link em discussão.

Veja também