Solucionar error shebang en múltiples scripts bash linux

¿Qué es eso del error "shebang"?

Un error shebang, es un error en el que no se encuentra el intérprete especificado en la primera línea del script 

En el caso de un script bash linux lo podemos comenter con un error tan aparentemente inocente como empezar los scripts con la línea:

#/bin/bash

 En lugar de:

#!/bin/bash

Desde luego comerse el carácter ! es un error fácil de cometer pero es un error y, aunque la mayoría de las veces el script se ejecuta con bash sin mayores problemas puede confundir a tu editor de código, también es una mala práctica que puede producir en el futuro misteriosos errores que nos vuelvan locos buscándolos. 

Lo normal es que te des cuenta cuanto ya tienes cientos de archivos bash con el error, ¿que harías? ¿abrir cada uno de los archivos y cambiar esa primera línea a mano, seguro que cometes nuevos errores, así que lo mejor sería entrar en cada directorio afectado y ejecutar sed tal que así:

sed -i '1s|^#/bin/bash|#!/bin/bash|' *

Así de una tacada arreglo todos los archivos del directorio.

Hay que tener cuidado con estos comandos porque son muy poderosos y te lo cambian todo, para mayor seguridad:

1. Asegurarse que estamos en el directorio correcto, es fácil hacer que recorra todos los subdirectorios, pero por ahora lo dejamos para un futuro artículo
2. Le pasamos el parámetro -i para que haga los cambios sin hacer copias temporales, así que hay que tener cuidado porque no hay vuelta atrás.
3. En la cadena ponemos 1s antes de la tubería para que cambie solo la primera línea y empiece la búsqueda al principio de ésta.
4. Bueno, en realidad no me he tirado sin red, ya que los cambios en el repositorio está controlados por git, si algo sale mal se puede volver atrás y se puede saber exactamente que se ha cambiado, a la línea y al caracter.

Esta es la potencia de bash en GNU/Linux, que hace el trabajo duro en lugar de nosotros.

Por cierto, hay errores shebang todavía más difíciles de detectar y normalmente se producen por usar editores patateros de Windows:

• Los saltos de línea deben ser estilo unix, así que te vas a ahorrar muchos quebraderos de cabeza usando GNU/Linux. Y no macOS no tiene los mismos saltos, aunque esté basado en un unix, los de la manzana también son especialitos con estos (son distintos a los de Linux/Unix y también a los de Windows).
• Los editores no profesionales como el blog de notas de Windows tienen a introducir caracteres invisibles que no vemos pero nuestro sistema sí, estos errores son muy difíciles de detectar y corregir. ¿por qué lo hacen? ellos sabrán...

Hacer juegos con bash

SÍ, no lo has leído mal pone "Hacer juegos con bash" no "Hacer juegos para bash", sabíamos que bash es un lenguaje de scripting para GNU/Linux muy potente pero, ¿tanto como para crear un videojuego? Pues sí, de hecho se han creado unos cuantos con él.

Lógicamente, no esperes un juego espectacular, pero hay varios creados para consola que se pueden hasta disfrutar. 

Algunos ejemplos:

1. Basheroids: estilo Asteroids en Bash. Lo puedes descargar de https://github.com/Kafito/BashGameEngine
2. Bash 2048: versión del juego 2048 programada en Bash. Lo puedes descargar de https://github.com/JosefZIla/bash2048
3. bashcrawl: aventura de texto en Bash para aprender a moverte por la terminal y encontrar un tesoro. Se puede descargar de https://github.com/planetacomputer/bashcrawl
4. Bash Hangman: ahorcado implementado en Bash. Lo puedes descargar de https://github.com/akshayub/Hangman-Bash
5. Bash Invaders: clon de Space Invaders hecho en script Bash. Lo puedes descargar de https://github.com/Datron/space_invaders
6. Bash minesweeper: buscaminas en Bash, normalmente en versión ASCII. Lo puedes descargar de https://github.com/matman26/shell-sweeper
7. Bash Quiz games: cuestionarios interactivos hechos con Bash. Lo puedes descargar de https://github.com/AleksandarKostovic/bash-game
8. Bash RPGs simples: aventuras de texto y combates por turnos en shell script. Lo puedes descargar de https://github.com/wolandark/bash-dungeon
9. Bash Snake: versión de Snake escrita en Bash. Lo puedes descargar de https://draft.blogger.com/#
10. Bash Tetris: Tetris hecho en bash. Lo puedes descargar de https://draft.blogger.com/#
    Bashtris: clon de Tetris hecho en Bash. Lo puedes descargar de https://github.com/dereksgithub/bash-tetris 
