Archivos de Tags: Debianizar - Paginas 3

Debianizando Programas. Parte 3

Enviado por el 29 enero, 2008 8 comentarios

Debianizando Programas Con Autotools o Scons

Hola. Bueno vamos con la tercera parte de este auto-tutorial que estoy dedicando a mi aprendizaje para debianizar programas. Hoy voy a escribir la parte en la que queremos debianizar un programa el cual para su instalación necesitamos compilarlo previamente. Esta forma de debianizar es la más traumática al principio :-S pero cuando llevas unos cuantos hechos ya no parece tan complicado.

Bueno he de decir que lo explicaré para aquellos programas que los debianizaremos en un único paquete, es lo que se llama de forma simple, los de forma múltiple no los he probado todavía.

Empecemos, lo primero será ver que nuestro programa para su instalación utiliza autotools ( es decir, que para instalarlo utilizamos lo del configure, make y make install). Después os recomiendo que leáis bien las instrucciones para su compilación. Una vez hecho esto pasamos a compilar con:

Clic para ver Texto Plano
CODE:
  1. sudo apt-get build-dep nombre_del_programa
  2. ./configure --prefix=/usr [más opciones extra necesarias para su compilación]
  3. make

Vamos a aclarar un par de cosas, lo primero es que el comando apt-get build-dep nos podrá servir de ayuda para instalar previamente algunas de las dependencias necesarias para poder compilar nuestro programa a debianizar.

Lo segundo es que con configure deberemos leer bien antes las instrucciones de nuestro programa para saber si debemos añadir al configure alguna opción más, nos puede servir de ayuda el hacer previamente ./configure --help. Yo antes de pasar a debianizar un programa os aconsejo hacer el make por si sale algún error. Estos errores pueden ser debidos a incumplimientos de dependencias, a un error en el código del programa o a una falta de opciones al realizar el configure; entre otras.

Vale, pensemos que nuestro programa se ha compilado perfectamente :D lo siguiente será preparar el programa con la creación de unos ficheros necesarios. Esto lo realizaremos con el siguiente comando:

Clic para ver Texto Plano
CODE:
  1. dh_make -e nuestrocorreo -s -n

en donde reemplazaremos donde dice nuestrocorreo por nuestro correo =)) La opción -s es para indicarle que vamos a debianizar de forma simple, con -m lo haremos de forma múltiple. Bien cuando se ejecuta esta opción nos aparecerán unas líneas de información de lo que nos creará, le decimos que Sí y ya esta esta parte hecha.

Al término de la ejecución del susodicho comando se nos habrá creado dentro del directorio de nuestro programa un directorio (( o carpeta )) llamado debian, en el que dentro de él tendremos nuestro fichero control y unos cuantos más, muchos de ellos acabados en su nombre con .ex o .EX ( abreviatura de example en inglés). Bien, de esos ficheros si el programa no es muy complicado podemos optar por borrar los siguientes:

  • Cualquiera que empiece por emacsen ( siempre y cuando nuestro programa no tenga soporte para Emacs)
  • cron.d.ex, init.d.ex, watch.ex

Si no estamos seguros podemos optar por la opción de no borrarlos. También podemos hacer, aunque no es necesario, borrar el .ex o .EX en todos ellos. Según la complejidad de nuestro programa a debianizar necesitaremos editar, borrar o no ciertos ficheros, esto es muy largo de explicar aquí, lo mejor es que leáis el siguiente enlace. Pero ya os digo que con lo que os he puesto aquí tendréis en general suficiente para llevar vuestra tarea a buen puerto.

Ahora viene el paso más importante, que es editar el fichero control que viene dentro del recién creado directorio debian. Lo podremos crear con cualquier editro de textos, como gedit. Toda la información de lo que tenemos que poner dentro del fichero la podéis leer en el artículo que escribí PINCHANDO AQUÍ, pero con la salvedad de que no hará falta editar la línea Depends, la cual nos aparecerá así:

Clic para ver Texto Plano
CODE:
  1. Depends: ${shlibs:Depends}, ${misc:Depends}

