Cómo usar jhbuild

Cómo usar jhbuild

jhbuild es una pequeña utilidad que permite mantener un entorno completo y aislado con aplicaciones construidas desde una fuente determinada. En buen español: nos permite decir 'descargame el código de éste servidor, éste otro, compilalo e instalalo en /home/diego/gnome-de-prueba/'.

¿Para qué queremos algo como esto? Pues por ejemplo para que podamos compilar la versión de desarrollo de GNOME sin comprometer la que viene con nuestra distribución y sin necesitar ser administrador de nuestro sistema para instalar o desinstalar nuevos módulos de GNOME.

Entonces, por ejemplo, si quieres probar GNOME 2.25 (la versión ahora en desarrollo), podrías descargar jhbuild y usarlo para construir un entorno en /home/diego/gnome-2.25/; probarlo, reportar bugs, jugar un rato, etc.

Glosario

Para entendernos mejor establezcamos algunos términos:

módulo: una aplicación como epiphany es considerada un módulo, gtk+ es un módulo, etc.
prefijo: le llamaremos prefijo al lugar donde instalamos los módulos compilados; para hacer una comparación con la realidad, el prefijo considerado por tu distribución es /usr, quiere decir que si uno instala epiphany encontrará el binario en /usr/bin/epiphany. Si usamos un prefijo /home/diego/prueba, entonces encontraremos un epiphany instalado por jhbuild en /home/diego/prueba/bin/epiphany.
compilar: pasar de código fuente a binario, es decir ejecutable
instalar: poner los ejecutables y otros archivos en el prefijo elegido al momento de compilar
~: esto significa /home/<tu nombre de usuario>/, prueba hacer 'echo ~' en tu terminal para q veas a q me refiero
checkout: cuando uno copia el código fuente disponible en el control de versiones (donde se mantiene ordenado y fechado y se registra cualquier cambio)
tarball: cuando una aplicación lanza una versión nueva (por ejemplo la 2.24.3 de epiphany), el mantenedor del proyecto empaqueta un tarball, osea una 'bola tar' que es un archivo comprimido que incluye el código fuente correspondiente a la versión 2.24.3

Antes de empezar

Asegúrate que tienes suficiente espacio en tu disco, unos 4 Gb se requieren para compilar un entorno GNOME completo (panel, explorador de archivos, gedit, epiphany, etc) Una recomendación importante es que de arranque definamos dos lugares: - dónde tendremos el código fuente descargado (checkouts de SVN o tarballs) - dónde se instalará lo producido luego de compilar el código, se le dice el prefix

Cómo empezar

Primero debemos descargar jhbuild, lo cual nos requerirá tener instalado subversion:

$ svn co http://library.gnome.org/devel/jhbuild

Ahora lo que haremos será rápidamente configurar e instalarlo, lo cual es realmente muy simple:

$ make
$ make install

Ahora tendremos jhbuild instalado en ~/bin, probablemente no tengas configurado tu variable $PATH para incluir ~/bin. La variable $PATH es la que le dice al shell (la línea de comando, la terminal, como quieras decirle) dónde buscar ejecutables, osea cuando escribes 'ls', si en tu $PATH no hay ningún directorio que contenga un archivo ejecutable 'ls' entonces obtendrás un mensaje 'comando no encontrado'.

Para modificar tu $PATH, edita el archivo ~/.bashrc y agrega al final de él (o crealo si es que no tienes uno):

...
export PATH=~/bin:$PATH

Eso en español quiere decir 'que la variable $PATH contenga ~/bin y lo que ya hay en ella'.

Probando que funcione

Simplemente:

$ jhbuild --help

si funciona, pues entonces jhbuild estará bien instalado.

Configurar jhbuild

jhbuild usa un archivo llamado jhbuildrc para saber de dónde descargar y dónde instalar lo compilado, es bastante simple, un ejemplo viene adjunto[0]

Podemos colocarlo en ~/.jhbuildrc o donde queramos, si no está en ~/.jhbuildrc entonces deberemos especificar siempre qué archivo de configuración usar. La configuración es bastante evidente, cualquier duda sobre otros parámetros disponibles se resuelve viendo el código de jhbuild (jhbuild/defaults.jhbuildrc)[1]

	# .jhbuildrc
	# Based on GNOME's jhbuildrc by Wouter Bolsterlee <uws+gnome@xs4all.nl>
	# Adapted by Diego Escalante Urrelo <diegoe@gnome.org>

	# - moduleset and modules ------------------------------------------------ {{{1

	moduleset = 'gnome-2.26'
	use_local_modulesets = True

	# - directories ---------------------------------------------------------- {{{1

	checkoutroot = '/home/diego/gnome/src/'
	prefix = '/home/diego/gnome/src/build/'

	# - autogen/configure flags ---------------------------------------------- {{{1

	autogenargs = '--disable-static --disable-gtk-doc --disable-scrollkeeper'

	# - compilation flags ---------------------------------------------------- {{{1

	os.environ['CFLAGS'] = '-g -O2'

	# - environment options -------------------------------------------------- {{{1

	## Para que las aplicaciones puedan encontrar los plugins de gstreamer
	os.environ['GST_PLUGIN_PATH'] = os.path.join(prefix, 'lib/gstreamer-0.10/')
	os.environ['PYTHONPATH'] = os.path.join(prefix, 'lib/python2.5/site-packages')

	# - extra env options ---------------------------------------------------- {{{1

	os.environ['DBUS_SYSTEM_BUS_ADDRESS'] = 'unix:path=/var/run/dbus/system_bus_socket'

Compilar una aplicación

Probemos compilar una aplicación simple y con pocas dependencias como por ejemplo Eye of GNOME:

$ jhbuild buildone eog

Explicando este comando, buildone es la órden 'compila e instala éste o estos módulos', eog es el nombre del módulo correspondiente a Eye of GNOME.

Nota: si hemos colocado nuestro jhbuildrc en algún otro lugar excepto ~/.jhbuildrc, habrá que especificarlo con la opción '-f <ruta al jhbuildrc>'. Por ejemplo, yo guardo el jhbuildrc correspondiente a cada entorno en el mismo directorio donde descargo el código fuente, entonces cuando quiero compilar algo ejecuto:

$ jhbuild -f jhbuildrc <órdenes>

Ejecutar una aplicación

$ jhbuild run <ejecutable>

Ingresar al entorno

$ jhbuild shell