Scripts

Un script es por norma general un fichero que contiene una agrupacion de ejecuciones que se quieren ejecutar de manera secuencial o conjunta.

Interprete

No todos los sistemas operativos contienen los mismos interpretes de shell, asi habras visto que los mas extendidos son /bin/sh y /bin/bash

La primera linea de un documento script es obligatoriamente el interprete que se debe usar para la ejecucion, de manera que si intentamos ejecutar un script para /bin/bash en un sistema operativo que no soporte /bin/sh nuestro script dara un error de ejecucion

Aqui tenemos un ejemplo muy sencillo:

#!/bin/bash

VarLoQueSea="mi valor"
echo "$VarLoQueSea"

Pasando argumentos a nuestro Shell Script

Es muy util ejecutar scripts, pero si ademas podemos leer los parametros de entrada pues mucho mejor. Vamos a ver como leer los argumentos de entrada de un script

Permisos de ejecucion script (chmod)

Cuando creamos un archivo, por defecto este no es un archivo ejecutable y debemos dar permisos de ejecucion en ese archivo para poder usarlo, para ello usamo chmod

touch myscript.sh # creamos el archivo que contendra el script
sudo chmod +x ./myscript.sh  # Damos permisos de ejecucion (+x)

El array de Argumentos

En la ejecucion de un bash script, siempre tenemos contexto a la linea completa de ejecucion que se acaba de ejecutar.

Podemos acceder a cada termino de la ejecucion por su indice.

Imaginemos este script myscript.sh

#!/bin/bash

echo "estos son los terminos de este proceso de ejecucion"
echo "el primero es $1"
echo "el segundo es $2"
echo "el tercero es $3"

y lo ejecutamos pasandole argumentos y vemos el resultado:

$ ./myscript.sh hola como estas
el primero es hola
el segundo es como
el tercero es estas

Tambien tenemos una referencia a modo de array de todos estos parametros que es @

Cambiamos el script por :

#!/bin/bash

echo "estos son los terminos de este proceso de ejecucion"
echo "etodos los argumentos son[$@]"

# y podemos recorrerlos en modo normal
for var in "$@"
do
    echo "$var"
done

Trabajando con parametros clave=valor

Hay veces que un script de ejecucion sencilla que no necesita parametros de configuracion (por ejemplo un script que pasa un string a uppercase).

Pero hay veces que nuestro script necesita se parametrizado para hacer una cosa y otra internamente.

Para ello podemos pasar argumentos en formato clave=valor y cargarlos como variable de entorno en la ejecucion y asi poder trabajar con ellos.

Imaginemos esta ejecucion

$ transformText.sh  mode=ToUpperCase text=comoestas

# Resultado 
COMOESTAS

Nuestro script tiene parametros que determinan el modo de transformacion.

Para leer estos clave valor podemos hacer export de cada pareja de argumentos y luego usarlos en el script.

Nos quedara asi:

#!/bin/bash

# Recorremos los argumentos y los cargamos como variables globales en nuestro script
for var in "$@"
do
    export $var
done

echo "el modo de transformacion es [$mode]"
echo "el valor a transformar es [$text]"
result=""

if [ "$mode" == "ToUpperCase" ] ; 
then
    result=$(echo $text | tr 'a-z' 'A-Z')
else
    result="Not valid transformation mode value."
    exit -1;
fi

echo "El resultado es: $result"

exit 0;

y la ejecucion sera:

$ ./transformText.sh mode=ToUpperCase  text=hola
el modo de transformacion es [ToUpperCase]
el valor a transformar es [hola]
HOLA

Trabajando con parametros complejos

Hay veces que nuestra ejecucion requiere de muchos parametros de configuracion y es tedioso pasarlos todos por linea de comandos.

Una opcion alternativa es agrupar todos esos clave valor en un archivo .properties (formado por claves valor) y que nuestro script solo pida el parametro de donde esta el fichero de configuracion.

Los ficheros properties (clave=valor) se pueden cargar directamente como variables de entorno usando el comando source mifichero.properties

Construimos nuestro fichero de configuracion, execution.properties:

mode=ToUpperCase
reverse=false
argumentoC=loquesea

Y cambiamos nuestro script, leemos el parametro y cargamos en memoria la configuracion desde el archivo y ejecutamos como anteriormente.

#!/bin/bash

# Recorremos los argumentos y los cargamos como variables globales en nuestro script
for var in "$@"
do
    if [[ "$var" =~ configFile* ]]; then
        export $var
    fi

    if [[ "$var" =~ "text"  ]]; then
        export $var  # Tambien exportamos el valor de la cadena a transformar
    fi

done

# Comprobamos que se ha cargado bien desde el fichero de configuracion
if [ -z "$configFile" ]
then
      echo "No se ha especificado el parametro de configuracion"
      exit -1;
else
      source $configFile
      echo "Loaded property mode=$mode"
      echo "Loaded property reverse=$reverse"
      echo "Loaded property argumentoC=$argumentoC"
fi

# EJECUTAMOS
result=""
if [ "$mode" == "ToUpperCase" ] ; 
then
    result=$(echo $text | tr 'a-z' 'A-Z')
else
    result="Not valid transformation mode value."
    exit -1;
fi

echo "El resultado es: $result"

exit 0;

y la ejecucion

$ ./transformText.sh mode=ToUpperCase  text=hola configFile=./execution.properties
Loaded property mode=ToUpperCase
Loaded property reverse=false
Loaded property argumentoC=loquesea
El resultado es: HOLA

Hacer Prompt desde shell script

Para leer una interaccion de un script con un usuario usamos read:

#!/bin/bash

read -p "Please insert full path to values-api file: " definitionFile

echo "definitio file is $definitionFile"

Conclusion

Hemos visto de manera sencilla como pasar parametros a la ejecucion de un script , leerlo para poder hacer sus tareas con los argumentos de entrada. Hemos visto que si tiene una configuracion compleja podemos usar un fichero properties y un source.