No la editaremos porque al ejecutar el siguiente comando que os voy a decir, ya nos la rellenará por nosotros. Cuando hayáis terminado de editar el fichero control y estéis seguros de todo lo demás finalizaréis con la introducción por terminal del siguiente comando:

Clic para ver Texto Plano
CODE:
  1. debuild --linda -us -uc

Este comando se encargará de crear nuestro paquete final debianizado o de si han habido fallos nos avisará de cuáles y sus posibles soluciones. La información de los posibles fallos se debe gracias a que al comando debuild le hemos añadido la opción --linda. En la pantalla si hay errores o avisos nos aparecerán etiquetados con E o W respectivamente.

ATENCIÓN: Apartir de Ubuntu Hardy Heron el script de linda desaparece como opción en debuild, así que deberéis ponerlo para debianizar así:

Clic para ver Texto Plano
CODE:
  1. debuild -i -us -uc -b

o si queréis así:

Clic para ver Texto Plano
CODE:
  1. debuild -us -uc

Seguirá habiendo control de errores y warnings de vuestras debianizaciones, pero serán a través del script lintian, el cual se activa como opción por defecto con debuild.

Y ya está, si todo ha ido bien restará instalar nuestro programa debianizado con Gdebi, ver si funciona bien y si queremos podemos compartirlo con los demás >:D< A ver si de aquí unos días os escribo cómo crearos vuestro propio repositorio.

Os recomiendo que antes que nada os leáis las dos primeras partes de este tutorial y que las encontraréis bajo la etiqueta Debianizar de este blog.

Este artículo se ha podido escribir gracias a la colaboración desinteresada para enseñarme a debianizar de mi colega por la red de redes Daniel Cremades <:-P

Saludos :-h

Debianizar Programas Con Checkinstall

Enviado por el 20 enero, 2008 Comentarios desactivados

Hola, Checkinstall es un programa con el cual podemos convertir con cierta facilidad programas que instalamos mediante compilación a un paquete debianizado ( con extensión .deb). Al convertir el programa a debianita conseguimos ciertas ventajas, como:

  1. Podemos desinstalar e instalar nuestro programa fácilmente desde Synaptic o Adept.
  2. Quedará registrado en el listado de paquetes instalados con apt y aptitude, cosa que no pasa si lo hacemos con la orden make install.
  3. Podemos distribuir nuestro programa con facilidad a otra gente para que se lo instale, bien por descarga directa del paquete o montando nuestro propio repositorio de terceros para Debian o cualquier distribución hija de Debian, salvando lógicamente los problemas de dependencias y demás.

Para poder utilizar checkinstall deberemos instalarlo previamente, lo cual es muy sencillo; ya que viene en los repositorios de cualquier distro Debian, así que desde Synaptic o Adept (en KDE) sólo tendremos que buscarlo e instalarlo. No tiene mayor complicación ;)
Para utilizarlo, bueno pues primero habrá que compilar el programa :-S ¿Cómo? Pues siguiendo estos pasos:

  1. Descomprimir el programa a instalar.
  2. Abrir terminal y situarnos con el comando cd en el directorio en que se encuentra el programa recién descomprimido. En GNOME este paso lo podéis hacer más sencillo si instaláis previamente desde Synaptic el programa nautilus-open-terminal.
  3. Ahora hay que hacer lo siguiente:
  4. ./configure --prefix=/usr [más todas las opciones que hagan falta para compilarlo] Normalmente con lo puesto es suficiente, pero lo mejor es documentarse antes. No voy a extenderme más en la explicación de este paso porque no es de lo quie trata el artículo. Luego tecleamos
  5. make (sin permisos de superusuario)

Una vez hecho estos pasos y siempre que no hayamos obtenido por terminal ningún mensaje de error pasaremos a utilizar checkinstall. Así que tan sólo tendremos que teclear desde la misma terminal y sin permisos de superusuario la orden:

checkinstall

Seguidamente nos preguntará si queremos crear un paquete de documentación del programa, lo normal es contestar que no. Luego nos pedirá que pongamos una descripción del programa, introducimos la descripción del programa, ha de ser corta, sin acentos ni símbolos raros. Para terminar la descripción basta con dar una vez a la tecla ENTER de nuestro teclado.
Después nos aparecerá un menú con distintas opciones numéricas con las cuales podremos editar nuestro fichero control, según la opción que tecleemos podremos poner el nombre del mantenedor del programa debianizado con su e-mail, la arquitectura del PC para la que se puede instalar el programa o las distintas dependencias que necesite para su instalación. Cuando hayamos terminado de introducir los datos necesarios bastará darle una vez a ENTER para terminar. Podéis consultar sobre la edición del fichero control AQUÍ.
Vale, ahora tan sólo hará falta esperar a que checkinstall nos haga por arte de magia nuestro paquete debianizado.
Seguramente obtengamos al final un mensaje de error informándonos de que se ha creado nuestro paquete pero no se ha podido instalar. No pasa nada, eso es debido a que hemos ejecutado checkinstall sin permisos de superusuario, pero es recomendable hacerlo así, ya que si no nuestro paquete debianizado nos aparecerá de forma que no podremos cambiarle los permisos, es decir; nos aparecerá con el emblema del candado; lo cual hará que sólo lo podamos instalar nosotros pero no lo podrán instalar otras personas en un ordenador distinto del nuestro. (( Supongo que con mc podría solucionarse esto, pero así me parece más cómodo ))

Y bien, ahora sólo queda instalarlo con Gdebi y ver si funciona :P
Si queremos que nuestro programa debianizado vaya a un repositorio, con frecuencia deberemos volver a editar el fichero control, para ello deberemos descomprimir el paquete .deb que hemos obtenido con checkinstall, entrar dentro del directorio que nos aparecerá tras la descompresión, veremos dos tres ficheros:

  • Uno es el control.tar.gz, deberemos descomprimirlo, renombrar el directorio recién descomprimido con el nombre DEBIAN, en mayúsculas.
  • Descomprimir el fichero data.tar.gz
  • Borrar los ficheros control.tar.gz, data.tar.gz y debian-policy.
  • Entrar dentro del directorio DEBIAN, borrar el fichero md5sum y abrir el fichero control para editarlo a nuestro gusto.
  • Luego seguir los siguientes pasos para obtener el paquete debianizado final.

Estos últimos pasos no es normal que los hagáis si sólo queréis obtener un programa debianizado para vuestro propio uso, así que no os preocupéis ;)

Me gustaría recalcar que checkinstall es un buen programa si el programa a debianizar es ligero, es decir; con pocas dependencias, o que no se tiene que debianizar de forma múltiple. En otro caso, hay otras formas de hacerlo, que son más arduas y complicadas, pero más seguras y fiables.

Saludos :-h

Debianiza Tus Programas Con Deb Creator

Enviado por el 6 enero, 2008 Comentarios desactivados

Hola, desde GnomeFiles me he enterado de este programa escrtito en GTK que nos permite debianizar nuestros programas de una forma muy sencilla y cómoda. Eso sí no os voy a engañar hay que saber un poco de compilar o de conocer todas las dependencias del programa a debianizar.
Lo he probado para debianizar en mi Ubuntu Gutsy la nueva versión de nautilus-image-converter y me ha funcionado perfecto.
Para su utilización lo que recomiendo es que antes compiléis el programa a debianizar con las consabidas órdenes:

./configure --prefix=/usr
make

No hagáis el make install. Si todo ha funcionado bien tan sólo queda abrir Deb Creator e ir rellenando las diferentes ventanas que van saliendo.
En la ventana "Select The Application" tendréis que indicarle el paquete a debianizar, si tenéis la opción "Select The Top Source Directory" desactivada sólo os dejará seleccionar el .tar.gz, si la tenéis activada os dejará seleccionar la carpeta (directorio) que habéis compilado previamente.
En la ventana "Package meta-data" os aparecerán tres pestañas:

  1. Pestaña General: En ella ponéis vuestro nombre, vuestro Email, una descripción corta del programa y otra más larga en la que podéis poner la web del creador del programa a debianizar (( a mi con nautilus-image-converter se me ha olvidado )) . También podéis especificar el tipo de licencia.
  2. Pestaña Optional: Atención esta pestaña puede engañar por su nombre, para mi es fundamental que la rellenéis correctamente, sobretodo la sección Depends que os aconsejo que borréis lo que os pone por defecto y la rellenéis a mano y bien. En Depends debéis poner los paquetes y versión de la que depende vuestro programa, una guía muy buena para ello es acudir a la web ubuntu-packages o a la de Debian. En Architecture podéis cambiar any por i386 o amd64 o ppc según sea el caso. En Section tenéis un listado a elegir, coged la más apropiada. En Recommends y Suggests podéis poner los paquetes recomendados y sugeridos, podéis dejarlos en blanco. Los demás los he dejado en blanco.
  3. Pestaña Files listing: Os da un listado de todos los directorios y ficheros que entran en la debianización.

Después de eso sólo queda seguir los dos "Siguientes" y esperar a que acabe.
Ya digo lo he probado y me ha funcionado, pero no se si funcionará cuando el configure necesite varias opciones o para programas que se empaquetan en varios.
Para descarga e instalación del programa AQUI
Si queréis podéis descargar nautilus-image-converter para Gutsy de AQUI
Saludos :)

Debianizando Programas. Parte 2

Enviado por el 25 diciembre, 2007 4 comentarios

Debianizando Programas Y Utilidades Sin Autotools

O Scons


Hola, vamos con la segunda parte de debianizar programas. En este caso trataremos el caso de cómo debianizar programas y utilidades que para su instalación no requieren hacer previamente una compilación para instalarlos.
Entre estos programas podemos encontrar los navegadores como Firefox, Netscape, Flock, etc. También podemos encontrar programas como Eclipse, EasyEclipse, Prism, Thunderbird, etc. Además podemos debianizar fácilmente también temas de iconos, de GDM, de Themes para GNOME, etc. Hay que tener una cosa clara, y es que el hecho de no requerir una compilación no implica necesariamente que no tengamos que conocer sus dependencias para debianizarlos. Por ejemplo, Azureus Vuze requiere la dependencia de sun-java5-jre para que funcione.
Para escribir este artículo nos apoyaremos como ejemplo en debianizar el programa Prism. Lo primero que haremos es descargar el programa a debianizar, normalmente vienen empaquetados en formato tar. Podéis descargar Prism de Aquí.
Una vez descargado nos vamos a crear una carpeta genérica en la que iremos metiendo los programas que queremos debianizar. La carpeta la crearemos en nuestro directorio personal, en mi caso el directorio personal se llama crislosi; y la carpeta genérica la he llamado EMPAQUETADOS (la podéis llamar como queráis). Dentro de esa carpeta crearemos otra carpeta con un nombre que identifique al programa que queremos debianizar, para Prism le voy a llamar prisma (llamarle como os de la gana). Resumiendo, tenemos por ahora la siguiente ruta de carpetas o directorios creados:

/home/crislosi/EMPAQUETADOS/prisma/

Fácil, ¿no?. Ahora dentro del directorio o carpeta prisma vamos a crear las carpetas en donde quedará guardado nuestro programa cuando se instale. Aquí tenemos dos posibles formas para hacerlo:

  1. Crear la ruta /usr/share
  2. O crear la ruta /opt

Podemos escoger la que queramos, yo por comodidad, como Prism no viene en los repositorios he optado por /opt. Pero si nuestro programa es alguno que viene ya en los repositorios oficiales de Ubuntu recomiendo la ruta /usr/share.
¡ATENCIÓN! si lo que queremos debianizar es un paquete de iconos es obligado que la ruta que creéis sea /usr/share/icons si son un tema de iconos para GNOME. Igualmente, si lo que vas a debianizar es un GDM deberás crear la ruta exacta de los gdms. Un buen truco para saber qué ruta es la correcta es abrir Synaptic, en Configuración->Preferencias habilitar la opción "Mostrar las propiedades del paquete en la ventana principal". Buscar un paquete de iconos o lo que vayáis a debianizar y en la pestaña "Ficheros Instalados" podréis ver la ruta exacta de dónde deberán estar instalados.
Volviendo pues a nuestro ejemplo y como he decidido escoger la opción 2 mentada arriba, tendremos creada la siguiente ruta de directorios:

/home/crislosi/EMPAQUETADOS/prisma/opt

Ahora dentro del directorio /opt que acabamos de crear descomprimimos el fichero que nos hemos descargado. Todo esto lo podéis hacer fácilmente con nautilus y el típico Copiar y Pegar, no hace falta utilizar la terminal para ello. Acordaros de si tenéis el programa comprimido a instalar guardado dentro de /opt de borrarlo una vez lo hayáis descomprimido. Bien, en nuestro caso de Prism se nos ha creado una carpeta llamada "prism", así pues tenemos:

/home/crislosi/EMPAQUETADOS/prisma/opt/prism

Ahora viene un paso fundamental hacerlo bien, y es el de crear la carpeta o directorio DEBIAN donde corresponde. La carpeta DEBIAN la crearemos en la ruta

/home/crislosi/EMPAQUETADOS/prisma

Fijaros que debe ir dentro del directorio prisma pero fuera de los directorios en que se instalarán los programas a debianizar que he especificado en las dos opciones anteriores y que en nuestro ejemplo es el /opt. Una cosa muy importante es que la carpeta DEBIAN debéis llamarla en mayúscula en la totalidad de su nombre, no en minúsculas.
Volviendo pues a nuestro ejemplo de Prism tenemos las dos rutas siguientes:

/home/crislosi/EMPAQUETADOS/prisma/opt
/home/crislosi/EMPAQUETADOS/prisma/DEBIAN

Bien, dentro del directorio DEBIAN vamos a crear el fichero que llamaremos "control" (en minúsculas y sin extensión alguna en su nombre). Lo podemos crear fácilmente con gedit.
Para Prism tenemos el siguiente control

Clic para ver Texto Plano
CODE:
  1. Package: prism
  2. Version: 0.8
  3. Architecture: i386
  4. Maintainer: Tobal
  5. Depends:
  6. Section: guada-users
  7. Priority: extra
  8. Description: Programa para internet
  9. Aplicacion que nos permite crear accesos directos a aplicaciones como gmail
  10. Homepage: http://starkravingfinkle.org/blog/

Este control os puede servir como plantilla para otras debianizaciones. Paso a explicaros cómo es su estructura.

  • En Package ponemos el nombre del programa, en éste caso prism
  • En Version ponemos la versión del programa a debianizar, la nuestra es la 0.8
  • En Architecture especificamos la arquitectura en la que esta soportada el programa, que puede ser: i386, amd64, ppc, all. Yo he elegido i386 para prism, así si alguien intenta instalar Prism desde GDebi en un Ubuntu de 64 bits le saldrá el mensaje de arquitectura no soportada y no lo podrá instalar. Si ponemos "all" no habrá problemas.
  • En Mainteiner ponemos nuestro nombre y correo electrónico.
  • En Depends debemos poner los paquetes de los que depende para que funcione. Como no depende de ninguno lo dejo en blanco. Pero para Azureus le puse que dependía de sun-java6-jre
  • En Section especificamos la sección en la que aparecerá en Synaptic, como no hay problemas aquí podemos crear una nueva, en éste caso le he llamado guada-users.
  • En Priority hemos de especificar su prioridad, como es un paquete no soportado oficialmente por Ubuntu y Debian le he puesto extra.
  • En Description ponemos una descripción corta del programa y en la línea siguiente otra un poco más larga (dejar un espacio en blanco al principio de la segunda línea y no pongáis acentos que salen feos)
  • En Homepage hay que poner la web del creador del programa.

Quiero aclarar una cosa importante en la sección Depends, es que si el programa depende de más de un paquete y de a partir de una versión específica la nomenclatura a seguir es, por ejemplo; para dos paquetes:

Depends: paquete1(>versionpaquete1), paquete2(>versionpaquete2)

En el fichero control podemos especificar más secciones, pero para el caso de debianizar programas sin autotools o scons no son muy importantes ni necesarios; con estos funciona bien.

