Difference between revisions of "Creating packages (Español)"

From ArchWiki
Jump to: navigation, search
(Creating packages (Español): Removida la bandera de mala traducción.)
 
(36 intermediate revisions by 5 users not shown)
Line 1: Line 1:
 
[[Category:About Arch (Español)]]
 
[[Category:About Arch (Español)]]
 
[[Category:Package development (Español)]]
 
[[Category:Package development (Español)]]
[[cs:Creating Packages]]
+
[[cs:Creating packages]]
[[en:Creating Packages]]
+
[[en:Creating packages]]
[[it:Creating Packages]]
+
[[fa:ایجاد بسته‌ها]]
[[ja:Creating Packages]]
+
[[fr:Standard paquetage]]
[[ru:Creating Packages]]
+
[[it:Creating packages]]
[[sk:Creating Packages]]
+
[[ja:パッケージの作成]]
[[tr:Paket_oluşturma]]
+
[[pt:Creating packages]]
[[zh-CN:Creating Packages]]
+
[[ru:Creating packages]]
{{Article summary start}}
+
[[tr:Paket oluşturma]]
{{Article summary text|Una descripcion detallada del proceso de construccion de paquetes. Cubre la creacion de paquetes, pruebas y agregarlo a [[AUR]].}}
+
[[zh-hans:Creating packages]]
{{Article summary heading|Relacionado}}
+
{{Related articles start (Español)}}
{{Article summary wiki|ABS}}
+
{{Related|Arch Build System}}
{{Article summary wiki|Arch User Repository}}
+
{{Related|Arch packaging standards}}
{{Article summary wiki|Arch Packaging Standards}}
+
{{Related|Arch User Repository}}
{{Article summary wiki|makepkg}}
+
{{Related|Creating packages for other distributions}}
{{Article summary wiki|pacman}}
+
{{Related|makepkg}}
{{Article summary wiki|PKGBUILD}}
+
{{Related|pacman}}
{{Article summary wiki|VCS PKGBUILD Guidelines}}
+
{{Related|Patching in ABS}}
{{Article summary end}}
+
{{Related|PKGBUILD}}
 +
{{Related|DeveloperWiki:Building in a Clean Chroot}}
 +
{{Related articles end}}
 +
 
 +
Este artículo tiene como objetivo ayudar a los usuarios a crear sus propios paquetes utilizando el [[Arch Build System|sistema de compilación]] de Arch Linux, asi como subirlos en [[AUR]]. Cubre la creación de un [[PKGBUILD]] - un archivo de descripción de compilación de paquetes originado por {{ic|makepkg}} para crear un paquete binario desde los archivos fuentes. Si ya está posee un archivo {{ic|PKGBUILD}}, vea [[makepkg]]. Para obtener instrucciones sobre las normas existentes y las formas de mejorar la calidad del paquete, consulte [[Arch packaging standards]]
  
Este artículo pretende ayudar al usuario a crear sus propios paquetes usando el sistema de empaquetado “tipo ports” de Arch Linux. Cubre la creación de un archivo [[PKGBUILD]] – un archivo de descripción del paquete empaquetado acompañado del archivo {{Ic|makepkg}} que sirve para crear un archivo binario desde las fuentes. Si ya tiene un [[PKGBUILD]], favor de leer la wiki de [[makepkg]].
 
  
 
== Resumen ==  
 
== Resumen ==  
  
Los paquetes en Arch Linux son ensamblados utilizando la utilidad [[makepkg]] con la información guardada en el archivo [[PKGBUILD]]. Cuando se ejecuta {{Ic|makepkg}} este busca en el archivo {{Ic|PKGBUILD}} en el directorio que se encuentre y sigue las instrucciones ahí guardadas para ya sea compilar o descargar los archivos necesarios para ser empaquetados en un archivo comprimido ({{Ic|nombredelpaquete.pkg.tar.xz}})
+
Los paquetes en Arch Linux se construyen utilizando la utilidad [[makepkg]] y la información almacenada en un archivo [[PKGBUILD]]. Cuando {{Ic|makepkg}} se ejecuta, busca un archivo {{Ic|PKGBUILD}} en el directorio actual y sigue las instrucciones en él para adquirir los archivos requeridos y/o copilarlos para enpaquetarlos en un archivo de paquete({{Ic|nombredelpaquete.pkg.tar.xz}}). El paquete resultante contiene archivos binarios e instrucciones de instalación listas para ser instaladas por [[pacman]].
  
Un paquete en ArchLinux  no es más que un archivo tar comprimido utilizando xz o “tarball” que contiene:
+
Un paquete de Arch no es más que un archivo tar o 'tarball', comprimido usando xz, que contiene los siguientes archivos generados por makepkg:
 
   
 
   
* Los archivos binarios a instalar.
+
* Archivos binarios a instalar.
 +
 
 +
* {{ic|.PKGINFO}}: contiene todos los metadatos requeridos por pacman para tratar con paquetes, dependencias, etc.
 +
 
 +
* {{ic|.MTREE}}: contiene hashes y marcas de tiempo de los archivos que se incluyen en la base de datos local para que pacman pueda verificar la integridad del paquete.
  
* {{ic|.PKGINFO}}: contiene toda la metadata necesaria para pacman para manejar los paquetes, dependencias, etc.
+
* {{ic|.INSTALL}}: un archivo opcional utilizado para ejecutar comandos después de la fase de instalación/actualización/eliminación. (Este archivo sólo está presente si se especifica en el {{ic|.PKGBUILD}}).
  
* {{ic|.INSTALL}}: Un archivo opcional con  comandos a ejecutar después de la instalación/ actualización/desinstalación de un paquete (se encuentra presente solo si se especificó en el {{ic|.PKGBUILD}}).
+
* {{ic|Changelog}}: un archivo opcional guardado por el responsable del paquete documentando los cambios del paquete. (No está presente en todos los paquetes.)
  
* {{ic|Changelog}}: Un archivo opcional mantenido por el administrador del paquete documentando los cambios del paquete (no está en todos los paquetes).
+
=== Metapaquetes y grupos ===
 +
 
 +