11. Bash Tic-Tac-Toe: tres en raya hecho en shell script. Lo puedes descargar de https://github.com/AshutoshNirkhe/tic-tac-toe
12. BashVenture: framework clásico de aventura textual para Bash. Se puede descargar de https://github.com/apetro/BashVenture 
13. Playground: buscaminas para la consola. Lo puedes descagar de https://github.com/abhiTamrakar/playground
14. Sausage: juego de palabras para terminal escrito en Bash, inspirado en Bookworm. Se puede descargar de https://gitlab.com/christosangel/sausage
15. shell-adventure: aventura de texto pequeña escrita en Bash. Se puede descargar de https://github.com/aafrecct/shell-adventure
16. tetri.sh: Tetris sencillo programado en Bash. Se puede descargar de https://github.com/psykulsk/tetri.sh

Algunos de estos programas los podéis encontrar en los repositorios de tu distro, por ejemplo en el paquete bash_games.

 

 

Leer parte de una URL de otra URL y con plan B

Supongamos que queremos descargar mediante un script un archivo, pero con estas circunstancias:

1. Cuando cambia de versión, la URL cambia porque el número de versión es parte de la descarga.
2. Si accedemos a una dirección concreta obtendremos el número de versión actual. Para ello usamos el comando wget URL -q -O - que nos devolverá el contenido del archivo descargado, si no tiene éxito nos devolverá una cadena vacía. El resultado de la operación lo pasamos una variable.
   
3. En el caso de haber obtenido una cadena vacía, por estar la dirección que nos devuelve la versión fuera de línea, indicamos una versión que sabemos que siempre vamos a tener disponible. Así al menos poder instalar el programa aunque no sea la última versión.

En el script de descarga del emulador ZESarUX, tenemos un buen ejemplo de implementación de todo lo explicado:

#/bin/bash
software="zesarux"
carpeta="zesaruxpack"
latestversionurl="http://51.83.33.13/check_updates/stable.txt"
versionpack=$(wget $latestversionurl -q -O -)
if ["$versionpack" == ""]; then
    versionpack="12.0"
fi
echo "ZESarUX $versionpack"
../commonscripts/instalator.sh git build-essential libsdl1.2-dev libsdl2-dev libncurses5-dev libaal-dev libcaca-dev wget
wget -c https://github.com/chernandezba/zesarux/releases/download/ZEsarUX-$versionpack/ZEsarUX_src-$versionpack.tar.gz -O $software.tar.gz
tar -zxvf $software.tar.gz
mv ZEsarUX-$versionpack $carpeta
cd $carpeta
# compilar
git pull
cd src
./configure
make
sudo make install

Este script descarga la última versión estable de código, que tenemos en http://51.83.33.13/check_updates/stable.txt tal y como me indicó su creador.

Controla tus cambios de configuración con etckeeper

etckeeper es una herramienta para controlar todos los cambios de configuración que hagas haciendo uso de git, de manera que si te equivocas al hacer una configuración vas a saber que has cambiado y hasta volver atrás.

Para que sea efectiva lo ideal es instalarla justo al completar la instalación del sistema operativo junto al propio git, en el caso de Debian y derivadas lo podrías hacer con un comando como éste:

sudo apt install git etckeeper

A partir de este momento la carpeta /etc estará controlada por git, de manera que cuando hagas ciertos cambios como instalar paquetes se van a crear commits registrando la operación.

Hay que tener en cuenta que dichos cambios se registran con permisos para root, por lo que tenemos que hacer las operaciones con ese usuario, ya sea con sudo o su-

Si queremos ver los cambios que se han ido haciendo:

sudo git log

Si hacemos cambios manuales y queremos registrarlos:

sudo git add .
sudo git commit -m "Descripción de los cambios en la configuración."

Si queremos renombrar el último commit:

sudo git commit --amend

Por lo demás podemos tener el mismo control que en cualquier otra carpeta con código gestionada por git.

Descargar un sitio web con wget, opciones mejoradas y limitaciones

Voy a poner algunos ejemplos útiles del comando wget, si conocéis más podéis ponerlos en los comentarios:

• Descargar archivos sueltos de Internet: simplemente pasánles su ruta completa en la red:
  wget http://www.sitioinventado.com/recurso.mp4
  
  
