Re: [maint-guide] Actualización - para revisión
Hola!
Aquí está el documento para revisión.
Tiene un par de traducciones un poco forzadas, pero están comentadas junto con
lo que dice en ingles, a ver que se os ocurre que quede mejor.
Un saludo,
Ana
El Miércoles, 15 de Diciembre de 2004 00:01, Javier Fernández-Sanguino Peña
escribió:
> On Tue, Dec 14, 2004 at 01:18:07AM +0100, Anja wrote:
> > Igualmente, ya mandaré el archivo a la lista por si alguien más le quiere
> > hechar un ojo.
>
> En realidad, la revisión de los documentos dentro de la lista es "condición
> sine qua non" para que los documentos se publiquen :-)
>
> Saludos
>
> Javier
<!doctype debiandoc system>
<!-- comentarios:
* URL's a package manual?
* por qué a veces usa tt y otras no para los programas ?
-->
<debiandoc>
<book>
<titlepag>
<title>Guía del Nuevo Desarrollador de Debian</title>
<author>Josip Rodin <email/joy-mg@debian.org/
</author>
<author>Traducido por:
Javier Fernández-Sanguino Peña <email/jfs@computer.org/
</author>
<author>Traducido por:
David Martinez <email/david.martinez@rediris.es/
</author>
<!--
<author>Traducido por:
Ana Beatriz Guerrero López <email/anja_isbilia@yahoo.es/
</author>
-->
<version>versión 1.2, 6 de Abril 2001.</version>
<copyright>
<copyrightsummary>Copyright © 1998-2002 Josip Rodin.
Translation Copyright © 1999, 2000, 2001 Javier Fernández-Sanguino Peña.</copyrightsummary>
<p>Este documento puede ser usado en los términos descritos en
la Licencia Pública GNU versión 2 o posterior.
<p>Este documento se ha hecho usando estos dos documentos como
ejemplo:
<p>Making a Debian Package (AKA the Debmake Manual), copyright ©
1997 Jaldhar Vyas.
<p>The New-Maintainer's Debian Packaging Howto, copyright © 1997
Will Lowe.
</copyright>
</titlepag>
<toc sect>
<chapt id="start">Empezando "de la Forma Correcta".
<p>Este documento tratará de describir cómo se construye un paquete
Debian GNU/Linux para el usuario común de Debian (y futuros
desarrolladores) en un lenguaje informal, y con multitud de
ejemplos. Hay un antiguo dicho romano que dice, <em>¡Longum iter est
per preaecepta, breve et efficax per exempla!</em> (¡Es un largo
camino con las reglas, pero corto y eficiente con ejemplos!)
<p>Una de las cosas que hace a Debian una de las distribuciones más
importantes del mercado, es su sistema de paquetes. Aunque hay una
gran cantidad de programas disponibles en forma de paquetes de
Debian, algunas veces, necesitarás instalar programas que no estén
disponible en este formato. Puedes que te preguntes cómo harás
tus propios paquetes y que pienses que
quizás ésta sea una tarea demasiada difícil. Bueno, si eres un
principiante en Linux, sí es duro, pero si eres un novato, no
deberías estar leyendo esto ahora mismo. :-) Necesitas saber algo
sobre programación en Unix, pero desde luego no tienes que ser un
maestro.
<p>Sin embargo, hay una cosa que es verdad: para crear y mantener
paquetes Debian adecuadamente, necesitarás muchas horas.
Para que nuestro sistema trabaje sin errores, nuestros mantenedores
necesitan ser técnicamente competentes y concienzudos.
<p>Este documento explicará cada pequeño paso (al principio quizás
irrelevantes), y te ayudará a crear tu primer paquete, ganar
alguna experiencia en construir próximas versiones de él, y quizás
otros paquetes después.
<p>Se pueden obtener versiones nuevas de este documento en línea
en <url name="http://www.debian.org/doc/maint-guide/";
id="http://www.debian.org/doc/maint-guide/";> y en el paquete
'maint-guide-es'.
<sect id="needprogs">Programas que necesitas para el desarrollo.
<p>Antes de empezar nada, deberías asegurarte que tienes instalados
algunos paquetes adicionales necesarios para el desarrollo. Observa
que en la lista no están incluidos paquetes cuyas prioridades son `esencial' o
`requerido' que se suponen ya instalados.
<p>En la revisión de este documento se han actualizado los paquetes
para Debian 2.2 (`potato') y 3.0 (`woody').
<p>Los siguientes paquetes vienen en una instalación estándar de
Debian, así que probablemente ya los tengas (junto con los
paquetes de los que dependen). Aún así, deberías comprobarlo con
`dpkg -s <paquete>`.
<list>
<item><package/dpkg-dev/ - este paquete contiene las herramientas
necesarias para desempaquetar, construir y enviar paquetes fuente de
Debian. (vease <manref name="dpkg-source" section="1">)
<item><package/file/ - este útil programa puede determinar de qué
tipo es un fichero. (vease <manref name="file" section="1">)
<item><package/gcc/ - el compilador de C de GNU, necesario si tu
programa como la gran mayoría, está escrito en el lenguaje de
programación C. (vease <manref name="gcc" section="1">,
Este paquete también vendrá con otros paquetes como
<package/binutils/ que incluye programas para ensamblar y enlazar
ficheros ficheros objeto
(vease `info binutils` en el paquete <package/binutils-doc/)
y el preprocesador de C en el paquete <package/cpp/.
(vease <manref name="cpp" section="1">)
<item><package/libc6-dev/ - las librerías y archivos de cabecera de C
que gcc necesita para enlazar y crear ficheros objeto.
(vease `info libc` en el paquete <package/glibc-doc/)
<item><package/make/ - habitualmente la creación de un programa consta de
varios pasos. En lugar de ejecutar los mismos comandos una y otra
vez, puedes utilizar este programa para automatizar el proceso,
creando `Makefile's. (vease `info make`)
<item><package/patch/ - esta utilidad es muy práctica, ya que permite
tomar un fichero que contiene un listado de diferencias (producido
por el programa diff) y aplicárselas al fichero original,
produciendo una versión "parcheada". (vease <manref name="patch"
section="1">)
<item><package/perl/ - Perl es uno de los lenguajes interpretados
para hacer guiones (scripts) más usados en los sistemas Un*x de hoy
en dia, comúnmente se refiere a él como la "Navaja Suiza de Unix".
(vease <manref name="perl" section="1">)
</list>
<p>Probablemente, necesitarás instalar además los siguientes paquetes:
<list>
<item><package/autoconf/ y <package/automake/ - muchos programas
nuevos usan guiones de configuración y Makefiles procesados con la
ayuda de programas como estos.
(vease `info autoconf`, `info automake`)
<item><package/dh-make/ y <package/debhelper/ - dh-make es necesario
para crear el esqueleto de nuestro paquete ejemplo, y se usarán
algunas de las herramientas de debhelper para crear paquetes. No son
imprescindibles para la creación de paquetes, pero se recomiendan
<strong>encarecidamente</strong> para nuevos desarrolladores. Hace
el proceso mucho más fácil al principio, y más fácil de controlar
también más adelante. (vease <manref name="dh_make" section="1">,
<manref name="debhelper" section="1">,
/usr/share/doc/debhelper/README)
<item><package/devscripts/ - este paquete contiene algunos guiones
útiles para los desarrolladores, pero no son necesarios para crear
paquetes. (vease /usr/share/doc/devscripts/README.gz)
<item><package/fakeroot/ - esta utilidad te permite emular ser root
(superusuario, n. del t.), lo cual es necesario para ciertas partes
del proceso de construcción. (vease <manref name="fakeroot"
section="1">)
<item><package/gnupg/ - herramienta que te permite <em>firmar</em>
digitalmente los paquetes.
Esto es especialmente importante si quieres distribuir tu paquete
a otras personas, y ciertamente, harás esto cuando tu trabajo sea
incluido en la distribución de Debian.
(vease <manref name="gpg" section="1">)
<item><package/g77/ - el compilador GNU de Fortran 77,
necesario si tu paquete está escrito en Fortran.
(vease <manref name="g77" section="1">)
<item><package/gpc/ - el compilador GNU de Pascal,
necesario si tu paquete está escrito en Pascal.
Merece la pena mencionar aquí <package/fp-compiler/,
un compilador libre de Pascal, que también es bueno en esta tarea.
(vease <manref name="gpc" section="1">, <manref name="ppc386" section="1">)
<item><package/imake/ and <package/xmkmf/ - algunos programas,
normalmente aquellos hechos para X11, también usan programas para
generar Makefiles de un conjunto de macrofunciones.
(vease <manref name="imake" section="1">, <manref name="xmkmf" section="1">)
<item><package/lintian/ - este es el comprobador de paquetes de Debian,
que te indica muchos de los errores comunes después de construir un
paquete, y explica los errores encontrados.
(vease <manref name="lintian" section="1">,
/usr/share/doc/lintian/lintian.html/index.html)
</list>
<p>Por último, esta documentación es de <em>gran importancia</em>
y debería leerse junto con este documento:
<list>
<item><package/debian-policy/ - incluye la estructura y contenidos
del archivo, ciertas notas sobre diseño del SO, el Estándar de la
Jerarquía del Sistema de Ficheros (Filesystem Hierarchy Standard,
n. del t.), y, lo más importante para ti, es que describe los
requisitos que debe satisfacer cada paquete para ser incluido en la
distribución. (vease
/usr/share/doc/debian-policy/policy.html/index.html)
<item><package/developers-reference/ - para todos los temas no
específicamente relacionados con los detalles técnicos de cómo
empaquetar, tales como la estructura del archivo, cómo renombrar,
abandonar, coger paquetes, cómo hacer NMUs (Non-Maintainer Uploads,
o envíos por personas distintas del desarrollador, n. del t.), como
gestionar los errores que los usuarios envíen, y cómo y cuando
enviar los paquetes, etc.
<!-- traduzco upload por "enviar" pero no me gusta mucho - jfs -->
(vease
/usr/share/doc/developers-reference/developers-reference.html/index.html)
</list>
<p>Las breves descripciones, dadas anteriormente, sólo sirven para
introducirte a lo que hace cada paquete. Antes de continuar, por
favor, lee la documentación de cada programa, al menos para su uso
normal. Puede parecerte algo duro ahora, pero más adelante estarás
<em>muy</em> contento/a de haberla leído.
<p>Nota: <package/debmake/ es una paquete que incluye otros programas
con funciones similares a dh-make, pero su uso específico
<strong>no</strong> está cubierto en este documento porque
está desaprobado su uso. Lee el <url
name="manual de Debmake" id="http://www.debian.org/~jaldhar/";> para
más información.
<sect id="otherinfo">Más información.
<p>Puedes construir dos tipos de paquetes, fuentes y binarios. Un
paquete fuente contiene el código que puede compilar en un programa.
Un paquete binario contiene sólo el programa terminado. ¡No mezcles
los términos como 'fuentes de un programa' y el 'paquete fuente de
un programa'! Por favor, lee los otros manuales si necesitas más
detalles sobre terminología.
<p>Debian usa el término `desarrollador' para la persona que hace
paquetes, `autor fuente' (`upstream author, n. del t.) para la
persona que hizo el programa, y `desarrollador fuente' (`upstream
maintainer', n. del t.) para la persona que actualmente mantiene el
programa fuera de Debian. Generalmente el autor y el desarrollador
fuente son la misma persona - y algunas veces incluso el
desarrollador es el mismo. Si haces un programa, y quieres
incluirlo en Debian, tienes total libertad para solicitar
convertirte en desarrollador.
<p>Después de construir tu paquete (o mientras lo haces), deberás
convertirte en un desarrollador oficial de Debian si deseas que tu
programa entre en la próxima distribución (si el programa es útil,
¿por qué no?). Este proceso se explica en la Referencia del
Desarrollador, por favor, léela.
<chapt id="first">Primeros pasos.
<sect id="choose">Elige tu programa.
<p>Probablemente hayas escogido ya el paquete que deseas construir.
Lo primero que necesitas hacer es comprobar si el paquete está ya
en la distribución.
Si usas la distribución `estable', quizás sea mejor que vayas a la <url
name="página de búsqueda de paquetes"
id="http://www.debian.org/distrib/packages";>. Si usas la <strong>actual</strong>
distribución `inestable', compruebalo con los comandos:
<example>
dpkg -s programa
dpkg -l '*programa*'
</example>
<p>Si el paquete ya existe, instalalo! :-) Si te encuentras con que
el paquete es huérfano (cuando su desarrollador es el "Debian QA Group"),
podrías adoptarlo.
Consulta
<url name="la lista de paquets huérfanos" id="http://www.debian.org/devel/wnpp/orphaned";>
y
<url name="la lista de paquetes en espera de adopción" id="http://www.debian.org/devel/wnpp/rfa_bypackage";>
para verificar que el paquete está libre.
<p>Si eres capaz de adoptar el paquete, bajate las fuentes (con algo como
<tt/apt-get source packagename/) y examínalas.
Este documento, desafortunadamente, no incluye información exhaustiva
sobre la adopción de paquete.
Afortunadamente no debería ser díficil entender como funciona el paquete
ya que alguien ha hecho el trabajo inicial por tí.
Aunque, sigue leyendo, muchos de los consejos de abajo serán aplicables
para tu caso.
<p>Si el paquete es nuevo, y decides que te gustaría verlo en Debian,
haz lo siguiente:
<list>
<item>comprueba que no hay nadie más ya trabajando en el paquete en
<url name="la lists de paquetes en los que se está trabajando" id="http://www.de.debian.org/devel/wnpp/being_packaged";>.
Si ya hay alguien trabajando en el paquete, contacta con esa persona
si lo crees conveniente.
Si no, intenta encontrar otro programa interesante que nadie mantenga.
</item>
<item>el programa <strong>debe</strong> tener una licencia, si es
posible, libre en el sentido marcado por las
<url name="Directrices de Debian para el software libre"
id="http://www.debian.org/social_contract.html#guidelines";>.
Si no sigue una de estas reglas, aún puede incluirse en las
secciones `contrib' o `non-free' de Debian. Si no estás seguro/a sobre
en qué lugar debería ir, envia el texto de la licencia a
<email/debian-legal@lists.debian.org/ y pide consejo.
</item>
<item>el programa <strong>no</strong> debería ejecutarse con setuid
root, o aún mejor: no debería tener ningún programa 'setuid' ni
'setgid'.</item>
<item>el programa no debería ser un demonio, o algo que vaya en los
directorios */sbin, o abrir un puerto como root.</item>
<item>el programa debería estar compuesto por binarios ejecutables,
no lo intentes aún con librerías.</item>
<item>debería tener una buena documentación, o al menos un código
legible, no ofuscado.
</item>
<item>deberías contactar con los autores del programa para
comprobar si están de acuerdo con que se empaquete. Esto es
importante para poder consultar estos autores sobre el programa
en caso de que haya problemas específicos, así que no intentes
empaquetar programas que no estén mantenidos.</item>
<item>y por último pero no menos importante, deberías saber cómo
funciona, y haberlo utilizado durante algún tiempo.</item>
</list>
<p>Por supuesto, esta lista es para tomar medidas de seguridad, y
con la intención de salvarte de usuarios enfurecidos si haces algo
mal con algún demonio setuid... Pero cuando tengas más experiencia
en empaquetar cosas, podrás hacer este tipo de paquetes,
incluso los desarrolladores más experimentados preguntan en la
lista de distribución de debian-devel cuando tienen dudas. La
gente allí te ayudará gustosamente.
<p>Para más ayuda sobre esto, lee la Referencia del Desarrollador.
<sect id="getit">Obtén el programa, y pruébalo.
<p>La primera cosa a hacer es encontrar y descargar el paquete
original. Supongo que ya tienes el código fuente que obtuviste de la
página del autor. Las fuentes de los programas gratuitos de Linux
generalmente vienen en formato tar/gzip, con extensión .tar.gz, y
generalmente contienen un subdirectorio llamado programa-versión
con todas las fuentes en él. Si tu programa viene en otro tipo de
archivo (por ejemplo, el fichero termina en ".Z" o ".zip"),
descomprímelo con las herramientas adecuadas, o pregunta en
debian-mentors si no estás seguro de cómo se puede desempaquetar
correctamente (pista: prueba `file archivo.extensión`).
<p>Como ejemplo, usaré el programa conocido como `gentoo', un gestor
de ficheros de X11 en GTK+. Observa que el programa ya ha sido
empaquetado previamente pero ha cambiado sustancialmente de versión
desde que este texto se escribió.
<p>Crea un subdirectorio bajo tu directorio personal llamado
'debian' o 'deb' o lo que creas apropiado (por ejemplo ~/gentoo/
estaría bien en este caso) Y mueve a él el archivo que has
descargado, y descomprímelo de la siguiente forma: `tar xzf
gentoo-0.9.12.tar.gz`. Asegúrate de que no hay errores, incluso
errores "irrelevantes", porque es muy probable que haya problemas
desempaquetando en sistemas de otras personas, cuyas herramientas de
desempaquetado puede que no ignoren estas anomalías.
<p>Ahora tienes otro subdirectorio, llamado 'gentoo-0.9.12'.
Muévete a ese directorio y lee <strong>en profundidad</strong> la
documentación que encuentres. Está generalmente en ficheros que se
llaman README*, INSTALL*, *.lsm o *.html. Allí encontrarás
instrucciones de cómo compilar e instalar el programa (muy
probablemente asumirán que lo quieres instalar en el directorio
/usr/local/bin: no harás esto, pero eso lo veremos más adelante en
<ref id="destdir">).
<p>El proceso varía de programa a programa, pero gran parte de los
programas modernos vienen con un guión 'configure' que configura
las fuentes para tu sistema y se asegura de que tu sistema está en
condiciones de compilarlo. Después de configurarlo (con
`./configure`), los programas generalmente se compilan con `make`.
Algunos de ellos soportan `make check` para ejecutarse incluyendo
comprobaciones automáticas. Generalmente se instalarán en sus
directorios de destino ejecutando `make install`.
<p>Ahora intenta compilar, y ejecutar el programa, para asegurarte
de que funciona bien y que no rompe nada más mientras está
instalándose o ejecutándose.
<P>También, generalmente, puedes escribir `make uninstall` para
eliminar todos los programas instalados, y `make clean` (o mejor
`make distclean`) para limpiar el directorio donde se genera el
programa.
<sect id="namever">Nombre del paquete y versión
<P>Deberías empezar a construir tu paquete en un directorio de
fuentes completamente limpio, o simplemente con las fuentes recién
desempaquetadas.
<p>Para construir correctamente el paquete, debes cambiar el nombre
original del programa en letras minúsculas (si no lo está ya), y
deberías renombrar el directorio de fuentes a
<nombre_de_paquete>-<versión>.
<P> Si el nombre del programa son varias palabras, contraelas a una
palabra o haz una abreviatura. Por ejemplo, el paquete del programa
"el editor para X de Javi" se podría llamar javiedx o jle4x, o lo
que decidas, siempre y cuando no se exceda de unos límites
razonables, como 20 caracteres.
<p>Comprueba también la versión exacta del programa (la que se
incluye en la versión del paquete). Si el programa no está numerado
con versiones del estilo de X.Y.Z, pero con fecha de lanzamiento,
eres libre de utilizar la fecha como número de versión, precedida
por "0.0" (sólo por si los desarrolladores originales deciden sacar
una versión nueva como 1.0). Así, si la fecha de las fuentes es el
19 de diciembre de 1998, puedes utilizar la abreviatura
norteamericana 0.0.19981219 como número de versión.
<p>Aún así habrá
algunos programas que ni siquiera estén numerados, en cuyo caso deberás
contactar con el 'desarrollador fuente' para ver si tienen algún
otro sistema de seguimiento de revisiones.
<sect id="dh_make">'Debianización' inicial.
<p>Asegúrate que estás en el directorio donde están las fuentes del
programa, y ejecuta lo siguiente:
<p><example>
dh_make -e tu.dirección@de.desarrollador -f ../gentoo-0.9.12.tar.gz
</example>
<p>Por supuesto, cambia la cadena
"tu.dirección@de.desarrollador" por tu dirección de correo
electrónico para que se incluya en la entrada del fichero de cambios
así como en otros ficheros, y el nombre de fichero de tu archivo
fuente original. Lee <manref name="dh_make" section="1"> para más
detalles.
<p>Saldrá alguna información. Te preguntará qué tipo de paquete
deseas crear. Gentoo es un sólo paquete de binarios - crea sólo un
binario, y, por tanto, sólo un fichero .deb - así que
seleccionaremos la primera opción, con la tecla `s'. Comprueba la
información que aparece en la pantalla y confirma pulsando la tecla
<intro>.
<p>Como nuevo desarrollador, está desaconsejado crear
paquetes multibinarios, o librerías, como se explicó antes. No es
extremadamente difícil, pero sí necesita algunos conocimientos más,
así que aquí no describiremos el proceso.
<p>Ten en cuenta que deberías ejecutar dh_make <strong>sólo una
vez</strong>, y que no se comportará correctamente si lo haces otra
vez en el mismo directorio, ya "debianizado". Esto también significa
que usarás un método distinto para crear una nueva revisión o una
nueva versión de tu paquete en el futuro. Lee más sobre esto más
adelante en <ref id="update">.
<chapt id="modify">Modificando las fuentes.
<p>Normalmente, los programas se instalan a sí mismos en el
subdirectorio /usr/local. Pero los paquetes Debian no pueden
utilizar este directorio ya que está reservado para el uso privado
del administrador (o de los usuarios). Esto significa que tienes que
mirar el sistema de construcción de tu programa, generalmente
empezando por el Makefile. Éste es el guión que <manref name="make"
section="1"> usará para automatizar la creación de este programa.
Para más detalles sobre Makefiles, mira en <ref id="rules">.
<p>Date cuenta que si tu programa usa GNU <manref name="automake"
section="1"> y/o <manref name="autoconf" section="1">, lo que quiere
decir que las fuentes incluyen ficheros Makefile.am y Makefile.in,
respectivamente, necesitarás modificar esos ficheros, porque cada
invocación de automake reescribirá los Makefile.in's con información
generada a partir de los Makefile.am's, y cada llamada a ./configure
hará lo mismo con los Makefile's, con información de los
Makefile.in's. Editar los ficheros Makefile.am requiere algunos
conocimientos de automake, sobre lo que puedes leer en la entrada
de info para automake, mientras que editar Makefile.in's es casi
lo mismo que editar ficheros Makefile, simplemente basta con poner
atención en las variables, es decir, cualquier cadena que empiece y
acabe por `@'s, como por ejemplo @CFLAGS@ o @LN_S@, que se rellenan
con cada vez que se ejecute ./configure.
<p>Ten en cuenta que no hay espacio aquí para entrar en
<em>todos</em> los detalles respecto a los arreglos, pero a continuación,
están algunos de los problemas frecuentes.
<sect id="destdir">Instalación en un subdirectorio.
<p>La mayor parte de los programas tienen alguna manera de
instalarse en la estructura de directorios existente en tu sistema,
para que los binarios sean incluidos en tu $PATH, y para que
encuentre la documentación y páginas de manual en los lugares
habituales. Sin embargo, si lo instalas de esta forma, el programa
se instalará entre las cosas que ya están en tu sistema.
Esto dificultará a las herramientas de paquetes, averiguar que
archivos pertenecen a tu paquete y cuales no.
<p>Por lo tanto, necesitas hacer algo más: instalar el programa en
un subdirectorio temporal desde el cual las herramientas de desarrollo
construirán el paquete .deb que se pueda instalar. Todo
lo que se incluye en este directorio será instalado en el sistema
del usuario cuando instale su paquete, la única diferencia es que
dpkg instalará los ficheros en el directorio raíz.
<p>Este directorio temporal se creará bajo el directorio debian/
que está dentro del árbol del código descomprimido,
generalmente con el nombre <file>debian/tmp</file> o
<file>debian/packagename</file>.
<p>Ten en cuenta que aunque necesitas que el programa se instale en
debian/packagename, también necesitas que se comporte correctamente cuando se
instale en el directrio raíz, es decir, cuando se instale desde el
paquete .deb. Así que no deberías permitir que al construirse,
lo haga con cadenas como
<tt>/home/me/deb/gentoo-0.9.12/usr/share/gentoo</tt>
dentro de los archivos del paquete.
<p>Con programas que utilicen la herramienta GNU autoconf, ésto será bien
sencillo. La mayoría de estos programas tienen makefiles que por defecto,
permiten configurar la instalación en un subdirectorio cualquiera, aunque
recordando que por ejemplo /usr, es el prefijo normal.
Cuando detecte que tu programa usa autoconf, dh_make pondrá las opciones
necesarias para hacer esto automáticamente, así que puedes dejar
de leer esta sección.
Pero con otros programas, puede ser necesario que examines y edites
los Makefiles.
<p>Esta es la parte importante del Makefile de gentoo:
<p><example>
# ¿Dónde poner el binario en 'make install'?
BIN = /usr/local/bin
# ¿Dónde poner los iconos en 'make install'?
ICONS = /usr/local/share/gentoo/
</example>
<p>Vemos que los ficheros está configurados para instalarse bajo
<file>/usr/local</file>.
Cambia estas rutas a:
<p><example>
# ¿Dónde poner el binario en 'make install'?
BIN = $(DESTDIR)/usr/bin
# ¿Dónde poner los iconos en 'make install'?
ICONS = $(DESTDIR)/usr/share/gentoo
</example>
<p>¿Pero por qué en este directorio y no en otro? Porque los paquetes
de Debian nunca se instalan bajo <file>/usr/local</file>, este árbol
de directorios, está reservado para el uso del administrador del sistema.
Asi que estos ficheros van bajo /usr en su lugar.
<p>La exacta localización de los binarios, iconos, documentación,
etc, está especificada en el Estándar de la Jerarquía del
Sistema de Ficheros (Filesystem Hierarchy Standard, n. del t.)
(Vease /usr/share/doc/debian-policy/fhs).
Te recomiendo que leas las secciones que podrían concernir a tu
paquete.
<p>Así, deberíamos instalar el
binario en /usr/bin en lugar de /usr/local/bin, y la página de
manual en /usr/share/man/man1 en lugar de /usr/local/man/man1.
No hemos mencionado ninguna página de manual en el Makefile de gentoo,
pero en Debian se requiere que cada programa debe tener una, asi que
haremos una más tarde y la instalaremos en /usr/share/man/man1.
<p>Algunos programas no usan variables en el makefile para definir
rutas como estas. Esto significa que tendrás que editar algunos de los
ficheros de código C para arreglarlos y que usen las rutas correctas.
Pero, ¿donde buscar?, y exactamente, ¿el qué?
Puedes probar a encontrarlos usando:
<p><example>
grep -rn usr/local/lib *.[ch]
</example>
(en cada subdirectorio que contenga ficheros .c y .h). Grep nos indicará el
nombre del fichero y la línea cuando encuentre una ocurrencia.
<p>Ahora edita esos ficheros y cambia en esas líneas usr/local/lib con
usr/share - y ya está. Simplemente reemplaza usr/local/lib por tu
localización, y sé muy cuidadoso para no tocar el resto del código,
si no sabes mucho sobre cómo programar en C. :-)
<p>Después de esto deberías encontrar el objetivo 'install' (busca
una línea que comience por 'install:') y renombra todas las
referencias a directorios distintos de los definidos al comienzo del
Makefile. Anteriormente el objetivo 'install' decía:
<p><example>
install: gentoo
install ./gentoo $(BIN)
install icons $(ICONS)
install gentoorc-example $(HOME)/.gentoorc
</example>
<p>Después del cambio dice:
<example>
install: gentoo-target
install -d $(BIN) $(ICONS) $(DESTDIR)/etc
install ./gentoo $(BIN)
install -m644 icons/* $(ICONS)
install -m644 gentoorc-example $(DESTDIR)/etc/gentoorc
</example>
<p>Seguramente has notado que ahora hay una orden <tt>install -d</tt>
antes de las demás órdenes de la regla. El makefile original no lo tenía
porque normalmente /usr/local/bin y otros directorios ya existen en el
sistema donde se ejecuta `make install`. Sin embargo, dado que lo instalaremos
en un directorio vacio (o incluso inexistente), tendremos que crear cada uno
de estos directorios.
<p>También podemos añadir otras cosas al final de la regla,
como la instalación de documentación adicionar que los desarrolladores
originales a veces omiten:
<p><example>
install -d $(DESTDIR)/usr/share/doc/gentoo/html
cp -a docs/* $(DESTDIR)/usr/share/doc/gentoo/html
</example>
<p>Un lector atento se dará cuenta de que he cambiado `gentoo' a
`gentoo-target' en la línea `install:'. A eso se le llama arreglar
un fallo en el programa. :-)
<p>Siempre que hagas cambios que no estén específicamente
relacionados con el paquete Debian, asegúrate de que los envías al
desarrollador original para que éste los pueda incluir en la próxima
revisión del programa y asi le puedan ser útiles a alguien más.
Además recuerda hacer que tus cambios no sean específicos para
Debian o Linux (ni siquiera Unix!) antes de enviarlos, hazlo portable.
Esto hará que tus arreglos sean más fáciles de aplicar.
<p>Observa que no tienes que enviar ninguno de los ficheros debian/*
al desarrollador original.
<sect id="difflibs">Librerías diferentes.
<p>Hay otro problema común: las librerías son generalmente diferentes
de plataforma a plataforma. Por ejemplo, un Makefile puede contener
una referencia a una librería que no exista en Debian o ni siquiera
en Linux. En este caso, se necesita cambiarla a una librería que sí
exista en Debian y sirva para el mismo propósito.
<p>Así, si hay una línea en el Makefile (o Makefile.in) de tu
programa que dice algo como lo siguiente (y tu programa no compila):
<p><example>
LIBS = -lcurses -lcosas -lmáscosas
</example>
<p>Entonces cámbiala a lo siguiente, y funcionará casi con
seguridad:
<p><example>
LIBS = -lncurses -lcosas -lmáscosas
</example>
<chapt id="dreq">Las cosas necesarias bajo debian/.
<p>Ahora hay un nuevo subdirectorio bajo el directorio principal del
programa (`gentoo-0.9.12'), que se llama `debian'.
Hay algunos ficheros en este directorio que debemos editar para adaptar
el comportamiento del paquete. La parte más importante es modificar
los ficheros `control', `rules' (reglas, n. del t.), `changelog', y
`copyright' que son necesarios en todos los paquetes.
<sect id="control">El fichero `control'.
<p>Este fichero contiene varios valores que <prgn/dpkg/ y <prgn/dselect/
usarán para gestionar el paquete.
<p>Aquí está el fichero de control que dh_make crea para nosotros:
<p><example>
1 Source: gentoo
2 Section: unknown
3 Priority: optional
4 Maintainer: Josip Rodin <joy-mg@debian.org>
5 Build-Depends: debhelper (>> 3.0.0)
6 Standards-Version: 3.5.2
7
8 Package: gentoo
9 Architecture: any
10 Depends: ${shlibs:Depends}
11 Description: <insert up to 60 chars description>
12 <insert long description, indented with spaces>
</example>
(He añadido los números de línea).
<p>Las líneas 1-6 son la información de control para el paquete
fuente.
<p>La línea 1 es el nombre del paquete fuente.
<p>La línea 2 es la sección de la distribución dentro de la que
estará este paquete.
<p>Como puede que hayas notado, Debian está dividida
en secciones: main (principal, n. del t.) (el software libre),
non-free (no libre, n. del t.) (el software que realmente no es
libre) y contrib (software libre que depende de software no libre).
Bajo ellas, hay subdivisiones lógicas que describen en una palabra
qué paquetes hay dentro. Así que tenemos `admin' para programas que
sólo usa un administrador, `base' para las herramientas básicas,
`devel' para las herramientas de programación, `doc' para la
documentación, `libs' para las bibliotecas o librerías, `mail' para
lectores y demonios de correo-e, `net' para aplicaciones y demonios
de red, `x11' para programas específicos de X11, y muchos más.
<p>Vamos a cambiarla para que ponga x11. (El prefijo "main/" ya va
implícito, así que podemos omitirlo.)
<p>La línea 3 describe cómo de importante es para el usuario la
instalación de este paquete. Lee el manual de Política de
Debian para una guía de qué valor deben tener estos campos.
La prioridad 'optional' suele ser lo mejor para los paquetes nuevos.
<p>Section y Priority se usan en aplicaciones (frontends, n. del t.),
como <prgn/dselect/ cuando ordenan los paquetes. Una vez que envies el
paquete a Debian, el valor de estos dos campos puede ser no aceptado
por los mantenedores del archivo, en cuyo caso te lo notificarán por
correo electrónico.
<p>Como es un paquete de prioridad normal y no tiene conflictos con
ningún otro, lo dejaremos con prioridad `optional' (opcional, n. del t.).
<p>La línea 4 es el nombre y correo electrónico del desarrollador.
Asegurate de que este campo incluye una cabecera válida "To: ",
para una dirección de correo electrónico, porque despues de que envies
el paquete, el sistema de seguimiento de bugs (bug tracking system, n. del t.)
utilizará esta dirección para enviarte los mensajes de los bugs.
Evita usar comas, ampersans y paréntesis.
<p>La línea 5 incluye la lista de paquetes requeridos para construir
tu paquete. Algunos paquetes como gcc y make están implícitos,
vease el paquete <package/build-essential/ para más detalles.
Si algún compilador no estándar u otra herramienta, es necesaria
para construir tu paquete, deberías añadirla en la línea `Build-Depends'.
Las entradas multiples se separan con comas; lee la explicación de las
dependencias binarias para averiguar más sobre la sintaxis de este campo.
<p>También tienes los campos Build-Depends-Indep, Build-Conflicts
entre otros. Estos datos los usarán los programas de construcción
automática de paquetes de Debian para crear paquetes binarios para
el resto de plataformas de computadoras. <!-- no quedaría mejor aquí poner
arquitecturas? Ana -->
Vease el manual de Política para más información sobre la dependencias
de construcción y la Referencia del Desarrollador para más información
sobre estas otras plataformas (arquitecturas) y como portar los programas
a ellas.
<p>Aquí tienes un truco que puedes usar para averiguar que paquetes
necesitará tu paquete en su construcción:
<example>
strace -f -o /tmp/log ./configure
# o make en lugar de ./configure, si el paquete no usa autoconf
for x in `dpkg -S $(grep open /tmp/log|perl -pe 's!.* open\(\"([^\"]*).*!$1!' |grep "^/"| sort | uniq| grep -v "^\(/tmp\|/dev\|/proc\)" ) 2>/dev/null|cut -f1 -d":"| sort | uniq`; do echo -n "$x (>=" `dpkg -s $x|grep ^Version|cut -f2 -d":"` "), "; done
</example>
<p>Gentoo también requiere <package/xlibs-dev/,
<package/libgtk1.2-dev/ y <package/libglib1.2-dev/
para su construcción, asi que lo añadiremos junto a
<package/debhelper/.
<p>La línea 6 es la versión de los estándares de la Política de
Debian que sigue este paquete, la versión del manual de la Política
que has leído mientras haces tu paquete.
<p>La línea 8 es el nombre del paquete binario. Este suele ser el mismo
que el del paquete fuente, pero no necesariamente tiene que ser así siempre.
<p>La línea 9 describe la arquitectura de CPU para la que el paquete binario
puede ser compilado. Dejaremos puesto 'any' (cualquiera, n. del t),
porque <manref name="dpkg-gencontrol" section="1"> la rellenará con
el valor apropiado cuando se compile este paquete en cualquier
arquitectura para la cual pueda ser compilado.
<p>Si tu paquete es independiente de la arquitectura (por ejemplo, un
documento, un programa de shell o un guión en Perl), cambia esto a
"all", y lee más adelante <ref id="rules"> sobre cómo usar la regla
'binary-indep' en lugar de 'binary-arch' para construir el paquete.
<p>La línea 10 muestra una de las más poderosas posibilidades del
sistema de paquetes de Debian. Los paquetes se pueden relacionar
unos con otros de diversas formas. Aparte de 'Depends:' (depende de,
n. del t.) otros campos de relación son 'Recommends:' (recomienda,
n. del t.), 'Suggests:' (sugiere, n. del t.), 'Pre-Depends:'
(predepende de, n. del t.), 'Conflicts:' (entra en conflicto con,
n. del t.), 'Provides:' (provee, n. del t.), 'Replaces:' (reemplaza
a, n. del t.).
<p>Las herramientas de gestión de paquetes normalmente se comportan
de la misma forma cuando tratan con esas relaciones entre paquetes;
si no es así, se explicará en cada caso.
(vease <manref name="dpkg" section="8">,
<manref name="dselect" section="8">,
<manref name="apt" section="8">,
<manref name="aptitude" section="1"> etc)
<p>Esto es lo que las dependencias significan:
<list>
<item>Depends:
<p>No se instalará el programa a menos que los paquetes de los que
depende estén instalados. Usa esto si tu programa no funcionará de
ninguna forma (o causará daños) a menos que esté instalado un
paquete determinado.</item>
<item>Recommends:
<p>Programas como dselect o aptitude informarán en la instalación
de los paquetes recomendados con tu paquete, dselect incluso insistirá.
dpkg y apt-get ignorarán este campo. Usa esto para paquetes que no
son estrictamente necesarios pero que tipicamente se usan con tu programa.
</item>
<item>Suggests:
<p>Cuando un usuario instale el paquete, todos las programas le informarán
de que puede instalar los paquetes sugeridos. dpkg y apt no le hacen
caso a esto. Utiliza esto para paquetes que funcionarán bien con tu
programa pero no son necesarios en absoluto.</item>
<item>Pre-Depends:
<p>Esto es más fuerte que 'Depends'. EL paquete no se instalará a menos
que los paquetes de los que pre-dependa esté instalados
<em>y correctamente configurados</em>. Utiliza esto
<strong>muy</strong> poco y sólo después de haberlo discutido en la
lista de distribución de debian-devel. En resumidas cuentas: no lo
utilices en absoluto. :-) </item>
<item>Conflicts:
<p>El paquete no será instalado hasta que todos los paquetes con los
que entra en conflicto hayan sido eliminados. Utiliza esto si tu
programa no funcionará en absoluto (o causará daños) si un paquete
en particular está presente.
</item>
<item>Provides:
<p>Para algunos tipos determinados de paquetes donde hay múltiples
alternativas se han definido nombres virtuales. Puedes obtener la
lista completa en el fichero
/usr/share/doc/debian-policy/virtual-package-names-list.text.gz.
Usa esto si tu programa ofrece las funciones de un paquete virtual
existente.</item>
<item>Replaces:
<p>Usa esto si tu programa reemplaza ficheros de otro paquete, o
reemplaza totalmente otro paquete (generalmente se usa conjuntamente
con 'Conflicts':). Se eliminarán los ficheros de los paquetes
indicados antes de instalar el tuyo.</item>
</list>
<p>Todos estos campos tienen una sintaxis uniforme. Son una lista
de nombres de paquetes separados por comas. Estos nombres de
paquetes también puede ser listas de paquetes alternativos,
separados por los símbolos de barra vertical <tt>|</tt> (símbolos
tubería).
<p>Los campos pueden restringir su aplicación a versiones
determinadas de cada paquete nombrado. Esto se hace listando después
de cada nombre de paquete individual las versiones entre paréntesis,
e indicando antes del número de versión una relación de la siguiente
lista. Las relaciones permitidas son: <tt><<</tt>,
<tt><=</tt>, <tt>=</tt>, <tt>>=</tt> y <tt>>></tt>
para estrictamente anterior, anterior o igual, exactamente igual,
posterior o igual o estrictamente posterior, respectivamente.
Por ejemplo:
<p><example>
Depends: foo (>= 1.2), libbar1 (= 1.3.4)
Conflicts: baz
Recommends: libbaz4 (>> 4.0.7)
Suggests: quux
Replaces: quux (<< 5), quux-foo (<= 7.6)
</example>
<p>La última funcionalidad que necesitas conocer es
$(shlibs:Depends). Despues de que tu paquete se compile y se
instale en el directorio temporal,
<manref name="dh_shlibdeps" section="1"> lo escaneará en busca
de binarios y bibliotecas, para determinar las dependencias
de bibliotecas compartidas y en que paquetes están, tales como
como libc6 o xlib6g. Luego pasará la lista a
<manref name="dh_gencontrol" section="1"> que rellenará estas
dependencias en el lugar adecuado, así que no tendrás que preocuparte
por esto.
<p>Despues de decir todo esto, podemos dejar la línea de Depends:
exactamente como está ahora e insertar otra línea tras esta que diga
<tt>Suggests: file</tt>, porque gentoo utiliza algunas funciones de
este paquete/programa.
<p>La línea 11 es una descripción corta. La mayor parte de los
monitores de la gente son de 80 columnas de ancho, así que no
debería tener más de 60 caracteres. Cambiaré esto a "A fully GUI
configurable GTK+ file manager" ("Un gestor de ficheros GTK+
completamente configurable por GUI").
<p>La línea 12 es donde va la descripción larga del paquete. Debería
ser al menos un párrafo que dé más detalles del paquete. La primera
columna de cada línea debería estar vacía. No puede haber líneas en
blanco, pero puede poner un . (punto) en una columna para simularlo.
Tampoco debe haber más de una línea en blanco después de la
descripción completa.
<p>Aquí está el fichero de control actualizado:
<p><example>
1 Source: gentoo
2 Section: x11
3 Priority: optional
4 Maintainer: Josip Rodin <joy-mg@debian.org>
5 Build-Depends: debhelper (>> 3.0.0), xlibs-dev, libgtk1.2-dev, libglib1.2-dev
6 Standards-Version: 3.5.2
7
8 Package: gentoo
9 Architecture: any
10 Depends: ${shlibs:Depends}
11 Suggests: file
12 Description: A fully GUI configurable X file manager using GTK+
13 gentoo is a file manager for Linux written from scratch in pure C. It
14 uses the GTK+ toolkit for all of its interface needs. gentoo provides
15 100% GUI configurability; no need to edit config files by hand and re-
16 start the program. gentoo supports identifying the type of various
17 files (using extension, regular expressions, or the 'file' command),
18 and can display files of different types with different colors and icons.
19 .
20 gentoo borrows some of its look and feel from the classic Amiga file
21 manager "Directory OPUS" (written by Jonathan Potter).
</example>
(He añadido los números de línea).
<sect id="copyright">El fichero `copyright'.
<p>Este fichero contiene la información sobre la licencia y copyright
de las fuentes originales del paquete. El formato no está definido en
la Política, pero sí sus contenidos (sección 6.5).
<p>dh_make crea un fichero por defecto que es así:
<p><example>
1 This package was debianized by Josip Rodin <joy-mg@debian.org> on
2 Wed, 11 Nov 1998 21:02:14 +0100.
3
4 It was downloaded from <fill in ftp site>
5
6 Upstream Author(s): <put author(s) name and email here>
7
8 Copyright:
9
10 <Must follow here>
</example>
(He añadido los números de línea).
<p>Las cosas importantes que se deben añadir a este fichero son el
lugar de donde obtuviste el paquete junto con la nota de copyright y
licencia originales. Debes incluir la licencia completa, a menos que
sea una licencia común en el mundo del software libre como GNU GPL o
LGPL, BSD o la 'Artistic license', donde basta referirse al fichero
apropiado en el directorio /usr/share/common-licenses/ que existe en
todo sistema Debian.
<p>Gentoo está gobernado bajo la Licencia Pública
General GNU, así que cambiaremos el fichero a esto:
<p><example>
1 This package was debianized by Josip Rodin <joy-mg@debian.org> on
2 Wed, 11 Nov 1998 21:02:14 +0100.
3
4 It was downloaded from: ftp://ftp.obsession.se/gentoo/
5
6 Upstream author: Emil Brink <emil@obsession.se>
7
8 This software is copyright (c) 1998-99 by Emil Brink, Obsession
9 Development.
10
11 You are free to distribute this software under the terms of
12 the GNU General Public License.
13 On Debian systems, the complete text of the GNU General Public
14 License can be found in the file `/usr/share/common-licenses/GPL'.
</example>
(He añadido los números de línea).
<p>(Nota del T.: la política de Debian actual indica que los
documentos aquí citados estén escritos en inglés, al ser el idioma
oficial del proyecto, por lo que no se traducen en este documento).
<sect id="changelog">El fichero `changelog'.
<p>Este es un fichero requerido, que tiene un formato especial
descrito en la Política, sección 5.3 "debian/changelog". Este es el
formato que usan dpkg y otros programas para obtener el número de
versión, revisión, distribución y urgencia de tu paquete.
<p>Para ti es también importante, ya que es bueno tener documentados
todos los cambios que hayas hecho. Esto ayudará a las personas que se
descarguen tu paquete para ver si hay temas pendientes en el paquete
que deberían conocer de forma inmediata. Se salvará como
`/usr/share/doc/gentoo/changelog.Debian.gz' en el paquete binario.
<p>dh_make crea uno por defecto, que es algo así:
<p><example>
1 gentoo (0.9.12-1) unstable; urgency=low
2
3 * Initial Release.
4
5 -- Josip Rodin <joy-mg@debian.org> Wed, 11 Nov 1998 21:02:14 +0100
6
</example>
(He añadido los números de línea).
<p>La línea 1 es el nombre del paquete, versión, distribución y
urgencia. El nombre debe coincidir con el nombre del paquete fuente,
la distribución debería ser, por ahora, `unstable' (o incluso `experimental')
y la urgencia no debería cambiarse a algo mayor que `low'. :-)
<p>Las línea 3-5 son una entrada de registro, donde se documentan
los cambios hechos en esta revisión del paquete (no los cambios en
las fuentes originales - hay un fichero especial para este
propósito, creado por los autores originales y que instalarás luego como
/usr/share/doc/gentoo/changelog.gz). Las nuevas líneas deben
insertarse justo antes de la línea que hay más arriba que comienza
por un asterisco (`*'). Puede hacerlo con <manref name="dch"
section="1">, o manualmente con cualquier editor de texto.
<p>Terminarás con algo así:
<p><example>
1 gentoo (0.9.12-1) unstable; urgency=low
2
3 * Initial Release.
4 * This is my first Debian package.
5 * Adjusted the Makefile to fix $DESTDIR problems.
6
7 -- Josip Rodin <joy-mg@debian.org> Wed, 11 Nov 1998 21:02:14 +0100
8
</example>
(He añadido los números de línea).
<p>Puede leer más sobre como actualizar el fichero changelog más
adelante en <ref id="update">.
<sect id="rules">El fichero `rules'.
<p>Ahora necesitamos mirar las reglas exactas que <manref
name="dpkg-buildpackage" section="1"> utilizará para crear el
paquete. Este fichero es en realidad otro Makefile,
pero diferente al que viene en las fuentes originales.
A diferencia de otros ficheros en debian/, este necesita ser
configurado como ejecutable.
<p>Cada fichero `rules' (de reglas, n. del t.), como muchos otros
Makefiles, se compone de varias reglas que especifican cómo tratar
las fuentes. Cada regla se compone de objetivos, ficheros o nombres
de acciones que se deben llevar a cabo (por ejemplo, `build:' o
`install:'). Las reglas que quieras ejecutar deberían llamarse como
argumentos de la línea de órdenes (por ejemplo, `./debian/rules
build' o `make -f rules install'). Después del nombre del objetivo,
puedes nombrar las dependencias, programas o ficheros de los que la
regla dependa. Después de esto, hay un número cualquiera de
instrucciones (¡indentado con <tab>!), hasta que se llega a
una línea en blanco. Ahí empieza otra regla. Las líneas múltiples en
blanco, y las líneas que empiezan por almohadillas ('#') se tratan
como comentarios y se ignoran.
<p>Probablemente ya te hayas perdido, pero todo quedará más claro
después de ver un fichero `rules' que dh_make pone por defecto.
Deberías leer también la entrada de `make' en info para más
información.
<p>La parte importante que debes conocer sobre el fichero de reglas
creado por dh_make, es que sólo es una sugerencia. Funcionará para
paquetes simples pero para más complicados, no te asustes y añade o
quita cosas de éste para ajustarlo a tus necesidades. Una cosa que
no debes cambiar son los nombres de las reglas, porque todas las
herramientas utilizan estos nombres, como se indica en la Política.
<p>Aqui está, aproximadamente, como es el fichero debian/rules que
dh_make genera por defecto:
<p><example>
1 #!/usr/bin/make -f
2 # Sample debian/rules that uses debhelper.
3 # GNU copyright 1997 to 1999 by Joey Hess.
4
5 # Uncomment this to turn on verbose mode.
6 #export DH_VERBOSE=1
7
8 # This is the debhelper compatibility version to use.
9 export DH_COMPAT=3
10
11 ifneq (,$(findstring debug,$(DEB_BUILD_OPTIONS)))
12 CFLAGS += -g
13 endif
14 ifeq (,$(findstring nostrip,$(DEB_BUILD_OPTIONS)))
15 INSTALL_PROGRAM += -s
16 endif
17
18 build: build-stamp
19 build-stamp:
20 dh_testdir
21
22 # Add here commands to compile the package.
23 $(MAKE)
24 #/usr/bin/docbook-to-man debian/gentoo.sgml > gentoo.1
25
26 touch build-stamp
27
28 clean:
29 dh_testdir
30 dh_testroot
31 rm -f build-stamp
32
33 # Add here commands to clean up after the build process.
34 -$(MAKE) clean
35
36 dh_clean
37
38 install: build
39 dh_testdir
40 dh_testroot
41 dh_clean -k
42 dh_installdirs
43
44 # Add here commands to install the package into debian/gentoo.
45 $(MAKE) install DESTDIR=$(CURDIR)/debian/gentoo
46
47 # Build architecture-independent files here.
48 binary-indep: build install
49 # We have nothing to do by default.
50
51 # Build architecture-dependent files here.
52 binary-arch: build install
53 dh_testdir
54 dh_testroot
55 # dh_installdebconf
56 dh_installdocs
57 dh_installexamples
58 dh_installmenu
59 # dh_installlogrotate
60 # dh_installemacsen
61 # dh_installpam
62 # dh_installmime
63 # dh_installinit
64 dh_installcron
65 dh_installman
66 dh_installinfo
67 # dh_undocumented
68 dh_installchangelogs ChangeLog
69 dh_link
70 dh_strip
71 dh_compress
72 dh_fixperms
73 # dh_makeshlibs
74 dh_installdeb
75 # dh_perl
76 dh_shlibdeps
77 dh_gencontrol
78 dh_md5sums
79 dh_builddeb
80
81 binary: binary-indep binary-arch
82 .PHONY: build clean binary-indep binary-arch binary install
</example>
(He añadido los números de línea).
<p>(N. del T.: se traduce el fichero de reglas, dh_make sólo lo
ofrece en inglés)
<p><example>
1 #!/usr/bin/make -f
2 # Fichero de ejemplo debian/rules que usa debhelper.
3 # GNU copyright 1997 to 1999 by Joey Hess.
4
5 # Quítele el comentario para activar el modo explícito.
6 #export DH_VERBOSE=1
7
8 # Esta es la versión de compatibilidad con debhelper que usaremos.
9 export DH_COMPAT=3
10
11 ifneq (,$(findstring debug,$(DEB_BUILD_OPTIONS)))
12 CFLAGS += -g
13 endif
14 ifeq (,$(findstring nostrip,$(DEB_BUILD_OPTIONS)))
15 INSTALL_PROGRAM += -s
16 endif
17
18 build: build-stamp
19 build-stamp:
20 dh_testdir
21
22 # Añade aquí las órdenes para compilar el paque
23 $(MAKE)
24 #/usr/bin/docbook-to-man debian/gentoo.sgml > gentoo.1
25
26 touch build-stamp
27
28 clean:
29 dh_testdir
30 dh_testroot
31 rm -f build-stamp
32
33 # Añade aquí las órdenes para limpiar después del proceso de creación.
34 -$(MAKE) clean
35
36 dh_clean
37
38 install: build
39 dh_testdir
40 dh_testroot
41 dh_clean -k
42 dh_installdirs
43
44 # Añade aquí las órdenes para instalar el paquete en debian/tmp.
45 $(MAKE) install DESTDIR=$(CURDIR)/debian/gentoo
46
47 # Construir los ficheros independientes de arquitectura aquí.
48 binary-indep: build install
49 # No hace nada por defecto.
50
51 # Construir los ficheros independientes de arquitectura aquí.
52 binary-arch: build install
53 dh_testdir
54 dh_testroot
55 # dh_installdebconf
56 dh_installdocs
57 dh_installexamples
58 dh_installmenu
59 # dh_installlogrotate
60 # dh_installemacsen
61 # dh_installpam
62 # dh_installmime
63 # dh_installinit
64 dh_installcron
65 dh_installman
66 dh_installinfo
67 # dh_undocumented
68 dh_installchangelogs ChangeLog
69 dh_link
70 dh_strip
71 dh_compress
72 dh_fixperms
73 # dh_makeshlibs
74 dh_installdeb
75 # dh_perl
76 dh_shlibdeps
77 dh_gencontrol
78 dh_md5sums
79 dh_builddeb
80
81 binary: binary-indep binary-arch
82 .PHONY: build clean binary-indep binary-arch binary install
</example>
<p>Probablemente estés familiarizado con líneas como la 1 de guiones
hechos en shell o Perl. Esto significa que el fichero debe
ejecutarse con /usr/bin/make.
<p>El significado de las variables DH_* que se mencionan en las
líneas 6 y 9 debería ser evidentes de la descripción corta.
Para más información sobre DH_COMPAT lease la sección
"Debhelper compatibility levels" del manual de
<manref name="debhelper" section="1">.
<p>Las líneas de la 11 a la 16 son el esqueleto de apoyo para
los parámetros de DEB_BUILD_OPTIONS, descritos en la Política sección
11.1 "Binarios". Basicamente, estas cosas controlan si los binarios
se construyen con los símbolos del depurador (debugger, n. del t.),
y si deberían quitarse con strip tras la instalación.
Es solo un esqueleto, una pista de lo que deberías hacer.
Deberías comprobar como el sistema de construcción de las fuentes
maneja la inclusión de los símbolos del depurador y su eliminación
en la instalación e implementarlo por ti mismo/a.
<p>Normalmente puedes decirle a gcc que compile con "-g" usando la variable
CFLAGS - si este es el caso de tu paquete, pon la variable
<em>añadiendo</em> <tt>CFLAGS="$(CFLAGS)"</tt> a la invocación de
$(MAKE) en la regla de construcción (ver más abajo). Alternativamente,
si tu paquete usa un guión de configuración de autoconf, puedes pasarle
esto configurando <em>para que se propage</em> la cadena de arriba a
la llamada de ./configure en la regla de construcción.
<!-- no pillo de lo de perpending:
Alternatively, if your package uses an
autoconf configure script, you can pass it to configure by
<em>prepending</em> the above string to the ./configure invocation in the
build rule.
-->
<p>Los programas a los que se le quitan los símbolos del
depurador con strip, se configuran normalmente para instalarse
sin pasar por strip, y a menudo sin una opción para cambiar esto.
Afortunadamente, tienes <manref name="dh_strip" section="1"> que
detectará cuando el flag DEB_BUILD_OPTIONS=nostrip está activado
y saldrá silenciosamente.
<p>Las líneas 12 a la 19 describen la regla build (y su hija `build-stamp'),
que ejecuta make con el propio Makefile de la aplicación para compilar
el programa.
Hablaremos sobre el ejemplo comentado docbook-to-man más tarde en
<ref id="manpage">.
<p>La regla `clean' (limpiar, n. del t.), como se especifica en las
líneas 28-36, limpia cualquier binario innecesario o cosas
automáticamente generadas, dejadas después de la construcción del
paquete.
Esta regla debe funcionar en todo momento (incluso cuando
el árbol de fuentes <em>esté</em> limpio!), así que, por favor, usa
las opciones que fuercen a hacer cosas (por ejemplo para rm, sería
`-f'), o ignora los valores devueltos (con un `-' al principio de la
orden).
<p>El proceso de instalación, la regla `install', comienza en la
línea 38. Básicamente ejecuta la regla `install' del Makefile del
programa, pero lo instala en el directorio <tt>$(CURDIR)/debian/gentoo</tt> -
esto es por lo que especificamos $(DESTDIR) como el directorio
raíz de instalación del Makefile de gentoo.
<p>Como sugiere el comentario, la regla 'binary-indep', en la línea 48,
se usa para construir paquetes independientes de arquitectura.
Como no tenemos ninguno aquí no se hará nada.
<p>Lo siguiente es la regla 'binary-arch', en las líneas 52 a 79, en
la que ejecutamos varias pequeñas utilidades del paquete debhelper
que nos permiten hacer diversas operaciones en nuestro paquete para
que cumpla la política de Debian.
<p>Si tu paquete es del tipo `Architecture: all' necesitarás incluir
todas las órdenes para crear el paquete bajo esta regla, y dejar la
siguiente regla (`binary-arch') vacía en su lugar.
<p>Los nombres comienzan con dh_ y el resto del nombre es la descripción
de lo que la utilidad en particular realmente hace. Es todo más o menos
auto-explicativo, pero a continuación tienes algunos añadidos a las
explicaciones:
<list>
<item><manref name="dh_testdir" section="1"> comprueba que estás en
el directorio correcto (esto es, el directorio raíz de la
distribución de las fuentes),
<item><manref name="dh_testroot" section="1"> comprueba que tienes
permisos de superusuario que son necesarios para las reglas
`binary-arch', `binary-indep' and `clean',
<item><manref name="dh_installman" section="1"> copiará todas las
páginas de manual que encuentre en el paquete fuente en
el paquete, tan solo has de indicarle donde están de forma relativa,
desde el nivel más alto del directorio de codigo.
<item><manref name="dh_strip" section="1"> elimina las cabeceras de
depuración de los ficheros ejecutables para hacerlos más
pequeños,
<item><manref name="dh_compress" section="1"> comprime las
páginas de manual y los ficheros de documentación que sean más
grandes de 4 kB con <manref name="gzip" section="1">,
<item><manref name="dh_installdeb" section="1"> copia los ficheros
relativos al paquete (es decir, los guiones del mantenedor)
bajo el directorio <file>debian/gentoo/DEBIAN</file>,
<item><manref name="dh_shlibdeps" section="1"> calcula las
dependencias de los ejecutables y librerías con las librerías
compartidas,
<item><manref name="dh_gencontrol" section="1"> genera e instala el
fichero de control en <file>debian/gentoo/DEBIAN</file>,
<item><manref name="dh_md5sums" section="1"> genera las sumas de
chequeo MD5 para todos los ficheros del paquete.
</list>
<p>Para información más completa de lo que hacen cada uno de estos
guiones dh_* , y qué otras opciones tienen, por favor lee sus
páginas de manual respectivas. Hay otros guiones con la misma
nomenclatura (dh_*) que no se han mencionado aquí, pero pueden serte
útiles. Si los necesitas, lee la documentación de debhelper.
<p>La sección binary-arch es en una de las que deberías comentar o eliminar
las líneas que llamen a funciones que no necesites. Para gentoo,
comentaré de ejemplos, cron, init, man e info,
simplemente porque gentoo no las necesita.
Tan solo, en la línea 68, reemplazaré `ChangeLog' con `FIXES',
porque este es el nombre del fichero de cambios de las fuentes.
<p>Las últimas dos líneas (junto con otras que no se explican) son
cosas más o menos necesarias, sobre las que puedes leer en el manual
de make, y la Política. Por ahora no es importante que sepas nada de
ellas.
<chapt id="dother">Otros ficheros en el directorio debian/.
<p>Verás que existen otros ficheros en el subdirectorio debian/,
muchas de los cuales tendrán el sufijo `.ex', que indica que son
ejemplos. Echale un vistazo a todos. Si lo deseas o necesitas usar
alguna de estas características:
<list>
<item>revisa todo la documentación relacionada (sugerencia: el Manual de la Política),
<item>si es necesario modifica los ficheros para sjustaros a tus necesidades,
<item>renombralos para eliminar el sufijo `ex.', si lo tiene,
<item>renombralos para eliminar el prefijo `.ex', si lo tiene,
<item>modifica el fichero `rules' si es necesario.
</list>
<p>Algunos de estos ficheros, los que se usan más comúnmente, se explican en
las secciones que siguen.
<sect id="readme">README.debian. (LÉEME.debian, n. del t.)
<p>Cualquier detalle extra o discrepancias entre el programa
original y su versión debianizada debería documentarse aquí.
<p>dh_make crea una por defecto, y éste es su aspecto:
<p><example>
gentoo for Debian
-----------------
<possible notes regarding this package - if none, delete this file>
-- Josip Rodin <joy-mg@debian.org>, Wed, 11 Nov 1998 21:02:14 +0100
</example>
<p>Dado que no tenemos que poner nada aquí - está permitido
borrarlo.
<sect id="conffiles">conffiles.
<p>Una de las cosas más molestas de los programas es cuando pasas
mucho tiempo y esfuerzo adaptando un programa y una actualización
destroza todos tus cambios. Debian resuelve este problema marcando
los ficheros de configuración de forma que cuando actualizas un
paquete se te pregunta si deseas mantener la nueva
configuración o no.
<p>Eso se consigue poniendo la ruta completa a cada
fichero de configuración (se encuentran generalmente en /etc), una
por línea, en un fichero llamado `conffiles'.
Gentoo tiene un fichero de configuración, /etc/gentoorc, y
meteremos éste en el fichero <tt/conffiles/.
<p>Si tu programa usa ficheros de configuración pero también los
reescribe el mismo, lo mejor es no marcarlos como conffiles porque
dpkg les informará a los usuarios que verifiquen los cambios todo el tiempo.
<p>Si el programa que estás empaquetando requiere que cada usuario
modifique su fichero de configuración para trabajar, considera también
no marcar el fichero como un conffile.
<p>Puedes tomar ejemplos de ficheros de configuración de los
`maintainer scripts', para más información vease <ref id="maintscripts">.
<p>Si tu programa no tiene conffiles, puedes eliminar el fichero
<tt/conffiles/ del directorio debian/.
<sect id="crond">cron.d.ex.
<p>Si tu paquete requiere tareas periódicas para funcionar adecuadamente,
puedes usar este archivo como patrón.
<p>Fijate que no incluye rotación de logs, para eso, vease
<manref name="dh_installlogrotate" section="1"> y
<manref name="logrotate" section="8">.
<p>Si no, elimínalo.
<sect id="dirs">dirs.
<p>Este fichero especifica los directorios que se necesitan pero que
por alguna razón no se crean en un proceso de instalación normal
(make install).
<p>Por defecto, tiene este aspecto:
<p><example>
1 usr/bin
2 usr/sbin
</example>
<p>Observa que la barra precedente no está incluida. Normalmente lo
cambiaríamos a algo así:
<p><example>
1 usr/bin
2 usr/man/man1
</example>
pero estos directorios ya se crean en el Makefile, así que no
necesitaremos este fichero y lo podremos borrar.
<sect id="docs">docs.
<p>Este fichero especifica los nombres de fichero de los ficheros
de documentación que dh_installdocs puede instalar en el directorio
temporal para nososotros.
<p>Por defecto, incluirá todos los ficheros existentes en los directorios
de más alto nivel del código que se llamen "BUGS", "README*", "TODO" etc.
<p>Para gentoo, también incluiré algunos otros:
<p><example>
BUGS
CONFIG-CHANGES
CREDITS
ONEWS
README
README.gtkrc
TODO
</example>
<p>También podemos eliminar este fichero y en su lugar listar
estos ficheros en la línea de ordenes de
<tt/dh_installdocs/ en el fichero <tt/rules/, de esta forma:
<p><example>
dh_installdocs BUGS CONFIG-CHANGES CREDITS ONEWS README \
README.gtkrc TODO
</example>
<p>Es posible que no tengas ninguno de estos ficheros en las fuentes
de tu paquete. En ese caso, puedes eliminar este fichero. Pero
no elimines la llamada a <tt/dh_installdocs/ desde el fichero
<tt/rules/ porque este se usa para instalar el fichero
<tt/copyright/ entre otras cosas.
<sect id="emacsen">emacsen-*.ex.
<p>Si tu paquete proporciona ficheros Emacs que pueden ser
compilados a bytes en el momento de la instalación, puede usar estos
ficheros.
<p>Se instalan en el directorio temporal por
<manref name="dh_installemacsen" section="1">,
así que no olvides descomentar esta línea en el fichero
<tt/rules/ si los usas.
<p>Si no los necesitas, eliminalos.
<sect id="initd">init.d.ex.
<p>Si tu paquete es un demonio que necesita ejecutarse en el inicio
del sistema, obviamente has desatendido mi recomendación inicial, ¿o no?
:-)
<p>Este fichero es prácticamente un esqueleto genérico para un fichero de
guiones en <file>/etc/init.d/</file>, asi que probablemente tendrás que
editarlo, mucho. Se instala en el directorio temporal por
<manref name="dh_installinit" section="1">.
<p>Si no lo necesitas, elimina el fichero.
<sect id="manpage">manpage.1.ex, manpage.sgml.es.
<p>Tu programa debería tener una página de manual. Si no lo tiene,
cada uno de estos ficheros es una plantilla que puedes rellenar.
<p>Las páginas de manual se escriben normalmente con <manref name="nroff" section="1">.
El ejemplo <tt/manpage.1.ex/ está también escrito con nroff.
Vease la página de manual <manref name="man" section="7"> para una breve
descripción de como editar el fichero.
<p>Por otro lado, puede que prefieras escribir usando SGML en lugar de
nroff, puedes usar la plantilla <tt/manpage.sgml.ex/.
Si haces esto, tendrás que:
<list>
<item>instalar el paquete <package/docbook-to-man/
<item>añadir <tt/docbook-to-man/ a la línea de <tt/Build-Depends/
en el fichero de <tt/control/
<item>eliminar el comentario de la llamada a docbook-to-man en
la regla `build' de tu fichero <tt/rules/
</list>
<p>Y recuerda renombrar el fichero a algo como <tt/gentoo.sgml/!
<p>La página final del nombre debería incluir el nombre del programa
que está documentando, asi que lo renombraremos de "manpage" a "gentoo".
El nombre del fichero incluye también ".1" como primer sufijo,
lo que significa que es una página de manual para una programa de usuario.
Asegurate de verificar que esa sección es la correcta.
Aquí tienes una pequeña lista de las secciones de las páginas de manual.
<p><example>
Sección | Descripción | Notas
1 Comandos de Usuario Programas o guiones ejecutables.
2 Llamadas al Sistema Funciones que ofrece el núcleo.
3 Llamadas a Librerías Funciones dadas por las librerías del sistema.
4 Ficheros Especiales Generalmente se encuentran en /dev.
5 Formatos de Fichero Por ejemplo, el formato del /etc/passwd.
6 Juegos U otros programas frívolos.
7 Paquetes de Macros Como las macros de man.
8 Administración del Sist. Programas que sólo suele ejecutar el superusuario.
9 Rutinas del Núcleo Llamadas al sistema no estándar.
</example>
<p>Asi que la página de manual de gentoo debería llamarse <tt/gentoo.1/.
Para programas X puedes añadir una "x" a la sección, por ejemplo,
<tt/gentoo.1x/.
No habia una pagina de manual gentoo.1 en el paquete fuente
asi que lo escribí usando la información del ejemplo y de los documentos
fuentes.
<sect id="menu">menu.ex.
<p>Los usuarios de X Windows tendrán un gestor de ventanas con menús
que pueden adaptarse para lanzar programas. Si tienen instalado el
paquete <package/menu/ de Debian, se creará un conjunto de menús para cada
programa del sistema para ellos.
<p>Aquí está el fichero <tt/menu.ex/ que dh_make crea por defecto:
<p><example>
?package(gentoo):needs=X11|text|vc|wm section=Apps/see-menu-manual\
title="gentoo" command="/usr/bin/gentoo"
</example>
<p>El primer campo tras la coma son las "needs", y especifica
que tipo de interfaz necesita el programa. Cambia esta a una de las
alternativas que se listan, por ejemplo "text" o "X11"
<p>Lo siguiente es "section", donde deberían aparecer la entrada del menú y
del submenú. La lista actual de secciones está en:
<file>/usr/share/doc/debian-policy/menu-policy.html/ch2.html#s2.1</file>
<p>El campo "title" es el nombre del programa. Puedes comenzar este
en mayúsculas si quieres, tan solo, hazlo lo más corto que puedas.
<p>Finalmente, el campo "command" es la orden que ejecuta el programa.
<p>Ahora cambiaremos la entrada del menú a esto:
<p><example>
?package(gentoo): needs=X11 section=Apps/Tools title="Gentoo" command="gentoo"
</example>
<p>También puedes añadir otros campos como "longtitle", "icon", "hints" etc.
Vease <manref name="menufile" section="5">,
<manref name="update-menus" section="1">
y <file>/usr/share/doc/debian-policy/menu-policy.html/</file> para más información.
<sect id="watch">watch.ex.
<p>Este fichero se usa para configurar los programas <manref
name="uscan" section="1"> y <manref name="uupdate" section="1">
(en el paquete <package/devscripts/), que se usan para vigilar
el servidor de donde obtuviste las fuentes originales.
<p>Esto es lo que he puesto yo:
<p><example>
# watch control file for uscan
# Site Directory Pattern Version Script
ftp.obsession.se /gentoo gentoo-(.*)\.tar\.gz debian uupdate
</example>
<p>Pista: conéctate a Internet, e intenta ejecutar el programa
"uscan" en el directorio donde has creado el fichero. Ve la página
de manual para más detalles.
<sect id="doc-base">ex.package.doc-base.
<p>Si tu paquete tiene documentación aparte de las páginas de manual
y documentos de información, deberías usar el fichero `<package/doc-base/'
para registrarlo, asi el usuario peude encontrarlos con con
<manref name="dhelp" section="1">,
<manref name="dwww" section="1"> o <manref name="doccentral" section="1">.
<p>Esto incluye generalmente ficheros HTML, PS y PDS, que se instalan en
<file>/usr/share/doc/packagename/</file>.
<p>Asi es como el fichero doc-base de gentoo <tt>gentoo.doc-base</tt> debe
ser:
<p><example>
Document: gentoo
Title: Gentoo Manual
Author: Emil Brink
Abstract: This manual describes what Gentoo is, and how it can be used.
Section: Apps/Tools
Format: HTML
Index: /usr/share/doc/gentoo/html/index.html
Files: /usr/share/doc/gentoo/html/*.html
</example>
<p>Para información sobre el formato del fichero, revisa <manref
name="install-docs" section="8"> y el manual de <package/doc-base/ en
<file>/usr/share/doc/doc-base/doc-base.html/index.html</file>.
<sect id="maintscripts">postinst.ex, preinst.ex, postrm.ex y prerm.ex.
<p>Estos ficheros se llaman guiones del desarrollador (maintainer
scripts, n. del t.), y son guiones que se colocan en el área de
control del paquete y que <package/dpkg/ ejecuta cuando tu paquete se instala,
se actualiza o se quita.
<p>Por ahora, deberías intentar evitar editar manualmente estos
guiones si puedes porque suelen hacerse muy complejos. Para más
información lee el Manual de Política, capítulo 6, y echa un
vistazo a los ejemplos dados por dh_make.
<chapt id="build">Construir el paquete.
<p>Deberíamos estar preparados para construir el paquete.
<sect id="completebuild">Reconstrucción completa.
<p>Entra en el directorio principal del programa y ejecuta la
siguiente orden:
<p><example>
dpkg-buildpackage -rfakeroot
</example>
<p>Esto lo hará todo por tí:
<list>
<item>limpia el árbol del código (debian/rules clean), usando <prgn/fakeroot/
<item>construye el paquete de codigo (dpkg-source -b)
<item>construye el programa (debian/rules build)
<item>construye el paquete binario (debian/rules binary), usando <prgn/fakeroot/
<item>firma el fichero fuente <tt/.dsc/, usando <prgn/gnupg/
<item>crea y firma el fichero de subida <tt/.changes/, usando
<prgn/dpkg-genchanges/ y <prgn/gnupg/
</list>
<p>Lo único que se te pedirá es que escribas tu contraseña secreta
de la clave GPG, dos veces.
<p>Después de hacer todo esto, verás las siguientes líneas en el directorio
encima del que está (<tt>~/debian/</tt>):
<p><list>
<item><em>gentoo_0.9.12.orig.tar.gz</em>
<p>Este es el código fuente original comprimido, simplemente se ha renombrado
para seguir los estándares de Debian. Nótese que ha sido creado usando
la opción `-f' de <prgn/dh_make/ cuando lo ejecutamos en el inicio.
<item><em>gentoo_0.9.12-1.dsc</em>
<p>Este es un sumario de los contenidos del código fuente. Este
fichero se genera a partir del fichero de `control'
y se usa cuando se descomprimen las fuentes con <manref
name="dpkg-source" section="1">. Este fichero está firmado con PGP
de forma que cualquiera pueda estar seguro de que es realmente suyo.
<item><em>gentoo_0.9.12-1.diff.gz</em>
<p>Este fichero comprimido contiene todos y cada uno de los cambios
que hizo al código fuente original, en un formato conocido como "diff
unificado". El programa que lo hace y lo usa es <manref name="dpkg-source"
section="1">. Precaución: si no renombras el archivo comprimido original
packagename_version.orig.tar.gz, <prgn/dpkg-source/
fallará al generar el fichero .diff.gz!
<p>Si alguien quiere volver a crear tu paquete desde cero, puede hacerlo
fácilmente usando los tres ficheros de arriba. El proceso de extracción
es trivial: tan solo copiar los tres ficheros en algún lado y ejecutar
<tt>dpkg-source -x gentoo_0.9.12-1.dsc</tt>.
<item><em>gentoo_0.9.12-1_i386.deb</em>
<p>Este es el paquete binario completo. Puedes usar <prgn/dpkg/
para instalar o eliminar tanto este como cualquier otro paquete.
<item><em>gentoo_0.9.12-1_i386.changes</em>
<p>Este fichero describe todos los cambios hechos en la revisión
actual del paquete, y se usa por los programas de gestión del
archivo FTP para instalar los paquetes binarios y fuentes en él. Se
genera parcialmente a partir del fichero `changelog' y el fichero .dsc.
Este fichero está firmado con PGP, de forma que
cualquiera puede estar aún más seguro de que es realmente tuyo.
<p>Mientras sigues trabajando en el paquete, cambiará su
comportamiento y se le añadirán nuevas funciones. Las personas que
descarguen tu paquete pueden mirar este fichero y ver qué ha
cambiado. Los programas de mantenimiento del archivo de Debian, también
enviarán el contenido de este fichero a la lista de correo
debian-devel-changes.
</list>
<p>Las largas listas de números son las sumas MD5 para los
ficheros. Las personas que descarguen estos ficheros pueden
comprobarlos con <manref name="md5sum" section="1"> y si los números
no coinciden, sabrán que el fichero está corrupto o ha sido
modificado.
<sect id="quickrebuild">Reconstrucción rápida.
<p>Con un paquete grande, puede que no quieras recompilar desde cero
cada vez que tocas un detalle en el fichero <file>debian/rules</file>.
Para propósitos de prueba, puedes hacer un fichero .deb sin necesidad de
recompilar las fuentes originales de esta forma:
<p><example>
fakeroot debian/rules binary
</example>
<p>Una vez que has terminado la puesta a punto, recuerda reconstruir el
paquete siguiendo el procedimiento adecuado que está arriba. Puede que no seas
capaz de enviarlo correctamente si intentas enviar los archivos .deb
construidos de esta forma.
<chapt id="checkit">Comprobar tu paquete para encontrar errores.
<p>Ejecuta <manref name="lintian" section="1"> sobre tu fichero de
cambios .changes; este programa comprobará muchos errores comunes al
empaquetar. El comando es:
<p><example>
lintian -i gentoo_0.9.12-1_i386.changes
</example>
<p>Por supuesto, cambia el nombre de fichero con el nombre del
fichero de cambios generado por tu paquete. Si parece que hay
algunos errores (líneas que comienzan por E:), lee la explicación
(líneas N:), corrige errores, y reconstruye como se describe en <ref
id="completebuild">. Si hay líneas que comienzan con W:, son sólo avisos
(warnings, n. del t.), asi que afina el paquete o verifica que los
avisos, son falsos (y hace que lintian
no lo acepte, vease la documentación para más detalles).
<p>Observa que puedes construir el paquete con <prgn/dpkg-buildpackage/ y
ejecutar <prgn/lintian/ todo de una sola vez con <manref name="debuild"
section="1">.
<p>Mira dentro del paquete usando un gestor de ficheros como <manref
name="mc" section="1">, o descomprímelo en algún punto temporal
usando <manref name="dpkg-deb" section="1">.
Vigila que no haya ficheros innecesarios extra, tanto en el binario
como en el paquete fuente.
A veces, hay cosas que no se limpiaron adecuadamente; ajusta tu fichero
de `rules' para arreglar esto.
Pista: `zgrep ^+++ ../gentoo_0.9.12-1.diff.gz` te dará
una lista de tus cambios/contribuciones a las fuentes, y `dpkg-deb
-c gentoo_0.9.12-1_i386.deb` listará los ficheros en el paquete binario.
<p>Instala el paquete para probarlo tú mismo/a, por ejemplo, usando la
orden <manref name="debi" section="1"> como superusuario. Intenta
instalarlo y ejecutarlo en otras máquinas distintas de la tuya, y
presta atención para detectar errores o avisos tanto en la instalación
como en la ejecución del programa.
<chapt id="upload">Enviando el paquete.
<p>Ahora que has probado tu nuevo paquete en profundidad, estarás
preparado/a para comenzar el proceso de Nuevo Desarrollador de Debian (Debian new
maintainer, n. del T.), como se describe en:
<url id="http://www.debian.org/devel/join/newmaint";>
<p>Una vez que llegues a ser desarrollador oficial, necesitarás
subir el paquete al archivo de Debian. Puedes hacer esto manualmente,
pero es más fácil hacerlo con las herramientas automáticas que se
proporcionan, como
<manref name="dupload" section="1"> o <manref name="dput" section="1">.
Describiremos como hacerlo con <prgn/dupload/.
<p>Primeramente, tienes que crear un fichero de configuración de upload.
Puedes hacerlo editando el fichero general del sistema <file>/etc/dupload.conf</file>,
o en tu propio fichero <file>~/.dupload.conf</file> con lo que tu quieras
cambiar.
Pon algo como esto en el fichero:
<p><example>
package config;
$default_host = "ftp-master";
$cfg{"ftp-master"}{"login"} = "yourdebianusername";
$cfg{"non-us"}{"login"} = "yourdebianusername";
1;
</example>
<p>Por supuesto, cambia mis valores personales por los tuyos, y lee
la página de manual <manref name="dupload.conf" section="5"> para
comprender qué significa cada una de estas opciones.
<p>La opción $default_host es la más problemática, determina cual de las
colas de envios se usará por defecto. "ftp-master" es la primaria,
pero es posible que quieras usar otra más rápida.
Para más información sobre las colas de envio, lee la Referencia del
Desarrollador (Developers's Referente, n. del t.), sección
"Uploading a package", en
<file>/usr/share/doc/developers-reference/developers-reference.html/ch-upload.en.html#s-uploading</file>
<p>Entonces conecta con tu proveedor de Internet, y ejecuta la
orden:
<p><example>
dupload --to master gentoo_0.9.12-1_i386.changes
</example>
<p><prgn/dupload/ comprueba que las sumas md5 coinciden con aquellas en el
fichero .changes, y te avisará de rehacer el paquete como se
describe en <ref id="completebuild"> para poder enviarlo correctamente.
<p>Si lo estás enviando a "ftp-master", <prgn/dupload/ te pedirá
tu contraseña en las máquinas Debian, y entonces enviará los paquetes.
<chapt id="update">Actualizar tu paquete.
<sect id="newrevision">Nueva revisión Debian del paquete.
<p>Supongamos que se ha creado un informe de fallo en tu paquete
con el número #54321, y que describe un problema que puedes solucionar.
Para crear una nueva revisión del paquete, necesitas:
<list>
<item>Corregir, por supuesto, el problema en las fuentes del
paquete.
<item>Añadir una nueva revisión en el fichero de cambios (changelog,
n. del t.) de Debian, con `dch -i`, o explícitamente con
`dch -v <version>-<revision>` y entonces insertar los
comentarios con tu editor favorito.
<p>Sugerencia: ¿Como obtener la fecha fácilmente en el formato requerido?
Usa `822-date`, o `date -R`.
<item>Incluir una breve descripción del error y su solución
en la entrada del fichero de cambios, seguido por: "Closes: #54321".
De esta forma, el informe del error será automágicamente cerrado por los
programas de gestión del archivo en el momento en que tu paquete se
acepte en el archivo de Debian.
<item>Repite lo que hiciste en <ref id="completebuild">, <ref id="checkit">,
y <ref id="upload">. La diferencia es que esta vez, las fuentes
originales del archivo no se incluirán, dado que no han cambiado y
ya existen en el archivo de Debian.
</list>
<sect id="newupstream"> Nueva versión del programa fuente.
<p>Ahora consideremos una situación diferente, algo más complicada:
ha salido una versión nueva de las fuentes originales, y, por
supuesto, deseas empaquetarla. Debes hacer lo siguiente:
<list>
<item>Descarga las nuevas fuentes y pon el archivo tar (pongamos que
se llama `gentoo-0.9.13.tar.gz') un directorio por encima del
antiguo árbol de fuentes (por ejemplo ~/debian/).
<item>Entra en el antiguo directorio y ejecuta:
<example>
uupdate -u gentoo-0.9.13.tar.gz
</example>
<p>Por supuesto, reemplaza este nombre de fichero con el nombre de las
fuentes de tu programa. <manref name="uupdate" section="1">
renombrará apropiadamente este fichero tar, intentará aplicar los
cambios de tu fichero .diff.gz previo y actualizará el nuevo fichero
debian/changelog.
<item>Cambia al directorio `../gentoo-0.9.13', el nuevo directorio
fuente del paquete, y repite la operación que hiciste en <ref
id="completebuild">, <ref id="checkit">, y <ref id="upload">.
</list>
<p>Observa que si has puesto el fichero `debian/watch' como se
describe en <ref id="watch">, puedes ejecutar <manref name="uscan"
section="1"> para buscar automágicamente fuentes revisadas,
descargarlas, y ejecutar <prgn/uupdate/
<sect id="upgrading">Verificar actualizaciones del paquete.
<p>Cuando construyas una nueva versión del paquete, deberías hacer
lo siguiente para verificar que el paquete puede ser actualizado
de forma segura:
<list>
<item>actualízate a partir de la versión previa,
<item>vuelve a la versión anterior y elimínala,
<item>instala el paquete nuevo,
<item>elimínalo y reinstalalo de nuevo,
<item>purgalo.
</list>
<p>Ten en cuenta que si tu paquete ha estado previamente en Debian,
lo más frecuente es que gente actualize el paquete desde la versión
que estaba en la última versión de Debian. Recuerda testear las
actualizaciones desde esa versión también.
<chapt id="helpme">Dónde pedir ayuda.
<p>Antes de que te decidas a preguntar en lugares públicos, por
favor, simplemente RTFM ("Lee El Jodido Manual", n. del t.), que
incluye la documentación en <file>/usr/share/doc/dpkg</file>,
<file>/usr/share/doc/debian</file>, <file>/usr/share/doc/package/*</file>
y las páginas de man/info para todos los programas mencionados
en este documento.
<p>Si tienes dudas sobre empaquetado a las que no has podido encontrar
respuesta en la documentación, puedes preguntar en la lista de correo
de Debian Mentors <email/debian-mentors@lists.debian.org/.
Los desarrolladores más experimentados de Debian, te ayudarán gustosamente,
pero !leete la documentación antes de preguntar!
<p>Vease <url id="http://lists.debian.org/debian-mentors/";> para más
información sobre esta lista de correo.
<p>Cuando recibas un aviso de fallo (bug report, n. del t.) (sí,
avisos de fallos, ¡de verdad!) sabrás que es el momento de indagar en
el <url name="Sistema de Seguimiento de Fallos de Debian"
id="http://www.debian.org/Bugs/";> y leer la documentación de allí
para poder tratar los informes de forma eficiente.
Te recomiendo la lectura la de la Refencia del Desarrollador (Developers'
Reference, n. de T.), el capítulo de "Manejo de Bugs" (Handling Bugs, n. de T.), en
<file>/usr/share/doc/developers-reference/developers-reference.html/ch-bug-handling.en.html</file>
<p>Si aún tienes preguntas, házlas en la lista de distribución de
Desarrolladores de Debian en <email/debian-devel@lists.debian.org/.
Vease <url id="http://lists.debian.org/debian-devel/";> para más
información sobre esta lista de correo.
<p>Aunque todo funcione bien, es el momento de empezar a
rezar. ¿Por qué? Por que en sólo unas horas (o días) usuarios de
todo el mundo empezarán a usar tu paquete, y si cometiste algún
error crítico te bombardearán con correos de centenares de
usuarios furiosos de Debian... Sólo bromeaba :-)
<p>Relájate y prepárate para recibir informes de fallos, porque hay
mucho más trabajo que hacer antes de seguir completamente las
políticas de Debian (una vez más lee la <em>documentación real</em>
para más detalles). ¡Buena suerte!
</book>
</debiandoc>
Reply to: