Tu terminal REACCIONA a todo. Eventos personalizados en Fish

Vistas: 692
0:00 / 0:00
Tu terminal REACCIONA a todo. Eventos personalizados en Fish

Después de lo que vimos en el episodio 785, titulado Tu Terminal ahora es mucho mas inteligente (gracias a Fish), nos quedamos con el potencial y las posibilidades que nos ofrecía Fish directamente de caja. Pero como te adelanté ya en ese episodio, esto podía ir a mas, en el sentido de que Fish te da la posibilidad de definir tus propios eventos. Es decir, no solo puede responder a los eventos integrados, sino que además te permite crear y disparar tus propios eventos personalizados. Y esto es precisamente lo que veremos en este episodio. No solo a crear tus propios eventos y como utilizar estos eventos, sino algunos ejemplos prácticos y casos de uso.

Tu terminal REACCIONA a todo. Eventos personalizados en Fish

La gran ventaja que te ofrece crear y utilizar tus propios eventos, es que puedes desacoplar simplificar enormemente tus funciones, y de la misma manera puedes hacer con tu configuración de config.fish.

Cómo funciona: emit y --on-event

Para trabajar con tus propios eventos en fish, necesitas de dos piezas,

  • El emisor (emit), que es el que dispara el evento.
  • El receptor (--on-event), es la función que se encarga de escuchar el evento, de forma que cuando se produce realiza alguna tarea.

Ejemplo práctico. Un sistema de notificaciones

Imagina que tienes varios scripts que realizan tareas pesadas (copias de seguridad, compilación de Rust, despliegue de contenedores) y quieres que todos envíen una notificación al terminar, pero sin repetir el código de notificación en cada sitio.

Definir la función receptora

El pimer paso es definir la función que escucha. Esta función vivirá en tu config.fish o en un archivo dentro de ~/.config/fish/conf.d/. Aquí sucedía exactamente igual que en los casos que te comenté en el episodio anterior. Esta función se tiene que cargar al inicio.

function al_finalizar_tarea --on-event tarea_completada
    # Recibe argumentos pasados por el emit
    set -l nombre_tarea $argv[1]
    set -l estado $argv[2]

    echo "--- [Notificación del Sistema] ---"
    echo "La tarea '$nombre_tarea' finalizó con estado: $estado"
    # Envías la notificación al sistema
    notify-send "Tarea terminada" "$nombre_tarea: $estado"
end

Disparar el evento desde cualquier sitio

Ahora, en cualquier script o incluso directamente en la terminal, puedes lanzar el evento,

# Simulamos una tarea
echo "Compilando proyecto..."
sleep 2

# Disparamos nuestro evento personalizado con argumentos
emit tarea_completada "Compilación Rust" "Éxito"

Ventajas de usar eventos personalizados

Como ya te puedes imaginar, esto de crear tus propios eventos, tiene muchas y grandes ventajas. Pero, no solo crear eventos, sino tener distintos oyentes para esos eventos. Algunas de las ventajas son las siguientes,

  • Desacoplamiento. El script que se está ejecutanto no necesita saber cómo se envía la notificación. Solo dice he terminado. Si mañana decides cambiar echo por un envío a Telegram, solo cambias la función receptora.
  • Múltiples receptores. Puedes tener varias funciones escuchando el mismo evento tarea_completada. Una podría guardar un log en un archivo y otra enviarte un correo, y ambas se ejecutarán automáticamente al hacer el emit.
  • Limpieza de código. Evitas pasar variables globales de un lado a otro para comunicar estados entre funciones.

Comandos útiles para depurar eventos

Si empiezas a crear muchos eventos, estos comandos te salvarán la vida:

  • functions. Para ver qué funciones están registradas.
  • functions --handlers. Te muestra específicamente qué funciones están escuchando qué eventos en ese momento.
  • functions --handlers | grep <evento>. Utilizando grep seguido del nombre del evento puedes ver que funciones escuchan o gestionan ese evento.
# Ejemplo para ver tus manejadores activos
functions --handlers

Un ejemplo mas completo

Se trata de reaccionar a distintos eventos, y según cada evento se realizan unas acciones u otras. Por ejemplo,