• Continuar la descarga por donde se quedó:
  wget -c http://www.sitioinventado.com/recurso.mp4
  Con este parámetro, si se ha interrumpido la descarga continuará por donde se quedó en lugar de empezar por el principio.
  No debes usarlo si el archivo va cambiando de versión, pues en el mejor de los casos no hará nada y seguirás con la versión antigua.
  
  
• Descargar un sitio web estático NO protegido:
  wget -rkc http://www.sitioinventado.com
  En esta caso pasamos varios parámetros:
• -r : descarga recursiva
• -k: convierte los enlaces en rutas relativas para navegar por el sitio descargado sin ir a Internet.
• -c: continuar si se ha interrumpido el comando previamente.
  
  
• Descargar un sitio web estático protegido por robots:
  wget -e robots=off -r -np  --page-requisites --convert-links http://www.sitioinventado.com
  En esta caso, aparte de los parámetros ya vistos pasamos algunos nuevos:
• - e: ejecuta un comando, en este caso robots=off, para hacer caso omiso al archivo robots.
• - np (--no-parent): Descarga recursiva en la que no descarga los archivos que están por encima de la ruta indicada.
• -- page-requisites
• -- convert-links: convierte los enlaces en rutas relativas para navegar por el sitio descargado sin ir a Internet (igual que -k).
  
  
• Descargar archivos sin chequear el certificado:
  wget --no-check-certificate http://www.sitioinventado.com/recurso.mp4
  Esto puede tiene algún riesgo si no es un sitio confiable.
  
  
• Profundidad ilimitada en los enlaces de descarga:
  wget -rkc -l 0 http://www.sitioinventado.com
  Por defecto el nivel máximo de profundidad es 5, pero lo podemos cambiar con el parámetro -l, si ponemos 0 significa profundidad ilimitada.
  
  
• Simular que estamos descargando desde un navegador:
  Hay algunos sitios que solo nos permiten descargar si en la cabecera de la petición ven que estamos accediendo desde un navegador, eso también se puede simular:
  wget http://www.sitioinventado.com/recurso.mp4 --header="User-Agent: Mozilla/5.0 (Windows NT 5.1; rv:23.0) Gecko/20100101 Firefox/23.0"
  

Todas estas opciones las puedes combinar según tus necesidades.

Montar automáticamente un disco duro interno auxiliar sin usar fstab

Cuando arranco Debian 12 Mate me monta automáticamente las particiones de la unidad SSD (sda) pero NO monta la partición del disco duro donde almaceno varios datos (sdb1) sino que necesito hacer clic en Lugares y la etiqueta de la partición o acceder a Caja (el "explorador de archivos" de MATE) y abrir la partición.

Lógicamente puedo añadir una nueva entrada en fstab y montar donde quiera mi disco duro pero, ¿no podría simplemente simular que hago clic en las opciones de montaje manual sin instalar nada más que lo que ya trae el sistema.

Pues sí se puede hacer, el comando en concreto es el siguiente:

udisksctl mount --block-device /dev/sdb1

Si queremos podemos poner el comando en el script de opciones de inicio y así se montará automáticamente la partición al iniciar el sistema.

Para ello podemos añadir gráficamente el comando mediante las opciones de menu:

Sistema ► Preferencias ► Personal ► Aplicaciones al inicio

Pulsamos el botón Añadir y le ponemos un nombre indicativo que lo que hace y en el campo comando el comando completo que deseamos ejecutar.

En este caso el comando a ejecutar es:

udisksctl mount --block-device /dev/sdb1

Esto hará que el disco se monte se monte en la ruta:

mi_etiqueta_de_disco

Donde mi_usuario es el usuario con el que trabajamos y mi_etiqueta_de_disco la etiqueta del disco que estamos usando.

Un problema es que como esta ruta pertenece en principio a root no nos va a funcionar la papelera ni crear carpetas en el raiz del disco externo, para solucionarlo simplemente otorgamos la propiedad a mi usuario:

sudo chown mi_usuario mi_etiqueta_de_disco

Si tuviéramos problemas para borrar alguna carpeta también deberíamos comprobar si esa carpeta es propiedad de mi usuario o de root. 

Si no quieres que te pida contraseña cada vez que inicie el sistema para montar la partición recuerda que puedes configurar para que no te pida nunca más.

RetroMultiInstaller: los menús solo muestran apps compatibles con el ordenador que lo ejecuta (e instalación desatendida)

RetroMultiInstaller, el script facilitador de instalaciones tenía el defecto de ofrecerte todos los scripts de instalación en sus menús, aunque no fueran compatibles con tu hardware, así por ejemplo, si lo ejecutabas en una Raspberry Pi podrías terminar instalando un programa que no fuera compatible con ARM y que por tanto no iba a funcionar.

También se ha corregido la instalación por lotes desatendida y ya aparecen solo los programas ordenados para la arquitectura actual.

 

Recuerda que, si ya tienes instalado RMI, lo puedes actualizar seleccionando las opciones:

Update ► update own

 

¿Como lo he hecho y como puedes añadir más instaladores?

Para solucionar esto he incluido un nuevo mecanismo que mira las arquitecturas declaradas en los archivos menu/*.txt de tal manera que la definición de cada línea de script quedaría ahora con esta estructura:

arquitecturas etiqueta definición

• Las arquitecturas se ponen una detrás de otra separadas por el carácter tubería "|" por ejemplo, NUNCA ESPACIOS NORMALES.
• La etiqueta sigue siendo el identificador del script.
• La definición tampoco permite ESPACIOS NORMALES pero sí espacios duros.

Algunos ejemplos, que podemos encontrar casi todos en el archivo menus/multisystem.txt:

• Si ponemos como arquitectura 'all' no filtrará, es decir, mostrará el script del menú independientemente del hardware desde el que ejecutemos RMI:
  

  all ZEsarUX ZEsarUX multi emulator

• Podemos poner una sola arquitectura, en la siguiente línea tenemos un script que solo se mostraría en Raspberry pi OS de 32 bits:
  

  armv7l Retropie Multi Emulationstation Enviroment

• Un ejemplo de un script que se ejecutaría en varias arquitecturas, en este caso solo para Intel de 32 o 64 bits o Raspberry pi OS de 64 bits.
  

  x86|x86_64|aarch64 RetroVM Retro Virtual Machine

• Las opciones para abrir otro menú o salir del actual deben tener la etiqueta menu para no aparecer en las opciones de la instalación desatendida:
  

  menu Exit Return to Main Menu

• Si en un momento un script dejara de funcionar ya no teníamos que borrarlo podemos dejarlo para arreglarlo más adelante y en el menú poner como arquitectura algo así como 'none' o 'disabled':
  

  none oldgame Old Game

 

He encontrado un programa que NO funciona, ¿qué hago?

Ahora queda la ardua tarea de ir comprobando que las arquitecturas definidas en cada script se corresponden con los programas que se pueden ejecutar en cada arquitectura, como seguro se me van a pasar muchos necesitaré vuestra ayuda en los comentarios para que me indiquéis los que no funcionan.

 

Aunque si abrís una incidencia en el propio gitlab me resultará más fácil tener el seguimiento de lo que está pendiente de arreglar. ;-)

Instalación desatendida por lotes (batch)

Script bash para comprimir cada directorio de la ruta actual en un archivo zip independiente

Supongamos que tenemos, en una ruta determinada de nuestro disco, varias carpetas cada una con los archivos correspondientes a un determinado programa y queremos que el contenido de cada una se guarde en un archivo zip independiente, lo podíamos hacer con un script como éste:

#!/bin/bash
for dir in */; do
    dirname=$(basename "${dir}")
    cd ${dir}
    zip -r "../${dirname}.zip" .
    cd ..
done

El script hace lo siguiente:

1. Recorre la lista de nombres de directorios
2. Nos cambia a la ruta
3. Comprime el contenido en un archivo zip con el mismo nombre que el directorio y guardándolo en un nivel inferior de la ruta, es decir, donde ejecutamos el script.
4. Vuelve a la ruta original, bajando un nivel.

Este script lo copiaría con el nombre dir2zip en la ruta /usr/local/bin para que esté disponible desde cualquier lugar de nuestro disco, ya que debe ejecutarse desde el mismo directorio.

Se puede mejorar fácilmente para que haga otras cosas:

• Pasar la ruta opcionalmente como parámetro.
• Comprimir solo un nivel e ir ejecutándose recursivamente, si esa es nuestra necesidad.
• Borrar la carpeta después de una compresión exitosa.
  

Si se te ocurre maneras de mejorar en el script exponlas en los comentarios y así seguimos aprendiendo entre todos.

Quien sabe lo mismo me animo y explico más adelante como hacer el script contrario: zip2dir.

Chafa, espectacular visor de imágenes para consola

Chafa es una de esas aplicaciones de consola que no te puedes creer que sean una aplicación de consola, se trata de un visor de imágenes que muestra lo mejor que puede una imagen usando simplemente la consola de texto de GNU/Linux... y vaya sí que lo hace lo mejor que puede...

