Creating Packages (Español)

From ParabolaWiki
Jump to: navigation, search
Resumen
Una descripción detallada del proceso de construcción de paquetes. Cubre la creación y testeo de paquetes.
Relacionadas
makepkg
pacman
PKGBUILD
VCS PKGBUILD Guidelines

Este artículo apunta a ayudar a los usuarios para que creen sus propios paquetes usando el sistema de construcción "tipo ports" de Arch. Cubre la creación de PKGBUILD – un archivo de descripción de la construcción de un paquete provisto por makepkg para crear un paquete binario desde la fuente. Si ya domina PKGBUILD, consulte makepkg.

1 Resumen

Los paquetes de Arch se construyen usando la utilidad makepkg y la información almacenada en el archivo PKGBUILD. Cuando ejecuta makepkg, este busca un PKGBUILD en el directorio actual y sigue las instrucciones sean estas de compilación o de adquisición de los archivos requeridos para ser empaquetados dentro del archivo del paquete (pkgname.pkg.tar.xz). El paquete resultante contiene archivos binarios e instrucciones de instalación; fácilmente instalables con pacman.

Un paquete de Arch no es más que un archivo comprimido tar usando xz, o 'tarball', que contiene:

  • Los archivos binarios a instalar
  • .PKGINFO: contiene todos los metadatos necesarios para que pacman se maneje con los paquetes, las dependencias, etc.
  • .INSTALL: un archivo opcional usado para ejecutar comandos después de las etapas de instalación/actualización/remoción. (Este archivo está presente solo si está especificado en PKGBUILD.)
  • .Changelog: un archivo opcional actualizado por el mantenedor del paquete que documenta sus cambios. (No está presente en todos los paquetess.)

2 Preparación

2.1 Prerrequisitos de software

Asegúrese que las herramientas necesarias están instaladas. El grupo de paquetes base-devel debería ser suficiente; incluye make y las herraminetas adicionales necesarias para compilar desde las fuentes.

# pacman -S base-devel

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

  1. Verifique que las dependencias de los paquetes estén instaladas.
  2. Descargue los archivos fuente desde los servidores específicos.
  3. Desempaque los archivos fuente.
  4. Compile el software e instálelo bajo un entorno fakeroot.
  5. Elimine los símbolos de los binarios y las bibliotecas.
  6. Genere el archivo del meta paquete incluído en cada paquete.
  7. Comprima el entorno fakeroot dentro de un archivo de paquete.
  8. Almacene el archivo del paquete en el directorio configurado de destino, presente en el directorio de trabajo por defecto.

2.2 Descarga y prueba de la instalación

Descargue el tarball de las fuentes del software que desee empaquetar, extráigalo y siga los pasos recomendados por el autor para instalar el programa. Tome nota de todos los comandos y/o pasos necesarios para compilarlo e instalarlo. Deberá repetir estos comandos en el archivo PKGBUILD.

La mayoría de los autores de software adhieren a un ciclo de construcción de 3 pasos:

./configure
make
make install

Este es un buen momento para asegurarse que el programa está trabajando correctamente.

3 Creación de PKGBUILD

Cuando ejecute makepkg, buscará un archivo PKGBUILD en el directorio actual de trabajo. Si encuentra un archivo PKGBUILD descargará el código fuente del software y lo compilará de acuerdo a las instrucciones especificadas en el archivo PKGBUILD. Las instrucciones deben ser completamente interpretables por el shell Bash. Después de completarse exitosamente, los binarios resultantes y los metadatos del paquete. por ejemplo la versión del paquete y las dependencias, están empaquetadas en un archivo pkgname.pkg.tar.xz que podrá instalarse con pacman -U <package file>.

Para comenzar con un nuevo paquete, primero debe crear un directorio de trabajo vacío, (preferiblemente ~/abs/pkgname), cambie a ese directorio, y cree un archivo PKGBUILD. Puede copiar el prototipo PKGBUILD /usr/share/pacman/PKGBUILD.proto a su directorio de trabajo o copiar un PKGBUILD desde un paquete similar. Esto último puede ser muy útil si sólo necesita cambiar unas pocas opciones.

3.1 Definiendo variables PKGBUILD

Para hallar ejemplos de PKGBUILD busque en /usr/share/pacman/.

makepkg define tres variables que debería usar como parte del proceso de instalación y construcción:

