Aunque ya he usado monit para avisar de determinados eventos, hay veces que necesito una notificación inmediata. En concreto quería monitorizar punto wifi que sospechosamente perdía la conexión más de lo habitual.
Para ello decidí no limitarme a mandar un "alert" cuando se pierde el ping, sino que lanzo un script que hará más ruido:
check host punto-wifi with address 192.168.0.1
if failed icmp type echo count 3 with timeout 5 seconds then exec "/usr/local/bin/aviso-wifi"
1. Avisos multicanal.
El script aviso-wifi usa distintos tipos de aviso por diferentes cauces:
Envía un correo mediante gmail usando mailsend, que tendríamos que instalar previamente.
Envía un mensaje push a nuestro móvil mediante la aplicación simplepush.io, que saltará de forma inmediata. Es tan sencillo como instalar esta aplicación en el móvil y poner en el script la PUSHKEY que nos aparece al abrirla, que identifica nuestro móvil de forma única como destinatario.
Como pequeño inconveniente tenemos que los mensajes son gratuitos los 7 primeros días, luego hay que comprar la aplicación (cuesta unos merkels) para poder recibir mensajes. Se pueden establecer alarmas sonoras distintas en función de diversos tipos de mensajes push.
Por último, por volver a los 90, mandamos un SMS a nuestro móvil (+34855123456, es un número ficticio, pon el tuyo empezando por +34). Este servicio de textbelt permte mandar un único SMS al día gratis, pero si nos resulta útil podemos comprar paquetes SMS prepago.
Tanto simplepush.io como textbelt son dos de los muchos servicios push y SMS que hay. Yo he puesto estos porque los encontré pronto y me resultaron fáciles de usar mediante sencillas peticiones web con el comando curl.
Por supuesto, se podría ampliar el script con otros medios de aviso, por ejemplo mensajes telegram o cualquier otro sistema que se pueda hacer mediante scripts.
2. Avisos sonoros.
Un escalón mas es hacer sonar un aviso por los altavoces del PC del aula donde se detecta el evento, para que si es especialmente grave el usuario tome medidas. El script sería:
# cat /usr/local/bin/aviso-audio
#!/bin/bash
#Subimos el volumen al máximo en el alsamixer
amixer set Master unmute
amixer set Master 100%
#Si hay un usuario logado, conectamos con su pulseaudio para subir el volumen al máximo
user=$(who | grep "(:0)" | head -1 | cut -f1 -d" ");
if [ -n "$user" ]
then
su $user -c "DISPLAY=:0 pactl set-sink-volume 0 150%"
su $user -c "DISPLAY=:0 pactl set-sink-mute 0 0"
fi
#Si esta instalado placasiatic es una siatic y podemos encender por comando la barra de sonido.
test -f /usr/sbin/placasiatic && placasiatic sonido up
if [ -n "$user" ]
then
while true
do
ffplay /root/scripts/locucion.mp3 -nodisp -nostats -hide_banner
su $user -c "DISPLAY=:0 zenity --info --width 400 --height 100 --title='Desconexion de sistema' --text='Avise al administrador informatico de forma urgente.'"
done
else
ffplay /root/scripts/locucion.mp3 -nodisp -nostats -hide_banner -loop 0
fi
exit 0
Comentamos:
Con amixer quitamos el mute (silencio) y subimos al 100% del volumen del canal de audio Master.
Si hay un usuario con sesión iniciada, conectamos con su instancia pulseaudio para subir al máximo el volumen allí mediante pactl y hacer unmute.
Si estamos en una Siatic encendemos la barra de sonido mediante el relé. Esto garantiza que si el usuario ha apagado la barra la encendemos de nuevo usando la utilidad placasiatic. Por supuesto, si los altavoces del PC son convencionales y están apagados físicamente en su interruptor, no saldrá nada de sonido. Es algo que puede pasar y para lo cual no tenemos solución.
Por último, se reproduce una locución en bucle infinito codificado en mp3 mediante ffplay. Si hay usuario con sesión iniciada se muestra además un mensaje de texto en su escritorio mediante zenity.
La locución se puede generar fácilmente con texttomp3.
Para ejecutar este script desde el del apartado anterior es suficiente con añadir:
Cuando lo extraordinario empieza a ser habitual es señal de que se está haciendo bien: SpaceX ha lanzado una nueva carga de satélites Starlink.
Se lanzan 60 microsatélites Starlink (que mientras se van desplegando en las próximas semanas se podrán ver como un tren por el cielo nocturno una vez más), la etapa inicial del Falcon reutilizado por cuarta vez aterriza en la plataforma barcaza Of Course I Still Love You y la cofia se reutiliza por primera vez y se recupera mediante un barco.
Y todavía hay gente que afirma que todo lo relacionado con Elon Musk es humo.
Como cualquier informático me toca muchas veces dar soporte a familiares, amigos y arrimados usando teamviewer. Cuando tienes Ubuntu o Fedora están en la página de descarga los paquetes preparados para descargar e instalar, pero cuando trabajamos con otra distribución con sistema de paquetes propio no nos queda otra que bajar el fichero .tar.xz con el ejecutable y los ficheros necesarios, descomprimirlo a mano y ejecutarlo.
Exite un paquete AUR de teamviewer para Manjaro, pero la verdad es que la versión original se actualiza tanto que el paquete no va muy fino y muchas veces no funciona. Es mejor descargar el tar.xz y trabajar directamente con él.
Un problema frecuente es que al abrir el programa se nos queda en estado de "error de conexión" y no funciona. Suponiendo que tengamos red y que no haya problema en los servidores de Teamviewer la razón típica es la versión del programa que tenemos instalado. A día de hoy solo Teamviewer 14 me funciona en el Manjaro, las versiones anteriores no conectan. Desconozco si es algo propio de Manjaro o afecta a otras implementaciones.
El segundo problema que me pasa es que cuando lanzamos el ejecutable de teamviewer:
$ cd teamviewer
$ ./teamviewer
Init...
CheckCPU: SSE2 support: yes
Checking setup...
Launching TeamViewer ...
Starting network process (no daemon)
Network process started (3703)
Launching TeamViewer GUI ...
Y ahí se queda sin mostrar nada.
El motivo real es que faltan por instalar dependencias, pero resulta que el ejecutable es tan mudito que no da error ninguno. Esto me recuerda un programa de Indra que vi una vez cuyo código tenia:
Si instalamos esos paquetes con pacman la cosa funciona sin problema.
El cometa interestelar 2I/Borisov. El segundo objeto extrasolar detectado en la historia, detectado el 30 de agosto de 2019 por el astrónomo aficionado Borisov en Crimea (Rusia, diga lo que diga Ucrania) con un telescopio modesto. Dado el aviso, la comunidad de aficionados se volcó en hacer seguimiento del objeto y determinar su órbita en los días siguientes, resultando que era un cuerpo que venía de fuera del Sistema Solar e iba a irse de nuestro lado. Ciencia ciudadana se llama.
La última noticia es una foto del Hubble y se ha confirmado que es un cometa que trae agua de otro sistema solar.
Teniendo en cuenta que 1I/ʻOumuamua se descubrió 2 años antes está claro que esos visitantes de fuera son mucho mas frecuentes de lo que podríamos pensar. Sería maravilloso ver llegar otro con tiempo para mandar una sonda...
Vaya, vaya, que meses mas ocupados entre inicios de curso y repetición de elecciones. A ver si aprendéis a votar bien de una vez y podemos avanzar.
Vamos a contar alguna cosita. Después del verano los móviles vienen petados de fotos y vídeos y cuando toca hacer limpieza y descargar unos cientos o miles de fotos siempre me pasa lo mismo. Si pincho el móvil con el cable USB e intento copiarlas a golpe de ratón resulta que se hace a paso de, tortuga, con mucha posibilidad de que se quede parado o aborte en algún punto.
Esto antes no era así pero en algún momento alguien ha decidido que la conexión USB del móvil no se haga como si fuera un pendrive, sino que use un protocolo MTP que por su (mala) implementación penaliza enormemente la transferencia de muchos archivos. Es el problema de añadir capas a las capas, que al final cada byte recorre tantos escalones que el proceso se eterniza. Una vez vi un programa hecho por Indra que mandaba datos en formato XML mediante SOAP, el cual transforma lo que envía a formato XML. Meter un XML dentro de un XML, que buena idea.
¿Tiene esto solución? Claro, usando la línea de comandos. Para ello necesitamos:
Una vez hecho esto, tenemos que conectar el móvil con el cable USB al PC y ejecutar:
# adb shell
para conectar a una shell dentro del móvil. Una vez allí, mediante los comandos "cd" y "ls" exploramos las diferentes carpetas para dar con la ruta donde están los ficheros multimedia que queremos transferir. Esto puede cambiar de un móvil a otro y por eso no puedo dar un path universal, en mi caso están concretamente en la ruta /storage/sdcard0/DCIM/camera.
Un vez averiguada la ruta, salimos con "exit". Ahora, para transferir los archivos:
# mkdir camera
# adb pull -a /storage/sdcard0/DCIM/camera camera
El comando "pull" de adb realizar una transferencia recursiva de ficheros desde la ruta /storage/sdcard0/DCIM/camera de la memoria del móvil a la ruta ./camera del PC. Esta transferencia de ficheros se realiza a una velocidad endiablada: la velocidad de mover bytes sin tener que hacerlos pasar por capas y protocolos farragosos. En un tiempo razonable tenemos en el PC todos los ficheros.
Ya he hablado de la sonda india Chandrayaan 2, que ha costado menos que las elecciones del 10N en nuestra patria. En su momento esas cabezas parlantes que salen por la TV haciendo con que dan información se limitaron a comentar que el aterrizador Vikram se había estrellado. En realidad se perdió el contacto con él, no se sabe que pasó.
Bueno, pues el aterrizador era una parte de la misión. El resto ha seguido adelante haciendo fotos desde el orbitador:
Esto son fotos con una resolución de 30cm por pixel de la superficie lunar, una resolución nunca vista. Lástima que su órbita no la lleve por encima del lugar de alunizaje del Apolo XI.
Insisto: 140 millones de dolares. El 10N han sido 136 millones de euros.
Nuestros Techcomputer TC11 son unos clónicos que van a darnos algunos quebraderos de cabeza hasta hacerlos funcionar completamente con Linux. Uno de estas puñetas es el touchpad, que se queda congelado de forma aleatoria obligando a reiniciar o cerrar sesión para hacerlo de nuevo utilizable.
Hemos probado con distintos kernels y configuraciones de /usr/share/X11/xorg.conf.d/70-synaptics.conf sin éxito. Es el típico problema que un día con una actualización se arreglará de forma inesperada y nadie sabrá que ha pasado, pero mientras tanto hay que dar una solución.
El touchpad se maneja con el módulo "i2c_hid". Si descargamos y cargamos dicho módulo cuando se queda pillado comprobamos que todo vuelve a funcionar. Entonces, en plan chapuza...¿podemos hacer un script que pueda ejecutar el usuario de forma sencilla para realizar tal tarea cuando se quede pillado? Sería una solución rápida y sucia pero al final nos sacaría del apuro. La respuesta a esta cuestión es "SÍ".
Este script no puede usarse por un usuario regular, ya que para ejecutar rmmod/modprobe necesitas ser administrador. La solución es utilizar sudoers, añadiendo en /etc/sudoers la línea:
ALL ALL = (ALL) NOPASSWD: /usr/local/bin/reinicio_touchpad
Para que el usuario no tenga que abrir un terminal y lanzar el script usamos un atajo de teclado de XFCE4, asociando la tecla F12 a dicha acción:
De esta manera, a nivel de sistema (ya que lo definimos /etc/xdg/xfce4/xfconf/xfce-perchannel-xml/ en lugar del home del usuario) asociamos la ejecución de "gksu /usr/local/bin/reinicio_touchpad" a la tecla F12.
Si nos fijamos hay un bonus track: con CTRL-F12 ejecutamos el script "brillo". Este script pone a 100% el brillo de la pantalla del portátil. Esto es debido a que hemos observado a que a veces (algo relacionado con la suspensión o algún enredo similar) baja mucho y no es trivial subirlo de nuevo.
Como no vamos a hacer todo esto a mano portátil a portátil, ponemos finalmente las reglas puppet que meten todos estos ficheros y configuraciones anteriores en su sitio:
#No tiene control de brillo con Fn, script que pone el brillo al 100% de nuevo
file {"/usr/local/bin/brillo":
owner => root , group => root , mode => 755 ,
source => "puppet:///modules/xubuntu18_portatil_ajustes/brillo",
}
#Script que reinicia el touchpad quitando y poniendo el módulo
file {"/usr/local/bin/reinicio_touchpad":
owner => root , group => root , mode => 755 ,
source => "puppet:///modules/xubuntu18_portatil_ajustes/reinicio_touchpad",
}
line { sudoers:
file => "/etc/sudoers",
line => "ALL ALL = (ALL) NOPASSWD: /usr/local/bin/reinicio_touchpad",
ensure => present
}
# Atajos de teclado: CTRL-F12 ejecuta "brillo", F12 ejecuta "gksu renicio_touchpad"
file {"/etc/xdg/xfce4/xfconf/xfce-perchannel-xml/xfce4-keyboard-shortcuts.xml" :
owner => root , group => root , mode => 644 ,
source => "puppet:///modules/xubuntu18_portatil_ajustes/xfce4-keyboard-shortcuts.xml"
}
Cambia "xubuntu18_portatil_ajustes" por la tarea puppet que uses en tu caso para configurar los portátiles. La nave india Chandrayaan 2 finalmente aterrizó en la Luna, aunque durante un tiempo nos hicieron creer que se había pegado un castañazo como hizo la sonda israelí.
El reto ahora es saber por qué se cortó la comunicación en el último momento y determinar el estado operativo de la sonda. Esto convierte a la India en el 4 país en aterrizar sobre nuestro satélite, en su caso con misiones muy baratas y optimizadas: mandar la sonda con un rover ha costado 130 millones de euros, más o menos unos 20 km de autovía en España.
Y otra imagen maravillosa:
Algún día de este siglo, un descendiente de esta máquina aterrizará en Marte con humanos dentro.
Tengo un grupo de máquinas con arranque dual Linux/Windows. Normalmente arrancan con Linux, siendo esta la opción por defecto en el Grub. Hay veces que estoy conectado a ellas de forma remota y quiero arrancar Windows para hacer algún cambio o actualización en dicho sistema.
Podría modificar la configuración de Grub para arrancar con Windows. El problema es que una vez está cambiada no es sencillo revertir el cambio desde el propio Windows y hay que desplazarse hasta la máquina para elegir y configurar manualmente el arranque de Linux. Yo solo quiero arrancar una única vez el Windows y que luego todo siga igual.
La solución es usar el desconocido comando grub-reboot, que permite especificar cual es la opción de arranque por defecto para el siguiente reinicio. Tras ese reinicio, al apagar la máquina todo volverá a su ser habitual y arrancará el sistema por defecto que hayamos tenido habitualmente.
Lo primero es saber como identificar la opción de arranque a programar:
# grep -e "menuentry\ " -e "submenu" /boot/grub/grub.cfg
menuentry 'Ubuntu'.....
submenu 'Opciones avanzadas para Ubuntu' ...
menuentry 'Ubuntu, con Linux 4.15.0-54-generic' ...
menuentry 'Ubuntu, con Linux 4.15.0-54-generic (recovery mode)' ...
menuentry 'Ubuntu, con Linux 4.15.0-20-generic' ...
menuentry 'Ubuntu, con Linux 4.15.0-20-generic (recovery mode)' ...
menuentry 'Windows 7 (en /dev/sda1)' ...
menuentry "Clonezilla live 2.5.5.38" ...
menuentry "Arranque por red: PXE" ...
El comando grub-reboot admite un parámetro numérico (empezando por 0, que identifica la posición en la lista), dos o más números separados por > (para indicar posiciones dentro de submenús, por ejemplo 1>2) o un texto con la etiqueta de la opción de arranque. Por ejemplo, para programar el arranque del Windows 7 haríamos:
# grub-reboot 'Windows 7 (en /dev/sda1)'
# reboot
Y ya está, el sistema se reinicia y arranca en Windows. Podemos conectar a él con rdesktop y hacer nuestras cosas. Cuando ese Windows se apague volverá a arrancar en Linux. Bueno, ayer 25 de julio SpaceX consiguió elevar sin anclajes hasta una altura de 20 metros la StarHopper, el prototipo de la nave que permitirá poner humanos en la Luna y Marte en el futuro.
Prueba superada. Todo listo para pasar a la siguiente fase.
El tener muchos portátiles iguales facilita que cuando la batería de uno de ellos se degrada y empieza a funcionar peor podemos comparar entre ellos e identificar las que están degenerando de una forma real.
Como en nuestro caso la garantía de los contratos cubre la batería durante varios años hemos pensado en cómo hacer una revisión de algunos modelos que daban signos de agotamiento, con el objeto de que nos cambien las baterías defectuosas antes de que expire la garantía.
En mi caso son portátiles Inves Helio-1106L, que son remarcados de Clevo W310CZ (y que se vende con otros etiquetados como Stone N120, Zoostorm 7270-9062, ...). Todos son el mismo.
1. Un poco de teoría de baterías.
Las características de una batería se definen por los mAh y el voltaje. Por ejemplo, para nuestros portátiles Inves tenemos baterías de 2800mAh y 14.8V, como se puede apreciar en la pegatina que traen (los Clevo originales traían baterías de 2200mAh, pero seguramente fueron ampliadas por requisitos del contrato, las cuales pedían una duración de 4 horas de uso medio según diversos tests).
Multiplicando ambos valores obtenemos la capacidad de energía acumulada, que sería 2.800*14.8=41.440wh. Eso significa que si el portátil consume de promedio 11w encendido, con 41.4wh tiene para 41.4/11=3.76 horas de funcionamiento. Con el tiempo y los ciclos de carga-descarga esa capacidad va mermando y es ese porcentaje de merma lo que queremos medir.
Para saber en tiempo real los datos de la batería usamos el comando upower. Cojo un portátil Inves cualquiera, lo cargo al 100% y con él enchufado a la corriente hago:
Lo interesante: la capacidad por diseño de batería es 41.44wh. La capacidad real actual con la batería llena es de 30.08wh, por lo que la capacidad real en este momento es un 72% de la original. En nuestro caso la batería se considera averiada a efectos de garantía si está por debajo del 30%, por lo que de momento se libra de ser cambiada. De esta forma chequearemos todos los portátiles que deseemos.
Si nuestra batería tiene una ruta de acceso distinta de /org/freedesktop/UPower/devices/battery_BAT0 la podemos averiguar con:
# upower -e | grep BAT
2. Testeando la batería.
Una vez embarcado en esto, se me ha ocurrido chequear la bateria durante un ciclo de descarga, para hacerme una idea de su estado, duración y comprender el proceso de drenaje. Los datos que tomaré serán:
Con los que haré un bucle que cada minuto guarde ese resultado en un log hasta que el portátil se apague por falta de energía. Para conseguir simular un uso continuo y exhaustivo desconectaré el apagado de pantalla (con xset), pondré el brillo al máximo (con xrandr), simularé mover el ratón cada minuto para evitar entradas en modo ahorro de energía (con xte) y mientras tanto reproduciré un vídeo de youtube de varias horas de duración conectado a la red wifi.
Este es el sript check-bateria.sh
#!/bin/bash
xset s off -dpms
while true
do
xrandr --output eDP-1 --brightness 1.0
xte 'mousermove 4 4'
date >> ~/log-bateria.txt
upower -i $(upower -e | grep 'BAT') | grep -E "state|to\ full|percentage|energy" >> ~/log-bateria.txt
sleep 60
xte 'mousermove -4 -4'
done
exit 0
Los pasos a seguir son encender el portátil con la batería cargada al 100%, iniciar sesión, conectar la wifi, iniciar el vídeo de Youtube y ejecutar el script anterior, dejando todo en marcha hasta que el portátil se apague.
El consumo instantáneo (energy-rate) está entre 15 y 17.5 watios de promedio. Con 30.0884wh de capacidad aguantaría una hora y 48 minutos de uso continuo intensivo = 1.8 horas expresado en valor decimal.
Con los 41.44 Wh iniciales nos daría dos horas y media de uso intensivo, 2.5 horas en valor decimal.
Según upower la batería está en el 72,6071% de su capacidad inicial de fábrica. Para cotejar con la realidad hallamos la razón de las duraciones con el cociente 1.8/2.5 = 0.72. Correcto, coincide con lo estimado por upower.
Como la batería aún retiene un 72% de su capacidad de carga inicial no podemos reemplazarla usando la garantía. Bueno, otra vez será.
Ayer día 22 la India lanzó la nave Chandrayaan 2 en dirección a la Luna, con la intención de aterrizar un rover y convertirse en el cuarto país en la historia que ha puesto de forma controlada una sonda de exploración en la superficie de nuestro satélite.
Esto lo hace sin asistencia de ningún otro país, con su programa espacial propio y de forma autónoma.
El coste de la misión es de 126 millones de euros. El coste de una repetición de elecciones en 2019 en el Reino de España sería superior a los 140 millones de euros. Como vemos, cada uno hace lo que puede según su capacidad.
En esta entrada contamos como instalar el sistema DRBL en un PC con Debian 9 para servir imágenes de Ubuntu 18, imágenes duales y variadas. En dicho post enumeré los pasos para partiendo de un Debian Stretch llegar a tener un servidor DRBL, pero por precaución he hecho una imagen Clonezilla (versión clonezilla-live-2.5.5-38) de todo el sistema instalado por si se me va el portátil que uso como servidor para la clonación multicast.
La imagen es una imagen de partición sda1 y se restaura por tanto usando Clonezilla con la opción "restore part". Si deseamos clonarla sobre una partición distinta a sda1 el propio clonezilla en sus versiones modernas nos permite elegir la partición donde cargarla (por si queremos tener un equipo con arranque dual, con otro sistema para su uso diario y un DRBL para cuando queramos clonar) A su vez dentro contiene la imagen /home/partimag/miniportatiles-xubuntu-13062018 que usamos en nuestros centros. Después podremos poner en /home/partimag todas la imágenes adicionales que necesitemos.
La contraseña de root del sistema DRBL es "linex".
Una profesora me pidió este curso escribir un programa para realizar capturas de pantalla de los escritorios de los alumnos de forma periódica. El objetivo era tener en su carpeta personal una colección con las capturas de pantalla realizadas cada X minutos de los PC de todos los alumnos del aula, para controlar a posteriori el trabajo que habían estado haciendo durante la clase.
Capturar la pantalla desde un script no es complicado, aunque si quieres hacerlo de forma remota y traerlo al ordenador del profesor hay que afinar un poco la cosa.
Como paso imprescindible e inicial es obligatorio que entre el ordenador del profesor y los de los alumnos exista una relación de confianza ssh que nos permita conectar desde la cuenta de root del PC del profesor sin necesidad de introducir contraseña. Tras generar y copiar las claves, en /root/.ssh/id_rsa y /root/.ssh/id_rsa.pub del profesor tendremos las claves pública y privada, mientras que en /root/.ssh/... de los alumnos tendremos la clave privada.
Una vez resuelto el problema de la comunicación entre profesor y alumnos, tenemos que pensar en los posibles escenarios que nos encontramos en nuestras aulas:
Aula aislada: profesor y alumnos están una red privada con rango de direcciones propio, mediante una VLAN creada en el switch. En mi caso con los alumnos tienen direccionamamiento 192.168.0.200-253, sin importar si se usan portátiles o equipos de sobremesa.
Aula integrada: profesor y alumnos no están aislados, si no que usan direcciones públicas de la red del centro. Hay que encontrar una manera de que el PC del profesor sepa a priori cuales son las IP de los PC de alumnos que dependen de él. Esta manera consiste en definir en el fichero /etc/escuela2.0 (el que usamos para configuraciones de nuestras máquinas) una variable llamada IES_IP_ALUMNOS, en la cual indicamos en rango de IP donde están los PC de los alumnos, por ejemplo: 172.23.241.70-85. El valor tomado por defecto es 192.168.0.200-253
Thinclients: en este caso también es un aula aislada, con direcciones del rango 192.168.0.200 en adelante, pero con una particularidad consistente en que con los thinclients las sesiones de los alumnos se ejecutan en el PC del profesor, en una sesión privada en la que la captura de pantalla se hace de una forma diferente. Para saber si el aula tiene thinclients usaremos la variable IES_ISLTSP de /etc/escuela2.0
Aparte de eso, la aplicación debe tener un interface gráfico sencillo para el usuario. Por esta razón he optado por hacer la aplicación de captura usando python e interface gráfico Qt con PyQt5. Para ello uso Qt Designer para diseñar el interface gráfico y Geany para escribir el programa.
Una vez implementado, los ficheros necesarios son distribuidos por la siguiente tarea puppet:
Como vemos la tarea instala varios paquetes necesarios, copia los ficheros y añade una linea a sudoers para permitir a los miembros del grupo teachers ejecutar el programa con permisos de root (necesario para acceder a los pc de los alumnos).
Vamos primero el código del programa principal:
# cat xubuntu18_photomaton/files/photomaton.py
#!/usr/bin/python3
from photomaton_ui import *
import sys
import socket
import subprocess
import os, errno
from datetime import datetime
import paramiko
Para acabar un pequeño detalle: en las au
import time
from configobj import ConfigObj
import psutil
import nmap
class MainWindow(QtWidgets.QMainWindow, Ui_Photomaton):
def __init__(self, *args, **kwargs):
QtWidgets.QMainWindow.__init__(self, *args, **kwargs)
self.setupUi(self)
#Conectamos los botones con los eventos
self.iniciarCaptura.clicked.connect(self.capturar)
self.visualizarCapturas.clicked.connect(self.visualizar)
self.finalizar.clicked.connect(self.finalizarApp)
#Definimos el entorno, creando el directorio destino y leyendo escuela2.0
hostname = socket.gethostname()
#Como se llama usando sudo, el usuario original está en SUDO_USER
try:
self.user=os.environ["SUDO_USER"]
except Exception as e:
print("No eres usuario sudo. Abortando")
#self.user="root"
sys.exit(0)
home = os.path.expanduser("~"+self.user) #Directorio $HOME del usuario
self.pathcapturas=home+"/capturas/"+hostname
config = ConfigObj("/etc/escuela2.0")
self.uso=config.get('USO') #infolab/siatic/...
self.isltsp=config.get('IES_ISLTSP') #true si tiene thinclients
self.ip_alumnos=config.get('IES_IP_ALUMNOS') # Rango de ip de los alumnos, para aulas de workstations.
self.capturando=False
if self.ip_alumnos is None or self.ip_alumnos == "" :
self.ip_alumnos="192.168.0.200-253" # Rango por defecto en aulas con vlan
try:
comando="su "+self.user+" -c 'mkdir -p "+self.pathcapturas+"'"
os.system(comando)
except FileExistsError:
# directory already exists
pass
def finalizarApp(self):
if self.capturando == False:
sys.exit(0)
else:
self.capturando=False
def visualizar(self):
comando="su "+self.user+" -c 'nohup thunar "+self.pathcapturas+" &'"
os.system(comando)
def capturar_ip(self, ip):
s = socket.socket() #Quizá esto se podria quiar, el ssh_client.connnect ya tiene timeout
s.settimeout(30)
address = ip
port = 22
try:
#Intenta conectar por ssh a ver si la IP acepta peticiones ssh
s.connect((address, port)) #Si falla se va a la excepcion
s.close()
#Conectamos por ssh y ejecutamos el comando de captura.
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect(ip, 22, 'root', key_filename="/root/.ssh/id_rsa" , timeout=30)
fecha=datetime.now().strftime("%Y-%m-%d-%H:%M:%S")
sleeptime = 0.001
comando='rm -f /tmp/captura.jpg; pc=$(hostname); user=$(who | grep "(:0)" | head -1 | cut -f1 -d" "); test -n "$user" && (su $user -c "DISPLAY=:0 import -window root /tmp/captura.jpg"; chmod 777 /tmp/captura.jpg; echo -n $pc/$user)'
#print("Ejecutando "+comando)
ssh_transp = ssh_client.get_transport()
chan = ssh_transp.open_session()
chan.setblocking(0)
outdata=""
chan.exec_command(comando)
while True: # Hay que esperar a que acabe el comando
while chan.recv_ready():
outdata += chan.recv(1000).decode('ascii')
if chan.exit_status_ready(): # If completed
break
time.sleep(sleeptime)
#Como salida se devuelve "pc/usuario"
signatura=outdata
#Aprovechando la conexion ssh se usa sftp para recuperar el fichero /tmp/captura.jpg y guardarlo en la ruta de destino
sftp = ssh_client.open_sftp()
destino=self.pathcapturas+"/"+signatura
try:
comando='su '+self.user+' -c "mkdir -p '+destino+'"'
os.system(comando)
except FileExistsError:
pass
fichero=destino+"/"+fecha+".jpg"
sftp.get("/tmp/captura.jpg", "/tmp/captura-local.jpg") #Traemos el fichero a local
comando='su '+self.user+' -c "cp /tmp/captura-local.jpg '+fichero+'"'
#print("Ejecutando "+comando)
os.system(comando)
# Cerramos todo lo abierto
ssh_transp.close()
sftp.close()
ssh_client.close()
except Exception as e:
print("Error "+str(e))
def capturar_thinclients(self):
#Obtenemos la lista de usuarios conectados en el servidor de aula, filtramos por aquellos que están conectados con la ip 192.X.Y.Z (thinclients)
for usuario in psutil.users():
if usuario.host[:4] == "192." :
try:
#Sacamos el home del usuario con getent
comando="getent passwd "+usuario.name
process = subprocess.Popen(comando.split(), stdout=subprocess.PIPE)
output, error = process.communicate()
home_user=output.decode("ascii").split(":")[5]
#Conectamos con el thinclient para sacar el hostname
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect(usuario.host, 22, 'root', key_filename="/root/.ssh/id_rsa", timeout=30)
fecha=datetime.now().strftime("%Y-%m-%d-%H:%M:%S")
sleeptime = 0.001
comando='cat /etc/hostname | tr -d "\n"'
ssh_transp = ssh_client.get_transport()
chan = ssh_transp.open_session()
# chan.settimeout(3 * 60 * 60)
chan.setblocking(0)
outdata=""
chan.exec_command(comando)
while True: # Hay que esperar a que acabe el comando
while chan.recv_ready():
outdata += chan.recv(1000).decode('ascii')
if chan.exit_status_ready(): # If completed
break
time.sleep(sleeptime)
host=outdata
# Cerramos todo lo abierto
ssh_transp.close()
ssh_client.close()
#Ejecutamos el comando de captura de la sesión del usuario. Se usa os.system porque para comandos complejos es mejor que subprocess.popen
comando='su '+usuario.name+' -c "DISPLAY='+usuario.host+':7 XAUTHORITY='+home_user+'/.Xauthority import -window root /tmp/capture.jpg"'
os.system(comando)
#Copiamos la captura a la carpeta destino
destino=self.pathcapturas+"/"+host+"/"+usuario.name
try:
comando='su '+self.user+' -c "mkdir -p '+destino+'"'
os.system(comando)
except FileExistsError:
pass
fichero=destino+"/"+fecha+".jpg"
comando='su '+self.user+' -c "cp /tmp/capture.jpg '+fichero+'"'
os.system(comando)
comando='rm -f /tmp/capture.jpg'
os.system(comando)
except Exception as e:
pass
def capturar(self):
try:
segundos=int(self.intervaloCaptura.text())*60
except ValueError:
segundos=0
self.capturando=True
self.iniciarCaptura.setText("Capturando...")
self.finalizar.setText("Parar captura")
self.iniciarCaptura.setEnabled(False)
while self.capturando == True:
self.iniciarCaptura.setText("Capturando...")
self.iniciarCaptura.setEnabled(False)
self.do_captura()
if segundos == 0:
break
else: #Espera activa hasta la próxima captura
for i in range(segundos):
time.sleep(1)
app.processEvents()
if self.capturando==False: break
self.iniciarCaptura.setEnabled(True)
self.iniciarCaptura.setText("Iniciar Captura")
self.finalizar.setText("Finalizar")
self.capturando=False
def do_captura(self):
app.processEvents()
#print("Inicio captura")
if self.isltsp == "true":
self.capturar_thinclients()
else:
nm = nmap.PortScanner()
nm.scan(self.ip_alumnos, '22')
for ip in nm.all_hosts():# Equipos conectados, up.
#print("Procesando "+ip)
if nm[ip]['tcp'][22]['state']=="open":
#print("Puerto ssh abierto")
self.capturar_ip(ip)
app.processEvents() # Para procesar clicks de raton durante el bucle.
app.processEvents()
#print("Fin captura")
if __name__ == "__main__":
app = QtWidgets.QApplication([])
window = MainWindow()
window.show()
app.exec_()
Como se puede apreciar es un código python que utiliza clases de conexión ssh para ejecutar en remoto los comandos bash de captura de sesión y traer los ficheros con la captura al home del usuario en el PC del profesor.
El fichero photomaton.jpg contendría la imagen:
Seguimos con el fichero .desktop, el acceso directo para poner en el menú principal y en el escritorio. Nótese el uso de "gksu" para ejecutar como root el programa photomaton.py.
Un vez distribuidos los ficheros con la tarea puppet el modo de funcionamiento es lanzarlo en el ordenador del profesor y ejecutarlo para conectar a los equipos de alumnos detectados como encendidos y realizar las capturas. La pantalla es:
En "Intervalo de capturas (min)" indicamos cada cuanto tiempo queremos hacer las capturas de pantalla. Si dejamos 0 solo se realiza una captura en el momento en que damos al botón "Iniciar Captura".
Mientras que está realizando las capturas el botón "Iniciar Captura" se desactiva. El proceso de captura para pulsando el botón "Parar Captura". A veces tarda un rato en responder ya que no se puede interrumpir mientras está ejecutando la conexión con uno de los clientes.
El botón "Visualizar Capturas" nos lleva al directorio donde se realizan las capturas para que veamos las imágenes. Las capturas se estructuran en directorios separados según el patrón: ~/Capturas/$pc_profesor/$pc_alumno/$login_alumno/*.jpg
Los nombres de ficheros jpg nos indican la fecha y hora de captura:
Y ya está. Con este sistema el profesor puede realizar un seguimiento desatendido completo de la actividad de los alumnos. No solo eso: nosotros también desde nuestro PC podremos realizar seguimiento de ordenadores de uso público del centro.
Ahora que con la magnífica serie Chernobyl (quizá desvirtuada con algunos elementos de ficción y drama innecesarios, en detrimento de otros más interesantes como la construcción del sarcófago y los biorobots) se ha reavivado el tema, dejo varios enlaces sobre accidentes nucleares bastante silenciados:
Three Mile Island: o como "refrigerar" un reactor con vapor de agua en lugar de con agua líquida durante horas hasta fundir parcialmente el núcleo y no darse cuenta.
Vandellós I: o cómo quedarte a dos grados de explotar, mientras que el director de la central se iba a por tabaco en helicóptero a Barcelona y los trabajadores conseguían controlar la temperatura in extremis con el único turbosoplante que no se había parado por inundación.
Lucens: o cómo los suizos se lo intentan montar por su cuenta y funden un reactor el día de su puesta en funcionamiento. La única idea buena: como por si las moscas lo hicieron debajo de una montaña, solo se contaminó ésta.
Por supuesto, recomiendo todos los artículos de Yuri sobre Chernobyl:
Ahora que llegan las vacaciones viene bien dar un repaso a todos los portátiles de los alumnos: ejecutar puppet, pkgsync, limpiar los usuarios cacheados,... No solo eso, también durante el curso de vez en cuando nos toca actuar sobre todos los portátiles de un armario para aplicar alguna configuración que nos han pedido o que soluciona un bug pendiente.
Hasta ahora para tener conectividad tras encender los portátiles había 2 alternativas:
Conectarlos por red cableada a las tomas del suelo o un switch del aula.
Iniciar sesión en cada uno de ellos y conectarlos manualmente a la red Wifi del aula.
Evidentemente ambas opciones son bastante reiterativas y aburridas. Lo ideal sería que para estos casos los portátiles se conectasen de forma autónoma a una red wifi y nosotros pudiesemos manejarlos de forma masiva con tmux-cssh.
Y esa es la idea de este post: basándome en un script de conexión que usa en su centro nuestro compañero Esteban lo he adaptado para que se conecte de forma autónoma a una red wifi concreta predefinida tan pronto como la detecte.
El código del script es (nota: he corregido algunas erratas en el script el 8/10/2019):
# cat /usr/local/bin/conecta-default-wifi
#!/bin/bash
idioma=$LC_ALL
export LC_ALL=C
wifi_maestra="WIFI_AULAS"
wifi_key="a12345678"
nombre_conexion="ies"
activado=$(nmcli radio wifi)
if [ "$activado" != "enabled" ]
then
nmcli radio wifi on #activamos la wifi si no lo esta
fi
conectado=$(nmcli dev status | grep wifi | grep -w -e 'connected' -e "conectado" | awk ' {print $4}')
if [ "$conectado" != "$nombre_conexion" ] # Si no estamos conectados a la wifi maestra...
then
definida=$(nmcli con | grep wifi | grep -w "$nombre_conexion") #Si ya se definió la conexión en network manager la quitamos, para crearla de nuevo cuando nos conectemos
if [ -n "$definida" ]
then
nmcli con delete "$nombre_conexion"conecta-default-wifi
fi
detectada=$(nmcli -f SSID,BSSID,SIGNAL,SECURITY dev wifi list | grep -w "$wifi_maestra")
if [ -n "$detectada" ] # Si la wifi maestra está al alcance....
then
#Si la wifi maestra está al alcance y no estamos en ella, conectamos automaticamente.
nmcli dev wifi con "$wifi_maestra" password "$wifi_key" name "$nombre_conexion"
#Si ya existiese la conession podriamos hacer: nmcli con up $ssidconfigurado
fi
fi
export LC_ALL=$idioma
exit 0
Por tanto tenemos un script y una tarea cron que lo llama cada 3 minutos. El script hace lo siguiente:
Configuramos parámetros para una red wifi con SSID "WIFI_AULAS", una clave fija y un nombre de conexión "ies" para el Network Manager.
Si la tarjeta wifi está apagada en Network Manager, se enciende.
Si la wifi está conectada a un punto wifi, mira si el nombre de la SSID es "WIFI_AULAS". En caso afirmativo, finalizamos el script y no continuamos en los pasos siguientes.
Si existe alguna conexión en Network Manager con el nombre "ies", la borramos. Esto es simplemente para hacer limpieza si ya nos habíamos conectado antes.
Escaneamos las redes wifi circundantes en busca de "WIFI_AULAS". Si la encontramos a nuestro alcance nos conectamos a ella creando una conexión "ies" en Network Manager.
Todo esto se repite cada 3 minutos, de tal forma que tan pronto aparezca en el espectro radioeléctrico la wifi "WIFI_AULAS" el portátil se conectará a ella, desconectando de cualquier otra red wifi en la que estuviera enlazado y permaneciendo conectado mientras esté a su alcance.
Con esto el trabajo queda reducido a llegar al aula con un punto wifi (vale cualquier punto de acceso portátil, incluido un router casero de ADSL) configurado con WIFI_AULAS y la clave indicada, enchufarlo a un punto de red cableado, sacar los portátiles del armario y encenderlos.
En pocos minutos todos estarán conectados a la wifi sin ninguna actuación por nuestra parte y con tmux-cssh o ssh podremos controlarlos. Incluso si tenemos puppet y pgksync en modo automático se ejecutarán sin que tengamos que hacer nada. El punto de acceso solo lo usaremos cuando queramos trabajar de esta manera. El resto del tiempo estará apagado y guardado.
Debido a que te encuentras que la gente mas insospechada se niega a creer la gesta del Apolo XI, ahí va el documental definitivo:
Tras la llegada de los portátiles Techcomputer TC11 he liberado un par de docenas de antiguos miniportátiles MSI L1350D y APD P10ALD. Son aparatos bastante antiguos y justitos (ambos con Intel Atom CPU N455 y 2GB de RAM) que ya daban problemas de usabilidad con Ubuntu 18.
Como he hecho en otros equipos obsoletos con buen resultado, probé a instalar FreeBSD/TrueOS pero la verdad es que no he notado mejora significativa. Pienso que la causa pudiera ser el limitado soporte a la tarjeta gráfica Intel que traen.
Luego probé con varias versiones de Android-x86 con idéntico resultado. Estaba a punto de probar Manjaro pero recordé que tenía pendiente testear una distribución que convierten un portátil en un ChromeBook, que es un sistema operativo ligero cuyo escritorio es un navegador Chrome y por tanto solo permite ejecutar dicho software y los plugins que instalemos en él. En algunos centros educativos están empezando a llegar este tipo de equipos. En otros países se usa masivamente en entornos educativos.
De esta manera tenemos un ordenador en el que hacemos login con las credenciales de Google y que solo permite trabajar con el navegador, en la nube (con Google Docs, Google Drive y las extensiones que instalemos de Chrome Web Store).
Por supuesto, el sistema Chrome OS es propietario de Google y no es fácil instalarlo en un equipo que no sea un ChromeBook certificado. Afortunadamente han salido clones y alternativas que remedan bastante bien el espíritu de Chrome OS. Aunque hay varios donde elegir me he decantado para probar por CloudReady en su versión Home (traducido: la gratuita). Tiene también buena pinta este desarrollo chino, ahora que Trump está en guerra comercial con China.
1. Descarga.
Lo descargamos de la página de Neverware. En caso de duda se descarga la imagen en un .zip para OSX. Lo descomprimimos y dentro hay un fichero .bin con la imagen de disco de arranque. La grabamos a un pendrive USB con:
sudo dd if=cloudready.bin of=/dev/sdX bs=4M
Luego reiniciamos el pc y arrancamos con el pendrive. La instalación comenzará.
2. Instalación.
Durante la instalación se borrará el disco completo, no es sencilla una instalación dual. Lo cierto es que CloudReady construye un sistema infernal basado en mas de 20 particiones, la causa al parecer es algo que viene de serie en Chromium OS. Esta estructura no es algo normal en Linux, pero si lo he visto muchas veces en Android.
La primera pantalla de instalación, con la bienvenida y la elección de idioma:
Luego nos pide una cuenta de gmail.com. Esta cuenta será la propietaria ("owner") del sistema instalado y nunca podrá borrarse. Por ello lo mejor es usar en la instalación una cuenta gmail.com genérica que nos permitirá entrar luego el pc. Una vez instalado todo el sistema, cualquier persona que tenga una cuenta de Gmail podrá iniciar sesión libremente sin problema (o usar una cuenta temporal de invitado, si no tiene/quiere usar su cuenta de gmail).
Evidentemente, para que esta cuenta pueda ser validada es necesario que el ordenador esté conectado a Internet, ya sea por cable o wifi. Esto es un imperativo siempre presente un Chromebook: un sistema diseñado para trabajar en la nube necesita Internet constante.
Por último nos pide el idioma de instalacion:
3. Configuración y uso.
Una vez instalado, el sistema reinicia y aparece la pantalla de login con varias posibilidades:
Iniciar sesión con la cuenta del propietario.
Iniciar sesión con una cuenta válida de Gmail, la cual quedará cacheada para futuros logins offline.
Iniciar sesión con una cuenta de invitado, que al cerrar sesión no quedará rastro en el disco duro local de su actividad.
Borrar una cuenta de las creadas, excepto la de invitado y propietario.
Conectar a una red wifi, necesario para poder iniciar sesión con cuentas de gmail no cacheadas.
Esta es la configuración desde la pantalla de login:
Y esta una pantalla con ya dos cuentas de gmail cacheadas:
Una vez iniciada sesión carga el Google Chrome como única aplicación:
Este sería menú de opciones de la derecha de la barra de tareas:
Y este el menú de la izquierda de la barra:
Si entramos en la configuración vemos las preferencias usuales del Google Chrome, mas varias opciones extra referidas al escritorio de CloudReady:
Comprobando el rendimiento podemos afirmar que no va nada mal. Al tener un Linux subyacente con drivers actualizados y un escritorio con Chrome y sus extensiones de la Chrome Web Store todo va bastante ligerito teniendo en cuenta la poca potencia de esta máquina.
4. Configuración final e imagen Clonezilla para clonar.
Debajo de esto hay un Linux, por lo que podemos acceder a un terminal para configurar otros aspectos. Con la combinación de teclas CTRL-Alt-T entramos en el terminal, llamado "crosh". Una vez dentro con el comando "shell" entramos en una shell parecida a bash.
Las credenciales por defecto para trabajar son chronos/chronos. Si queremos cambiar la contraseña los pasos son:
# sudo mount -o rw,remount /
# sudo passwd chronos
# sudo mount -o ro,remount /
Y después reiniciamos.
Otra cosa que me resulta útil es desactivar la suspensión. Los pasos, tras entrar en el terminal:
# shell
# sudo su
# disable_verity
Reiniciamos la máquina y repetimos los anteriores comandos una vez. Luego hacemos
Aquí tenemos bastante soporte y trucos de configuración adicionales.
Una vez tenemos configurado es el momento de hacer una imagen con clonezilla para instalarlo en otros equipos. La creación de la imagen se inicia normalmente, pero al llear a la partición sda16 siempre aborta con este mensaje:
Starting to clone device (/dev/sda16) to image (-)
Reading Super Block
memory needed: 28369449 bytes
bitmap 7397925 bytes, blocks 2*10485760 bytes, checksum 4 bytes
Calculating bitmap... Please wait...
extfsclone.c: bitmap free count err, partclone get free:57578015 but extfs get 57553763.
Please run fsck to check and repair the file system
Failed to use partclone program to save or restore an image!
Tras muchas pruebas solo puedo afirmar que CloudReady al apaar el sistema siempre deja la partición sda16 en ese estado, provocando un error al crear la imagen. La solución es arrancar clonezilla y, antes de empezar a hacer nada, irnos a un terminal y teclear:
# sudo fsck -a /dev/sda16
Después de esto ya podemos realizar la imagen sin problema. La restauración funciona correctamente.
Esta semana los camaradas chinos nos han sorprendido lanzando un cohete Larga Marcha 11 desde una plataforma marítima.
Espectacular. Con este sistema resulta mucho mas barato y eficiente el envío de satélites.