Para te genere la imagen basta con ejecutar:

chafa miimagen.png

Si le pasas un GIF animado te lo muestra en movimiento y no te devuelve el prompt hasta que tecleas CTRL y C

Si no la tienes instalada, la puedes instalar desde los repositorios oficiales de tu distro, en el caso de Debian y derivadas se podría instalar desde consola con el comando:

sudo apt install chafa

chafa permite definir el número de colores y el tamaño, si no intentará mostrar la imagen con el máximo espacio disponible.

¿Quién dice que la terminal es fea y aburrida?

Con Chafa un nuevo nivel de ASCII Art a todo color se abre ante tí.

Compartir una sessión SSH con Tmux

Compartir una sesión con SSH es algo muy útil para un trabajo que estás haciendo con más personas o para enseñar a usar la consola. 

Antes de empezar debemos tener instalados tanto ssh como tmux en los ordenadores que van a usarse, en el caso de distribuciones de la familia Debian lo podrían hacer con el siguiente comando:

sudo apt install tmux openssh-client

En el que nos vamos a conectar ADEMÁS tendría que tener instalado el servidor de ssh:

sudo apt install openssh-server

Supongamos para el ejemplo que queremos conectarnos desde dos PCs que tenemos en la casa a nuestra raspberrypi, tenemos un ordenador llamado 'i3' con usuario 'uno', otro llamado 'i5' con usuario 'dos', y el servidor al que nos queremos conectar por SSH se llama raspberrypi

Desde el ordenador 'i3', abrimos un terminal y iniciamos Tmux:

tmux

Nos aparecerá una consola especial con una línea verde al final indicándonos que estamos en una sesión tmux 

Ahora nos conectamos al servidor por SSH:

ssh uno@raspberrypi.local

Nos pedirá la contraseña, la escribimos y ya estamos conectados al servidor. En la terminal del servidor creamos una sesión para compartir llamada 'compartiendo':

tmux new-session -s sesioncompartida

Después de ejecutar el comando nos aparecerá otra línea con fondo verde informando de que se está compartiendo una sesión.

 

En el ordenador 'i5' seguimos los pasos anteriores para conectarnos al servidor, y cuando ya estamos logueados en la terminal del servidor verificamos las sesiones de Tmux abiertas con:

tmux list-sessions

nos aparecerá la sesión 'compartiendo' creada por el usuario 'uno'. para conectarnos a ella escribimos:

tmux attach -t sessioncompartida

Ahora tendremos a los dos usuarios compartiendo la misma sesión, por lo que se escribe en un ordenador se ve también en el otro.

Para salir de la sesión se puede ir haciendo pulsando CTRL y la tecla D simultáneamente hasta que desaparecen las líneas verdes




Fuente: 

• https://fortinux.gitbooks.io/humble_tips/content/capitulo_2/compartir_sesiones_ssh_con_tmux_en_gnulinux.html
  

Ampliando RetroMultiInstaller: los scripts de instalación (V)

El directorio installers es la carpeta que contiene toda colección de scripts que instalan cada uno de los programas.

Estos scripts se ejecutan desde el script instalador.sh desde la carpeta tmp para que los archivos temporales se creen en esa ruta.

El nombre del archivo del script de instalación que vamos a ejecutar sería la etiqueta que tenemos definida en el correspondiente archivo txt de la carpeta /menu seguido del sufijo _installer.sh
Si lo ejecutamos manualmente para probar que funciona correctamente hay que ir a la carpeta tmp y ejecutarlos así:

../installers/programa_installer.sh

Un ejemplo simple de script de instalación de software podría ser así:

#/bin/bash
../commonscripts/instalator.sh git
../commonscripts/createshortcuts.sh desktopcal
source ../commonscripts/makeopenchangetodir.sh /opt/webapps
git clone https://github.com/hvianna/desktopCal.js desktopcal

Los scripts que están dentro de la carpeta ../commonscripts son scripts para diversos usos que veremos en el próximo epígrafe.
El último de estos script se invoca con la instrucción source al principio, esto se hace para cambiar al directorio indicado. Hay que tener especial cuidado con los scripts que se ejecuten después de él, ya que a partir de ahora ya no se van a ejecutar desde la carpeta tmp sino por la indicada en este último script.
Después de git clone se pueden añadir todos los comandos para compilar el programa, si requiriera compilación, integración, etc…

Ampliando RetroMultiInstaller: el script principal (IV)