Pues bien, hasta aquí ya lo tenemos en principo casi todo, pero muchos programas no nos vienen con un acceso directo para ejecutarlos, es el caso de Prism; así que vamos a crearlo. Para ello crearemos la ruta de carpetas /usr/share/applications dentro de la carpeta prisma, tendremos pues las tres rutas siguientes:

/home/crislosi/EMPAQUETADOS/prisma/opt
/home/crislosi/EMPAQUETADOS/prisma/DEBIAN
/home/crislosi/EMPAQUETADOS/prisma/usr/share/applications

Dentro de la tercera ruta crearemos con gedit el fichero lanzador de la aplicación, y le llamaremos nombreprograma.desktop, en nuestro caso prism.desktop y tendrá el siguiente contenido:

Clic para ver Texto Plano
CODE:
  1. [Desktop Entry]
  2. Encoding=UTF-8
  3. Name=Prism
  4. Comment=Prism
  5. Exec=/opt/prism/prism
  6. Icon=/opt/prism/chrome/icons/default/webrunner48.png
  7. Terminal=false
  8. Type=Application
  9. Categories=Application;Network;
  10. StartupNotify=true

La explicación de estos ficheros Pinchando Aquí
Ahora que ya lo tenemos todo tan solo nos queda crear el fichero md5sum. Para ello abrimos terminal y nos situamos en la ruta correcta, en nuestro caso:

/home/crislosi/EMPAQUETADOS/prisma

En la terminal escribimos la siguiente orden:

find . -type f -print0 | xargs -0 md5sum > md5sums

Ahora abrimos con gedit md5sums y hacemos lo siguiente: borramos las líneas que hacen referencia al fichero md5sums y al directorio DEBIAN. Después desde gedit en Buscar->Reemplazar cambiamos los ./ por / y lo guardamos. Finalmente lo movemos a la carpeta DEBIAN. Es aconsejable que este fichero lo hagáis cuando lo tengáis todo listo, si os equivocáis en algún paso anterior deberéis volver a crear desde cero el md5sum.

Y ahora el paso final, crear el paquete .deb con la herramientas dpkg y fakeroot, seguiremos la siguiente nomenclatura generalizada:

Clic para ver Texto Plano
CODE:
  1. fakeroot dpkg-deb -b ruta_de_lo_que se_empaqueta ruta_donde_guardar_lo_empaquetado/nombre_del_fichero_empaquetado.deb

Para Prism será:

Clic para ver Texto Plano
CODE:
  1. fakeroot dpkg-deb -b /home/crislosi/EMPAQUETADOS/prisma/ /home/crislosi/EMPAQUETADOS/prism_0.8ubuntu_i386.deb

Fijaros bien en las rutas porque sino os puede pasar que en el fichero.deb creado os guarde dentro el mismo fichero .deb. Recordad que un .deb no es mas que una forma de empaquetar (comprimir) ficheros que podemos descomprimir con FileRoller.
La instrucción dpkg se debe hacer sin permisos de root, y la opción -b es una abreviación de build (construir) para que nos construya el paquete. Si ponemos -i nos lo instalará.
Para saber cómo llamar a nuestros paquetes debianitas AQUÍ

Pues bien, tan sólo nos queda instalarlo con GDebi y probar si funciona ;)
El fichero de Prism debianizado os lo podéis descargar de AQUÍ

Fuente->OcioLinux para Prism
Fuente->Blog del creador de Prism
Fuente->Debian

Saludos :)

Etiquetas:

Debianizando Programas. Parte 1

Enviado por el 21 diciembre, 2007 13 comentarios

Requisitos Previos A La Debianización

Hola, voy a empezar a escribir una serie de artículos sobre cómo debianizar programas que me van a servir de modo de apuntes. También espero que si alguien llega a leerlos le puedan servir. Estos tengo pensado que me ocupen tres artículos, que consistirán en:

  1. Requisitos previos a la debianización.
  2. Debianizando programas y utilidades que no poseen autotools o scons.
  3. Debianizando programas y utilidades que sí poseen autotools.

