Crear nuevos módulos de software

Una vez que tengas un SDK y un poco de espacio disponible en tu disco duro puedes empezar a crear tus propios módulos de software para agregar aplicaciones a dyne:bolic. Si necesitas más información sobre las características y el uso de los modulos dyne, puedes revisar la sección "Módulos extra de software" de este manual. Ahora continuaremos con algunas instrucciones en cómo crearlos.

Antes que nada asegurate que tienes un dock de tu sistema en un disco duro y luego crea un SDK (mira el capítulo anterior). Cuando tengas un directorio SDK en tu directorio puedes ver su localización con tan solo teclear:

[d:b] ~ # echo $DYNE_SYS_MNT/SDK [Enter]

El próximo paso es crear el directorio para los módulos en el SDK y para eso elegiremos un nombre para nuestro módulo: vamos a crear el módulo tortilla con los comandos:

[d:b] ~ # mkdir -p $DYNE_SYS_MNT/SDK/modules/tortilla [Enter]
[d:b] ~ # mkdir $DYNE_SYS_MNT/SDK/modules/tortilla/bin [Enter]
[d:b] ~ # mkdir $DYNE_SYS_MNT/SDK/modules/tortilla/lib [Enter]
[d:b] ~ # touch $DYNE_SYS_MNT/SDK/modules/tortilla/VERSION [Enter]

básicamente estamos creando los directorios bin y lib además del archivo VERSION dentro del módulo, lo que puedes hacer con cualquier explorador de archivos o con midnight commander si quieres: vamos, sientete cómoda ;)

El último paso es activar nuestro módulo tortilla montándolo en /opt/tortilla ya que todos los módulos son activados en el prefijo /opt. Para hacer esto usamos nuevamente el comando DyneSdk:

[d:b] ~ # dynesdk mount [Enter]
[d:b] ~ # source /boot/dynenv.modules [Enter]

¡Eso es todo! Nuestro nuevo módulo está montado en /opt y tenemos nuestras rutas configuradas correctamente.

Ten en cuenta que antes de comenzar el desarrollo de tu módulo, necesitas montar el dynesdk cada vez que reinicies. Puedes también abrir un módulo existente para trabajar en su desarrollo, pongamos por ejemplo tu excelente módulo tlayuda en el que tienes semanas trabajando; para hacer esto utilizas el comando:

[d:b] ~ # dynesdk devel tlayuda [Enter]

Te regresará una pregunta, si es que quieres descomprimir el contenido del módulo para su desarrollo, indicándote el espacio que ocupará en tu disco duro. Paso seguido puedes compilar el software tortilla con

[d:b] ~ # ./configure --prefix=/opt/tortilla [Enter]

o en algunos casos editar el PREFIX en el Makefile - ¡y no olvides ponerle salsa! :)

Para hacerlo más facil, cuando el software se construye con los usuales "./configure && make && make install" puedes usar el comando dynemodconf (seguido por el nombre del módulo) en vez de llamar directamente a ./configure. Esto ajustará el prefijo mas correctamente. Por ejemplo para compilar "mole-0.5" con el flag "--con-frijoles" dentro de tu módulo de tortilla:

[d:b] ~/mole-0.5 # dynemodconf tortilla --con-frijoles [Enter]

Una vez que has terminado de cocinar... digo, compilar, entonces puedes juntar todo en un módulo comprimido .dyne con

[d:b] ~/mole-0.5 # dynesdk squash tortilla [Enter]

¡y ahi está! tu nuevo módulo se encontrará en $DYNE_SYS_MNT/dyne/SDK/cdrom/dyne/modules/tortilla.dyne listo para ser incluido en el próximo CD ISO que puedes empaquetar con dynesdk mkiso.

Antes de liberar tu módulo a la comunidad, es una buena idea llenar alguna información acerca de tu creación para que la gente pueda contactarte y visitar las páginas del software. Para esto es el archivo VERSION que contiene un formato muy simple:

name            Tortilla
desc            Frijoles negros en salsa de mole con tortillas
version         1.0
url             http://craizymaiz.tv/tortilla
packager        La Tlayudera Loca http://craizymaiz.tv/~tlayudera

Usa tu editor de texto preferido para llenar estos campos, deja un espacio o una tabla entre cada nombre de campo y eso es todo.