retroinstaller.sh es el script principal que debemos ejecutar para lanzar el RetroMultiinstaller, para analizar el código más en profundidad, he incluido en el mismo un comentario con un número que identifica lo explicado en los siguientes puntos:

1. La primera línea es distinta al típico /bin/bash para que también podamos ejecutarlo haciendo doble clic sobre el script en un entorno gráfico.
2. Definimos la función is_missing_dialog_pkg que comprueba si el paquete dialog está instalado y si no es así lo instala.
3. Después de invocar la función para instalar dialog si es preciso entramos en un bucle infinito.
4. Se asigna a la variable “seleccion” la salida del comando menugen.sh, pasada a minúsculas. El script ‘menugen.sh’ es el que realmente dibuja los menús y lo veremos más adelante.
5. Si se elige “exit” o se cancela el menú se sale del menú y se acaba la ejecución.
6. Si existe un archivo en la carpeta menús cuyo nombre sea igual al valor de la variable “seleccion” más la extensión “.txt” se ejecuta de nuevo el script pero pasándole como parámetro el valor de la variable “seleccion”.
7. Si selección toma un valor distinto a “exit” se ejecuta el comando cuyo nombre es el valor de la variable selección seguido de “_installer.sh”.
8. En este caso también se muestra un texto de ayuda con el script warninggen.sh de la carpeta commonscripts, si existe el archivo warning/seleccion.txt 

A continuación podemos ver como quedaría el script:

#!/usr/bin/env bash
function is_missing_dialog_pkg() { #2
    if [ ! -f /usr/bin/dialog ]; then
        while true; do
            read -p "Missing 'dialog' package. Do you wish to let me try to install it for you? (aprox. 1.3 kB) [y/n] " yn
            case $yn in
            [Yy]*)
                ./commonscripts/instalator.sh dialog
                break
                ;;
            [Nn]*)
                echo "Please install 'dialog' package to continue."
                exit 1
                ;;
            *) echo "Please answer (y)es or (n)o." ;;
            esac
        done
    fi
}

#3
is_missing_dialog_pkg
#Blue infinito para pintar los menus #3
while true; do
    #4
    seleccion=$(./commonscripts/menugen.sh $1  | tr '[:upper:]' '[:lower:]')
    #5
    if [ $seleccion == "exit" ] || [ -z "$seleccion" ]; then
        clear
        break
    fi
    #6
    if  [ -f "./menus/${seleccion}.txt" ]; then
        ./retroinstaller.sh $seleccion
    else
        #7
        mkdir tmp
        clear
        echo ">>> Installing ${seleccion}..."
        cd tmp
        ../installers/${seleccion}_installer.sh
        #8
        ../commonscripts/warninggen.sh ${seleccion}
        cd ..
    fi
done

Ampliando RetroMultiInstaller: archivos del directorio principal (III)

En el propio directorio donde hemos copiado Multi-installer tenemos una serie de archivos esenciales para su funcionamiento:

• retroinstaller.sh: es el script principal que tendremos que ejecutar para la ejecución del programa desde el directorio donde hemos copiado el programa, ya sea desde consola con la instrucción ./instalador.sh o haciendo doble clic desde el entorno gráfico de GNU/Linux, en cuyo caso tendremos que seleccionar la opción ‘Ejecutar desde una terminal’.
• README.md: documento escrito en el lenguaje markup para wiki en el que podemos incluir una descripción del programa Multi-installer junto con la relación de programas que se pueden instalar con el script, en cada ítem debería incluirse al menos una descripción de lo que hace, enlace para descargar el programa de su página oficial, arquitecturas soportadas, etc.
• TO_DO.md: documento con las mejoras que se desean incluir en un futuro sin plazo determinado.
  
• logo.png: icono identificativo de la aplicación que se mostrará en la descripción del proyecto si se sube a algún servicio de hospedaje de código gestionado por git, como github o gitlab.
  Se recomienda que sea cuadrado, no muy pesado ni grande, 256x256 pixels es una buena opción.
  
• LICENSE: licencia del programa, GNU GPL 3.
  

En el próximo capítulo veremos como funciona el script retroinstaller.sh en más profundidad.

Ampliando RetroMultiInstaller: carpetas principales (II)

Los próximos primeros viernes de cada mes voy a retomar el análisis de la herramienta que creé para agrupar todos los scripts de instalación que tengo y seleccionarlo con un sencillo menú.

Así cada uno podrá adaptar RetroMultiInstaller a sus necesidades.

