SCRIPTS – Construcción de comandos en tiempo de ejecución: eval (Referencia Indirecta).-

El comando eval construye un comando mediante la concatenación de sus argumentos (pueden ser variables, etc.) separados por espacios.

Dicho comando construido es leído por el shell e interpretado. La sintaxis del comando es:

eval[argumentos …]

Un posible uso es la creación de referencias indirectas a variables (parecido a usar punteros en lenguaje de programación C).

#ejemplo de referencia indirecta con eval
VAR="Texto"
REF=VAR 
#REF es una variable que valeVAR
eval OTRA='$'$REF 
#equivale a ejecutar OTRA=$VAR
echo $OTRA 
#se ha accedido al contenido de VAR a#traves de REF

Publicado en Unix - Linux | Deja un comentario

BASH – Verificar ingreso de un número valido.-

A continuación se valida mediante una función que el parámetro ingresado corresponde a un numero valido.

#!/usr/bin/bash
isint()
{
    re='^[-]?[0-9]+$'
    [[ $1 =~ $re ]]
}
if isint ${1} ; then
   echo " Es un numero valido"
   else
   echo " No ha ingresado un numero valido"
fi
Publicado en Unix - Linux | Deja un comentario

BASH – Leer linea a linea con comando READ.-

También podemos a partir de un archivo estructurado (como una libretas de direcciones o /etc/passwd por ejemplo) obtener los valores de cada campo y asignarlos a varias variables con el comando “read”. Sin embargo hay que tener cuidado de asignar a la variable “IFS” el separador de campo adecuado (espacio por defecto).

#! /bin/bash
while IFS=: read user pass uid gid full home shell
do
echo -e "$full :\n\
Pseudo : $user\n\
UID :\t $uid\n\
GID :\t $gid\n\
Home :\t $home\n\
Shell :\t $shell\n\n"
done < /etc/passwd
Publicado en Unix - Linux | Deja un comentario

BASH- Control de flujo CASE. Ejemplo.-

Controla el flujo de ejecución basándose en la “palabra” dada. La palabra se compara, en orden, con todos los patrones. Cuando la palabra coincida con un patrón, se ejecutan todas las órdenes que vayan a continuación, hasta encontrar ;; (doble punto y coma).

#!/bin/bash
#############################
# Ejemplo de uso de case-esac
#############################
dia=$(date | cut –c 1-3)
case $dia in
	lun)   echo Hoy es lunes ;;
	mar)   echo Hoy es martes ;;
	mié)   echo Hoy es miércoles ;;
	jue)   echo Hoy es jueves ;;
	vie)   echo Hoy es viernes ;;
	sáb)   echo Hoy es sábado ;;
	dom)   echo Hoy es domingo ;;
	*)     echo No se sabe qué es hoy ;;
esac

#!/bin/bash
read -p "Introduzca A, B o C: " letra
case "$letra" in
	a|A)
		echo Introdujo A
		;;
	b|B)
		echo Introdujo B
		;;
	c|C)
		echo Introdujo C
		;;
	*)     
		echo No introdujo A, B o C
		;;
esac
Publicado en Unix - Linux | Deja un comentario

BASH – Retornar valor de una función.-

La función Bash puede pasar valores numéricos y de cadena. En el
siguiente ejemplo se muestra cómo puede pasar un valor de cadena
desde la función.
#!/bin/bash
function greeting() {

str="Hello, $name"
echo $str

}

echo "Enter your name"
read name

val=$(greeting)
echo "Return value of the function is $val"
Publicado en Unix - Linux | Deja un comentario

BASH – LINUX – Como hacer bucles en shell script.-

Los Bucles, en programación, son uno de los pilares fundamentales en los cuales nos apoyamos a la hora de desarrollar cualquier tipo de aplicación, bien sea una web, una APP para Android o IOS, una aplicación de escritorio etc… 

BUCLE WHILE – En el siguiente ejemplo, podemos ver que, mientras la variable $contador sea menor o igual a 15, imprimiremos un mensaje por pantalla. Una vez que la variable tenga el valor 15, el bucle finalizará y el script imprimirá otro mensaje de finalización.