startdir
contiene la ruta absoluta al directorio donde se ubica el archivo PKGBUILD. Esta variable se usa en combinación con los sufijos /src o /pkg, pero el método moderno es usar variables srcdir y pkgdir. No hay garantías de que $startdir/src sea lo mismo que $srcdir; lo mismo para $pkgdir. Esta variable es obsoleta y su uso está seriamente desaconsejado.
srcdir
apunta al directorio donde makepkg extrae o copia todos los archivos fuente
pkgdir
apunta al directorio donde makepkg coloca el paquete instalado, el cual se convierte en el directorio raíz de su paquete construído.
Nota: makepkg, y por consiguiente las funciones build() y package(), están planeadas para no ser interactivas. Las utilidades interactivas o los scripts llamados en aquellas funciones pueden romper a makepkg, particularlmente si es invocado con (-l) habilitado. (Consulte Issue#13214.)
Nota: Además del actual mantenedor del paquete, pueden existir mantenedores anteriores listados más arriba como contribuyentes.

3.2 La función build()

Ahora deberá implementar la función build() en el archivo PKGBUILD. Esta función usa comandos shell habituales en sintaxis Bash_%28Unix_shell%29 Bash para compilar software automáticamente y crear el directorio pkg para instalar el software. Esto permite a makepkg empaquetar archivos sin tener que seleccionarlos a través de su sistema.

El primer paso en la función build() es cambiar al directorio creado al descomprimir el tarball con las fuentes. En la amyoría de los casos el primer comando es algo como esto:

 cd "$srcdir/$pkgname-$pkgver"

Ahora, necesita listar los mismos comandos que usó 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 construcción fakeroot. Si el software que está empaquetando usa un script de configuración, es una buena práctica usar --prefix=/usr cuando construye paquetes para pacman. Una gran cantidad de software instala archivos relativos al directorio /usr/local, lo que solamente debería hacerse si está construyendo manualmente a partir de las fuentes. Todos los paquetes de Arch deberían usar el directorio /usr. Según lo visto en el archivo /usr/share/pacman/PKGBUILD.proto, las dos líneas próximas a menudo lucen como esto:

./configure --prefix=/usr
make

3.3 La función check()

Da lugar a llamadas a make check y rutinas de testeo similares. Los usuarios que no la necesiten (y ocasionalmente mantenedores que no puedan arreglar paquetes) pueden deshabilitar !check en las opciones de PKGBUILD/makepkg.

3.4 La función package()

El paso final consiste en colocar los archivos compilados en un directorio donde makepkg pueda recuperarlos para crear un paquete. Este directorio es, por defecto, 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 debe colocar manualmente archivos en la raíz de su sistema de archivos, debería instalarlos en el directoriopkg bajo la misma estructura. Por ejemplo, si desea instalar un archivo en /usr/bin, debería ser instalado además en $pkgdir/usr/bin. Muy pocos procedimientos de instalación requieren que el usuario copie docenas de archivos manualmente. En su lugar, para la mayoría del software, la llamada make install lo hará. La última línea debería lucir como la siguiente para instalar correctamente el software en el directorio pkg:

make DESTDIR="$pkgdir" install
Nota: Este es el caso en donde algunas veces DESTDIR no se usa en Makefile; puede que necesite usar prefix en su lugar. Si el paquete está construido con autoconf/automake, use DESTDIR; esto es lo que está documentado en los manuales. Si DESTDIR no funciona, intente construir con make prefix="$pkgdir/usr/" install. Si esto tampoco funciona, tendrá que buscar más allá en los comandos de instalación que son ejecutados por "make <...> install".

En algunos otros casos, el software espera ejecutarse a partir de un directorio único. En tales casos, es recomendable copiarlo a $pkgdir/opt.

A menudo, el proceso de instalación del software creará algunos sub-directories dentro deñ directorio pkg. Si no sucede, sin embargo, makepkg generará una serie de errores y será necesario crearlos manualmente agregando los correspodientes comandos mkdir -p en la función build() antes de proceder a la instalación.

En paquetes antiguos, no existe la función package(). Por lo tanto, los archivos compilados se ubican al finalizar la función build(). Si no está presente package(), build() se ejecuta fakeroot. Si está presente package(), build() se ejecuta como el usuario que llama a makepkg, package() se ejecuta vía fakeroot.

makepkg --repackage ejecuta solamente la función package(), entonces crea un archivo *.pkg.* sin compilar el paquete. Esto puede ahorrar tiempo por ejemplo si solamente ha cambiado la variable depends del paquete.

3.5 Directrices adicionales

Por favor lea detalladamente los Arch Packaging Standards para unas mejores prácticas y consideraciones adicionales.

4 Testeo de PKGBUILD y del paquete

Como usted ha escrito la función build(), querrá probar sus cambios frecuentemente para asegurarse que no hayan bugs. Podrá hacer esto 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 inconcluso, dará un error.

Si makepkg concluye exitosamente, dará lugar a 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, solo porque un archivo de paquete fue construido no implica que sea totalmente funcional. Podría contener, posiblemente, solo el directorio sin ningún archivo en absoluto si, por ejemplo, se especifica impropiamente un prefijo. Puede usar funciones de consulta para mostrar una lista de archivos contenidos en el paquete y las dependencias que requiere con pacman -Qlp [package file] y pacman -Qip [package file] respectivamente.

Si el paquete luce sano, ¡entonces usted lo ha hecho! Sin embargo, si planea liberar el archivo PKGBUILD, es imperativo que chequee y rechequee el contenido de su matriz de depends.

¡Tambiém asegúrese que los paquetes binarios realmente "corran" sin fallos! Es muy irritante liberar un paquete que contiene todos los archivos necesarios pero no funcionan porque alguna oscura opción de configuración que no acaba de funcionar bien con el resto del sistema. Si solo desea compilar paquetes para su sistema, sin embargo, no deberá preocuparse demasiado acerca de este paso de aseguramiento de la calidad, ya que usted será la única persona que sufrirá estos errores, después de todo.

4.1 Chequeo de la sanidad de un paquete

Después de chequear la funcionalidad del paquete compruebe si existen errores usando namcap:

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

Namcap hará lo siguiente:

  1. Chequear los contenidos de PKGBUILD buscando errores comunes y la jerarquía de archivos de paquetes por archivos perdidos/innecesarios
  2. escanear todos los archivos ELF en paquetes usando ldd, reportando automáticamente a los paquetes que requieren bibliotecas compartidas y perdidas de {Ic|depends}} y que pueden ser omitidos como dependencias transitivas
  3. buscar heurísticamente dependencias redundantes y perdidas

