Esta receta explica de forma muy resumida los pasos más importantes para crear y mantener un paquetillo Debian, y cumpliendo la política de Debian.

Introducción

Concretamente se explica cómo crear y mantener un paquete Debian muy sencillo utilizando CDBS (Common Debian Build System). Se trata de un paquete que contiene un script Python y poco más, de modo que probablemente es uno de los más simples que se pueden hacer.

Ingredientes

  • dh-make
  • build-essentials

Obteniendo los fuentes

Aquí hay varias posibilidades. Puedes empaquetar un programa o librería:

  • Distribuido por otra persona con un típico .tgz
  • Descargarlo de un repositorio CVS o SVN
  • Un programa propio
  • etc

Para seguir la receta vamos a empaquetar pyhello (así que se trata del primer caso). En realidad, como habrás adivinado es un ejemplo hecho ex profeso para esta receta. Descarga y descomprime el archivo tal como sigue:

 $ wget https://bitbucket.org/crysol_org/samples/get/tip.tar.gz

Crear el paquete

Sea como fuere, debes asegurarte de que tienes los fuentes en un directorio con un nombre similar a pyhello-0.1 (hay normas precisas sobre este nombre, que debes cumplir) y un .tgz con el mismo contenido en el directorio padre de ese. A continuación:

  • Entra en el directorio
  • Define el nombre del mantenedor (tú) como variable de entorno ($DEBFULLNAME)
  • Y ejecuta dh_make como se indica
$ cd pyhello-0.1/
pyhello-0.1$ export DEBFULLNAME="Juan Nadie"
pyhello-0.1$ dh_make -f ../pyhello-0.1.tar.gz -e juan.nadie@loquesea.es -b -c gpl
Maintainer name : Juan Nadie
Email-Address   : juan.nadie@loquesea.es
Date            : Mon,  5 Jun 2006 19:07:39 +0200
Package Name    : pyhello
Version         : 0.1
License         : gpl
Type of Package : cdbs
Hit <enter> to confirm:

Nota: Sólo hay que utilizar dh_make cuando se crea el paquete y nunca más.

Cosas que ha hecho dh_make:

  • Un archivo pyhello-0.1/../pyhello-0.1.orig.tar.gz. Este archivo es el software tal como lo distribuye el autor, lo que se llama upstream y formará parte del paquete Debian de fuentes.
  • Un directorio pyhello-0.1/debian con un montón de ficheros que voy a comentar a continuación.

Página man

En Debian todos los paquetes deben tener su página de manual. Si el programa viene con su página te puedes saltar este paso, pero es esta receta vamos a suponer que no la tiene, que es lo más probable. Para estos casos, dh_make te crea unas plantillas en pyhello-0.1/debian/ que llevan por nombre:

  • manpage.1.ex
  • manpage.sgml.ex
  • manpage.xml.ex

La primera está en formato nroff y las otras dos en DocBook. Lo más fácil es usar el XML. Así que renombra el fichero:

 pyhello-0.1$ *mv debian/manpage.xml.ex debian/pyhello.xml* 

Después la editas convenientemente y borra las otras dos plantillas.

Licencia

dh_make ha dejado una plantilla de la licencia que hayas elegido en el fichero pyhello-0.1/debian/copyright. Simplemente rellena los datos que faltan.

Editar el fichero debian/control

El fichero control dice qué es el paquete. A continuación puedes ver como quedaría para nuestro ejemplo, una vez hechos los cambios sobre lo generado por dh_make:

Source: pyhello
Section: utils
Priority: optional
Maintainer: Juan Nadie <juan.nadie@loquesea.es>
Build-Depends: debhelper (>= 5.0.38)
Build-Depends-Indep: cdbs (>= 0.4.43), python-all-dev (>= 2.3.5-11), python-central (>= 0.5.6), docbook-xsl
Standards-Version: 3.7.2
XS-Python-Version: all

Package: pyhello
Architecture: all
Depends: ${python:Depends}
XB-Python-Version: ${python:Versions}
Description: Ejemplo básico de script Python empaquetado en Debian GNU/Linux
 Un script "hola mundo" que sirve únicamente para explicar cómo se
 empaquetan scripts Python en GNU/Linux de forma adecuada.

Básicamente debes elegir:

Editar el fichero debian/rules

El fichero rules es realmente un Makefile e indica cómo hacer todas las tareas relacionadas con el paquete: compilación, instalación, limpieza, etc. Este fichero solía tener un tamaño y complejidad considerable, incluso para un paquete tan simple como éste. Pero con la llegada de CDBS, todo es mucho más sencillo. Así quedaría en este caso:

#!/usr/bin/make -f

DEB_PYTHON_SYSTEM=pycentral
DBK2MAN_XSL=/usr/share/xml/docbook/stylesheet/nwalsh/manpages/docbook.xsl

include /usr/share/cdbs/1/rules/debhelper.mk
include /usr/share/cdbs/1/class/python-distutils.mk

build/pyhello::
	xsltproc --nonet $(DBK2MAN_XSL) debian/pyhello.xml