#!/bin/bash
# Bucle básico While
contador=1
while [ $contador -le 15 ]
do
     echo "Este es el mensaje número" $contador
     ((contador++))
done
echo "Bucle finalizado" 

BUCLE UNTIL – En el siguiente ejemplo, la variable $contador se inicializa con un valor de 1. Hasta que la variable $contador no sea superior a 10, la variable $contador se incrementará en +1 hasta que sea superior a 10. El código es el siguiente:

#!/bin/bash
# Bucle básico Until
contador=1
until [ $contador -gt 10 ]
do
     echo "El valor de la variable $contador es: " $contador
     ((contador++))
done
echo "Bucle finalizado. Enhorabuena!"

BUCLE FOR – n el siguiente ejemplo, vamos a crear una serie de elementos (marchas de coches) que asignaremos a la variable coche y que posteriormente iremos recorriendo uno a uno para mostrar el nombre de cada una de las marcas. Lo que hace el bucle básicamente es, para cada uno de los elementos, hacer N cosas:

#!/bin/bash
# Bucle básico For
coches='Ford Seat Mercedes Fiat Opel'
print "El listado de marcas de coches es:"
for coche in $coches
do
     echo $coche
done
echo "Bucle <for> finalizado!"

BREAK y CONTINUE EN BUCLES – Aunque no son realmente ningún tipo de bucle, break y continue se suelen utilizar dentro de los bucles vistos anteriormente para obligar al bucle a seguir o salirse de la ejecución. En el siguiente ejemplo, $a toma valores entre 0 y 10, pero si a=5, el bucle finalizará:

#!/bin/bash
a=0

while [ $a -lt 10 ]
do
     echo "Valor: $a"
     ((i++))
     if [[ "$a" == '5' ]]; then
          break
     fi
done

En el siguiente ejemplo, $a toma valores entre 0 y 10, y se mostrará un mensaje solo cuando a sea diferente de 7:

#!/bin/bash
a=0

while [ $a -lt 10 ]
do
    ((a++))
     if [[ "$a" == '7' ]]; then
          continue
     fi
     echo "Valor: $a"
done
echo 'Finalizado!'

Publicado en Unix - Linux | 1 comentario

BASH – Como generar un HERE DOCUMENT en BASH.-

Ahora veamos cómo nos facilita la vida el uso de Here Document, indicando un delimitador (en este caso le he dado el nombre EOF) para el código que queremos volcar en el fichero html_example.html

#!/bin/sh
 
fecha=`date +%F`
parrafo1="Este es el primer parrafo"
parrafo2="Este es el segundo parrafo"
parrafo3="Este es el tercer parrafo"
 
 
cat << EOF > /home/julio/html_example.html
<html>
        <head><title>HTML ejemplo</title></head>
        <body>
                <h1>Este es el header principal</h1>
                <h2>Aqui incluimos una variable, su contenido es $fecha</h2>
                <p>$parrafo1</p>
                <p>$parrafo2</p>
                <p>$parrafo3</p>
                <p>Ejemplo de tabla<p>
                <table style="width:100%">
                        <tr>
                                <td align="center">Primera columna</td>
                                <td align="center">Segunda Columna</td>
                                <td align="center">Tercera columna</td>
                        </tr>
                        <tr>
                                <td align="center">50</td>
                                <td align="center">60</td>
                                <td align="center">70</td>
                        </tr>
                </table>
        </body>
</html>
EOF
Publicado en Unix - Linux | 1 comentario

LINUX – Algunos códigos interesantes para nuestros SCRIPTS :

Esta corresponde a una consulta WEB, en donde la respuesta se almacena en la variable “check” para ser procesada posteriormente, en la respuesta se quitan los símbolos “{}” y los espacios que deja adelante y atrás de la variable (check).-