Aunque en el anterior artículo ya comenté algo de la estructura interna del programa, en este voy a explicar los directorios esenciales que cuelgan de la carpeta donde descomprimos RMI.

En el directorio donde copiamos Multi-installer hay una serie de directorios que contienen otros directorios y archivos.
La estructura de directorios es la siguiente:

├── commonscripts
├── installers
├── menus
├── shotcuts
│   ├── etc
│   │   └── xdg
│   │       └── menus
│   │           └── applications-merged
│   ├── opt
│   └── usr
│       └── share
│           ├── applications
│           ├── desktop-directories
│           └── pixmaps
└── resources
└── warning
└──tmp

Analizando cada directorio con más detalle:

• commonscripts: aquí se incluyen todos los scripts de uso común y que llamaremos desde otros scripts.
• installers: aquí se incluyen los script de instalación, uno por cada programa.
• menus: son los archivos txt que contienen la definición de los menús.
  Cada archivo tiene la definición de un menú y cada línea de cada menú la definición de un programa a instalar o una categoría que abre un nuevo menú.
• shotcuts: incluye todos los archivos para crear los accesos directos con sus iconos y las categorías especiales para agruparlos.
  Dentro de este directorio hay una estructura de subdirectorios igual que donde se van a copiar los archivos en el sistema operativo.
  
• warning: incluye los archivos de texto con instrucciones u otra información que se mostrará al terminar la instalación del programa.
• tmp: carpeta donde se crearán los archivos temporales para las instalaciones tales como el código fuente antes de compilar e instalar.

Casi todos los scripts se ejecutarán desde esta carpeta, por lo que siempre deberemos referirnos a ellos con una ruta relativa que parte de esta carpeta.
Todos los archivos que contienen las carpetas installers, menus, shotcuts y warning correspondientes a un programa a instalar, contienen al principio de su nombre la etiqueta que identifica ese programa en minúsculas.

Controlar la temperatura de tu PC

Para controlar la temperatura de los componentes de tu PC hay varios comandos, vamos a ver algunos:

sensors

Este comando de consola te muestra información de todos los sensores de temperatura que tiene tu ordenador, para ello hay que instalar el paquete lm-sensors que está en los repositorios oficiales de tu distro, en el caso de Debian y derivadas se puede instalar con el comando:

sudo apt install lm-sensors

Este comando muestra información desde consola del momento exacto en el que se ejecuta el comando:

sensors

Si se quiere monitorizar en tiempo real podemos abrir otra consola en nuestro monitor secundario y ejecutar:

watch sensors

Lógicamente tendremos que haber instalado watch previamente.

xmbmon y mbmon

Otro programa para monitorizar temperaturas y voltajes, desde consola con mbmon o entorno gráfico con su front-end xmbmon

No funciona con todas las placas.

El comando watch

El comando watch te permite ejecutar una instrucción sin devolver el prompt de manera que vamos viendo en tiempo real los cambios en el resultado de dicho comando.

Por ejemplo, si queremos saber la evolución del espacio ocupado en nuestras particiones podríamos ejecutar en una ventana, un segundo monitor o consola virtual:

watch df -h

Y así podríamos ver una lista de todas las particiones con el tamaño de las mismas, el espacio usado y disponible e uso en cada momento.

Arrays en bash: un ejemplo práctico y explicativo

En bash también podemos usar arrays, para ello voy a hacer un sencillo script que me compila todos los archivos .c que habría que compilar uno a uno en el emulador CPCEC:

#/bin/bash
emulators=(cpcec zxsec xrf csfec msxec runec)
for i in "${emulators[@]}"
do
    echo "** Compiling $i, please wait... **"
    gcc -fsigned-char -DDEBUG -DSDL2 -O2 -xc $i.c -lSDL2 -o$i
    chmod +x $i
done

Vamos a analizar cada línea:

1. Definimos este archivo como un script bash.
2. Definimos emulators como un array, para ello se ponen los valores entre paréntesis separados por un espacio, si algún valor tuviera un espacio debería estar entre comillas o escapado poniendo antes del espacio el caracter \
3. Línea que crea el bucle que recorre todos los valores del array definido en la variable "emulators".
4. Inicio del bucle, dentro de él $i será cada uno de los valores del array en cada iteración.
   
5. Texto informativo.
6. Instrucción de compilación.
7. Dar permiso de ejecución al binario generado.
8. Fin del bucle.

 

Renombrar todos los archivos de un directorio a minúsculas o mayúsculas