El Núcleo: El «Watcher» (Observador)

Esta función monitorea los cambios y simplemente «anuncia» que algo ha pasado.

function watch_rust_project
    echo "Monitoreando el proyecto Rust..."
    # Usamos fswatch para detectar cambios en la carpeta src/
    fswatch -o src/ | while read -l event
        echo "¡Cambio detectado! Iniciando compilación..."
        emit rust_file_changed
    end
end

El Constructor: handle_build

Esta función reacciona al cambio de archivos. Si la compilación tiene éxito, lanza un nuevo evento.

function handle_build --on-event rust_file_changed
    if cargo build --release
        set -l bin_path "./target/release/mi_mcp_skill"
        emit build_success $bin_path
    else
        emit build_failure $status
    end
end

El Desplegador: update_container

A esta función solo le importa cuando hay un binario nuevo listo. Aquí es donde entra Podman.

function update_container --on-event build_success
    set -l bin_path $argv[1]
    echo "Actualizando contenedor Podman con $bin_path..."

    # Comandos de Podman para copiar el binario y reiniciar
    podman cp $bin_path mcp_container:/usr/local/bin/
    podman restart mcp_container

    emit deployment_complete "Producción"
end

El Notificador: log_deployment

Un tercer receptor que escucha el evento final para llevar un registro.

function log_deployment --on-event deployment_complete
    set -l entorno $argv[1]
    echo "[$(date)] Despliegue exitoso en $entorno" >> ~/dev_history.log
end

Conclusión

Realmente tienes una opción muy potente para simplificar tus scripts y para llevarlos a un plano superior. Puedes encadenar acciones o incluso realizarlas en paralelo. Lo cierto es que esto abre todo un mundo de opciones y posibilidades, dejando el código sencillo y utilizando y exprimiendo al máximo las posibilidades que te ofrece Fish.

Ver el vídeo de este episodio
Transcripción

Después de lo que vimos en el episodio 785,

Titulado tu terminal ahora es mucho más inteligente,

Gracias a Fizz,

Nos quedamos con la miel en los labios,

Porque me guardé lo mejor para el final,

Es básicamente la posibilidad de crear tus propios eventos,

Y no solamente de crear tus propios eventos,

Sino de crear funciones, de crear métodos,

Que respondan a esos eventos,

A esos eventos que tú has creado,

Esto como te puedes imaginar,

Te abre un abanico realmente brutal,

Para hacer casi cualquier cosa,

Pero no solamente para hacer casi cualquier cosa,

Sino para simplificar todos tus proyectos,

De una manera brutal, valga la redundancia,

En el sentido de que esto de poder simplificar,

De poder crear funciones,

La misma función que responda siempre a los mismos tipos de eventos,

Es decir, no estar reescribiendo código una y otra vez,

Y además tenerlo ordenado en base a eventos,

Yo creo que es algo realmente espectacular,

Como te digo, al final,

En el episodio 785,

Me guardé este pequeño premio,

Vamos, me guardé lo mejor,

Para este episodio,

Y quiero compartirlo contigo,

Quiero compartirlo en este episodio,

Así que vamos directos al turrón,

En este episodio te voy a hablar,

Sobre eventos,

Crear eventos en FISH,

Y responder a esos eventos,

Como te decía,

Como te decía en el episodio,

La gran ventaja de esto,

De los eventos,

De FISH,

Básicamente es que,

Te va a permitir responder a los eventos,

Te va a permitir,

Tener,

En lugar de tener una función realmente complicada,

Una función que,

Tenga distintas funciones metidas,

O un script,

Que tenga muchas funciones,

Y en función,

Y en función,

Valga la redundancia,

Madre mía,

Quiero decir,

Si lo que tienes básicamente,

Es una,

Un script enormemente grande,

Con una gran cantidad de funciones,

De manera que,

Según lo que vaya sucediendo en ese script,

Se ejecutarán unas u otras funciones,

Pues puede llegar un momento,

En que ese script,

Sea prácticamente ingobernable,

Y no solamente eso,

Sino que a lo mejor,

En otro script,

También necesitas parte de ese script,