check=`curl -s curl http://jupiter.cl:8281/compras-rs/message/getStatus | tr '{}"' " " | sed 's/^[[:space:]]*//' | sed 's/[[:space:]]*$//'`

El siguiente codigo nos permite listar los archivos contenidos en la ruta “/usr19/servicios/” con grep –v se filtran los nombres de archivo que finalizan con números, signo “:” y “/”, también los que contienen en su nombre el patrón “respaldo”.

find /usr19/servicios/ -type f | grep -v *.sh | grep -v '[0-9,:,/]$' | grep -v respaldo

Elimina todos los espacios en blanco de una variable :

variable="Esto es una cadena de texto con espacios en blanco"
sinespacios=$(echo "$variable" | tr -d '[[:space:]]')
echo $sinespacios

Lista en forma recursiva los archivos, mostrando su ruta completa y filtrando los que en sus nombres finalicen con un número :

ls -R | sed "s;^;`pwd`\/;" | grep -v *.sh | grep -v '[0-9,:,/]$'

Si lo que quieres es eliminar el primer y el último carácter de una cadena, usa:

$ echo '*hola que tal;' | sed -e 's/^.//' -e 's/.$//'
hola que tal

Publicado en Unix - Linux | Deja un comentario

LINUX – Uso de operadores logicos AND (&&) – OR (||) y NOT (¡) en shell script.-

Estos códigos permiten la ejecución o no, de un comando en función del código de retorno desde otro comando. Podemos combinar varios códigos de terminación de comandos mediante los operadores lógicos and (representada con &&) or (representada con ||) y not (representada con !).

#!/bin/bash
direc=/tmp/existe
echo " Prueba de operadores Logicos"
echo -e "ingrese usuario  : \\c "
read username
echo -e "ingrese password : \\c "
read password
# Uso de operadores AND y OR
if [[ ( $username == "admin" &amp;&amp; $password == "secret" ) || ( $username == "system" &amp;&amp; $password == "paso" ) ]]; then
echo "valid user"
else
echo "invalid user"
fi
# Uso de operador NOT
if [[ ! -d $direc ]]; then
   echo "El directorio $direc, NO existe"
fi

Linea correcta de SCRIPT, por algún motivo no muestra en forma correcta los signos && :

if [[ ( $username == “admin” && $password == “secret” ) || ( $username == “system” && $password == “paso” ) ]]; then

AND (&&)

  • El comando comando2 se ejecuta únicamente si el comando comando1 devuelve el código verdadero.
  • Si los dos expresiones son verdaderas entonces los dos comandos devuelven verdadero.

OR (||)

  • El comando2 se ejecuta únicamente si el comando1 devuelve un código falso.
  • La expresión global es verdadera si al menos uno de los comandos devuelve verdadero.

NOT (!) En el ejemplo si el directorio /tmp/existe no existe, entonces se jecuta el comando echo.

Publicado en Unix - Linux | Deja un comentario

LINUX – Convertir segundos (timestamp) a formato tipo HH:MM:SS (horas:minutos:segundos).-

$ echo - | awk -v "S=73180" '{printf "%02d:%02d:%02d",S/(60*60),S%(60*60)/60,S%60}'

Al ejecutar el comando anterior, trasformaremos 73180 segundos, el resultado sera el siguiente :

20:19:40

Publicado en Unix - Linux | Deja un comentario

LINUX – Bash Script con código AWK embebido.-

#!/bin/bash
PASSWORD_FILE=/etc/passwd
n=1       #Numero de usuario
for name in $(awk 'BEGIN{FS=":"}{print $1}' < "$PASSWORD_FILE")
do
      echo "USER #$n = $name"
      let "n += 1"
done

Publicado en Unix - Linux | Deja un comentario

LINUX – Uso de IFS y comando READ en SCRIPTS BASH.-

El IFS (Input Field Separator) es una variable global cuyo valor es el carácter o caracteres que funcionan como delimitador para separar un valor de otro en la línea leída. Podemos imprimir el valor del IFS con el siguiente comando:

$ cat -et <<<"$IFS"
 ^I$
