Creación automática de paquetes

+1
0
-1

Le falta muy poco. Pero Ubuntu no es perfecta. Hay paquetes que no tiene, o que tiene en una versión anterior a la que a tí te gustaría, o compilados con opciones distintas a las que tú quieres (aunque esto es menos común). Todos sabemos que hay una solución a esto: bajarse el fuente, descomprimir y compilar. El ./configure y el make están muy bien, le permiten a uno pensar que es un mostruo, sólo porque compila (con un script totalmente automatizado) lo que otros han escrito y mira las crípticas salidas como si entendiera algo. Cuando ejecutas el sudo make install, ya es otra cosa, un sudor frío te recorre el espinazo poque sólo Dios sabe cómo podrás desinstalar ese programa el día que te aburras de él, o qué pasará si desinstalas algún paquete del que éste dependa. Y es que, siendo una de las mejores cosas que hay en Casa Debian, no parece muy inteligente no usar su magnífico sistema de paquetes. Así que voy a explicaros cómo crear un .deb a partir del típico .tar.gz de código fuente, para a posteriori instalarlo as usual con dpkg, apt-get, etc. con las ventajas que ello trae.

¿Cuáles son esas ventajas?

La prime, ya la he dicho. Te quedas dentro del sistema de paquetes y dependencias. La segunda, que puedes pasarle a alguien el paquete, o colgarlo en alguna web, y le evitas el coñazo que es compilarlo (no nos engañemos).

Así pues, al lío.

Notas previas

  • Yo esto lo he probado en Ubuntu, y lo escribo en ubuntu-es, pero debería valer para cualquier Debian, tal y como ya he dejado caer.
  • Mi conocimiento sobre esto es absolutamente empírico, lo cual significa que probablemente me deje detalles importantes. Corríjanme. Aun así, me funciona razonablemente bien.
  • Asumo que los que lo estáis leyendo sabéis lo mínimo del mencionado proceso ./configure && make && sudo make install y del sistema de paquetes de Debian. Si no, puede que os lieis un poco.

Ingredientes

  • El código fuente de algún programa, el que más rabia os de (yo lo he hecho con Planner, que en Warty viene la 0.11 y necesito una característica de la 0.12) típicamente en formato .tar.gz (o .tar.bz2, o cualquier otro). Descomprimirlo con tar xzf paquete.tar.gz y entrad al directorio que se creará con cd paquete.
  • Tener instalados los paquetes debmake, fakeroot y devscripts. Puede que me olvide alguno que ya tuviera instalado cuando inicié mi investigación, si algo falla poned un comentario.

El proceso
Lo primero, debianizar el paquete. Algunos paquetes pueden venir debianizados de serie, de modo que os podréis saltar este paso. Si tenéis un directorio que se llame debian y dentro de él, como mínimo, un archivo llamado rules, es que está debianizado.

Para debianizarlo, ejecutad deb-make native. La opción native es para que no genere un archivo .orig, con registro de cambios y movidas. Por lo que sé, si no váis a meter vuestro paquete en alguna infraestructura seria, no lo necesitaréis.

Nos van a preguntar qué tipo de paquete es. Lo normal es S (Single Binary), aunque siempre depende de lo que estéis compilando, claro. A mí no me miréis, vosotros sabréis. Leed man deb-make si tenéis dudas.

deb-make toma el mantenedor (toma palabro) del paquete de la variable $MAIL, así que si la tenéis bien definida, mejor que mejor.

Bien, ya tenemos el famoso debian/rules de las camisetas. Pues a editarlo: $ vim debian/rules. No os esforcéis en usar un editor que no sea vim: no va a funcionar =;-)

¿Qué queremos editar en debian/rules? Pues principalmente (yo diría que únicamente) la linea del ./configure. Poned ahí (sin quitar el --prefix=/usr, ya sabéis que en Debian los programas van ahí) las opciones que sean oportunas (para conocerlas, ya sabéis: $ ./configure --help).

Estamos listos para compilar. El comando es debuild. Es un script de front-end a otros varios comandos, así que el habitualmente ingente número de opciones de los comandos Unix se multiplica por 5 o 6. Pongo una minimísima parte que a mí me ha sido de utilidad:

  • -m: dirección de correo del mantenedor (para saltarse la que cogió deb-make de la variable $MAIL)
  • -us -uc (las dos): no firmar el paquete con GPG (si no se especifica, lo intenta firmar con la clave de la dirección del mantenedor)

Guau, incluso menos opciones de las que creía que iba a poner. Más información en man debuild y man dpkg-buildpackage.

Pues bien, lanzado el comando debuild se inicia la compilación propiamente dicha, ya sabéis, ese proceso de ensayo y error de repetición semi-infinita en la cual el ./configure o el make se paran porque falta alguna biblioteca, la instalas con apt-get y vuelves a ejecutar, en este caso, debuild.

Pues nada, si todo termina con éxito, fuera (muy importante, no os volváis locos) del directorio de código fuente tendréis vuestro .deb (junto con una serie de "archivos intermedios" que, si no me engaño, podéis borrar con tranquilidad), con un nombre, cabecera y dependencias bastante razonables listo para instalar con dpkg, apt-get, etc.

Salvo error u omisión (comentarios bienvenidos).

Comentarios