Y tienes que utilizarlo,

Es cierto que puedes llamar,

Desde un script a otro script,

Pero,

¿Por qué no utilizar eventos,

Realmente el uso de eventos,

Es algo brutal,

Porque,

Simplemente tienes que declarar,

Todos los eventos,

Y,

Gestionar,

O declarar también,

Todas aquellas funciones,

Que van a gestionar esos eventos,

Y claro,

Con esta solución,

Con una solución como esa,

Vamos,

Es que es brutal,

Y es brutal,

Por la sencilla razón,

De que,

Esto de,

Tanto,

Crear eventos,

Como crear,

Gestionadores de eventos,

Crear funciones,

Que respondan a esos eventos,

Realmente es muy sencillo,

Simplemente,

Tienes que,

Definir,

La función,

Que,

Que emite,

El evento,

Y la función,

Bueno,

Simplemente tienes que,

Indicar que se emite,

Un evento,

Y,

En la función,

A la que quieres responder,

Simplemente es declararla,

Con on event,

De esto,

Como de costumbre,

En las notas del episodio,

Te he dejado suficientes,

Ejemplos,

Para que lo veas,

No hace falta,

Ni que te plantees,

Ni en un momento,

Tomar notas,

O parar tu coche,

Y empezar a escribir,

Simplemente,

Acuérdate del episodio,

787,

Y,

Nada más que,

Entrar en,

Atareao.es,

Barra podcast,

Barra 787,

Vas a encontrar,

Todas las notas,

Como te digo,

La operación,

Es tan sencilla,

Como declarar,

Un emit,

Que es la función,

Que se encarga,

De emitir,

El evento,

Seguida por el nombre,

Del evento,

Y una función,

Como puede ser,

La función,

Avisar,

Que cuando se produzca,

El evento,

Haga acciones,

Las acciones,

Que tú quieras,

Por ejemplo,

Yo he declarado,

Una función,

Que se llama,

Avisar,

Y una,

Un evento,

Que se llama,

Tarea completada,

De manera que,

Cuando se produce,

El evento,

Tarea completada,

Esta función,

Lo que hace,

Es simplemente,

Escribir un eco,

De la tarea,

Finalizó,

Con éxito,

O con estado,

O lo que sea,

Incluso mandar,

Al sistema,

De notificaciones,

De tu,

Equipo,

En el caso,

De que lo lances,

En un entorno,

De escritorio,

Pues que te aparezca,

Esa burbuja,

En la que te indica,

Que bueno,

Pues que tu tarea,

Ha terminado,

Con éxito,

O sin éxito,

O como quieras,

Claro,

Evidentemente,

Esto es cuando,

Lo ejecutas,

Directamente,

En un,

En un equipo,

Con entorno,

De escritorio,

Para poder,

Aparecer,

Que te aparezcan,

Esas burbujas,

Esas notificaciones,

Pero que sucede,

Cuando lo lanzas,

En un servidor,

Pues el problema,

De un servidor,

Evidentemente,

Es que no puedes,

Hacerlo de esa manera,

Pero,

Como ya te puedes imaginar,

Lo puedes lanzar,

O puedes enviarte,

Esa notificación,

A telegram,

Te la puedes enviar,

A lo que sea,

De manera que tienes,

Un sistema,

De notificaciones,

Espectacular,

Y lo puedes,

Personalizar,

Y particularizar,

Según tus necesidades,

Como quieras,

En este sentido,

Puedes hacer,

Todo tipo,

De operaciones,

Todo tipo,

De combinaciones,

De distintas,

Funciones,

Que en base,

A los resultados,

Que vaya generando,

Lance eventos,

Y se respondan,

A esos eventos,

Como te digo,

Para definir,

La función,

O mejor dicho,

Para definir,

El gestionador,

El handle,

Que va a manejar,

Cada uno,

De los eventos,

Simplemente,

Tienes que,

Añadir,

El on event,

Y el evento,

Que tienes que,

Ejecutar,

Y ya está,

Sí que es importante,

Que esto,

Lo tienes que poner,

En el directorio,

.Config,

Barra fish,

Barra conf,

Porque,