Puedes agregar entradas o submenús para que el usuario pueda ejecutar tu software. Para hacer esto crea un archivo applist dentro del directorio etc de tu módulo, por ejemplo opt/tortilla/etc/applist. El archivo applist contendrá una lista de las aplicaciones binarias, las descripciones y los modos para comenzarlo mediante la utilización de flags. A continuación se muestra una descripción del formato, que es básicamente una lista separada por un |

# formato:
# nombre | descripcion | comado | flags | web url | autor

# flags:
# runonce | multi = si debería ejecutarse sólo una instancia, o no
# terminal        = si debería ejecutarse en una terminal
# manual          = si es una entrada de manual
# root | user     = si debe ejecutarse como root o como usario

# submenús pueden comenzar o finalizar con
# Begin | MiSubmenu
# End | MiSubmenu

por ejemplo:

Begin | TORTILLA

Sope | maiz blanco agua y cal | masa --ovalo-chico | | http://craizymaiz.tv/ | La Tlayudera Loca
Tlayuda | maiz azul agua y cal | masa --circulo-gigante | | http://craizymaiz.tv/ | La Tlayudera Loca
Memela | maiz rojo agua y cal | masa --circulo-chico | | http://craizymaiz.tv/ | La Tlayudera Loca

End | TORTILLA

Puedes también tener submenus utilizando Begin y End cada vez que lo necesites. Para ver un ejemplo completo mira la lista que se encuentra en $DYNE_SYS_MNT/applist.

En caso de que tu módulo necesite ajustar variables de entorno (como rutas opcionales y ajustes generales para aplicaciones) puedes simplemente declararlas en un archivo env dentro del directorio etc. Este archivo puede contener declaraciones y variables de entorno, una por línea, las cuales serán exportadas en el sistema que se ejecuta, por ejemplo en nuestro módulo tortilla /opt/tortilla/etc/env mostrará algo similar a esto:

COCINA_PATH=/opt/tortilla/lib/cocina
SABOR_GLOBAL=picante
PERFIL_COCINERA=narigona

Puedes incluir tu configuración personal de usuario (home settings) dentro del módulo, para que estos sobrescriban los ajustes de usuario que dyne:II trae predeterminados. Esto es útil cuando quieres cambiar los ajustes predeterminados del manejador de ventanas (con una imágen para el escritorio por ejemplo) o mostrar aplicaciones preconfiguradas (con un archivo .config en tu home).

Para hacer esto simplemente tienes que crear un directorio skel dentro de tu módulo: todos los archivos que sean incluidos en el serán automáticamente copiados a todos los directorios home de todos los usuarios, ajustándolos para que sean adoptados por los usuarios que sean creados en el futuro.

En tus módulos puedes incluir cualquier módulo de kernel correctamente compilado para el kernel de dyne:II.

Para hacer eso tienes que crear un directorio kernel dentro de tu módulo: para que estos módulos sean usados en vez del modprobe standard, todos los módulos de kernel contenidos serán buscados y cargados si el comando loadmod los encuentra.

En caso de que el módulo no sea solicitado de manera natural por la configuración de tu hardware (osea que no sea listado por el comando pcmimodules), construye tu propia detección o forza la carga de tu módulo dentro de un módulo con un script de arranque. Puedes hacer un script dentro de tu módulo para que se ejecute cada vez que tu módulo es activado.

Para hacer esto tienes que crear un directorio etc dentro de tu módulo: todos los archivos ejecutables incluidos en el comodín rc.* serán lanzados al inicio, siendo el primer argumento $1 parte del nombre del módulo mismo.

Esta es en resumen la estructura del archivo contenida en los módulos:

VERSION archivo requerido     contiene información acerca del módulo y sus fuentes

bin     directorio opcional,  contiene todos los binarios, automáticamente incluido en $PATH

lib     directorio opcional,  contiene todas las librerías, automáticamente incluido en $LD_LIBRARY_PATH

etc     directorio opcional,  contiene scripts de arranque rc.* ejecutados durante la activación

skel    directorio opcional,  contiene todas las configuraciones que serán agregadas a /home/usuario y /etc/skel

kernel  directorio opcional,  contiene módulos de kernel que pueden ser cargados por loadmod

¡Tienes el poder de crear, ahora inventa algo maravilloso! :)