COMO contruir un paquete Debian Alvaro Alea (aleasoft@geocites.com) V0.1alpha ,4 de Marzo de 1999 En esta pequeña guia aprenderemos como construir un paquete debian a partir del codigo fuente de un programa para linux. ______________________________________________________________________ Índice general 1. Introducion 2. Entender los makefiles 3. Preparar el arbol de directorios: 4. Descomprimir un paquete ya debianizado 5. Preparar las fuentes para compilar 6. Mas secciones ______________________________________________________________________ 11.. IInnttrroodduucciioonn Los paquetes .deb utilizados por debian en sus distribuciones de sistemas operativos ( Linux ¿ y Hurd? ) son basntante faciles de realizar, e incorporan algunas ventajas con respecto a su "oponente" RPM. Cuando afronte el construir algun paquete para un par de programas de los que tenia fuentes, y no encontre el fichero .deb, me encontre con poca documentacion y en ingles, con este COMO, pretendo esplicar los pasos basicos para la generacion de un paquete, aprobechando algunas de las utilidades que proporciona debian para estas cosas, hay mas metodos, se pueden generar otro tipo de paquetes, y hay cosas que no toco ( supondre que estamos debianizando una aplicacion para el usuario final, que no modifique gran cosa en el /etc ) pero creo que es un buen comienzo: Antes de nada, estos son los pasos "oficiales": · Lee (obligatoriamente) el manual de normas de Debian ("debian- policy") y el manual de empaquetamiento ("packaging manual"). · Toma el paquete fuente de GNU hello como ejemplo. · Los paquetes debhelper y debmake son opcionales, no estás obligado a usar ninguno de ellos. · Construye el paquete usando dpkg-buildpackage -rfakeroot · Cuando hayas terminado, usa lintian para comprobar que no has cometido ningún error de empaquetamiento. · Instálalo en tu máquina y comprueba que funciona. · Comprueba que la desinstalación también funciona. · En caso de duda, y preferentemente cuando no encuentres respuesta en los manuales correspondientes, puedes consultar en la lista debian-mentors. ( han sido cogido de la lista de correo spanish-debian-user ) que el autor me perdone ;-) 22.. EEnntteennddeerr llooss mmaakkeeffiilleess Una de las cosas que debes entender a fondo es el fichero rules, este fichero contiene todos los pasos que se van ha dar para la construcion de paquete, de manera que se pueda automatizar al maximo. Este fichero no es en realidad mas que otra cosa que un guion del make, similar a los fichero Makefile que se encuentran en muchos de los codigos fuente. Si estas familiarizado con los ficheros Makefile, quiza te puedas saltar esta seccion, echale un vistazo al del paquete hello, y si no lo ves claro sigue leyendo. Estos guiones, estan compuestos por una serie de objetivos, de objetivos que hay que hacer antes y de pasos necesarios para conseguir ese objetivo. Si alguna vez has recompilado el kernel ( supongo que si, no creo que de otra manera estubieses leyendo esto ), recordaras que haces make clean, make xconfig, clean, xconfig son objetivos, y make que es el programa que interpreta los guiones, se encarga de cumplir esos objetivos. Veamos ahora algunas partes: ______________________________________________________________________ #!/usr/make -f ______________________________________________________________________ Esta linea, tiene que ser la primera y simplemente sirve para que, despues de dar permisos de ejecucion al fichero, podamos ejecutarlo directamente, de otra manera tendriamos que ejecutar make -f nombre del fichero (make busca por defecto el fichero Makefile, si el guion tiene otro nombre hay que indicarselo). ______________________________________________________________________ # Esto es un gracioso comentario ;-) ______________________________________________________________________ Creo que no hace falta decir mas. ______________________________________________________________________ objetivo: objetivo_anterior_a_realizar otro_objetivo paso uno a ejecutar - un paso que no importa que falle otro paso mas ______________________________________________________________________ Aqui tenemos una definicion completa de los pasos a realizar para conseguir un objetivo, pero antes definamos objetivo: Objetivo es un fichero, asi de simple, si ese fichero existe entonces make considera que no es necesario volver a hacerlo, y acaba. Si ese fichero no existe, entonces primero mira a ver si son necesario otros objetivos antes que ese ( son las palabras que aparecen en esa linea tras los dos puntos. Si todos los objetivos anteriores estan cumplidos empieza a ejecutar los pasos necesarios, notese que es MUY IMPORTANTE que EL PRIMER CARACTER de las lineas de pasos SEA UN TABULADOR ya que de otra manera no funciona. Los pasos los ejecuta como si los teclease en la linea de comandos, en esto se comporta parecido a un guion del bash. Un detalle interesante es que si cualquiera de los pasos falla, el make para la construcion del objetivo y muestra un mensaje de error. una escepcion a esto es cuando antes del comando hay un guion '-' en este caso make continuara aunque falle el paso. De manera similar a los guiones del bash podemos definir variables, y usarlas si ponemos $(nombre). Otra cosa que se puede hacer definir varias acciones a una variable, si usamos ______________________________________________________________________ define nombre pasos de los que consta nombre mas pasos endef ______________________________________________________________________ Analicemos ahora un trozo de un fichero rules para aclarar un par de cosas: ______________________________________________________________________ #!/usr/bin/make -f # based on the sample debian/rules file for GNU hello by Ian Jackson. # I used debmake, but I change it a lot. # Alvaro Alea, 1999, package=siag build: $(checkdir) ./configure --prefix=/usr make CFLAGS="-O2 -g -Wall" touch build ______________________________________________________________________ Fijese en que para construir build se dan cuatro pasos, primero se ejecuta $(checkdir) que es definido mas adelante ( no importa el orden ) Despues se ejecuta ./configure --prefix=/usr, note que todas las ordenes del rules se suponen que estan realizadas desde el raiz del codigo fuente, aunque el fichero rules se encuentra en el directorio debian que cuelga de este. luego se llama a make ( se puede llamar recursivamente sin problemas ) que como no se le pasan el fichero a usar, utilizara el Makefile que halla en el directorio raiz del codigo fuente, y como no se le pasa ningun objetivo ejecutara el primero que pille, el tercer detalle es que es posible sobreescribir las definiciones de variables desde fuera, en este caso CFLAGS . despues hay un touch build, touch actualiza la fecha del fichero que se le pase como parametro, y si no existe, crea uno de 0 bytes, notese que build es tambien el nombre del fichero objetivo, esto se hace por que aunque el objetivo se llama build, lo normal es que el fichero que se cree se llame de otra forma. ______________________________________________________________________ clean: $(checkdir) -rm -f build -make distclean dh_clean ______________________________________________________________________ Aqui lo unico destacable es que el objetivo clean, aparte de ejecutar las ordenes necesarias para limpiar el arbol de codigo fuente, borra build ( solo si existe, tiene un guion antes para indicar que continue si falla al borrarlo). ______________________________________________________________________ binary-indep: checkroot build $(checkdir) ______________________________________________________________________ En este objetivo vemos como antes de realizarlo, realiza checkroot ( por cuestiones de permisos, para construir ciertas partes del paquete es necesario ser root, o al menos parecerlo ) y despues build, para continuar con el proceso. ______________________________________________________________________ . . . .PHONY: binary binary-arch binary-indep clean checkroot ______________________________________________________________________ La ultima linea indica que objetivos no van a crear un fichero con el nombre del objetivo, normalmente se deja como esta. Y para acabar, no estaria de mas que le echases un vistazo al rules del paquete hello, a la pagina man del make (que esta en español) y la ayuda que ofrece el programa info ( que es la que se actualiza ). 33.. PPrreeppaarraarr eell aarrbbooll ddee ddiirreeccttoorriiooss:: lo primero create un directorio para trabajar, y entra en el, cuando crees el paquete, te generaran cuatro o cinco ficheros, y no esta bien enguarrar tu home. El siguente paso es descomprimir los fuentes en este directorio, si el que los hizo era un poco civilizado, te habra creado otro directorio con el nombre del fichero, bien, si no es asi create otro y muevelo todo a el. Este directorio tiene que tener un nombre del tipo -, no se si es demasiado buena idea tener espacios por el medio, la version suele ser la que de el autor, y las posibles subversiones deberias separarlas por puntos. Ahora coge el fichero original comprimido, si era del tipo tar.gz ( .tgz ) bien, copialo al directorio de trabajo, y si no, ya sabes: tar zcvf nombre.tar.gz * El nombre de este fichero tiene que ser _.orig.tar.gz Esto es importante, el nombre del directorio tiene que estar separado de la version por un guion '-' pero el tgz tiene que ser con un subrayado '_' y despues tiene que aparecer .orig.tar.gz , asi, si pones _orig.tgz ya no vale. ¿ y si es un paquete especial para debian y no tengo el fuente ? bien, en ese caso no crees el fichero, veras, cuando creas el paquete, el programa se encarga de ver si existe ese fichero, si existe simplemente crea un fichero con las diferencias al original, pero si no existe ( o el nombre estaba mal puesto ) te creara el tgz, y a mi personalmente me pueteaba un poco al principio, hasta que entendi como iba el tema, y por que me creaba otro tgz. Ahora tienes dos opciones, o escribes debmake y dejas que el programa cree el directorio debian dentro de las fuentes y ponga unos ficheros de ejemplo, o te lo creas tu y lo rellenas tu, por ahora creo que mejor ejecutabas ese programa, y le echabas una ojeada a todo lo que creo el fichero. 44.. DDeessccoommpprriimmiirr uunn ppaaqquueettee yyaa ddeebbiiaanniizzaaddoo Si tienes la version completa en CD de debian ( y si no lo puedes conseguir por FPT en los principales mirrors ), tendras tambien el codigo fuente, por lo menos era interesante que consiguieses el del paquete hello, aunque otro cualquiera podria valer. El caso es que seria interesante conseguir el codigo fuente a partir de estos ficheros comprimidos con su directorio debian y todo lo demas ya echo, esto es muy sencillo: Necesitamos tres ficheros, que son: Las fuentes comprimidas, en formato tar.gz, por ejemplo hello_x.x.orig.tar.gz Las modificaciones de las fuentes, hello_x.x-x.diff.gz La descripcion del paquete, hello_x.x-x.dsc ahora create un directorio para trabajar y copia los tres ficheros a ese directorio, y estando en el ejecuta dpkg-source -x hello_x.x- x.dsc, que te descomprimira las fuentes, y las modificara para crear el paquete debian. Eso es todo. 55.. PPrreeppaarraarr llaass ffuueenntteess ppaarraa ccoommppiillaarr El proceso de creacion de un packete debian son tres pasos: 1. Compilacion de los fuentes 2. Instalacion de los binarios 3. Preparacion del fichero .deb Lo primero que tienes que hacer es comprobar que las fuentes compilan, y anotar en un papel, fichero o donde quieras los pasos que hay que hacer para ello. Modifica las fuentes de manera que compilan solas, sin interacion con el usuario a ser posible. En unas fuentes tipicas seria algo similar a : ______________________________________________________________________ #./configure #make ______________________________________________________________________ Apunta tambien los pasos necesarios para limpiar las fuentes de binarios, temporales, fichero objeto y cualquier otra cosa que se genere en la compilacion. En algunos casos bastaria con: ______________________________________________________________________ #make clean ______________________________________________________________________ Tambien puede ser necesario que modifiques las fuentes para que funcionen en los directorios adecuados ( hay varios documentos que describen donde deben ir las cosas, creo que debian tiene uno, y hay un COMO FSSTS o algo asi por hay traducido, si alguien tiene datos concretos que me avise, gracias... ) Por ejemplo muchas fuentes estan preparadas para instalarse en /usr/local, y en los directorios que cuelgan, en debian deberian hacerlo de /usr, segun las fuentes sera una tarea mas o menos complicada. Por ultimo hay que instalarlas, bien, esto requiere calma, vamos por pasos: Cuando se crea un paquete, dentro del directorio debian, se crea automaticamente un directorio tmp, y dentro de este DEBIAN, en este ultimo ira informacion necesaria para la construcion del paquete, eso ya lo veremos, pero tmp sera el raiz donde hay que instalar todos los fichero de los que consta el paquete, generando los directorios que sean necesarios, asi un paquete cualquiera, vamos a llamarlo abptdn (``a big program that do nothing'' para los mas curiosos) podria generar algo asi: ______________________________________________________________________ abptdn \-debian \-tmp +-DEBIAN \-usr +-bin +-man | \-man1 \-doc \-abptdn ______________________________________________________________________ Tendras que apuntar los comandos necesarios para generar el arbol de directorios adecuado, y copiar los ficheros al mismo. Si las fuentes usan ¿automake?, ( es decir si el proceso de compilacion consiste en ./configure y make ) existira un objetivo del Makefile, make install que te instalara todos los fichero necesarios, investiga que parametros hay que pasarle para que te lo instale a partir de debian/tmp en lugar de en el raiz de tu disco. Las fuentes ya estan preparadas, ahora toca crear o ajustar los fichero necesarios para que el programa genere el paquete. 66.. MMaass sseecccciioonneess