Todas estas funciones,

Se cargan,

Al inicio,

De esta manera,

Si yo ahora,

Ejecuto,

Una,

Simplemente,

Un emit,

Tarea completada,

Es decir,

Tarea completada,

Es el nombre,

Del evento,

El nombre,

De la tarea,

Que le he puesto,

Esta tarea,

Y el resultado,

Exit,

Lo que va a hacer,

Es primero,

Me va a imprimir,

Directamente,

Una notificación,

Del sistema,

Donde dice,

La tarea,

Esta tarea,

Que le he puesto,

Finaliza con éxito,

Y además,

Me pone,

Esa burbujilla,

Donde dice,

Que la tarea,

Ha terminado,

Así de sencillo,

O sea,

Simplemente,

He conseguido,

Emitir,

El evento,

Y como ya te puedes,

Imaginar,

Esto de emit,

Seguido por el nombre,

Del evento,

Lo puedo poner,

Donde quiera,

Es así de sencillo,

Es decir,

Podemos disparar,

El evento,

Desde cualquier sitio,

¿Qué ventajas tiene esto,

Bueno pues un poco,

Las ventajas es,

Lo que te he ido comentando,

Lo primero es,

El desacoplamento,

Con el,

Con este tipo,

De solución,

De,

Evento,

Y disparador,

Bueno,

Disparador,

Y handler,

Disparador,

Y gestionador,

De evento,

Puedes,

Puedes,

Separar,

La lógica,

De toda tu,

Función,

En distintas,

Partes,

De manera que,

Cada una de esas partes,

Haga,

O responda,

A uno de los eventos,

Que tú has generado,

Y esto,

Es brutal,

No solamente,

Porque,

Puedes,

Reutilizar,

Todo el código,

Sino porque,

Para,

Modificar una parte,

Del código,

Solamente vas a tener,

Que cambiar,

Ese,

Ese gestionador,

Ese handler,

Que responde,

A ese evento,

Concreto,

Por ejemplo,

Si en un momento,

Determinado,

Estás utilizando,

Una función,

Para notificar,

Como puede ser,

Notify send,

Y en un futuro,

Lo que quieres es enviar,

Tu mensaje a telegram,

Simplemente tienes que,

Modificar esa parte,

De tu código,

Ese script,

Ese,

Gestionador,

Ese,

Escuchador,

De evento,

Para que haga,

La opción,

Que tú quieres,

La siguiente ventaja,

Es que puedes poner,

Tantos receptores,

Como quieras,

Esto que quiere decir,

Bueno,

Básicamente es que,

No solamente,

Hay una función,

Que esté escuchando,

El evento,

Sino que puedes poner,

Tantas funciones,

Como quieras,

De manera que,

Tú,

Ante un evento,

No solamente,

Por ejemplo,

Lo guardas,

En un registro,

Sino que también,

Te puedes mandar,

Un mensaje a telegram,

También te puedes mandar,

Una notificación,

En el escritorio,

O puedes hacer,

Distintas acciones,

Por ejemplo,

En el caso,

De que quieras hacer,

Una copia,

Un backup,

Puedes lanzar,

En paralelo,

Tres backups,

O todo este tipo,

De cosas,

Que te van a permitir,

Responder,

De forma,

Simultánea,

A varios eventos,

A la vez,

Y luego,

El tercero,

Y yo creo que es,

El más beneficioso,

Bueno,

Más beneficioso,

Es cualquiera,

De estos tres,

Pero vamos,

Es la limpieza,

De código,

Que es un poco,

Lo que acabamos,

De ver,

En el sentido,

De que,

Al final,

Cada parte,

De tu código,

Va a estar,

En distintos,

Scripts,

Realmente,

Muy sencillos,

Y cuando necesiten,

Modificar cualquier cosa,

Simplemente,

Tienes que ir,

A ese script,

No tienes que estar,

Haciendo,

Distintas,

Quiero decir,

No tienes que modificar,

Un script,

Enormemente grande,

Ni tienes que ir buscando,

Qué script,

Responde a qué cosa,

O dónde guardaste,

Qué código,

Todo eso,

Lo tienes de una manera,

