Este tutorial está hecho con la intención de ayudar a la gente a construir sus propios paquetes «deb». Lo que necesitamos para este tutorial será un programa, echarle ganas y tener paciencia.

Creación de un programa: una interfaz sencilla con Python

Este paso no es realmente necesario. Haremos esto únicamente para generar un programa que empaquetar en este tutorial. Si ya tienes uno creado con anterioridad, puedes omitir esto y saltar al siguiente punto.

Si por lo contrario necesitas crear el binario, con PyGTK (para crear interfaces de GTK usando Python) podremos trabajar cómodamente. Como la finalidad del tutorial no se centra en crear el binario, os proponemos algo tan sencillo como esto:

Para alguien que no tenga ni idea de Python debe ser muy agobiante tener que hacer eso desde cero. Pero no os preocupéis, hemos dicho que la intención de este tutorial es ayudar, así que os proporcionamos el código de la interfaz:

[code]import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk

class Ventana(Gtk.Dialog):
    def __init__(self):
        Gtk.Dialog.__init__(self,
                                    'Ventana de Prueba',
                                    None,
                                    Gtk.DialogFlags.MODAL |
                                    Gtk.DialogFlags.DESTROY_WITH_PARENT,
                                    (Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT,
                                    Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT))    
        self.set_position(Gtk.WindowPosition.CENTER_ALWAYS)
 
        vbox0 = Gtk.VBox(spacing=5)
        vbox0.set_border_width(5)
        self.get_content_area().add(vbox0)
    
        tabs = Gtk.Notebook.new()
        vbox0.add(tabs)
    
        vbox11 = Gtk.VBox(spacing=5)
        vbox11.set_border_width(5)
        tabs.append_page(vbox11, Gtk.Label.new('Tab'))
        frame11 = Gtk.Frame()
        vbox11.pack_start(frame11, False, True, 1)
        table11 = Gtk.Table(1, 1, False)
        frame11.add(table11)
    
        label11 = Gtk.Label('Interruptor Switch:')
        label11.set_alignment(0, 0.5)
        table11.attach(label11, 0, 1, 0, 1, xpadding=5, ypadding=5)
        self.switch1 = Gtk.Switch()
        self.switch1.set_active(True)
        table11.attach(self.switch1, 1, 2, 0, 1,
                                                xpadding=5,
                                                ypadding=5,
                                                xoptions=Gtk.AttachOptions.SHRINK) 
        self.show_all()
    
if __name__ == "__main__":
    cm = Ventana()
if cm.run() == Gtk.ResponseType.ACCEPT:
    print("adios")
cm.hide()
cm.destroy()
exit(0)
Gtk.main() [/code]

Abrid vuestro editor de texto predeterminado y utilizad el código. Nosotros hemos llamado al fichero «ventana.py», pero sois libres de darle el nombre que queráis. No influirá en el proceso.

Para comprobar si ha funcionado correctamente, abrid un Terminal (Ctrl+Alt+T) e introducid «python [nombre_archivo]», donde pondréis el nombre de vuestro fichero, evidentemente. Con eso se os debería abrir la ventana que acabamos de crear.

Nota: Tened en cuenta que necesitáis tener instalado Python para esto. Instaladlo poniendo esto en la consola:

sudo apt-get install python

Estructura de los directorios

Ahora es cuando realmente empezamos con el tutorial. Es importante organizar los ficheros y directorios de una forma específica. Ya no solo por comodidad, si no porque existe el directorio «debian» que será aquel en el que incluiremos los archivos específicos de Debian para la configuración del paquete.

Creamos una carpeta raiz para nuestro proyecto. Es muy importante que el nombre de la carpeta tenga la siguiente estructura: [nombreprograma]-[version]. En breve explicaremos el por qué. Nuestro directorio se llama «ventana-0.1». Dentro de éste pondremos el «*.py» que hemos creado hace un momento o el binario que tengamos.

En la misma carpeta, junto al binario, es el momento de crear un directorio «debian». ¡Por favor! Respetad la capitalización del nombre, porque en caso contrario estaremos haciéndolo mal. Ahora tendremos que conocer todos los ficheros que contendrá esta nueva carpeta:

Archivo «debian/control»

Este archivo describe el paquete que estás creando mediante los campos de control de Debian. A continuación veremos un ejemplo de cómo es el fichero y cómo incluye tanto el binario como el paquete fuente:

Source: ventana
Section: utils
Priority: extra
Maintainer: slimbook <sat@slimbook.es>
Build-Depends: debhelper (>= 9)
Standards-Version: 3.9.6
Homepage: <http://slimbook.es> 
 
Package: ventana
Architecture: all
Depends: ${misc:Depends}, ${python:Depends},
     python3,
     python3-gi,
     python3-pil,
     python3-dbus
Description: Esto es una ventana
 Ventana realizada para tutorial de empaquetado

