Ejecuta un comando de forma automática cada vez que guardes un archivo

A veces hay que escribir comandos en consola para compilar o procesar unos archivos que se han modificado. Es tremendamente útil que esta operación se haga de forma automática. Por ejemplo, se están editando unos archivos en LATEX, cada vez que guardemos el archivo podemos conseguir que se genere el PDF correspondiente y nos lo muestre de forma totalmente automática.

Este proceso se puede automatizar usando el comando inotifywait. Este comando nos avisa de las modificaciones que se produzcan en el o los archivos que se le indiquen. Para usarlo, se puede usar un script como el que se muestra a continuación. En archivo se introduce el nombre del archivo que se quiere vigilar. En comando el comando que se ejecutará cada vez que haya una modificación:

b=0
inotifywait -m --event modify archivo | while read a ;
do
  if [[ $b -eq 0 ]] ; then
    b=1
  else
    echo $a
    comando
    b=0
  fi
done

Tecleando en un terminal:

man inotifywait

Tendremos disponible la documentación en la que se puede encontrar más opciones y ejemplos  de uso.

Probando Wayland en Ubuntu 16.04

Hasta ahora para dibujar ventanas en Linux usabamos X11. El protocolo X11 data de mediados de los 80. Esta escala temporal en el mundo de la informática es una barbaridad, por lo que alguien pensó que era hora de actualizarlo.

Wayland va a ser la nueva forma que vamos a tener de dibujar ventanas en Linux. Viene incluido de serie en Ubuntu 16.04 y ya puede ser probado.

Lo primero que hay que hacer es instalar los paquetes necesarios. Para ello se ejecuta:

sudo apt-get install weston 
sudo apt-get install qtwayland5 
sudo apt-get install xwayland libreoffice-gtk3

Una vez instaladas las dependencias necesarias, se procede a configurar Weston. Weston es la implementación por defecto de cómo debería ser un entorno de escritorio bajo Wayland.

Con nuestro editor de texto favorito se va a crear el archivo “~/.config/weston.ini”:

[core]
modules=xwayland.so,cms-colord.so
shell=desktop-shell.so
#gbm-format=xrgb2101010

[shell]
#background-image=/usr/share/backgrounds/gnome/Aqua.jpg
#background-color=0xff002244
#background-type=tile
#panel-color=0x90ff0000
panel-location=top
#locking=true
#animation=zoom
#startup-animation=fade
#binding-modifier=ctrl
#num-workspaces=6
#cursor-theme=whiteglass
#cursor-size=24

#lockscreen-icon=/usr/share/icons/gnome/256x256/actions/lock.png
#lockscreen=/usr/share/backgrounds/gnome/Garden.jpg
#homescreen=/usr/share/backgrounds/gnome/Blinds.jpg
#animation=fade

[launcher]
icon=/usr/share/icons/gnome/24x24/apps/utilities-terminal.png
path=/usr/bin/weston-terminal

[launcher]
icon=/usr/share/pixmaps/firefox.png
path=/usr/bin/firefox


[input-method]
#path=/usr/lib/weston/weston-keyboard
path=/bin/ls


#[output]
#name=LVDS1
#mode=1680x1050
#transform=90
#icc_profile=/usr/share/color/icc/colord/Bluish.icc

#[output]
#name=VGA1
#mode=173.00 1920 2048 2248 2576 1080 1083 1088 1120 -hsync +vsync
#transform=flipped

#[output]
#name=X1
#mode=1024x768
#transform=flipped-90

[libinput]
enable_tap=true

#[touchpad]
#constant_accel_factor = 50
#min_accel_factor = 0.16
#max_accel_factor = 1.0

[keyboard]
keymap_layout=es

[screen-share]
#command=/usr/bin/weston --backend=rdp-backend.so --shell=fullscreen-shell.so --no-clients-resize

Ahora sí. Vamos a ejecutar Wayland. Para ello pulsamos la combinación de teclas “Ctr+Alt+F1”, entraremos en modo consola. Siempre podemos volver al modo gráfico con “Ctr+Alt+F7”. Nos autentificamos y escribimos en el terminal:

weston-launch

Por ahora sólo podemos lanzar terminales, para poder ejecutar otras aplicaciones se abre un terminal dentro de Wayland y se debe escribir:

export QT_QPA_PLATFORM=wayland-egl
export GDK_BACKEND=wayland
export QT_QPA_PLATFORMTHEME=fusion
export QT_STYLE_OVERRIDE=fusion
export SAL_USE_VCLPLUGIN=gtk3