Imagen de Anónimo

Es un programa que hace lo que tu quieres
./configure
make
checkinstall (en vez de makeinstall)

te construye el paquete .deb solo, y asi lo puedes desinstalar cuando quieras (te lo instala)
Saludos

Imagen de Anonimo

Sí he probado checkinstall, lo usaba todo el rato en Mandrake, y al principio de usar Ubuntu también, pero me parece que el método debuild es superior por varias razones.

El primer argumento es un argumento de autoridad, que a mí no me suelen gustar pero en fin, aquí lo dejo por si a alguien le convence: es el método que usan los desarrolladores de Debian (supongo que también los de Ubuntu). Por algo será.

Siendo un poco más serios, me gusta más el método debuild por flexibilidad y potencia. checkinstall y debuild están igualados por abajo. Currándonoslo lo mínimo, la cosa es bastante parecida.

$ ./configure <opciones>
$ make
$ sudo checkinstall

Contra

$ deb-make
$ vim debian/rules (para escribir esas <opciones>)
$ debuild

Misma dificultad, mismo tiempo, mismo resultado (con la salvedad de que debuild maneja que te cagas y de forma automática las dependencias del paquete, cosa que no sé qué tal hace checkinstall; daremos el beneficio de la duda y lo dejamos en empate).

Sin embargo, con checkinstall no puedes hacer mucho más (que yo sepa). Con debuild la cosa no ha hecho más que empezar, y así, en el paso de vim debian/rules puedes hacer millones de cosas, como por ejemplo:

  • Automatizar la creación de cosas como entradas de menú, asociaciones de tipos MIME, etc.
  • Incluir archivos que no sean resultado del make install, al estilo de lo que he explicado antes
  • Crear automáticamente scripts de instalación que pregunten cosas a través de debconf
  • Crear varios paquetes a partir de un sólo código fuente (típicamente: noseque, libnoseque, noseque-doc, libnoseque-dev, etc.)
  • Mogollón de cosas más que ni me imagino

De todas ellas no hablé en la entrada original porque no las domino, pero como ando investigando en cuanto sepa más y tenga tiempo os las cuento =;-)

Imagen de porras

Mismo patinazo: el comentario es mío =:-P

Imagen de Anónimo

Donde bajo deb-make?

Imagen de ErCarlos

¿Y para crear un paquete que me cree una entrada de menu como lo tengo que hacer?

Imagen de Anónimo

Si por ejemplo quiero una paquete que instale, no sé, temas que se copien en /usr/share/themes, sin partir de un código fuente ¿qué se tendría que hacer?

Imagen de Anónimo

Esto es bastante sencillo, se parece bastante a comprimir en un zip o cosa así, los pasos serían, más o menos:

  1. Crea un directorio para el paquete (mkdir mipaquete)
  2. Crea en el la estructura de directorios y archivos que quieras que estén en el paquete (vamos, que crees mipaquete/usr/share/themes/ y metas en él los archivos).
  3. Crea el directorio mipaquete/DEBIAN y en él, el archivo control. Este archivo contiene información de versión, descripción, dependencias, etc. Aquí tienes un ejemplo que acabo de encontrar con google:
  4. Package: acme
    Version: 1.0
    Section: web 
    Priority: optional
    Architecture: all
    Essential: no
    Depends: libwww-perl, acme-base (>= 1.2)
    Pre-Depends: perl 
    Recommends: mozilla | netscape  
    Suggests: docbook 
    Installed-Size: 1024
    Maintainer: Joe Brockmeier [jzb@dissociatedpress.net]
    Conflicts: wile-e-coyote
    Replaces: sam-sheepdog
    Provides: acme
    Description: The description can contain free-form text
                 describing the function of the program, what
                 kind of features it has, and so on.
    
  5. Sal del directorio y ejecuta dpkg -b mipaquete/. Ya está.
Imagen de porras

Patinazo, el comentario es mío =:-P

Imagen de manwy

¿Y como instalas un paquete deb con apt-get o con synaptic?

Imagen de porras

Pues que yo sepa, directamente no se puede, sólo creando un repositorio y añadiéndolo en /etc/apt/sources.list o con el menú de Synaptic. Eso también es muy sencillito, otro día lo explico. Mientras, ya sabéis, dpkg -i.

Imagen de porras

Hum, me ha dado por ahí y, en el mismo directorio de fuentes del planner que os comenté, he ejecutado el checkinstall. El paquete se ha creado sin problemas. Pero revisándolo... ¡no tiene dependencia alguna! De modo que el beneficio de la duda que le dimos, hay que quitárselo fulminantemente. Así, ni siquiera en el escenario más sencillo posible podemos hablar de empate. Sólo por eso de las dependencias, me parece mucho mejor usar debuild.

Imagen de mob

En hoary, cuando instalo los paquetes debmake devscripts y fakeroot, cuando trato de hacer "deb-make native" no existe el deb-make y por mas que lo busco en los paquetes instalados, no lo encuentro

Se ocupara otra cosa en Hoary?

Saludos!

~~ MoB ~~

Saludos!

~~ MoB ~~

Imagen de Anónimo

deb-make se ha vuelvo obsoleto y no van a seguir manteniédolo más. Su función la hará a partir de ahora dh_make (está en el paquete "dh-make")