Realmente sencilla,

Para ayudarte,

Con todo esto,

Además de,

Los eventos,

Y los,

Y los,

La gestión,

De eventos,

Y los receptores,

Tienes,

Básicamente,

Dos funciones,

Bueno mejor dicho,

Una función,

Que se llama,

Functions,

Esta función,

Functions,

Lo que te permite,

Es saber,

Todos los eventos,

Que hay registrados,

Por ejemplo,

Yo tengo,

El evento,

Avisar,

O el evento,

Warning me,

Aparte de todos estos,

Aparte de estos,

Eventos propios,

También están todos los eventos,

Del sistema,

Eventos que vimos,

En la,

En el episodio anterior,

En el episodio 785,

Y si quieres ver,

Qué eventos,

O qué funciones,

Responden a los eventos,

Simplemente tienes que ejecutar,

Functions,

Seguido de handlers,

De la opción handlers,

Como te digo,

Todo esto está en las notas,

Del episodio,

Aquí por ejemplo,

Puedes ver que,

Tienes una que es,

Tarea completar,

Avisar,

Tarea completada,

Pues lo que hace es,

Responde avisar,

Igual que esa,

También tienes otras,

Bueno,

Otras propias,

Que he hecho yo,

Por ejemplo,

Rust,

Rast,

File change,

Que responde,

A,

Al evento,

Handle by,

Build,

O,

En fin,

Todo tipo,

De opciones,

Y posibilidades,

Si quisieras ver,

Por ejemplo,

Los que responden,

A un determinado evento,

Simplemente tienes que,

Filtrarlo con un grep,

Un grep,

Que sea,

Filtrar con grep,

Avisar,

Vas a ver,

Todas las funciones,

Que tienen asociadas,

Como ves,

Esto es una herramienta,

Muy potente,

No solamente para,

Depurar,

Tu sistema,

Sino para saber,

Exactamente,

Quién responde,

A quién,

No tienes,

De nuevo,

Que ir investigando,

A lo largo de todo,

El código,

Qué es lo que sucede,

O lo que no sucede,

Simplemente,

Utilizando,

Estas ayudas,

Que te pone,

A tu disposición,

FIS,

Lo tienes,

De una manera,

Súper sencilla,

Dicho esto,

Lo suyo es,

Probar una herramienta,

Que sea mucho más,

Complicada,

Quiero decir,

Encadenar,

Distintos eventos,

Para ver,

Cómo funciona,

Todo,

En este sentido,

Yo lo que he hecho,

Ha sido,

Encadenar,

Varios,

Eventos,

En la compilación,

De un proyecto,

De RAST,

De la manera,

Que en el momento,

Que uno de los archivos,

De RAST,

Se modifique,

Se desencadenen,

Una serie,

De eventos,

Dependiendo,

De si,

El proceso,

Ha sido,

Exitoso,

O no,

Por ejemplo,

En el caso,

Que te comento,

Simplemente,

Al inicializarlo,

Te va a poner,

Que está,

Monitorizando,

El proyecto,

RAST,

Cuando se produzca,

Cualquier cambio,

Utilizando,

Una herramienta,

E-notify,

Wait,

Lo que te va a mostrar,

O lo que va a hacer,

Es desencadenar,

Directamente,

Que se ha cambiado,

Un archivo,

Esto también,

Lo puedes hacer,

En vez de con,

E-notify wait,

Lo puedes hacer,

Con watch exec,

Con cualquiera,

De los dos,

Se puede hacer,

Y a partir de aquí,

Como te digo,

Se desencadena,

Por un lado,

La compilación,

De RAST,

Y luego,

Una vez se ha compilado,

RAST,

Dependiendo de si,

El resultado,

Ha sido exitoso,

O ha sido,

Un fracaso,

O lo que va a hacer,

Es directamente,

Copiarlo,

En un contenedor,

Copiar el build,

En un contenedor,

O en otras opciones,

Guardarlo,

O enviarte,

Una notificación,

Es más,

No solamente es esto,

También tienes,

La ventaja,

De que,

Como te decía,

Anteriormente,

Lo puedes guardar,

O lo puedes,

Hacer en paralelo,