Con esta configuración podemos lanzar aplicaciones desde ese terminal. Vamos a notar diferencia entre las aplicaciones GTK3, Qt5 y X11. Las aplicaciones GTK3 y Qt5 se ejecutarán en modo Wayland nativo. Para las X11 se creará una ventana dentro de Weston, al estilo que usan los Mac. Por ejemplo, se puede ejecutar LibreOffice con el comando “lowriter”. Se puede navegar por Internet con el comando “webbroser”.

Weston trabaja mucho con las combinaciones del teclado, al estilo de Unity. Las más interesantes son:

Ctr + Alt + borrar → Salir de Weston

Super + tab → Cambiar de ventana

Super + rueda del ratón → Zoom

Super + Alt + rueda del ratón → Cambiar opacidad de la ventana

Super + k → Cerrar ventana

Super + s → Hacer captura de pantalla

Super + r → Hacer un vídeo de la pantalla

Toda la configuración de Weston se puede encontrar en el archivo “~/.config/weston.ini”. Para ver el manual de este archivo, se puede usar el comando “man weston.ini”. Aquí se cambian cosas como pueden ser la resolución de la pantalla, el idioma del teclado o la imagen de fondo.

El consumo de RAM es bajo. Una sesión recién abierta de Weston consume 82 Mb. Comparando con X11, una sesión recién iniciada de Openbox consume 96 Mb. Para hacer esta prueba he parado lightdm usando el comando “service lightdm stop”. Como Weston es un gestor de ventanas ligero, por eso lo comparo con Openbox.

He notado que se puede trabajar bajo Wayland, llegando a lanzar documentos de LibreOffice bajo Wayland y trabajar sin problemas. Pero la integración de las aplicaciones con Wayland está todavía muy verde. Supongo que con el tiempo esto se solucionará. De hecho, no he sido capaz de ejecutar Firefox, que suelta una extraña ventana de error. Las ventanas de las aplicaciones GTK3 y Qt5 tienen decoraciones diferentes. La decoración de la ventana también es diferente cuando se lanza una aplicación X11 pura o una aplicación de Weston pura. Por ahora me voy a quedar con X11, pero Wayland será una opción interesante cuando en un futuro se mejore la integración de las aplicaciones.

Adapt: La forma sencilla de instalar paquetes de otra versión de Ubuntu

Adapt es un programa que permite instalar paquetes de otras versión de Ubuntu en la versión que tengamos instalada. Se pueden instalar paquetes de una Ubuntu 15.10 en una Ubuntu 14.04, por ejemplo. Todo esto funciona gracias a contenedores que descargan una versión de la distribución que se haya elegido.

Si queréis saber más sobre adapt os recomiendo leer la siguiente presentación realizada por Dustin Kirkland:

http://people.canonical.com/~kirkland/SCALE%2014x-%20adapt%20install%20anything.pdf

¿Por qué puede ser útil?

La mayoría de las personas tratan de usar las versiones estables de Ubuntu, las LTS. Esto significa que vamos a trabajar con versiones de los programas “estables”. Es decir, que si nuestra Ubuntu 14.04 viene con la versión 4.2 de LibreOffice, aunque salga la versión 5 de LibreOffice, las actualizaciones sólo nos van a permitir instalar la versión 4.2. A no ser que instalemos LibreOffice desde los backports, desde un ppa o bajando el instalador de LibreOffice, seguiremos siempre con la misma versión 4.2 de LibreOffice.

Esto es cierto para casi todos los paquetes de la distribución. Por ejemplo, Firefox sí se actualiza a la última versión que salga, pero LibreOffice no. Esto es así por motivos de seguridad.

Esta forma de gestionar las versiones se hace por estabilidad de la distribución, que es algo muy deseable en servidores, pero puede resultar fustrante para el usuario doméstico.

Si queremos estar siempre a la última, tenemos dos opciones, pasarnos a una distribución rolling-release (que instala siempre las últimas versiones de los programas) o intentamos instalar los paquetes por otros medios.

Ahora aparece adapt que instala un contenedor y dentro de ese contenedor descarga la versión que necesitemos de Ubuntu. Las aplicaciones se ejecutarán dentro de dicho contenedor.

