Useful shell scripts in any program

Bash It is a computer program whose function is to interpret orders. It is based on the shell of Unix and was written for the project GNU being the default shell in most distributions of GNU / Linux. His name is an acronym for Bourne–Again Shell (another shell bourne), making a play on words (born-again means rebirth) about him Bourne shell (sh), which was one of the first major interpreters of Unix.

Today we are going to show some shell scripts that can be very useful for developers. Most work in any shell Unix, although some require that they be specifically executed by Bash.

Prevent non-privileged users from running the script

Some scripts perform administrative tasks so we might want only the root user to run the script. In that case we can use something like this:

#!/bin/bash
if [[ $EUID -ne 0 ]]; then
echo "Este script debe ser ejecutado por el usuario root" 1>&2
exit 1
fi

Allow script execution only to a specific user

Similar to the code above, we might want only a specific user to run the script. We do it so:

#!/bin/bash
AUTHORIZED_USER="usuario_permitido"
if [ $USER != $AUTHORIZED_USER ]; then
echo "Este script debe ser ejecutado por el usuario $AUTHORIZED_USER" 1>&2
exit 1
fi

Verify that a service / process is running

If we want to know if there are processes of any service or program running we could use this script (in this case it verifies that the demon of Apache is running):

#!/bin/sh
SERVICE='httpd'
if ps ax | grep -v grep | grep $SERVICE > /dev/null
then
echo "El servicio $SERVICE esta ejecutandose"
else
echo "Chanfle! El servicio $SERVICE esta detenido"
fi

Create a lock file

Sometimes we must make sure that the script does not run two or more times simultaneously. For this we can make use of the lock files. This is a simple version of a script that allows us to do this:

#!/bin/bash
lockfile=/var/lock/loquesea.lock
if [ ! -e $lockfile ]; then
touch $lockfile
echo "hago muchas cosas importantes aqui"
rm $lockfile
else
echo "ya hay otro proceso corriendo"
fi

In this case, it is verified that the file whatever.lock exist. In case it exists, the script DOES NOT execute its tasks. If it doesn't exist, it creates the file, runs the tasks it needs to run, and removes it. But, this is not entirely reliable. What would happen if while our script is running it is closed abruptly?

In that case the lock file would not be deleted, and therefore it would not allow us to run the script again. To cover those cases, we could make use of the trap command that allows us to execute commands in case our script ends unexpectedly. This is a more advanced version that also saves the PID of the script that executes it within the lock file:

#!/bin/bash
lockfile=/var/lock/loquesea.lock
if ( set -o noclobber; echo "$$" > "$lockfile") 2> /dev/null;
then
trap 'rm -f "$lockfile"; exit $?' INT TERM EXIT
echo "hago muchas cosas aqui tranquilamente"
rm -f "$lockfile"
trap - INT TERM EXIT
else
echo "Ya hay otro proceso de este script ejecutandose"
echo "corriendo con el PID: $(cat $lockfile)"
fi

Let's understand the command a little better systematic trap: every time. Its syntax is basically this: trap command signal [signal…]; where signal is the termination signal you want to catch. If you want to see a list of available signals you can run the command kill -l. For the previous case, the INT signals were used (captures the termination produced by a Ctrl + c), TERMS (termination produced by kill command) and EXIT (normal termination of a script, either because there are no more lines to run or because it comes across the exit command).

Options menu

To make a menu where we allow the user to select a series of options we can use the following scheme:

#!/bin/bash
clear
while :
do
echo " Escoja una opcion "
echo "1. quien soy?"
echo "2. cuanto espacio tengo"
echo "3. que es esto?"
echo "4. Salir"
echo -n "Seleccione una opcion [1 - 4]"
read opcion
case $opcion in
1) echo "este eres:";
whoami;;
2) echo "tienes esto";
df;;
3) uname -r;;
4) echo "chao";
exit 1;;
*) echo "$opc es una opcion invalida. Es tan dificil?";
echo "Presiona una tecla para continuar...";
read foo;;
esac
done

Ask for confirmation before running a script

Sometimes it is useful to have the user confirm the execution of a batch of statements, that is, the typical message that asks the user to type yes or no. We can do this like this:

#!/bin/bash
while true; do
echo
read -p "esta seguro de hacer lo que sea que vaya a hacer " yn
case $yn in
yes ) break;;
no ) exit;;
* ) echo "por favor responda yes o no";;
esac
done
echo "si se ejecuta esto es que aceptaste"

End of article. Simply great 😀

Editorial: You have to be careful with spaces and tabs, which for some reason are not coming out ¬¬