Los dos primeros artículos los tengo claros, el tercero es ciertamente jodido de aprender y no se cuándo lo escribiré :( Igual me hago viejo antes ;)

Bueno, empecemos con el asunto. Leyendo mucho y con ayuda de Daniel he llegado a la conclusión que lo primero es tener un esquema de aquello que necesitamos antes de debianizar, como instalación de programas o entender ciertos conceptos.

Para los que no lo sepan todavía, debianizar un programa es crear un instalador del programa, para que lo podamos instalar mediante un simple doble click izquierdo de ratón. Como el instalador tendrá como extensión de nombre .deb, abreviación de Debian, de ahí que al proceso de obtener dicho instalador se le suela llamar debianización. Para los que
vienen de windows el .deb es el equivalente al .exe de windows de los ficheros que se llaman Setup.exe. Los otros .exe que hay en windows son los ejecutables de los programas, y que en Linux suelen ser los de extensión .bin. Pero esto que acabo de decir no es del todo cierto, baste bajarse el instalador para linux de jdk6 que es un .bin pero es un instalador, además de ser un ejecutable; no se si me explico :( .

En cuanto a los programas a instalar he decidido que una buena forma de empezar es tener instalados los siguientes:

build-essential dpkg-dev file libc6-dev patch perl
autoconf automake dh-make debhelper devscripts fakeroot gnupg g77 gpc
xutils lintian cdbs pbuilder debian-policy developers-reference
manpages-es manpages-es-extra debian-reference-es

Todos ellos los podéis instalar de una tacada desde una terminal con apt-get install o aptitude install en modo superusuario. De todos ellos, el build-essential nos será necesario para poder compilar aquellos programas que requieran de ello para su instalación mediante los archiconocidos comandos:

./configure

make

sudo make install

Este paquete además nos será necesario para debianizar paquetes que trataré en el tercer artículo, ya que para convertirlos en .deb es preciso hacer previamente bien la compilación, por lo menos, hacer bien el configure.

Otro paquete a tener muy en cuenta es dpkg y dpkg-dev ya que nos servirán para convertir programas que no requieran de compilación en formato .deb, de esto se tratará en el segundo artículo.

Los paquetes linda y lintian son paquetes que nos servirán sobre todo para ver si hemos cometido errores en nuestra debianización. Me explico, es normal que podamos llegar a poder debianizar un paquete (obtener su .deb) pero que no sea correcto. Estos scripts nos ayudarán a depurar posibles errores, muy frecuentes son los errores de sintaxis. No os preocupéis, de esto ya hablaremos.

Como el artículo me puede salir demasiado largo os dejo la explicación de los demás programas en el siguiente enlace Yo tampoco entendí ni jota al leerlo por primera vez, pero conforme te vas metiendo en el fango empieza tu mente a esclarecer.

Una cosa que debemos de tener muy clara es saber cuáles son las dependencias, si las tiene, de los programas a debianizar. No sólo para su futura instalación si no también para su compilación. Para buscar cuáles son, más o menos, hay pautas a seguir:

  1. Leer los archivos README e INSTALL de los tar que nos hayamos bajado.
  2. Leer la documentación de la web oficial del programa a instalar.
  3. Si el programa a debianizar es una actualización de alguno que
    está en los repositorios oficiales de ubuntu, debian, guadalinex o
    cualquier distro basada en debian podemos consultar las dependencias
    desde el mismo Synaptic. Yo a veces me guio en ubuntu-packages.
  4. Para la compilación hay que tener en cuenta que si necesitamos un paquete X también necesitaremos el mismo paquete pero en su versión de desarrollo, es decir, el que se suele llamar X-dev
  5. Escribir desde la terminal ./configure --help

Estas son algunas de las pautas que yo sigo, si alguien tiene más soy todo oídos :D

Hay que tener muy claro que para debianizar programas, que en su instalación conlleva hacer la compilación, también la tendremos que hacer para su debianización. Para tener claro qué es compilar, lo resumo en pocas palabras:

  • Primero hacemos el configure, que consiste básicamente en comprobar
    qué tipo de arquitectura es nuestro Linux (i386, 64 bits, ppc ) y en
    ver que los paquetes que necesitamos para compilar los tenemos todos
    instalados. Además en el configure podremos especificar dónde se
    instalará nuestro programa con la opción --prefix =/directorio. También podremos habilitar o deshabilitar ciertas características del programa.
  • Después haremos el make, el cual es el paso de verdad. En este
    compilamos el programa, es decir; comprobamos si el código de nuestro
    programa posee errores o no. También se nos avisa de posibles warnings. Si no posee errores nos creará los
    correspondientes ficheros ejecutables.
  • El último paso es el make install, este básicamente lo que hace es
    pasar nuestros programas a los directorios de nuestro disco duro para
    poder tenerlo "instalado" en nuestro PC. Este paso lo omitiremos en la
    debianización, ya que cuando obtengamos nuestro paquete debianizado,
    será mediante éste último con el que instalaremos nuestro programa.

Repito que esto sólo es una muy somera explicación de lo que significa compilar un programa. Ya que faltaría explicar que relación hay entre este tipo de compilación y la que hacemos cuando escribimos el código de un programa.

Otra cosa a tener en cuenta, es que muchas veces tendremos que crear nosotros mismos los ficheros de acceso directo al programa. Por ejemplo, supongamos que debianizamos el programa Prism, nos lo bajamos y al descomprimirlo nos damos cuenta que no está el fichero para que nos aparezca su acceso directo en Aplicaciones->Internet ( en GNOME ).
¿Cómo lo hacemos? Pues creando un fichero que llevará la extensión .desktop en su nombre; para Prism sería prism.desktop. Este fichero lo podemos editar con gedit y sigue un esquema como el siguiente:

Clic para ver Texto Plano
CODE:
  1. [Desktop Entry]
  2. Encoding=UTF-8
  3. Name=Prism
  4. Comment=Prism
  5. Exec=/opt/prism/prism
  6. Icon=/opt/prism/chrome/icons/default/webrunner48.png
  7. Terminal=false
  8. Type=Application
  9. Categories=Application;Network;
  10. StartupNotify=true

Donde Name es el nombre del programa, Comment es el comentario del mismo,Exec es la ruta hacia el ejecutable del programa, Icon es la ruta hacia el icono que le asignaremos a nuestro programa por defecto (el cual cambiará automáticamente si cambiamos el tema de iconos), Terminal es donde especificamos si se abre por terminal o no (false/true, es un valor booleano ). Type donde queremos que aparezca en el menú, en este caso en Aplicaciones (hay que ponerlo en inglés). Las dos últimas opciones creo que están claras ;)