Un contenedor es una forma de virtualización que simplemente le dice a los programas vais a estar confinados dentro de este espacio en el disco duro, vais a poder usar estas conexiones de red, podéis usar estos recursos de CPU y ¡tenéis prohibido salir de ahí! Evidentemente lo que vayamos a ejecutar dentro del contenedor tiene que estar adaptado a funcionar en ese entorno. Es fácil darse cuenta que un contenedor va a usar menos recursos que una máquina virtual de VirtualBox y podemos tener miles funcionando en un servidor.

Para saber más sobre la magia de los contenedores:

https://es.wikipedia.org/wiki/LXC

http://www.ubuntu.com/cloud/lxd

https://wiki.gentoo.org/wiki/LXD

Insertar o extraer archivos en un PDF

Muchas veces tengo que generar un archivo PDF a partir, por ejemplo, de un LibreOffice o de unos archivos en LaTEX.

El problema es que, o se es muy ordenado, o con el tiempo te puedes quedar con el PDF pero sin los archivos que lo generaron.

Sería práctico, por ejemplo, poder incluir los ficheros LaTEX dentro del PDF y extraerlos cuando fuese necesario.

Por eso he escrito los siguientes scripts:

Para insertar archivos en el PDF se puede usar el siguiente script que llamaremos “pdf-insert-file.sh”:

#!/bin/bash

_new_pdf=`echo "$1" | sed 's/pdf$//g' | sed 's/PDF$//g'`tar.pdf
cp "$1" "$_new_pdf"
echo >> "$_new_pdf"
shift
tar --to-stdout -cJ $* |  base64 | awk '{print "% tar:" $1}' >> "$_new_pdf"

Para extraer los archivos se usará el script “pdf-extract-file.sh”:

#!/bin/bash

grep -ae '^% tar:' "$1" | sed 's/% tar://g' | base64 -d  | tar -xJvf -

Por ejemplo, supongamos que se tiene el archivo texto.pdf y se quieren insertar los archivos texto.tex e imagen.png, escribiríamos en un terminal:

bash pdf-insert-file.sh texto.pdf texto.tex imagen.png

Se generará el archivo texto.tar.pdf. Se puede comprobar que tiene mayor tamaño que el texto.pdf original.

Como se puede ver primero se pone el nombre del PDF y a continuación el nombre de los archivos a insertar.

Para posteriormente poder extraerlos se usará:

bash pdf-extract-file.sh texto.tar.pdf

Con esto extraerá los archivos texto.tex e imagen.png.

¿Cómo funcionan los scripts?

La idea es sencilla. Los archivos PDF se pueden editar como archivos de texto y se les pueden añadir comentarios que deben comenzar con el símbolo %. En un archivo PDF toda línea que comience por % es ignorada.

Lo que hace el script pdf-insert-file es:

  • Se crea un archivo tar.xz con los archivos que se quieren incluir.
  • Se codifica en base64. Ya que las secuencias del archivo tar podrían estropear el PDF con sólo insertar un salto de línea.
  • A cada línea del resultado se le añade al principio la cadena “% tar:”, así se pueden distinguir los comentarios del PDF del los comentarios que se van a añadir con los contenidos.
  • Finalmente se incluyen al final del PDF los comentarios que se han generado con los contenidos.

Espero que os sea útil.

Como instalar la versión de desarrollo de LXQt en Ubuntu 15.10

Hace poco se liberó la nueva versión de LXQt. LXQt es un escritorio ligero basado en Qt y que en un futuro será el sustituto de LXDE en Lubuntu.

Si alguien quiere instalarse la versión de desarrollo en Ubuntu 15.10 de este escritorio, sólo tiene que ejecutar los siguientes comandos:

sudo apt-get install git
git clone https://github.com/selairi/compile-lxqt-ubuntu.git
cd compile-lxqt-ubuntu
bash install-lxqt.sh

Lo que haremos es bajarnos un script que instalará las dependencias necesarias, descargará el código fuente de LXQt, lo compilará y lo instalará en nuestro sistema. Esto llevará su tiempo, por lo que paciencia.

Ojo, como es la versión en desarrollo veréis que puede resultar inestable, por lo que estáis avisados.

He estado probando esta versión a día de hoy y luce así:
lxqt-2

Podemos configurar los efectos de escritorio añadiendo transparencias, sombras o efectos de desvanecimiento al desaparecer o aparecer las ventanas:
lxqt-3

Una característica que me gusta es la posibilidad de poder aprovechar todo el espacio de la pantalla para una aplicación, eliminando distracciones. Para ello hay que esconder el panel y haciendo clic con el botón derecho del ratón sobre una ventana maximizada quitarle las decoraciones:

lxqt-5