install/pyhello::
        mv $(CURDIR)/debian/pyhello/usr/bin/pyhello.py $(CURDIR)/debian/pyhello/usr/bin/pyhello

clean::
	-rm pyhello.1

El mv se debe a que la política de Debian no permite que haya programas con extensión en los directorios bin, que es donde va a ir a parar el script.

El fichero setup.py

En este ejemplo estamos utilizando distutils, que simplifica mucho las cosas (aprovechando que CDBS ofrece soporte específico). distutils es un sistema para construir e instalar módulos Python. El rules era tan sencillo porque delega parte de la tarea de la instalación en distutils. Para usarlo simplemente hay que escribir un fichero setup.py muy sencillo y colocarlo en el directorio pyhello-0.1/:

#!/usr/bin/env python

from distutils.core import setup

setup(name         = 'pyhello',
      version      = '0.1',
      description  = 'Ejemplo básico de script Python empaquetado en Debian',
      author       = 'Fulanito Mengano',
      author_email = '<FulanitoMengano@gmain.com>',
      url          = 'https://arco.inf-cr.uclm.es/svn/public/prj/debian-python-hello/',
      license      = 'GPL v2 or later',
      data_files   = [('share/man/man1',['pyhello.1'])],
      scripts      = ['pyhello.py']
      )

Generar el paquete ‘binario’

Ejecuta:

 pyhello-0.1$ *dpkg-buildpackage -rfakeroot* 

Si la compilación del paquete ha funcionado sin problemas, habrán aparecido varios ficheros en el directorio “pyhello-0.1/..”. Por lo menos deberías tener los siguientes:

pyhello-0.1-1.all.deb - El paquete Debian binario (listo para instalar)
pyhello-0.1-1.diff.gz - Todos los cambios respecto al archivo orig
pyhello-0.1-1.dsc - Resumen del paquete con MD5 para el orig y el diff
pyhello-0.1-1_i386.changes - Los cambios que has hecho en esta versión
pyhello-0.1.orig.tar.gz - Lo que distribuye el autor del programa (upstream)

Verificación

Una vez creado, debes comprobar que todo es correcto, es decir:

  • Que instala correctamente (con dpkg -i)
  • Que tiene los ficheros necesarios y ninguno más (con mc o lesspipe)
  • Que cumple la policy de Debian (con lintian y linda)

Limpieza

 pyhello-0.1$ fakeroot debian/rules clean 

Mantenimiento básico

Una vez terminado el paquete, lo lógico es distribuirlo de algún modo, ya sea como parte de Debian, en un repositorio de paquetes no-oficial o incluso en tu propia página web.

En cualquier caso, debes tener claro un principio universal: “no hay nada definitivo”. Es decir, que más tarde o más temprano tendrás que hacer cambios en el paquete, ya sea para adoptar los cambios que el autor haga en su programa o para arreglar bugs cometidos por él o por ti (no es relevante que el autor y el mantenedor sean la misma persona). También puede que a los simpáticos Debian Developers les dé por hacer cambios en la policy.

Cerrar un bug

Como mantenedor del paquete serás responsable de solucionar los problemas que seguro tendrá el paquete. Estos problemas pueden ser errores de empaquetado, de aplicación de la política o también errores en la codificación del propio programa (que deberías notificar al autor).

En estos casos, debes solucionar el problema y crear una nueva revisión del paquete, para eso ejecuta:

 pyhello-0.1$ dch -i 

Después edita el debian/changelog y escribe una breve descripción de cómo has solucionado el error. Si se trata de un paquete oficial, deberás utilizar el DBTS(Debian Bug Tracking System, en el que cada bug notificado tiene un número asociado. Cuando resuelve el problema debes citar ese número con algo como “Closes: #5432”. Todo esto, también está “legislado” en Debian.

Nueva versión del ‘upstream’

La otra tarea importante que realiza un mantenedor es empaquetar las nuevas versiones que produce el autor (lo que se llama upstream). En este caso se procede de modo similar a cuando se creó el paquete: se copia el .tgz de rigor en el directorio padre del directorio de los fuentes y se ejecuta:

 pyhello-0.1$ uupdate -u pyhello-0.2.tar.gz 

Como en el caso anterior, deberías editar el fichero debian/changelog y explicar la jugada, normalmente algo del tipo “New uptream release” o similar.

Comentarios

No pretendo que esto sea una guía completa para crear paquetes, ¡eso es imposible! y para eso ya está la documentación oficial de referencia. Sólo pretendo que sea un punto de partida para quién quiera empaquetar sus programillas, y ¿por qué no? quizá para despertar el gusanillo de quien quiera ayudar a Debian manteniendo algún paquetillo que esté huerfanito. Si tienes alguna duda o crees que se me ha pasado algo importante, deja un comentario. Yo estoy empezando con esto, no soy ningún experto, así que entre todos igual hasta podemos aprender algo.

Relacionado

Paquetería Debian

Python



blog comments powered by Disqus