$

Como podemos ver, el IFS por defecto es cualquiera de:

  • un espacio en blanco
  • un tabulador
  • un salto de línea

Pero en ocasiones, podemos tener como valor de una variable una secuencia de valores unidos por otro tipo de separador (una coma, dos puntos, etc…)

Cambiando temporalmente el valor del IFS, podemos utilizar el comando «read» para descomponer este valor en los valores individuales de que consta.

Por ejemplo, supongamos que tenemos que procesar una línea en el formato del fichero /etc/passwd

linea="miusuario:x:1002:1002::/home/miusuario:/bin/sh"

Comenzamos por guardar el valor de la variable IFS, para poder recuperarlo más tarde, y asignar temporalmente el carácter «:» como separador

IFS_anterior="$IFS"
IFS=:

Con esto, podemos descomponer el valor de la línea en los campos de que consta, con el comando «read»:

read usuario clave uid gid info home shell <<< "$linea"

Y por último, volvemos a asignar a IFS el valor que tenía previamente:

IFS=»$IFS_anterior»
Publicado en Unix - Linux | 1 comentario

BASH – Dividir variable por delimitador especifico.-

#!/usr/bin/env bash
readonly connections="
                      192.168.1.4/24|tcp|22
                      192.168.1.4/24|tcp|53
                      192.168.1.4/24|tcp|80
                      192.168.1.4/24|tcp|139
                      192.168.1.4/24|tcp|443
                      192.168.1.4/24|tcp|445
                      192.168.1.4/24|tcp|631
                      192.168.1.4/24|tcp|5901
                      192.168.1.4/24|tcp|6566
"
function set_connections()
{
    local range proto port
    for fields in ${connections[@]}
    do
            IFS=$'|' read -r range proto port <<< "$fields"
            echo "$range - $proto - $port"
    done
}
set_connections

Al ejecutar este SCRIPT obtendremos el siguiente resultado. En esta ocasión se definió los valores dentro de una variable, también se puede definir un ARRAY o leer directamente de un archivo. Los usos quedan a la imaginación.-

192.168.1.4/24 - tcp - 22
192.168.1.4/24 - tcp - 53
192.168.1.4/24 - tcp - 80
192.168.1.4/24 - tcp - 139
192.168.1.4/24 - tcp - 443
192.168.1.4/24 - tcp - 445
192.168.1.4/24 - tcp - 631
192.168.1.4/24 - tcp - 5901
192.168.1.4/24 - tcp - 6566
Publicado en Unix - Linux | Deja un comentario

BASH – Script para encontrar ejecutables de la variable PATH.-

Para obtener todos los archivos ejecutables en tu sistema, puedes recorrer los directorios en la variable PATH.