Esta opción ya estaba disponible en LXDE. Para que la ventana vuelva a tener decoraciones, hay que pulsar la combinación de teclas Atl+Espacio y en el menú emergente volver a colocar las decoraciones.

Como es un escritorio ligero, tampoco hay mucho donde rascar, se nos provee de lo mínimo para poder trabajar de forma cómoda. A cambio ganamos ahorro en los recursos y velocidad.

Crea tu propio escritorio

Una de las posibilidades que ofrece Linux es alta capacidad de configuración. ¿Por qué no usar estas capacidades para crear tu propio escritorio?

He probado Unity, Gnome, KDE, LXQt,… y a todos se les encuentra una pega. En mi caso es el tiempo que tardan en iniciar la sesión. Se me ocurrió entonces intentar crear mi propio escritorio eliminando estos fallos. Elegiré el tema, los efectos, el fondo de escritorio y eliminaré todo lo que preveo que no usaré.

Sigue leyendo

Emmabuntüs y Labdoo: Ejemplos de proyectos humanitarios del software libre

Con le lanzamiento de la nueva versión de Emmabuntüs, os quería hablar de dos proyectos muy similares basados en software libre, Emmabuntüs y Labdoo.

Emmabuntüs

emmabuntus-logo

Se ha lanzado Emmabuntüs 3 1.02. Está basada en Xubuntu 14.04.3 y está destinada a equipos con pocos recursos. Las notas de lanzamiento de la versión las tenéis en el siguiente enlace.

Emmabuntüs es un proyecto orientado a recuperar ordenadores que de otro modo acabarían en la basura y reenviarlos a comunidades que los pudieran necesitar. Si les donáis un equipo que ya no usáis, lo revisarán, le pondrán su propia distribución de Linux, Emmabuntüs, y lo enviarán a un sitio donde sea necesario.

Si visitáis las páginas de Emmabuntüs, veréis una imagen curiosa, el jerrycan:

JerryCSE_03

Como se puede apreciar es un ordenador metido dentro de una garrafa de 5 litros. Es útil para ser transportado de un sitio a otro, fácil de reparar y de actualizar.

Labdoo

labdoo_logo

Hay otros proyectos similares como Labdoo. La gracia de este proyecto está en que se puede hacer un seguimiento de los equipos que han sido donados. Se orientan a ordenadores portátiles, pues es más fácil que lleguen a comunidades necesitadas.

El funcionamiento es el siguiente. Tu donas el portátil viejo, te piden el correo electrónico, lo revisan, le ponen Ubuntu y lo reenvían a una OMG que lo necesite. Cuando el equipo llega a su destino final, te envían un correo electrónico con la ubicación final de tu viejo portátil.

Tienen también una página con el seguimiento de los equipos enviados: https://www.labdoo.org/es/dootrips

El proyecto fue creado por Jordi Ros, ingeniero de telecomunicaciones catalán. Aquí le podéis ver dando una charla sobre el tema:

https://www.youtube.com/watch?v=dGTZfOhE5Xo

Si tenéis un equipo para donar, sólo tenéis que buscar en la página de Labdoo vuestro punto de donación más cercano. Por ejemplo, en Madrid tenemos:

Mejora el rendimiento de tu equipo con ZRAM

ZRAM es un mecanismo que permite crear una nueva unidad de memoria swap en la RAM. La peculiaridad de esta nueva swap es que está comprimida. Con esto se reduce mucho el trasiego de información con el disco duro cuando la RAM está muy llena, mejorando así el rendimiento.

Desde el punto de vista práctico es como si a tu ordenador le añadieses un nuevo módulo de RAM más lento que los módulos que tienes instalados pero mucho más rápido que la swap.

Para instalarlo en Ubuntu sólo hay que teclear lo siguiente en el terminal:

sudo apt-get install zram-config

Lo he probado en un equipo con 2Gb de RAM y la mejora de rendimiento es apreciable.

Si tenéis memoria swap presente en el sistema, primero se llenará la swap de ZRAM, después se llenará a la swap física.

Espero que os resulte útil.

Cambiando el brillo de fondo de la pantalla de forma automática

Una cosa que suele suceder cuando trabajas mucho tiempo ante el ordenador es que la luz ambiente va cambiando. No hay la misma cantidad de luz a medio día que por la noche. Al final uno se descubre cambiando el brillo de la pantalla en función de la hora del día para no dañarse la vista.

¿Esto se puede automatizar? Sí.