Cambiando de tema, otra cosa a tener en cuenta es que debemos saber el nombre del paquete, su versión y la arquitectura en la que lo instalaremos; ya que a parte de tener que especificarlo en el fichero control ( que ya veremos qué es) ; lo deberemos de especificar en el nombre del paquete debianizado. Así, para un programa cualquiera tendremos lo siguiente: sunombre_XXX_YYY.deb, siendo XXX su número de versión ( por ejemplo, 1.0.1 ) e YYY su arquitectura ( i386, amd64, all, ppc )

Otra cosa importante es saber que un buen sitio para instalar nuestros programas debianizados es en /usr/share o en /opt, siempre y cuando no sean oficiales o programas que deban estar en ciertos sitios específicos. Me explico, si queremos debianizar un tema de iconos debemos hacer que se instalen en /usr/share/icons y no en otro lugar, para que cuando vayamos a cambiar nuestro tema de iconos lo podamos cambiar desde Sistema->Preferencias->Apariencia, suponiendo
obviamente que nuestro tema de iconos es para GNOME.

Bueno, hasta aquí esta primera parte de debianización. Aclarar que son mis apuntes, para aclararme yo, y por eso no son rigurosos. Los apunto para mi y para compartirlos en la red con todos los demás.

Este artículo no se habría podido escribir sin la inestimable ayuda de Daniel Cremades, que pacientemente y por mensajero me ayuda a entender cómo debianizar. Muchas gracias pañero :)

Fuente->Debian

Saludos :)

Etiquetas:

Page 3 of 3123