#!/bin/bash
backIFS=$IFS
IFS=:
for dir in $PATH; do
        echo " DIRECTORIO : $dir"
        for myfile in $dir/*; do
                if [ -x $myfile ]; then
                        echo " $myfile"
                fi
        done
done
IFS=$backIFS
Publicado en Unix - Linux | Deja un comentario

BASH – Script para leer archivo linea por linea.-

Para leer un archivo en BASH linea por linea se podría implementar realizando :

#!/bin/bash
while read linea; do
	echo -e "Línea: $linea"
done < archivo

Fíjate que en la última línea, el fichero (hay que poner su path completo) se utiliza como entrada para el comando while. Pero con esta versión sencilla podemos encontrarnos con varios problemas. Una versión más segura es:

#!/bin/bash
while IFS='' read -r linea || [[ -n "$linea" ]]; do
	echo -e "Línea: $linea"
done < archivo

IFS es una variable interna de bash que establece el separador de palabras. Al dejarlo vacío evitamos que se eliminen los espacios que hubiera al principio de la línea. El parámetro -r en el comando read hace que no se interpreten los caracteres escapados (con \). Y la condición || [[ -n $line ]] evita que se produzca un error si la última línea no termina con \n. Como conviene no alterar IFS, podemos mejorar la solución con :

#!/bin/bash
backIFS=$IFS
while IFS='' read -r linea || [[ -n "$linea" ]]; do
	echo -e "Línea: $linea"
done < archivo
IFS=$backIFS
Publicado en Unix - Linux | Deja un comentario

Bash – Factorial de un número pasado por parámetro.-

#!/bin/bash
function factorial(){
fact=1;
cont=1;
while test $1 -ge $cont
do
fact=`expr $fact \* $cont`;
cont=`expr $cont + 1`;
done
echo "El factorial de $1 es $fact"; 
}
factorial $1; 
#Factorial
Publicado en Unix - Linux | Deja un comentario

Linux: Comprobar si un ARCHIVO tiene datos o esta vació.-

#!/bin/bash
ARCHIVO=$1
if [ -s "$ARCHIVO" ]
then
    echo "El archivo $ARCHIVO tiene datos."
else
    echo "El archivo $ARCHIVO esta vacio."
fi

Publicado en Unix - Linux | Deja un comentario

LINUX – Arrays en BASH.-

#!/bin/bash
<<INFO
Ejemplo de utilizacióe arrays en bash
${valores[*]}         # Muestra todos los valores de un array
${!valores[*]}        # Muestra todos los indices de un array
${#valores[*]}        # Devuelve el numero de valores en un array
${#valores[0]}        # Devuelve la longitud del indice 0
INFO
# definimos un array de valores
valores=("primero" "segundo" "tercero")
# añmos un nuevo valor en la posicion 3 del array
valores[3]="quarto"
# añmos un nuevo valor en la posicion 5 del array
valores[5]="quinto"
printf "\nCantidad de valores dentro del array\n"
printf "   %s\n" ${#valores[*]}
printf "\nMostramos un valor dado\n"
printf "   %s\n" ${valores[2]}
printf "\nMostramos la longitud del indice 2\n"
printf "   %s\n" ${#valores[2]}
# recorremos todos los valores del array
printf "\nmostramos todos los valores\n"
for item in ${valores[*]}
do
    printf "   %s\n" $item
done
# recorremos todos los indices del array
printf "\nMostramos todos los indices\n"
for index in ${!valores[*]}
do
    printf "   %d\n" $index
done
# mostramos los indices y sus valores
printf "\nMostramos todos los indices con sus valores\n"
for index in ${!valores[*]}
do
    printf "%4d: %s\n" $index ${valores[$index]}
done

Si ejecutamos el SCRIPT nos mostrara por pantalla el siguiente resultado :

Cantidad de valores dentro del array
5
Mostramos un valor dado
tercero
Mostramos la longitud del indice 2
7
mostramos todos los valores
primero
segundo
tercero
quarto
quinto
Mostramos todos los indices
0
1
2
3
5
Mostramos todos los indices con sus valores
0: primero
1: segundo
2: tercero
3: quarto
5: quinto

Publicado en Unix - Linux | Deja un comentario

LINUX . MATAR MUCHOS PROCESOS CON EL MISMO NOMBRE Y/Ó PATRÓN.-

En lugar de tener que hacer kill a cada PID de forma “manual”, con el siguiente script lo haremos en una línea y sin apenas trabajo.

for i in $(ps aux | grep "/tmp/prueba.sh"  | awk '{print $2}'); do kill -9 $i; done

De esta forma podremos matar uno, decenas ó miles de procesos que se hayan quedado colgados.

Publicado en Unix - Linux | 2 comentarios

LINUX – Como saber que procesos consumen mas CPU y MEMORIA.-

Para conocer los procesos que consumen más CPU y MEMORIA se utiliza el siguiente comando :

ps aux --width 30 --sort -rss | head

Con el parámetro “width” , indicamos el ancho de pantalla; con “sort” ordenamos el resultado, combinado con el parámetro “rss”, por uso de memoria. Por último, mediante una tubería o pipe, utilizamos el comando “head”, de esta manera se nos muestran las primeras 10 líneas.

Publicado en Unix - Linux | Deja un comentario