Hay programas que juegan con la temperatura del color para no afectar a la calidad del sueño. Yo buscaba otra cosa. Jugar con la iluminación de la pantalla. He buscado y no he encontrado nada que lo hiciera.

Por todo ello he escrito un script que en función de la hora del día va cambiando la iluminación de la pantalla. Para que funcione necesitaréis instalar programa xbacklight:

sudo apt-get install xbacklight

Para saber si os funciona deberéis teclear:

xbacklight -5

Si notáis que el brillo de la pantalla ha bajado, podéis continuar.

El script en cuestión es el siguiente, que deberéis guardar (copiar y pegar) en un fichero llamado brillo.py:

#!/usr/bin/python3

# Para que el script funcione se debe tener instalado xbacklight
# y que la pantalla soporte cambiar el brillo usando xbacklight

brillo = [
    # [hora (0..23), minuto (0..59), brillo (0..100) ]
    # Debe estar en orden de horas
    [0,0,2],
    [1,0,2],
    [2,0,2],
    [3,0,2],
    [4,0,2],
    [5,0,2],
    [6,0,2],
    [7,0,2],
    [8,0,3],
    [9,0,4],
    [10,0,4],
    [11,0,4],
    [12,0,4],
    [13,0,4],
    [14,0,4],
    [15,0,4],
    [16,0,4],
    [17,0,4],
    [18,0,4],
    [19,0,4],
    [20,0,3],
    [21,0,2],
    [22,0,2],
    [23,0,2]
]


import datetime
import time
import os


ultimo_brillo = -1
while True:
    # Se busca el brillo para la hora actual
    t = datetime.datetime.today()
    print('Hora: {0}:{1}'.format(t.hour,t.minute))
    # Se mira si el brillo se ha cambiado de forma manual
    fin = os.popen('xbacklight -get','r')
    brillo_actual = int(0.5 +float(fin.read()))
    fin.close()
    print( 'Brillo de la pantalla: {0}'.format(brillo_actual) )
    if ultimo_brillo < 0:
        ultimo_brillo = brillo_actual
    # Si el brillo se ha cambiado manualmente, se corta la ejecución
    if brillo_actual != ultimo_brillo:
        print('El brillo ha cambiado manualmente. Fin de la gestión automática.')
        break
    siguiente_hora = datetime.time(brillo[0][0],brillo[0][1])
    hora_actual = datetime.time(t.hour, t.minute)
    for l in brillo:
        if t.hour > l[0]:
            ultimo_brillo = l[2]
        elif t.hour == l[0] and t.minute >= l[1]:
            ultimo_brillo = l[2]
        else:
            siguiente_hora = datetime.time(l[0],l[1])
            break
    print('Brillo: {0}'.format(ultimo_brillo))
    os.system('xbacklight -set {0}'.format(ultimo_brillo))
    # Se calcula el tiempo de espera hasta la siguiente hora
    delta = 0
    if siguiente_hora < hora_actual:
        delta = 24*60*60 
    delta = delta + ((siguiente_hora.hour - hora_actual.hour)*60 + (siguiente_hora.minute-hora_actual.minute))*60
    print(delta)
    time.sleep(delta)

¿Cómo funciona? Fácil, tenéis una lista de la forma:

brillo = [
    # [hora (0..23), minuto (0..59), brillo (0..100) ]
    # Debe estar en orden de horas
    [0,0,2],
    [1,0,2],
    [2,0,2],
    [3,0,2],
    [4,0,2],
    ...

Aquí tenéis que indicar el nivel de brillo en función de la hora del día. Por ejemplo:

     [3,0,2],

significa que a las 3:00 horas el brillo será del 2%. En la terna el primer número es la hora (de 0 a 23), el segundo los minutos (de 0 a 59) y el último el brillo (de 0 a 100).

Una vez que hemos puesto los brillos que van bien con nuestro equipo, sólo tenemos que ejecutarlo con:

python3 brillo.py

El script parará de funcionar si cambiamos el brillo de forma manual. Lo he puesto así ya que no es agradable ponerse a ver un vídeo o a jugar y que el brillo se baje en una escena oscura.

Evidentemente si se desea que se ejecute cada vez que iniciamos la sesión, habrá que introducirlo en los “Programas al inicio”.

Si os fijáis, en mi caso he puesto brillos muy bajos, del orden del 2 ó el 4%. Es porque mi portátil tiene la pantalla excesivamente brillante y con un 4% me sobra para ver correctamente.

Espero que lo disfrutéis.