y mucho más. Tenga el hábito de chequear sus paquetes con namcap para ayudar a arreglar los errores más simples después de enviar los paquetes.

5 Resumen

  1. Descargue el tarball con las fuentes del software que quiera empaquetar.
  2. Intente compilar el paquete e instalarlo en un directorio arbitrario.
  3. Copie el prototipo /usr/share/pacman/PKGBUILD.proto y cámbiele el nombre a PKGBUILD en un directorio de trabajo temporario -- preferiblemente ~/abs/.
  4. Edite el PKGBUILD de acuerdo a las necesidades de su paquete.
  5. Ejecute makepkg y vea el paquete resultante sin importar si está construído correctamente.
  6. Si no lo está, repita los dos últimos pasos.

5.1 Advertencias

Antes de automatizar el proceso de construcción de paquetes, deberia hacerlo manualmente al menos una vez para que sepa "exactamente" que es lo que está haciendo "de antemano"', en ese caso usted no debería estar leyendo esto en primer lugar. Desafortunadamente, aunque una gran parte de los autores de un programa adhieren al ciclo de construcción de tres pasos, a saber "./configure; make; make install". Esto no siempre resulta así, y las cosas pueden tornarse realmente feas si tiene que aplicar parches para hacer que todo funcione. Regla de oro: si no puede lograr que el programa compile desde el tarball con las fuentes, y que se instale solo en un subdirectorio temporal, definido, ni siquiera es necesario intentar el empaquetado. No existe ningún polvo mágico en makepkg que haga que los problemas de las fuentes desaparezcan.

  • En algunos casos, los paquetes ni siquiera están disponibles como fuente y tendrá que usar algo como sh installer.run para hacerlo funcionar. Tendrá que investigar un poco (leer READMEs, instrucciones INSTALL, páginas man, quizás ebuilds de Gentoo u otros instaladores de paquetes, quizás hasta los MAKEFILEs o el código fuente) para hacerlo trabajar. En algunos csos realmente malos, tendrá que editar los archivos fuente para lograr que funcione todo. Sin embargo, makepkg necesita ser completamente autónomo, sin participación de los usuarios. Sin embargo si usted necesita editar los makefiles, tendrá que empaquetar un parche a medida con el PKGBUILD e instalarlo desde adentro de la función build(), o podría tener que lanzar algún comando sed desde adentro de la función build().

6 Vea también

7 Reconocimientos

Este artículo está basado de ArchWiki. Es posible que hayamos eliminado pedazos con contenido "no-FSDG" en ella.