Me he encontrado con viejos programas en C++ procedentes de MS-DOS que no se pueden compilar porque se referencias los nombres en minúsculas y los nombres de archivos están en mayúsculas, lo cual es un problema con los sistemas Unix que si distinguen entre minúsculas y mayúsculas.

Para pasar todos los nombres de archivos de un directorio hay que ejecutar el siguiente comando dentro de dicho directorio:

for original in *; do mv $original `echo $original | tr '[:upper:]' '[:lower:]'`; done

Y listo ya podríamos compilar el programa.

Lógicamente, si por algo necesitáramos pasar todos los nombres a mayúsculas el comando sería:

for original in *; do mv $original `echo $original | tr '[:lower:]' '[:upper:]'`; done

Sabiendo un poco de bash estos problemitas son fáciles de resolver. ;-)

¡Ah! Si está en un zip también se puede descomprimir con todos los archivos en minúsculas con el comando:

unzip -LL archivo.zip

Algo más "para todos los públicos" pero que no siempre funciona.

Ampliando RetroMultiInstaller: estructura interna (I)

RetroMultiInstaller es una colección de scripts que facilitan la instalación de programas en distros GNU/Linux de la familia Debian, éste va a ser el primero de varios artículos en el que vamos a aprender a ampliar esta aplicación para que instale también los programas que necesitemos y que aún no estén incluidos, incluso me podéis sugerir la inclusión de scripts de interés adjuntándolos junto a una descripción en la sección de issues.

El primer paso para conocer una nueva herramienta es saber algo de su estructura interna y eso es lo que vamos a tratar de ver hoy, RetroMultiInstaler está pensado para que podamos ver y entender que hacen los scripts aunque seamos novatos en el uso de los mismos, tratando que el código sea claro y comprensible.

Requisitos preliminares

Para usar RetroMultiInstaler necesitamos dos cosas:

• git para su descarga y mantenimiento.
• Que nuestro usuario esté autorizado en sudoers, es decir, que pueda ejecutar programas como administrador mediante la orden sudo.

También necesitaremos el paquete dialog para que pinte los menús, pero el propio script nos pedirá instalarlo en su primera ejecución si no está presente.

Descarga y actualización

Ya podemos descargar el script con toda su estructura con el comando:

git clone https://gitlab.com/cpcbegin/retromultiinstaller

Si ya lo tenemos descargado podemos actualizarlo a la última versión con el comando:

git pull

La actualización es fundamental antes de cambiar algo en el script.

Estructura interna

Estos son los archivos y carpetas principales que cuelgan de la carpeta que contiene el script

• retroinstaller.sh: script principal con el que ejecutamos la herramienta.
• opt: carpeta donde se generan los archivos y carpetas , todos los scripts se ejecutan desde esta ubicación y por tanto todas las rutas relativas deben componerse como si estuviéramos en este directorio. También es conveniente excluirlo del contol de git
• commonscripts: scripts que se usan en varios sitios.
• installers: contiene los scripts de instalación.
• menus: contiene los archivos con los menús, el principal es main.txt que llama al resto de menús ya que se pueden llamar unos a otros. Cada línea contiene una etiqueta índice un espacio y una descripción, dentro de la descripción puede haber espacios pero deben ser espacios duros.
• resources: diversos recursos incluidos en el script.
• shotcuts: archivos a copiar en la estructura del sistema.
• warning: archivos con texto de aviso al finalizar la instalación.
• README.md: Información sobre el software que se puede instalar.

La etiqueta índice del menú debe coinidir con el prefijo del script de instalación, cuyo nombre será indice_installer.sh

También es conveniente que se use en el nombre del resto de archivos del script para mantener la coherencia y facilitar el mantenimiento.   

Quitar líneas repetidas de un archivo de texto sin alterar su orden

En muchos casos podemos necesitar que un archivo no tenga líneas repetidas, pero en la mayoría de los sitios lo que recomiendan es ordenar el archivo y luego quitar las líneas repetidas con el comando:

sort archivo_original.txt | uniq > archivo_ordenado_lineas_unicas.txt

Pero en muchos casos simplemente queremos que quite las líneas repetidas respetando el orden original, para ello tenemos que usar el comando unique, que no viene instalado por defecto sino que se incluyen en las utilidades john para detectar contraseñas débiles.

Por tanto lo primero es instalar john:

sudo apt install john

El uso es sencillo:

unique archivo_lineas_unicas_sin_ordenar.txt < archivo_original.txt

Así de simple.