Ojo con los detalles: las dependencias son importantes, ya que son los paquetes que incluiréis en la instalación y que tendrán relación con la aplicación que hacéis. El ejemplo más claro es este, ya que adjuntamos dependencias de Python para poder ejecutar correctamente nuestro binario en otros equipos que puedan no tenerlo. Además, bajo la descripción del paquete, ampliaremos con una descripción detallada, ¡pero tiene un espacio en blanco delante de la línea, no lo borréis!

Archivo «debian/changelog»

Simple de explicar: un log con los cambios de la aplicación. Este fichero deberá tener por lo menos una entrada para poder crear nuestro paquete Debian.

La estructura de este archivo es más delicada que el de «control». Podéis optar por hacerlo manualmente, si sois cuidadosos; o podéis hacerlo mediante la instrucción «dch» en el Terminal, si sois algo más despistados:

Instalación de comando dch:

sudo apt install devscripts[/code][code]dch -i --create

dch -i --create

Ejecutad esto desde la carpeta raíz del programa y veréis como vuestra consola abre su editor por defecto con una entrada de Changelog similar a esta:

Para el que quiera crear el fichero de forma manual, la estructura es la misma:

Si habéis modificado las cosas con relativa precaución, al final conseguiréis vuestro fichero de cambios «changelog». Recordad editarlo con cada entrada o modificación nueva que realicéis, siguiendo la misma estructura y poniendo cada nuevo cambio encima del anterior. Para los cómodos, recordad que podéis hacer eso:

dch -i

Archivo «debian/rules»

Este fichero os dirá cómo se va a construir vuestro paquete. Su estructura es así:

#!/usr/bin/make -f  
 
%:
  dh $@

Archivo «debian/copyright»

Lintian nos va a exigir un archivo de copyright, aunque pueda estar vacío. Haremos uno simple, que quedará tal que así:

Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Upstream-Name: slimbooktouchpad
Source: <[email protected]>
 
Files: *
Copyright: 2016, Slimbook <[email protected]>
License: GPL

Archivo «debian/install»

Disponemos de un fichero que nos permitirá indicarle todos los archivos a instalar y la respectiva ubicación que crearemos. Nosotros vamos a pedirle que nos instale el binario en «/usr/share/ventana/», asi que tras crear el archivo pondremos esto en la primera línea:

ventana /usr/share/ventana/

Un par de aclaraciones:

Creación del paquete de origen «orig»

Con lo que tenemos, este paso es relativamente sencillo. Aprovecha para detenerte aquí y pegarle un vistazo a todo lo que tienes:

¿Todo correcto? Pues regresamos a la carpeta raiz, esa a la que le pusimos un nombre con versión y todo. Y ahora os explicamos por qué.

Desde este mismo directorio tenemos que abrir un Terminal y ejecutar la siguiente línea:

dh_make --createorig

Si no lo tienes instalado, puedes ejecutar el comando

sudo apt-get install dh-make

Os pedirá que le introduzcáis el tipo de paquete (el single nos vale) y confirméis los datos. Si el nombre de vuestro directorio raiz no hubiese sido el correcto, este comando no se habría podido ejecutar. Os invito a que hagáis la prueba, y le quitéis la versión.

Después de haber toqueteado por vuestra cuenta el directorio (¡cuidado con no romper nada!) debería haberos quedado algo así:

Si tenéis algo similar, vais por buen camino.

Creación del paquete Debian «deb»

Este punto lo vamos a desglosar en dos partes. Todo dependerá de si dispones de una clave GPG para firmar el paquete, pero en caso de no tenerla también te explicamos cómo empaquetar tu aplicación.

¡Yo no tengo la clave GPG!

No te preocupes, no la necesitas. Accede a la carpeta raiz de nuestro programa (sí, donde están el binario y la carpeta «debian») y, suponiendo que ya creaste el «orig» en el paso anterior, ejecuta un Terminal desde dentro de este directorio. Escribe lo siguiente:

debuild -D

Si no lo tienes instalado:

sudo apt-get install devscripts build-essential lintian

¡Voilà! Tras un rato de ver líneas y líneas de código por la consola, tu «deb» se habrá generado en el exterior de la carpeta raiz (junto con unos cuantos archivos más).

¿Clave GPG? La tengo, ¿ahora qué?

Si tienes la clave GPG porque tu intención es firmar el paquete para subirlo a Launchpad o similares, necesitarás este comando:

debuild -S

Asumiendo que ya tienes la clave GPG asignada a tu usuario, con este comando empaquetarás tu «deb» y además lo firmarás. Si además de esto quieres subir el Debian a tu Launchpad, introduce (subiendo un nivel el directorio para salir del raiz) la siguiente instrucción:

dput ppa:nombreusuario/nombrerepositorio nombreprogramaversion_sources.changes

Según vayas sacando nuevas versiones para tú programa python es necesario ejecutar el siguiente comando para actualizar los ficheros:

dpkg-source --commit

Espero que hayáis generado el paquete Debian con éxito ;)