No solamente,

El hecho,

De que te guarde,

Registro,

Sino que además,

Te mande,

Una notificación,

Esto puesto en marcha,

Pues simplemente,

Lo que tienes que hacer,

Es lanzas,

El primero,

El primero,

De los ejemplos,

Que te he puesto,

El watch RAST,

Project,

Y lo que va a hacer,

En ese momento,

Es monitorizarlo,

Si yo ahora,

Hago cualquier modificación,

En este archivo,

Simplemente,

Por ejemplo,

Borrar,

Una línea,

Y la guardo,

Lo que va a producirse,

Es directamente,

Te va a decir,

Cambios,

Cambios,

Se va a empezar,

A hacer,

El proyecto,

Y una vez,

Ha terminado,

Pues,

Sigue notificándote,

Por ejemplo,

Si yo ahora añadiera,

Otro comentario,

Otra vez,

Tendríamos,

Los mismos,

Intenta hacer,

La compilación,

Si no puede hacer,

La compilación,

Por ejemplo,

Si yo,

En lugar de,

Ahora lo guardo,

Que no va a funcionar,

Directamente,

Me ha mandado,

Un mensaje,

De algo pasó,

En el sentido,

De que,

No ha seguido,

La lógica normal,

Que la lógica normal,

Era compilar,

Una vez compilado,

Empezar a copiar,

El binario,

Claro,

Como,

Hay un error,

No te puede compilar,

El binario,

Y como no te puede compilar,

El binario,

No va a continuar,

En un proceso secuencial,

Lo intentaría,

Y te generaría,

Un error,

Diciendo que el binario,

No existe,

Aquí,

Lo que hemos hecho,

Ha sido que,

Directamente,

Si no compila,

No continúa,

El proceso,

De copiar,

El archivo,

Sino que directamente,

Te diga,

Oye,

Se ha producido,

Un error,

Y básicamente,

Esto,

Es lo que,

Quería mostrarte,

En este episodio,

Ahora,

Realmente,

Tenemos,

Una herramienta,

Donde,

Hace,

A fish,

Algo realmente,

Potente,

En el sentido,

De que,

Puedes,

Gestionar,

Tus eventos,

Puedes responder,

A esos eventos,

Y puedes hacer,

Todo tipo,

De operaciones,

De manera que,

Por un lado,

Vas a simplificar,

Tu código,

Y por otro lado,

Lo que vas a conseguir,

Es un sistema,

Que responde,

A eventos,

Yo creo que,

Sinceramente,

Se trata de algo,

Que tiene muchísimo,

Potencial,

Puedes simplificar,

Como te digo,

Muchísimo,

Tus scripts,

Y puedes hacerlo,

Vamos,

Realmente potente,

Y esto es un poco,

Lo que quería contarte,

En este episodio,

Simplemente,

Estas dos funciones,

La de emit,

Y on event,

Que te va a permitir,

Tanto crear,

Tus propios eventos,

Como responder a ellos,

Y poco más que decirte,

Realmente estoy,

Muy emocionado,

Con este,

Con este,

Estos eventos,

Y creo que se pueden,

Hacer muchísimas cosas,

Recordate que este es un podcast,

De la red de podcast,

De sospechosos habituales,

Donde puedes encontrar,

Fantásticos y maravillosos podcasts,

Puedes participar en esa red,

Entrando en,

Win tablet info,

Y de la misma manera,

Si quieres participar,

En el grupo,

Atareado con Linux,

Simplemente,

Tienes que buscar,

Eso en telegram,

Atareado con Linux,

Y allí nos vas a encontrar,

Hablando de,

Pues fish,

Poco,

De Docker,

De servicios,

De auto alojamiento,

Y todo este tipo de cosas,

Y nada más que decirte,

Recordate que la vida,

Son dos días,

Y uno ya ha pasado,

Así que disfruta,

Como si no hubiera mañana,

Y si puede ser con Linux,

Y en este caso,

Con fish,

Emit,

Y on event,

Mejor que mejor,

Un saludo,

Y nos escuchamos,

El próximo jueves,

Hasta luego,

Adiós.

Deja una respuesta