Un grupo de paquetes es un conjunto de paquetes relacionados, definido por el empaquetador, que se pueden instalar o desinstalar simultáneamente utilizando el nombre de grupo como un sustituto para cada nombre de paquete individual. Si bien un grupo no es un paquete, puede instalarse de manera similar a un paquete, vea [[Pacman#Installing package groups]] y [[PKGBUILD#groups]].
 +
 
 +
Un metapaquete a menudo (aunque no siempre) titulado con -meta sufijo, proporciona funcionalidad similar a un grupo de paquetes que permite que se instalen o desinstalen simultáneamente varios paquetes relacionados. Los metapaquetes pueden ser instalados como cualquier otro paquete, vea [[Pacman#Installing specific packages]]. La única diferencia entre un paquete meta y un paquete regular es que una metapaquete está vacío y existe puramente para vincular paquetes relacionados a través de dependencias.
 +
 
 +
La ventaja de un metapaquete, en comparación con un grupo, es que cualquier nuevo miembro del paquete se instalará cuando el propio metapaquete sea actualizado con un nuevo conjunto de dependencias. Esto contrasta con un grupo en el que los nuevos miembros del grupo no se instalarán automáticamente. La desventaja de un metapaquete  es que no es tan flexible como un grupo - puede elegir los miembros del grupo que desea instalar pero no puede elegir qué dependencias del metapaquete desea instalar. Asimismo, puede desinstalar los miembros del grupo sin tener que quitar el grupo entero, sin embargo no se pueden quitar dependencias del metapaquete sin tener que desinstalar el metapaquete en sí mismo.
  
 
== Preparación ==  
 
== Preparación ==  
  
=== Pre requisitos de software ===
+
=== Programas necesarios ===
  
En primer lugar garantizar que las herramientas necesarias están instaladas. El grupo de paquetes “base-devel” debe ser suficiente; incluye make y las herramientas necesarias para compilar desde fuentes.
+
Asegúrese primero de que las herramientas necesarias estén instaladas. [[Help:Reading#Installation_of_packages|Instalando]] el grupo de paquetes {{Grp|base-devel}} debe ser suficiente; incluye '''make''' y herramientas adicionales necesarias para compilar desde el codigo fuente.
 
# pacman -S base-devel
 
  
Una de las herramientas clave para armar paquetes es [[makepkg]] (proporcionado por {{Pkg|pacman}}) que cumple con las siguientes características:
+
Una de las herramientas clave para la construcción de paquetes es [[makepkg]] (proporcionado por [[pacman]]), que hace lo siguiente:
  
#Verificar si las dependencias están instaladas.
+
#Comprueba que las dependencias del paquete están instaladas.
#Descargar el(los) archivo(s) fuente del (los) servidor(es)
+
#Descarga el(los) archivo(s) fuente desde el(los) servidor(es) especificado(s).
#Desempaquetar el (los) archivo(s) fuente
+
#Desempaque el(los) archivo(s) fuente(s).
#Compilar el software e instalarlo dentro de un ambiente de fakeroot
+
#Compila el software y lo instala en un entorno fakeroot.
#Limpia de símbolos  los binarios y librerías
+
#Despojar los símbolos innecesarios de los binarios y las bibliotecas.
#Generar el archivo de meta-paquete que se incluye en cada paquete
+
#Genera el archivo del metapaquete que se incluye con cada paquete.
#Comprimir el ambiente de fakeroot en el archivo del paquete
+
#Comprime el entorno fakeroot en un archivo de paquete.
#Crear y guardar el paquete creado en el directorio destino, que es el directorio de trabajo por default
+
#Almacena el archivo de paquete en el directorio de destino configurado, que es el directorio de trabajo actual de forma predeterminada.
  
 
=== Descargar y probar la instalación ===
 
=== Descargar y probar la instalación ===
  
Descargue el archivo comprimido tarball del software que quiere empaquetar, extráigalo, y sigua las instrucciones  del autor para instalar el programa. Tome nota de todos los comandos y pasos a seguir para compilar e instalar este software. Estará repitiendo esos mismos pasos en el archivo ''PKGBUILD''.
+
Descargue el tarball con el codigo fuente del software que desea empaquetar, extráigalo, y siga los pasos del autor para instalar el programa. Anote todos los comandos y/o pasos necesarios para compilarlo e instalarlo. Usted repetirá los mismos comandos en el archivo ''PKGBUILD''.
 +
La mayoría de los autores de software se adhieren al ciclo de compilación de 3 pasos:
  
Muchos autores se apegan al proceso de compilación e instalación tradicional:
+
./configure
 +
make
 +
make install
  
./configure
+
Este es un buen momento para asegurarse de que el programa funciona correctamente.
make
 
make install
 
También es buen momento para verificar que el programa cumpla su tarea correctamente.
 
  
 
== Creando el PKGBUILD ==
 
== Creando el PKGBUILD ==
  
Cuando ejecuta {{Ic|makepkg}} buscara el archivo {{ic|PKGBUILD}} en el directorio actual. Si este archivo es encontrado descargará el código fuente del software, y lo compilará de acuerdo a las instrucciones guardadas en el archivo {{ic|PKGBUILD}}. Estas instrucciones deben ser completamente comprensibles para el [[Wikipedia:Bash|Bash]] Shell. Después de una compilación exitosa los binarios resultantes y la metadata del software (versión del software y dependencias) son empaquetadas en un archivo comprimido paquete.pkg.tar.xz que puede ser instalado con el comando {{Ic|pacman -U [package file]}}
+
Cuando usted ejecuta {{ic|makepkg}}, buscará un archivo {{ic|PKGBUILD}} en el directorio de trabajo actual. Si se encuentra un archivo {{ic|PKGBUILD}} se descargará el código fuente del software y compilará de acuerdo con las instrucciones especificadas en el archivo {{ic|PKGBUILD}}. Las instrucciones deben ser completamente interpretables por el shell [[Wikipedia:Bash_(Unix_shell)|Bash]]. Después de la finalización satisfactoria, los binarios y metadatos resultantes del paquete, i.e. versión del paquete y dependencias, se empaquetan en un archivo de paquete {{ic|pkgname.pkg.tar.xz}} que se puede instalar con {{ic|pacman -U <Archivo paquete>}}.
 +
 
 +
Para comenzar con un nuevo paquete, primero debe crear un directorio de trabajo vacío, entre en ese directorio y cree un archivo {{ic|PKGBUILD}}. Puede copiar el PKGBUILD de ejemplo desde el directorio {{ic|/usr/share/pacman/}} a su directorio de trabajo o copiar un {{ic|PKGBUILD}} de un paquete similar. Este último puede ser útil si sólo necesita cambiar algunas opciones.
  
 
=== Definiendo las variables del {{ic|PKGBUILD}} ===
 
=== Definiendo las variables del {{ic|PKGBUILD}} ===
  
El archivo {{ic|PKGBUILD}} contiene metadata referente al software a instalar. Es un archivo de texto plano. El siguiente es un archivo PKGBUILD de ejemplo que se puede localizar en el directorio {{ic|/usr/share/pacman}} junto con otras plantillas-.
+
Ejemplos de archivos PKGBUILD se encuentran en {{Ic|/usr/share/pacman/}}. Se puede encontrar una explicación de las posibles variables {{ic|PKGBUILD}} en el artículo [[PKGBUILD]].
 +
 
 +
''makepkg'' define dos variables que se debe utilizar como parte del proceso de creación e instalación:
  
{{hc|/usr/share/pacman/PKGBUILD.proto
+
; {{ic|srcdir}}: Esto apunta al directorio donde ''makepkg'' extrae o crea enlaces simbólicos de todos los archivos de la matriz de origen.
|2=<nowiki>
+
; {{ic|pkgdir}}: Esto apunta al directorio en el que ''makepkg'' agrupa el paquete instalado, que se convierte en el directorio raíz del paquete construido.
# This is an example PKGBUILD file. Use this as a start to creating your own,
 
# and remove these comments. For more information, see 'man PKGBUILD'.
 
# NOTE: Please fill out the license field for your package! If it is unknown,
 
# then please put 'unknown'.
 
  
# Maintainer: Your Name <youremail@domain.com>
+
Todos ellos contienen rutas ''absolutas'', lo que significa que no tiene que preocuparse por su directorio de trabajo si utiliza estas variables correctamente.
pkgname=NAME
 
pkgver=VERSION
 
pkgrel=1
 
pkgdesc=""
 
arch=()
 
url=""
 
license=('GPL')
 
groups=()
 
depends=()
 
makedepends=()
 
optdepends=()
 
provides=()
 
conflicts=()
 
replaces=()
 
backup=()
 
options=()
 
install=
 
changelog=
 
source=($pkgname-$pkgver.tar.gz)
 
noextract=()
 
md5sums=() #generate with 'makepkg -g'
 
  
build() {
+
{{Nota|''makepkg'' y, por tanto, las funciones {{ic|build()}} y {{ic|package()}}, están destinados a ser no interactivos. Utilidades interactivas o scripts llamados en esas funciones pueden romper ''makepkg'', especialmente si se invoca con el registro de compilación habilitado ({{ic|-L}}). ({{Bug|13214}}.)}}
  cd "$srcdir/$pkgname-$pkgver"
 
  
  ./configure --prefix=/usr
+
{{Nota|aparte del actual mantenedor de paquetes, es posible que existan mantenedores anteriores listados como colaboradores.}}
  make
 
}
 
  
package() {
+
=== Funciones PKGBUILD ===
  cd "$srcdir/$pkgname-$pkgver"
 
  
  make DESTDIR="$pkgdir/" install
+
Hay cinco funciones, enumeradas aquí en el orden en que se ejecutan si todas existen. Si una no existe, simplemente se omite.
}
 
</nowiki>}}
 
  
Una explicación de posibles variables del {{ic|PKGBUILD}} se encuentra en la wiki de [[PKGBUILD]].
+
{{Nota|: Esto no se aplica a la función {{ic|package()}}, como se requiere en cada PKGBUILD.}}
  
=== La función {{Ic|build()}} ===
+
==== prepare() ====
  
Ahora hay que implementar la función {{Ic|build()}} en el archivo {{ic|PKGBUILD}}. Esta función utiliza sintaxis de comandos comunes de [http://es.wikipedia.org/wiki/Bash Bash] para compilar automáticamente el software y también crear el directorio {{ic|pkg}} para instalar el software. Esto permite a {{ic|makepkg}} empaquetar  los archivos sin envegar entre directorios de su filesystem.
+
Esta función, utiliza comandos para preparar las fuentes para la construcción que se ejecuta, como [[Patching in ABS|parches]]. Esta función se ejecuta justo después de la extracción del paquete, antes de [[#pkgver()|pkgver()]] y la función de build. Si la extracción se omite ({{ic|makepkg -e}}), entonces {{ic|prepare()}} no se ejecuta.
  
El primer paso de la función {{Ic|build()}} es entrar al directorio creado al descomprimir el archivo fuente. En la mayoría de los casos ese comando se vera como este:
+
{{Nota|: (Desde {{ic|man PKGBUILD}}) La función se ejecuta en modo {{ic|bash -e}}, significa que cualquier comando que aparezca con un estado distinto de
 +
cero hará que la función termine.}}
  
cd $srcdir/$pkgname-$pkgver
+
==== pkgver() ====
  
Ahora hay que listar todos los comandos que utilizo al compilar e instalar manualmente el software. Esencialmente la función {{Ic|build()}}  pretende automatizar todo esto y compilar el software en un ambiente de fakeroot. Si el software a instalar utiliza un script configure, es buena practica utilizar  --prefix=/usr al crear paquetes para pacman. Hay mucho software que instala archivos en el directorio /usr/local, esto debería ser hecho solamente si usted esta instalando  manualmente desde código fuente. Así como se especifica en el archivo /usr/share/pacman/PKGBUILD.proto, las siguientes dos líneas pueden ser parecidas a esto:  
+
{{ic|pkgver()}} se ejecuta después de la obtención de las fuentes, la extracción y la ejecución de [[#prepare()|prepare()]]. Así que uested puede actualizar la variable pkgver durante la etapa makepkg.
 +
 
 +
Esto es particularmente útil si está haciendo [[VCS PKGBUILD Guidelines|making git/svn/hg/etc. paquetes]], donde el proceso de construcción puede seguir siendo el mismo, pero el codigo fuente podría ser actualizado todos los días, incluso cada hora. La vieja manera de hacer esto era poner la fecha en el campo del pkgver, donde si el Software no se actualizaba, makepkg aún así lo reconstruiría pensando que la versión había cambiado. Algunos comandos útiles para esto son {{ic|git describe}}, {{ic|hg identify -ni}}, etc. Por favor pruebe estos antes de enviar un PKGBUILD, ya que un error en la función {{ic|pkgver()}} puede detener la compilación.
 +
 
 +
Nota: pkgver no puede contener espacios ni guiones ({{ic|-}}). El uso de sed para corregir esto es común.
 +
 
 +
==== build() ====
 +
 
 +
Ahora necesita implementar la función {{ic|build()}} en el archivo {{ic|PKGBUILD}}. Esta función utiliza comandos de shell comunes en la sintaxis de [[Wikipedia:Bash_(Unix_shell)|Bash]] para compilar automáticamente el software y crear un directorio {{ic|pkg}} para instalar el software. Esto permite a makepkg empaquetar archivos sin tener sin tener que filtrar el sistema de archivos.
 +
 
 +
El primer paso en la función {{ic|build()}} es cambiar al directorio creado descomprimiendo el tarball de origen. ''makepkg'' cambiará el directorio actual a {{ic|$srcdir}} antes de ejecutar la función {{ic|build()}}. Por lo tanto, en la mayoría de los casos, como se sugiere en {{ic|/usr/share/pacman/PKGBUILD.proto}}, el primer comando se verá así:
 +
 
 +
  cd "$pkgname-$pkgver"
 +
 
 +
Ahora, necesita listar los mismos comandos que utilizó cuando compiló manualmente el software. La función {{ic|build()}} en esencia automatiza todo lo que hizo a mano y compila el software en el entorno de compilación fakeroot. Si el software que está empaquetando utiliza un script, es una buena práctica usar {{ic|1=--prefix=/usr}} al crear paquetes para pacman. Una gran cantidad de software instala archivos relativos al directorio {{ic|/usr/local}}, que sólo se debe hacer si se está generando manualmente desde el codigo fuente. Todos los paquetes Arch Linux deben usar el directorio {{ic|/usr}}. Como se ve en el archivo {{ic|/usr/share/pacman/PKGBUILD.proto}}, las siguientes dos líneas suelen tener este aspecto:  
  
 
  ./configure --prefix=/usr
 
  ./configure --prefix=/usr
 
  make
 
  make
  
El paso final en la función {{Ic|build()}}  es poner los archivos compilados donde makepkg los pueda llamar para crear un paquete. Esto por default es el directorio pkg – un simple entorno fakeroot. El directorio pkg replica la jerarquía del sistema de archivos raíz  de las rutas de instalación del software, si necesita dejar archivos dentro de su sistema de archivos raíz, deberá instalarlos en el directorio {{ic|pkg}} dentro de la misma estructura de directorios. Por ejemplo, si quiere instalar un programa dentro del directorio {{ic|/usr/bin}}, debe ser ubicado dentro de {{ic|$pkgdir/usr/bin}}. Hay muy pocos procedimientos de instalación que requieran que el usuario copie manualmente estos archivos, pero vale la pena aclararlo. En vez de eso, en la mayoría del software, llamar a make install automatizara esa tarea. La última línea deberá parecer a la siguiente, para instalar el software correctamente en el directorio {{ic|pkg}}:
+
{{Nota|: Si su software no necesita construir nada, NO utilice la función {{ic|build()}}. La función {{ic|build()}} no es necesaria, pero la La función {{ic|package()}} si lo es.}}
  
make DESTDIR=$pkgdir install
+
==== check() ====
  
{{Nota|se puede dar el caso que el argumento {{Ic|DESTDIR}} no sea utilizado en el {{ic|Makefile}}; en vez de esto habrá que utilizar el argumento {{Ic|prefix}}, si el paquete es compilado con ''automake''/''autoconf'', utiliza {{Ic|DESTDIR}}, esto esta documentado en los manuales. Si {{Ic|DESTDIR}} no funciona trate de compilarlo con {{ic|1=make prefix="$pkgdir/usr/" install}}. Si es no funciona, tendrá que investigar aun más en los comandos de instalación que son ejecutados por ''make'' e ''install''.}}
+
Momento para llamar a {{ic|make check}} para hacer chequeos y rutinas similares de prueba. Es muy recomendable tener {{Ic|check()}}, ya que ayuda a asegurar que el software se ha construido correctamente y funciona bien con sus dependencias.  
  
En algunos casos raros, el software espera ser ejecutado dentro de algún directorio en específico. En estos casos se recomienda copiar estos a {{ic|$pkgdir/opt}}. Muy seguido, el proceso de instalación creara subdirectorios dentro del directorio {{ic|pkg}}. Si no es así, ''makepkg'' generara muchos errores y usted se vera obligado a crear estos directorios manualmente agregando los comandos {{Ic|mkdir -p}} dentro de la función {{Ic|build()}} antes de que inicie el proceso de instalación.
+
Usuarios que no lo necesitan (Y ocasionalmente los mantenedores que no pueden arreglar un paquete para que esto pase) puede inhabilitarlo usando {{ic|1=BUILDENV+=('!check')}} en el PKGBUILD/makepkg.conf o llamar {{ic|makepkg}} con flag {{ic|--nocheck}}.
  
También ''makepkg'' define tres variables que deberá tomar en cuenta como parte del proceso de compilación e instalación:
+
==== package() ====
  
; {{Ic|startdir}}:Contiene la ruta absoluta al directorio donde el {{ic|PKGBUILD}} esta localizado. Esta variable se utiliza en combinación con los postfijos {{ic|/src}} o {{ic|/pkg}}, sin embargo el uso de {{Ic|srcdir}} y {{Ic|pkgdir}} son los métodos modernos utilizados.{{Ic|$startdir/src}} no es garantía de ser igual a {{Ic|$srcdir}} y muy seguramente para {{Ic|$pkgdir}}. El uso de esta variable esta depreciado se recomienda ampliamente no utilizarlo.
+
El paso final es poner los archivos compilados en un directorio donde ''makepkg'' puede recuperarlos para crear un paquete. Por defecto es el directorio {{ic|pkg}} - un simple entorno fakeroot. El directorio {{ic|pkg}} replica la jerarquía del sistema de archivos raíz de las rutas de instalación del software. Si tiene que colocar manualmente los directorios raíz de su sistema de archivos, debe instalarlos en el directorio {{ic|pkg}} bajo la misma estructura de directorios. Por ejemplo, si desea instalar un archivo en {{ic|/usr/bin}}, debe colocarse en {{ic|$pkgdir/usr/bin}}. Muy pocos procedimientos de instalación requieren que el usuario copie docenas de archivos manualmente. En su lugar, la mayoría de software {{ic|make install}} lo hará. La última línea debe ser similar a la siguiente para poder instalar correctamente el software en el directorio {{ic|pkg}}:
; {{Ic|srcdir}}:Apunta al directorio donde ''makepkg´ extrae o copia todos los archivos fuente
 
; {{Ic|pkgdir}}: Apunta al directorio donde ''makepkg'' empaqueta el software instalado, que se convierte el directorio raíz del paquete construido.
 
  
{{Nota| ''makepkg'', y por ende la función {{Ic|build()}}  son pensadas para no ser interactivas. Las rutinas que requieran interacción del usuario que sean llamadas dentro de la función  {{Ic|build()}} podrían destruir el ''makepkg'', particularmente si es invocado con el registro de compilación habilitado (ver [http://bugs.archlinux.org/task/13214 Arch Linux Bug #13214])}}
+
  make DESTDIR="$pkgdir/" install
  
=== Guías adicionales. ===
+
{{Nota|: A veces está el caso en que {{ic|DESTDIR}} no se utiliza en el {{ic|Makefile}}; puede que tenga que usar {{ic|prefix}} en su lugar. Si el paquete está construido con ''autoconf'' / ''automake'', use {{ic|DESTDIR}}; esto es lo que se  documenta  en los [https://www.gnu.org/software/automake/manual/automake.html#Install manuales]. Si {{ic|DESTDIR}} no funciona, trate de construir con {{ic|1=make prefix="$pkgdir/usr/" install}}. Si eso no funciona, tendrá que buscar más en los comandos de instalación que son ejecutados por "{{ic|make <...> install}}".}}
  
Por favor lea los estándares de empaquetado de Arch para mejores prácticas y consideraciones adicionales.
+
En algunos casos raros, el software espera ejecutarse desde un único directorio. En tales casos, es aconsejable simplemente
 +
copiarlos {{ic|$pkgdir/opt}}.
  
== Probando el PKGBUILD y el paquete ==
+
A menudo, el proceso de instalación del software creará subdirectorios debajo del directorio {{ic|pkg}}. Si no lo hace, ''makepkg'' generará muchos errores y necesitará crear manualmente subdirectorios añadiendo los comandos apropiados de {{ic|mkdir -p}} en la función {{ic|build()}} antes de ejecutar el procedimiento de instalación.
  
Mientras escribe la función {{Ic|build()}} deberá probar los cambios con frecuencia para asegurarse de que no haya fallas. Puede hacerlo utilizando el comando {{Ic|makepkg}} en el directorio donde se encuentre el archivo {{ic|PKGBUILD}}. Con un {{ic|PKGBUILD}} correctamente compuesto {{Ic|makepkg}} será capaz de crear un paquete, con un {{ic|PKGBUILD}} incorrecto o roto {{ic|PKGBUILD}} mostrara un error.
+
En los paquetes antiguos, no había ninguna función {{ic|package()}}. Por lo tanto, los archivos se colocaban en el directorio ''pkg'' al final de la función {{ic|build()}}. Si {{ic|package()}} no está presente, {{ic|build()}} se ejecuta a través de ''fakeroot''. En paquetes nuevos, {{ic|package()}} es necesario y se ejecuta a través de ''fakeroot'' en su lugar, y {{ic|build()}} se ejecuta sin privilegios especiales.
  
Si {{Ic|makepkg}} finaliza correctamente, creara un archivo llamado {{ic|pkgname-pkgver.pkg.tar.xz}} en su directorio de trabajo. Este paquete puede ser instalado con el comando {{Ic|pacman -U}}. Sin embargo solo por que un paquete haya sido correctamente construido esto no implica que sea completamente funcional, es concebible que contenga solo el directorio y ningún archivo si por ejemplo, un prefijo fue especificado incorrectamente. Puede utilizar las herramientas de consulta de pacman para ver la lista de archivos contenidos en el paquete y las dependencias que puede requerir con {{Ic|pacman -Qlp [nombre del paquete]}} y {{Ic|pacman -Qip [nombre del paquete]}}
+
{{ic|makepkg --repackage}} ejecuta sólo la función {{ic|package()}}, por lo que crea un archivo {{ic|*.pkg.*}} archivo sin compilar el paquete. Esto puede ahorrar tiempo, e.g. si acaba de cambiar las variables {{ic|depends}} del paquete.
  
Si el paquete se ve sano, entonces ha terminado!, sin embargo si va a publicar el {{ic|PKGBUILD}}, es imperativo que revise y vuelva a revisar el contenido de la variable depends.
+
{{Nota| La función {{ic|package()}} es la única función requerida en un PKGBUILD. Si sólo debe copiar archivos en sus respectivos
 +
directorios para instalar un programa, no lo ponga en la función {{ic|build()}}, póngalo en la función {{ic|package()}}.}}
  
También asegúrese de que el software ejecute sin ningún fallo. Es molesto que al publicar un paquete que contenga todos los archivos necesarios deje de funcionar por alguna opción en alguna configuración obsoleta que ya no funciona en relación con el resto del sistema. Si solo va a compilar paquetes solo para su sistema, entonces no tendrá que preocuparse mucho de este procedimiento de seguranza de calidad, al final de cuentas solo usted sufrirá las consecuencias de una mala configuración.
+
{{Nota| Crear enlaces simbólicos es un proceso un poco incómodo en la función {{ic|package()}}. Utilizando el enfoque ingenuo {{ic|ln -s "${pkgdir}/from/foo" "${pkgdir}/to/goo"}} resultará en un enlace simbólico roto al directorio de compilación. La manera correcta de crear una link es crearlo apuntando a una fuente inicialmente rota, {{ic|ln -s "/from/foo" "${pkgdir}/to/goo"}}. Una vez instalado el paquete, el enlace apuntará al lugar correcto.}}
  
=== {{Ic|Ldd}} y {{Ic|namcap}} ===
+
== Prueba del PKGBUILD y del paquete ==
  
Las dependencias incumplidas son el error más común del empaquetado. Hay dos excelentes herramientas para verificar el cumplimiento de las dependencias. La primera es ''ldd'' que mostrara las dependencias compartidas de librerías de ejecutables:
+
Al escribir la función {{ic|build()}}, querrá probar sus cambios frecuentemente para asegurarse de que no haya errores. Puedes hacerlo usando el comando {{ic|makepkg}} en el directorio que contiene el archivo {{ic|PKGBUILD}}. Con un {{ic|PKGBUILD}} correctamente formateado, makepkg creará un paquete; con un {{ic|PKGBUILD}} roto o inacabado, provocará un error.
  
$ ldd gcc
+
Si makepkg finaliza correctamente, colocará un archivo denominado {{ic|pkgname-pkgver.pkg.tar.xz}} en su directorio de trabajo.  
linux-gate.so.1 =>  (0xb7f33000)
+
Este paquete puede ser instalado con el comando {{ic|pacman -U}}. Sin embargo, sólo porque un archivo de paquete fue construido no implica que es totalmente funcional. Eso 11 Posiblemente sólo contenga el directorio y ningún archivo en si, por ejemplo,
libc.so.6 => /lib/libc.so.6 (0xb7de0000)
+
un prefijo se especificó incorrectamente. Puedes usar las funciones de consulta de pacman para mostrar una lista de archivos contenidos en el paquete y las dependencias que requiere con p{{ic|pacman -Qlp [package file]}} y {{ic|pacman -Qip [package file]}}, respectivamente.
/lib/ld-linux.so.2 (0xb7f34000)
 
  
La otra herramienta es ''namcap'', que solo verifica por las dependencias y no por la sanidad del todo el paquete en si. Por favor lea el artículo sobre namcap para mayores referencias.
+
¡Si el paquete parece sano, entonces usted a terminado! Sin embargo, si planea liberar el archivo {{ic|PKGBUILD}}, es imperativo que compruebe y compruebe de nuevo el contenido de la matriz de {{ic|dependencias}}.
 +
 
 +
También asegúrese de que los binarios del paquete realmente ''funcionan'' perfectamente! Es molesto liberar un paquete que contiene todos los archivos necesarios, pero se bloquea Debido a alguna opción de configuración poco clara que no funciona bien con el resto del sistema. Si solo va a compilar paquetes para su propio sistema, entonces usted no necesita preocuparse demasiado sobre este paso de aseguramiento de calidad, después de todo es la única persona que sufre de errores.
 +
 
 +
=== Comprobación de la sanidad del paquete ===
 +
 
 +
Después de comprobar la funcionalidad del paquete, compruebe si hay errores con namcap:
 +
 
 +
$ namcap PKGBUILD
 +
$ namcap ''<package file name>''.pkg.tar.xz
 +
 
 +
 
 +
Namcap deberá:
 +
 
 +
# Comprobar el contenido de PKGBUILD para buscar errores comunes y la jerarquía de archivos de paquetes para archivos innecesarios/extraviados.
 +
# Escanea todos los archivos ELF en el paquete usando ldd, informando automáticamente qué paquetes con las bibliotecas compartidas requeridas faltan de las dependencias y que se pueden omitir como dependencias transitivas.
 +
# Búsqueda heurística de dependencias perdidas y redundantes.
 +
 
 +
y mucho más. Adquiera el hábito de revisar sus paquetes con namcap para evitar tener que arreglar los errores más simples después de
 +
la subida del paquete.
  
 
== Subir paquetes a AUR ==
 
== Subir paquetes a AUR ==
  
Por favor lea  [[AUR User Guidelines#Submitting Packages to UNSUPPORTED]] de la guía de AUR. Para una descripción detallada del proceso.
+
Por favor lea  [[Arch User Repository#Submitting packages]] de la guía de AUR. Para una descripción detallada del proceso.
  
 
== Resumen ==
 
== Resumen ==
Line 190: Line 207:
 
=== Advertencias ===
 
=== Advertencias ===
  
Antes de automatizar el proceso de construcción de paquetes, deberá haberlo hecho por lo menos una vez de manera manual para saber de antemano exactamente lo que esta haciendo. Desafortunadamente muchos autores de paquetes se apegan al proceso de 3 pasos de {{Ic|./configure, make make install}}, este no es siempre el caso y puede quedar un paquete en muy malas condiciones si no aplica el cuidado necesario para que todo funcione bien.
+
* Antes de automatizar el proceso de construcción de paquetes, deberá haberlo hecho por lo menos una vez de manera manual para saber de antemano exactamente lo que esta haciendo. Desafortunadamente muchos autores de paquetes se apegan al proceso de 3 pasos de {{Ic|./configure, make make install}}, este no es siempre el caso y puede quedar un paquete en muy malas condiciones si no aplica el cuidado necesario para que todo funcione bien.
En algunos pocos casos, los paquetes no son disponibles en código fuente y habrá que recurrir a scripts como {{Ic|sh instalador.run}} para poder ejecutarlo, habrá de hacer una extensa investigación acerca de otros {{ic|PKGBUILD}}, leer los {{ic|README}}, buscar información del creador del programa, o buscar {{ic|EBUILDS}} de Gentoo para poder ejecutar la instalación, recuerde que makepkg debe ser completamente automático y sin intervención del usuario.
+
* En algunos pocos casos, los paquetes no son disponibles en código fuente y habrá que recurrir a scripts como {{Ic|sh instalador.run}} para poder ejecutarlo, habrá de hacer una extensa investigación acerca de otros {{ic|PKGBUILD}}, leer los {{ic|README}}, buscar información del creador del programa, o buscar {{ic|EBUILDS}} de Gentoo para poder ejecutar la instalación, recuerde que makepkg debe ser completamente automático y sin intervención del usuario.
 +
 
 +
== Directrices más detalladas ==
 +
{{Package guidelines}}
 +
 
 +
== Ver también ==
 +
* [https://bbs.archlinux.org/viewtopic.php?id=91408 How to correctly create a patch file].
 +
* [https://archwomen.org/media/project_classroom/classlogs/ Arch Linux Classroom IRC Logs of classes about creating PKGBUILDs].
 +
* [http://www.linuxfromscratch.org/hints/downloads/files/fakeroot.txt Fakeroot approach for package installation]

Latest revision as of 00:49, 8 August 2017

Este artículo tiene como objetivo ayudar a los usuarios a crear sus propios paquetes utilizando el sistema de compilación de Arch Linux, asi como subirlos en AUR. Cubre la creación de un PKGBUILD - un archivo de descripción de compilación de paquetes originado por makepkg para crear un paquete binario desde los archivos fuentes. Si ya está posee un archivo PKGBUILD, vea makepkg. Para obtener instrucciones sobre las normas existentes y las formas de mejorar la calidad del paquete, consulte Arch packaging standards


Resumen

Los paquetes en Arch Linux se construyen utilizando la utilidad makepkg y la información almacenada en un archivo PKGBUILD. Cuando makepkg se ejecuta, busca un archivo PKGBUILD en el directorio actual y sigue las instrucciones en él para adquirir los archivos requeridos y/o copilarlos para enpaquetarlos en un archivo de paquete(nombredelpaquete.pkg.tar.xz). El paquete resultante contiene archivos binarios e instrucciones de instalación listas para ser instaladas por pacman.

Un paquete de Arch no es más que un archivo tar o 'tarball', comprimido usando xz, que contiene los siguientes archivos generados por makepkg:

  • Archivos binarios a instalar.
  • .PKGINFO: contiene todos los metadatos requeridos por pacman para tratar con paquetes, dependencias, etc.
  • .MTREE: contiene hashes y marcas de tiempo de los archivos que se incluyen en la base de datos local para que pacman pueda verificar la integridad del paquete.
  • .INSTALL: un archivo opcional utilizado para ejecutar comandos después de la fase de instalación/actualización/eliminación. (Este archivo sólo está presente si se especifica en el .PKGBUILD).
  • Changelog: un archivo opcional guardado por el responsable del paquete documentando los cambios del paquete. (No está presente en todos los paquetes.)

Metapaquetes y grupos

Un grupo de paquetes es un conjunto de paquetes relacionados, definido por el empaquetador, que se pueden instalar o desinstalar simultáneamente utilizando el nombre de grupo como un sustituto para cada nombre de paquete individual. Si bien un grupo no es un paquete, puede instalarse de manera similar a un paquete, vea Pacman#Installing package groups y PKGBUILD#groups.

Un metapaquete a menudo (aunque no siempre) titulado con -meta sufijo, proporciona funcionalidad similar a un grupo de paquetes que permite que se instalen o desinstalen simultáneamente varios paquetes relacionados. Los metapaquetes pueden ser instalados como cualquier otro paquete, vea Pacman#Installing specific packages. La única diferencia entre un paquete meta y un paquete regular es que una metapaquete está vacío y existe puramente para vincular paquetes relacionados a través de dependencias.

La ventaja de un metapaquete, en comparación con un grupo, es que cualquier nuevo miembro del paquete se instalará cuando el propio metapaquete sea actualizado con un nuevo conjunto de dependencias. Esto contrasta con un grupo en el que los nuevos miembros del grupo no se instalarán automáticamente. La desventaja de un metapaquete es que no es tan flexible como un grupo - puede elegir los miembros del grupo que desea instalar pero no puede elegir qué dependencias del metapaquete desea instalar. Asimismo, puede desinstalar los miembros del grupo sin tener que quitar el grupo entero, sin embargo no se pueden quitar dependencias del metapaquete sin tener que desinstalar el metapaquete en sí mismo.

Preparación

Programas necesarios

Asegúrese primero de que las herramientas necesarias estén instaladas. Instalando el grupo de paquetes base-devel debe ser suficiente; incluye make y herramientas adicionales necesarias para compilar desde el codigo fuente.

Una de las herramientas clave para la construcción de paquetes es makepkg (proporcionado por pacman), que hace lo siguiente:

  1. Comprueba que las dependencias del paquete están instaladas.
  2. Descarga el(los) archivo(s) fuente desde el(los) servidor(es) especificado(s).
  3. Desempaque el(los) archivo(s) fuente(s).
  4. Compila el software y lo instala en un entorno fakeroot.
  5. Despojar los símbolos innecesarios de los binarios y las bibliotecas.
  6. Genera el archivo del metapaquete que se incluye con cada paquete.
  7. Comprime el entorno fakeroot en un archivo de paquete.
  8. Almacena el archivo de paquete en el directorio de destino configurado, que es el directorio de trabajo actual de forma predeterminada.

Descargar y probar la instalación

Descargue el tarball con el codigo fuente del software que desea empaquetar, extráigalo, y siga los pasos del autor para instalar el programa. Anote todos los comandos y/o pasos necesarios para compilarlo e instalarlo. Usted repetirá los mismos comandos en el archivo PKGBUILD. La mayoría de los autores de software se adhieren al ciclo de compilación de 3 pasos:

./configure
make
make install

Este es un buen momento para asegurarse de que el programa funciona correctamente.

Creando el PKGBUILD

Cuando usted ejecuta makepkg, buscará un archivo PKGBUILD en el directorio de trabajo actual. Si se encuentra un archivo PKGBUILD se descargará el código fuente del software y compilará de acuerdo con las instrucciones especificadas en el archivo PKGBUILD. Las instrucciones deben ser completamente interpretables por el shell Bash. Después de la finalización satisfactoria, los binarios y metadatos resultantes del paquete, i.e. versión del paquete y dependencias, se empaquetan en un archivo de paquete pkgname.pkg.tar.xz que se puede instalar con pacman -U <Archivo paquete>.

Para comenzar con un nuevo paquete, primero debe crear un directorio de trabajo vacío, entre en ese directorio y cree un archivo PKGBUILD. Puede copiar el PKGBUILD de ejemplo desde el directorio /usr/share/pacman/ a su directorio de trabajo o copiar un PKGBUILD de un paquete similar. Este último puede ser útil si sólo necesita cambiar algunas opciones.

Definiendo las variables del PKGBUILD

Ejemplos de archivos PKGBUILD se encuentran en /usr/share/pacman/. Se puede encontrar una explicación de las posibles variables PKGBUILD en el artículo PKGBUILD.

makepkg define dos variables que se debe utilizar como parte del proceso de creación e instalación:

srcdir
Esto apunta al directorio donde makepkg extrae o crea enlaces simbólicos de todos los archivos de la matriz de origen.
pkgdir
Esto apunta al directorio en el que makepkg agrupa el paquete instalado, que se convierte en el directorio raíz del paquete construido.

Todos ellos contienen rutas absolutas, lo que significa que no tiene que preocuparse por su directorio de trabajo si utiliza estas variables correctamente.

Nota: makepkg y, por tanto, las funciones build() y package(), están destinados a ser no interactivos. Utilidades interactivas o scripts llamados en esas funciones pueden romper makepkg, especialmente si se invoca con el registro de compilación habilitado (-L). (FS#13214.)
Nota: aparte del actual mantenedor de paquetes, es posible que existan mantenedores anteriores listados como colaboradores.

Funciones PKGBUILD

Hay cinco funciones, enumeradas aquí en el orden en que se ejecutan si todas existen. Si una no existe, simplemente se omite.

Nota: : Esto no se aplica a la función package(), como se requiere en cada PKGBUILD.

prepare()

Esta función, utiliza comandos para preparar las fuentes para la construcción que se ejecuta, como parches. Esta función se ejecuta justo después de la extracción del paquete, antes de pkgver() y la función de build. Si la extracción se omite (makepkg -e), entonces prepare() no se ejecuta.

Nota: : (Desde man PKGBUILD) La función se ejecuta en modo bash -e, significa que cualquier comando que aparezca con un estado distinto de cero hará que la función termine.

pkgver()

pkgver() se ejecuta después de la obtención de las fuentes, la extracción y la ejecución de prepare(). Así que uested puede actualizar la variable pkgver durante la etapa makepkg.

Esto es particularmente útil si está haciendo making git/svn/hg/etc. paquetes, donde el proceso de construcción puede seguir siendo el mismo, pero el codigo fuente podría ser actualizado todos los días, incluso cada hora. La vieja manera de hacer esto era poner la fecha en el campo del pkgver, donde si el Software no se actualizaba, makepkg aún así lo reconstruiría pensando que la versión había cambiado. Algunos comandos útiles para esto son git describe, hg identify -ni, etc. Por favor pruebe estos antes de enviar un PKGBUILD, ya que un error en la función pkgver() puede detener la compilación.

Nota: pkgver no puede contener espacios ni guiones (-). El uso de sed para corregir esto es común.

build()

Ahora necesita implementar la función build() en el archivo PKGBUILD. Esta función utiliza comandos de shell comunes en la sintaxis de Bash para compilar automáticamente el software y crear un directorio pkg para instalar el software. Esto permite a makepkg empaquetar archivos sin tener sin tener que filtrar el sistema de archivos.

El primer paso en la función build() es cambiar al directorio creado descomprimiendo el tarball de origen. makepkg cambiará el directorio actual a $srcdir antes de ejecutar la función build(). Por lo tanto, en la mayoría de los casos, como se sugiere en /usr/share/pacman/PKGBUILD.proto, el primer comando se verá así:

cd "$pkgname-$pkgver"

Ahora, necesita listar los mismos comandos que utilizó cuando compiló manualmente el software. La función build() en esencia automatiza todo lo que hizo a mano y compila el software en el entorno de compilación fakeroot. Si el software que está empaquetando utiliza un script, es una buena práctica usar --prefix=/usr al crear paquetes para pacman. Una gran cantidad de software instala archivos relativos al directorio /usr/local, que sólo se debe hacer si se está generando manualmente desde el codigo fuente. Todos los paquetes Arch Linux deben usar el directorio /usr. Como se ve en el archivo /usr/share/pacman/PKGBUILD.proto, las siguientes dos líneas suelen tener este aspecto:

./configure --prefix=/usr
make
Nota: : Si su software no necesita construir nada, NO utilice la función build(). La función build() no es necesaria, pero la La función package() si lo es.

check()

Momento para llamar a make check para hacer chequeos y rutinas similares de prueba. Es muy recomendable tener check(), ya que ayuda a asegurar que el software se ha construido correctamente y funciona bien con sus dependencias.

Usuarios que no lo necesitan (Y ocasionalmente los mantenedores que no pueden arreglar un paquete para que esto pase) puede inhabilitarlo usando BUILDENV+=('!check') en el PKGBUILD/makepkg.conf o llamar makepkg con flag --nocheck.

package()

El paso final es poner los archivos compilados en un directorio donde makepkg puede recuperarlos para crear un paquete. Por defecto es el directorio pkg - un simple entorno fakeroot. El directorio pkg replica la jerarquía del sistema de archivos raíz de las rutas de instalación del software. Si tiene que colocar manualmente los directorios raíz de su sistema de archivos, debe instalarlos en el directorio pkg bajo la misma estructura de directorios. Por ejemplo, si desea instalar un archivo en /usr/bin, debe colocarse en $pkgdir/usr/bin. Muy pocos procedimientos de instalación requieren que el usuario copie docenas de archivos manualmente. En su lugar, la mayoría de software make install lo hará. La última línea debe ser similar a la siguiente para poder instalar correctamente el software en el directorio pkg:

make DESTDIR="$pkgdir/" install
Nota: : A veces está el caso en que DESTDIR no se utiliza en el Makefile; puede que tenga que usar prefix en su lugar. Si el paquete está construido con autoconf / automake, use DESTDIR; esto es lo que se documenta en los manuales. Si DESTDIR no funciona, trate de construir con make prefix="$pkgdir/usr/" install. Si eso no funciona, tendrá que buscar más en los comandos de instalación que son ejecutados por "make <...> install".

En algunos casos raros, el software espera ejecutarse desde un único directorio. En tales casos, es aconsejable simplemente copiarlos $pkgdir/opt.

A menudo, el proceso de instalación del software creará subdirectorios debajo del directorio pkg. Si no lo hace, makepkg generará muchos errores y necesitará crear manualmente subdirectorios añadiendo los comandos apropiados de mkdir -p en la función build() antes de ejecutar el procedimiento de instalación.

En los paquetes antiguos, no había ninguna función package(). Por lo tanto, los archivos se colocaban en el directorio pkg al final de la función build(). Si package() no está presente, build() se ejecuta a través de fakeroot. En paquetes nuevos, package() es necesario y se ejecuta a través de fakeroot en su lugar, y build() se ejecuta sin privilegios especiales.

makepkg --repackage ejecuta sólo la función package(), por lo que crea un archivo *.pkg.* archivo sin compilar el paquete. Esto puede ahorrar tiempo, e.g. si acaba de cambiar las variables depends del paquete.

Nota: La función package() es la única función requerida en un PKGBUILD. Si sólo debe copiar archivos en sus respectivos directorios para instalar un programa, no lo ponga en la función build(), póngalo en la función package().
Nota: Crear enlaces simbólicos es un proceso un poco incómodo en la función package(). Utilizando el enfoque ingenuo ln -s "${pkgdir}/from/foo" "${pkgdir}/to/goo" resultará en un enlace simbólico roto al directorio de compilación. La manera correcta de crear una link es crearlo apuntando a una fuente inicialmente rota, ln -s "/from/foo" "${pkgdir}/to/goo". Una vez instalado el paquete, el enlace apuntará al lugar correcto.

Prueba del PKGBUILD y del paquete

Al escribir la función build(), querrá probar sus cambios frecuentemente para asegurarse de que no haya errores. Puedes hacerlo usando el comando makepkg en el directorio que contiene el archivo PKGBUILD. Con un PKGBUILD correctamente formateado, makepkg creará un paquete; con un PKGBUILD roto o inacabado, provocará un error.

Si makepkg finaliza correctamente, colocará un archivo denominado pkgname-pkgver.pkg.tar.xz en su directorio de trabajo. Este paquete puede ser instalado con el comando pacman -U. Sin embargo, sólo porque un archivo de paquete fue construido no implica que es totalmente funcional. Eso 11 Posiblemente sólo contenga el directorio y ningún archivo en si, por ejemplo, un prefijo se especificó incorrectamente. Puedes usar las funciones de consulta de pacman para mostrar una lista de archivos contenidos en el paquete y las dependencias que requiere con ppacman -Qlp [package file] y pacman -Qip [package file], respectivamente.

¡Si el paquete parece sano, entonces usted a terminado! Sin embargo, si planea liberar el archivo PKGBUILD, es imperativo que compruebe y compruebe de nuevo el contenido de la matriz de dependencias.

También asegúrese de que los binarios del paquete realmente funcionan perfectamente! Es molesto liberar un paquete que contiene todos los archivos necesarios, pero se bloquea Debido a alguna opción de configuración poco clara que no funciona bien con el resto del sistema. Si solo va a compilar paquetes para su propio sistema, entonces usted no necesita preocuparse demasiado sobre este paso de aseguramiento de calidad, después de todo es la única persona que sufre de errores.

Comprobación de la sanidad del paquete

Después de comprobar la funcionalidad del paquete, compruebe si hay errores con namcap:

$ namcap PKGBUILD
$ namcap <package file name>.pkg.tar.xz


Namcap deberá:

  1. Comprobar el contenido de PKGBUILD para buscar errores comunes y la jerarquía de archivos de paquetes para archivos innecesarios/extraviados.
  2. Escanea todos los archivos ELF en el paquete usando ldd, informando automáticamente qué paquetes con las bibliotecas compartidas requeridas faltan de las dependencias y que se pueden omitir como dependencias transitivas.
  3. Búsqueda heurística de dependencias perdidas y redundantes.

y mucho más. Adquiera el hábito de revisar sus paquetes con namcap para evitar tener que arreglar los errores más simples después de la subida del paquete.

Subir paquetes a AUR

Por favor lea Arch User Repository#Submitting packages de la guía de AUR. Para una descripción detallada del proceso.

Resumen

  1. Descargue el código fuente del software que quiera empaquetar.
  2. Trate de compilar e instalar el software en un directorio arbitrario
  3. Copie el prototipo de /usr/share/pacman/PKGBUILD.proto y renómbrelo como PKGBUILD en un directorio de trabajo, preferiblemente ~/abs
  4. Edite el PKGBUILD de acuerdo a las necesidades de su paquete
  5. Ejecute makepkg para verificar si el paquete se construye correctamente
  6. Si no es así, repita los últimos dos pasos

Advertencias

  • Antes de automatizar el proceso de construcción de paquetes, deberá haberlo hecho por lo menos una vez de manera manual para saber de antemano exactamente lo que esta haciendo. Desafortunadamente muchos autores de paquetes se apegan al proceso de 3 pasos de ./configure, make make install, este no es siempre el caso y puede quedar un paquete en muy malas condiciones si no aplica el cuidado necesario para que todo funcione bien.
  • En algunos pocos casos, los paquetes no son disponibles en código fuente y habrá que recurrir a scripts como sh instalador.run para poder ejecutarlo, habrá de hacer una extensa investigación acerca de otros PKGBUILD, leer los README, buscar información del creador del programa, o buscar EBUILDS de Gentoo para poder ejecutar la instalación, recuerde que makepkg debe ser completamente automático y sin intervención del usuario.

Directrices más detalladas

Package creation guidelines

CLRCrossEclipseFree PascalGNOMEGoHaskellJavaKDEKernelLispMinGWNode.jsNonfreeOCamlPerlPHPPythonRubyVCSWebWine

Ver también