LINUX – Comando TR – Ejemplos para aprender el uso.

En el caso que tengamos un texto y queramos transformar la totalidad de a a A lo haremos del siguiente modo:

echo "Esto es una ejemplo de tr para el blog geekland" | tr 'a' 'A'

En el caso que queramos reemplazar todas las vocales de una frase de minúscula a mayúscula lo podemos hacer del siguiente modo:

echo "Esto es una ejemplo de tr para el blog geekland" | tr 'aeiou' 'AEIOU'

En el caso que queramos transformar la totalidad de letras mayúsculas a minúsculas lo podemos hacer del siguiente modo:

echo "Esto es una ejemplo de tr para el blog geekland" | tr 'a-z' 'A-Z' > geekland.txt

Si queremos también podemos añadir una línea nueva al fichero geekland.txt que sea igual que la primera pero en minúscula siguiendo el siguiente procedimiento:

cat geekland.txt | tr 'A-Z' 'a-z' >> geekland.txt 

Si ejecutamos el siguiente comando:

echo "Esto es un ejemplo de tr para el blog geekland" | tr 'a-z' 'AB'

Vemos que ha ocurrido lo siguiente:

La letra a se reemplaza por la A. La b por la B y a partir de aquí la cef… hasta llegar la z se reemplazarán por la B.

Si queremos evitar este comportamiento podemos usar la opción -t o truncate. Si ejecutamos el mismo comando añadiendo la opción -t:

echo "Esto es un ejemplo de tr para el blog geekland" | tr -t 'a-z' 'AB'

Vemos que ha ocurrido lo siguiente:

La letra a se reemplaza por la A. La b por la B y a partir de aquí no se reemplazará ninguna otra letra. El comportamiento ahora será de este modo gracias a la opción -t. Por lo tanto la opción -t hace que la longitud del primero de los argumentos introducidos en el comando tr sea igual que la del segundo argumento.

Nota: Con la opción -t el primero de los argumentos introducidos del comando tr tiene que tener una longitud igual o superior al segundo de los argumentos.

Si queremos borrar todas las vocales mayúsculas y minúsculas de una frase y que sean reemplazadas por un espacio en blanco lo haremos mediante la opción tr -d. Un ejemplo de lo que acabo de citar es el siguiente:

echo "Esto es un ejemplo de tr para el blog geekland" | tr -d 'aeiou' | tr -d 'AEIOU'

Si quisiéramos que las vocales borradas fueran reemplazadas por espacios en blanco deberíamos haber usado el siguiente comando:

echo "Esto es un ejemplo de tr para el blog geekland" | tr 'aeiou' ' '

Para borrar todo el contenido de una frase excepto las vocales aeiou, tendremos que usar la opción -c. La opción -c o complemento vendría a actuar como lo contrario a la orden que introducimos en el comando. Por lo tanto para borrar todas las letras que no sea vocales de una frase lo haremos del siguiente modo:

echo "Esto es un ejemplo de tr para el blog geekland" | tr -cd 'aeiou'

Para borra todos los caracteres que no son legibles, se utiliza el siguiente comando :

head /dev/urandom | tr -cd '[:print:]\n'

Nota: Mediante la opción -cd '[:print:]' estamos diciendo que se borre todo carácter que no se imprimible/legíble. Además la opción \n hará que al finalizar la tarea el cursos de la terminal quede ubicado en una nueva línea.

Para borra todo lo que no sea un digito o numero se realizara con el siguiente comando :

echo "Esto es un ejemplo de tr para el blog gee1kland 1234" | tr -cd '[:digit:]\n'

Si por lo contrario quieren borrar la totalidad de números que aparecen a la frase tan solo tendrían que eliminar la opción -c complemento y obtendrían el siguiente resultado:

echo "Esto es un ejemplo de tr para el blog gee1kland 1234" | tr -d '[:digit:]\n'

En ocasiones escribimos rápido y es posible que por error escribamos 2 caracteres repetidos de forma consecutiva. Un ejemplo de lo que acabo de citar es el siguiente:

Esto es un ejeeemplo de tr para el blog.

En el ejemplo vemos que a la palabra ejemplo le sobran dos e. Para eliminarlas lo podemos hacer con la opción -s Squeeze del siguiente modo:

echo "Esto es un ejeeemplo de tr para el blog geekland" | tr -s 'e'

Si tuviéramos una frase con exceso de espacios, como por ejemplo la siguiente:

El comando    tr  es       útil                   en determinados               casos

Y quisiéramos eliminar los espacios sobrantes lo haríamos del siguiente modo:

echo "El comando    tr  es       útil   en determinados casos" | tr -s [:space:]

Transformar los espacios en tabulaciones horizontales o verticales con TR

En el ejemplo que propondremos a continuación tenemos 3 palabras separadas por un espacio:

joan carles geekland

Si queremos transformar este espacio por un tabulación lo haremos usando la opción [:space:] y \t del siguiente modo:

echo "joan carles geekland" | tr [:space:] '\t'

La opción \t añade una tabulación horizontal. Si quisiéramos añadir una tabulación vertical lo haríamos con la opción \v del siguiente modo obteniendo un resultado parecido al siguiente:

echo "joan carles geekland" | tr [:space:] '\v'

Generar una nueva línea cada vez que encontremos un determinado carácter delimitador

Si tenemos una frase, que obviamente está compuesta por palabras separadas por espacio, podemos separar cada una de las palabras en una nueva línea usando la siguiente sintaxis:

echo "joan carles geekland" | tr [:space:] '\n'

Obviamente este artículo únicamente detalla algunas de las opciones del comando tr.

Publicado en Unix - Linux | Deja un comentario

Lenguaje programación AWK.

Articulo obtenido desde la siguiente página : «https://learnxinyminutes.com/docs/es-es/awk-es/».

Usando el buscador, puedes obtener más códigos útiles del lenguaje AWK..

AWK es una herramienta estándar en cada sistema UNIX compatible con POSIX. Es como un Perl restringido, perfecto para tareas de procesamiento de texto y otras necesidades de scripting. Tiene una sintaxis similar a C, pero sin puntos y comas, manejo manual de memoria y tipado estático. Puedes llamarlo desde un script de shell o usarlo como un lenguaje stand-alone para scripting.

¿Por qué elegir AWK sobre Perl? Principalmente, porque AWK es parte de UNIX. Siempre puedes contar con él, mientras que el futuro de Perl está en duda. AWK es más fácil de leer que Perl. Para scripts sencillos de procesamiento de texto, particularmente si es para leer archivos línea a línea y dividir por delimitadores, probablemente AWK es la herramienta correcta para el trabajo.

#!/usr/bin/awk -f
# Los comentarios tienen este aspecto.
# Los programas AWK son una colección de patrones y acciones. El patrón más
# importante es BEGIN. Las acciones van en bloques delimitados por llaves.
BEGIN {
    # BEGIN correrá al inicio del programa. Es donde pones todo el código
    # preliminar antes de procesar los archivos de texto. Si no tienes archivos
    # de texto, piensa en BEGIN como el punto de entrada principal del script.
    # Las variables son globales. Asígnalas o úsalas sin declararlas.
    count = 0
    # Los operadores son justo como en C (y amigos).
    a = count + 1
    b = count - 1
    c = count * 1
    d = count / 1
    e = count % 1 # módulo
    f = count ^ 1 # exponenciación
    a += 1
    b -= 1
    c *= 1
    d /= 1
    e %= 1
    f ^= 1
    # Incremento y decremento en uno
    a++
    b--
    # Como un operador prefijo, regresa el valor modificado
    ++a
    --b
    # Nota que no hay puntación para terminar las instrucciones
    # Instrucciones de control
    if (count == 0)
        print "Iniciando count en 0"
    else
        print "Eh?"
    # O puedes usar el operador ternario
    print (count == 0) ? "Iniciando count en 0" : "Eh?"

    # Bloques formados por múltiples líneas usan llaves
    while (a < 10) {
        print "La concatenación de strings se hace " " con series " 
	print " de" " strings separados por espacios"
        print a
        a++
    }
    for (i = 0; i < 10; i++)
        print "El viejo confiable ciclo for"
    # Los operaciones de comparación son estándar...
    a < b   # Menor que
    a <= b  # Menor o igual que
    a != b  # No igual
    a == b  # Igual
    a > b   # Mayor que
    a >= b  # Mayor o igual que
    # ...así como los operadores lógicos
    a && b  # AND
    a || b  # OR
    # Además están las expresiones regulares
    if ("foo" ~ "^fo+$")
        print "Fooey!"
    if ("boo" !~ "^fo+$")
        print "Boo!"
    # Arrays
    arr[0] = "foo"
    arr[1] = "bar"
    # Desafortunadamente no hay otra manera de inicializar un array.
    # Tienes que inicializar cada posición del array.
    # También hay arrays asociativos
    assoc["foo"] = "bar"
    assoc["bar"] = "baz"
    # Y arrays multidimensionales con limitaciones que no mencionaré aquí
    multidim[0,0] = "foo"
    multidim[0,1] = "bar"
    multidim[1,0] = "baz"
    multidim[1,1] = "boo"
    # Puedes probar pertenencia a un array
    if ("foo" in assoc)
        print "Fooey!"
    # También puedes usar el operador 'in' para iterar las claves de un array
    for (key in assoc)
        print assoc[key]
    # La terminal es un array especial llamado ARGV
    for (argnum in ARGV)
        print ARGV[argnum]
    # Puedes eliminar elementos de un array.
    # Esto es útil para prevenir que AWK suponga que algunos argumentos
    # son archivos por procesar.
    delete ARGV[1]
    # El número de argumentos de la terminal está en la variable ARGC
    print ARGC
    # AWK tiene tres categorías de funciones incluidas.
    # Demostraré esas funciones posteriormente.
    return_value = arithmetic_functions(a, b, c)
    string_functions()
    io_functions()
}
# Así se define una función
function arithmetic_functions(a, b, c,     localvar) {
    # Probablemente la parte más molesta de AWK es que no hay variables locales
    # Todo es global. No es problema en scripts pequeños, pero sí para
    # scripts más grandes.

    # Hay un work-around (mmm... hack). Los argumentos de las funciones son 
    # locales para la función, y AWK permite definir más argumentos de función
    # de los que necesita, por lo que define las variables locales en la 
    # declaración como en la función de arriba. Como convención, agrega
    # espacios en blanco para distinguir los parámetros de la función de las 
    # variables locales. En este ejemplo, a, b y c son parámetros y localvar es una 
    # variable local.
    # Ahora, a demostrar las funciones aritméticas
    # La mayoría de las implementaciones de AWK tienen funciones
    # trigonométricas estándar
    localvar = sin(a)
    localvar = cos(a)
    localvar = atan2(b, a) # arcotangente de b / a
    # Y cosas logarítmicas
    localvar = exp(a)
    localvar = log(a)
    # Raíz cuadrada
    localvar = sqrt(a)
    # Trucar un flotante a entero
    localvar = int(5.34) # localvar => 5
    # Números aleatorios
    srand() # La semilla es el argumento. Por defecto usa el tiempo del sistema
    localvar = rand() # Número aleatorio entre 0 y 1.
    # Y aquí se regresa el valor
    return localvar
}
function string_functions(    localvar, arr) {
    # AWK tiene algunas funciones para procesamiento de strings,
    # y muchas dependen fuertemente en expresiones regulares.
    # Buscar y remplazar, primer instancia (sub) o todas las instancias (gsub)
    # Ambas regresan el número de matches remplazados.
    localvar = "fooooobar"
    sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar"
    gsub("e", ".", localvar) # localvar => "m..t m. at th. bar"
    # Buscar una cadena que haga match con una expresión regular
    # index() hace lo mismo, pero no permite expresiones regulares
    match(localvar, "t") # => 4, dado que 't' es el cuarto caracter
    # Separar con base en un delimitador
    split("foo-bar-baz", arr, "-") # a => ["foo", "bar", "baz"]
    # Otras funciones útiles
    sprintf("%s %d %d %d", "Testing", 1, 2, 3) # => "Testing 1 2 3"
    substr("foobar", 2, 3) # => "oob"
    substr("foobar", 4) # => "bar"
    length("foo") # => 3
    tolower("FOO") # => "foo"
    toupper("foo") # => "FOO"
}
function io_functions(    localvar) {
    # Ya has visto print
    print "Hello world"
    # También hay printf
    printf("%s %d %d %d\n", "Testing", 1, 2, 3)
    # AWK no tiene handles de archivos en sí mismo. Automáticamente abrirá un 
    # handle de archivo cuando use algo que necesite uno. El string que usaste 
    # para esto puede ser tratada como un handle de archivo para propósitos de I/O.
    # Esto lo hace similar al scripting de shell:
    print "foobar" >"/tmp/foobar.txt"
    # Ahora el string "/tmp/foobar.txt" es un handle. Puedes cerrarlo:
    close("/tmp/foobar.txt")
    # Aquí está como correr algo en el shell
    system("echo foobar") # => muestra foobar
    # Lee una línea de la entrada estándar (stdin) y lo guarda en localvar
    getline localvar
    # Lee una línea desde un pipe
    "echo foobar" | getline localvar # localvar => "foobar"
    close("echo foobar")
    # Lee una línea desde un archivo y la guarda en localvar
    getline localvar <"/tmp/foobar.txt"
    close("/tmp/foobar.txt")
}
# Como dije al inicio, los programas en AWK son una colección de patrones y 
# acciones. Ya conociste el patrón BEGIN. otros patrones sólo se usan si estás
# procesando líneas desde archivos o stdin.
# Cuando pasas argumentos a AWK, son tratados como nombres de archivos a 
# procesar. Los va a procesar todos, en orden. Imagínalos como un ciclo for 
# implícito, iterando sobre las líneas de estos archivos. Estos patrones y
# acciones son como instrucciones switch dentro del ciclo.
/^fo+bar$/ {
    # Esta acción se ejecutará por cada línea que haga match con la expresión
    # regular /^fo+bar$/, y será saltada por cualquier línea que no haga match.
    # Vamos a sólo mostrar la línea:
    print
    # ¡Wow, sin argumento! Eso es porque print tiene uno por defecto: $0.
    # $0 es el nombre de la línea actual que se está procesando.
    # Se crea automáticamente para ti.
    # Probablemente puedas adivinar que hay otras variables $. Cada línea es 
    # separada implícitamente antes de que se llame cada acción, justo como lo
    # hace shell. Y, como shell, cada campo puede ser accesado con $.
    # Esto mostrará el segundo y cuarto campos de la línea
    print $2, $4
    # AWK automáticamente define muchas otras variables que te ayudan a
    # inspeccionar y procesar cada línea. La más importante es NF
    # Imprime el número de campos de esta línea
    print NF
    # Imprime el último campo de esta línea
    print $NF
}
# Cada patrón es realmente un prueba de verdadero/falso. La expresión regular
# en el último patrón también es una prueba verdadero/falso, pero parte de eso
# estaba oculto. Si no le das un string a la prueba, supondrá $0, la línea que
# se está procesando. La versión completa de esto es:
$0 ~ /^fo+bar$/ {
    print "Equivalente al último patrón"
}
a > 0 {
    # Esto se ejecutará una vez por línea, mientras a sea positivo
}
# Y ya te das una idea. Procesar archivos de texto, leyendo una línea a la vez,
# y haciendo algo con ella, particularmente separando en un deliminator, es tan
# común en UNIX que AWK es un lenguaje de scripting que hace todo eso por ti
# sin que tengas que pedirlo. Basta con escribir los patrones y acciones 
# basados en lo que esperas de la entrada y lo quieras quieras hacer con ella.

# Aquí está un ejemplo de un script simple, para lo que AWK es perfecto.
# El script lee un nombre de stdin y muestra el promedio de edad para todos los
# que tengan ese nombre. Digamos que como argumento pasamos el nombre de un
# archivo con este contenido:
#
# Bob Jones 32
# Jane Doe 22
# Steve Stevens 83
# Bob Smith 29
# Bob Barker 72
#
# Éste es el script:
BEGIN {
    # Primero, pedir al usuario el nombre
    print "¿Para qué nombre quieres el promedio de edad?"
    # Recuperar una línea de stdin, no de archivos en la línea de comandos
    getline name <"/dev/stdin"
}
# Ahora, hacer match con cada línea cuyo primer campo es el nombre dado
$1 == name {
    # Aquí dentro tenemos acceso a variables útiles precargadas:
    # $0 es toda la línea
    # $3 es el tercer campo, la edad, que es lo que nos interesa
    # NF es el número de campos, que debe ser 3
    # NR es el número de registros (líneas) vistos hasta ahora
    # FILENAME es el nombre del archivo que está siendo procesado
    # FS es el campo separador, " " en este caso
    # Y muchas más que puedes conocer ejecutando 'man awk' en la terminal.

    # Llevar el registro de la suma y cuantas líneas han hecho match.
    sum += $3
    nlines++
}
# Otro patrón especial es END. Va a ejecutarse después de procesar todos los 
# archivos de texto. A diferencia de BEGIN, sólo se ejecuta si le das dado una
# entrada a procesar. Se ejecutará después de que todos los archivos hayan sido
# leídos y procesados según las reglas y acciones que programaste. El propósito
# es usualmente para mostrar un reporte final, o hacer algo con el agregado de
# los datos que has acumulado durante la ejecución del script.
END {
    if (nlines)
        print "La edad promedio para " name " es " sum / nlines
}
Publicado en Unix - Linux | Deja un comentario

LINUX – Poniendo color a nuestros SCRIPTS.

También existe la posibilidad de darle un toque más visual a aquello que imprimimos por pantalla; eso se logra mediante la inclusión de Etiquetas de color y mediante el mostrado de la cadena mediante el comando echo -e «cadena». Una etiqueta de color siempre tiene que ser almacenada en una variable y tienen que tener la siguiente estructura:

variable='\e[${codigo_color}m'

Los colores que se quieren especificar poseen un código númerico en concreto; es decir no se puede especificar un color como Rojo, negro, etc… Se tratan de códigos algo complejos de memorizar, es por ello que os listo a continuación cada color con su correspondiente código:

Negro             --> 0;30 
Gris oscuro   --> 1;30
Gris claro      --> 0;37
Azul               --> 0;34 
Azul claro     --> 1;34
Verde            --> 0;32 
Verde claro  --> 1;32
Cyan             --> 0;36 
Cyan claro   --> 1;36
Rojo              --> 0;31 
Rojo claro     --> 1;31
Morado          --> 0;35 
Morado claro --> 1;35
Marrón           --> 0;33 
Amarillo          -->1;33 
Blanco            --> 1;37
No color         --> 0

Queremos mostrar esta cadena con diferentes colores; para ello crearemos cuatro variables llamadas ROJO, CYAN, VERDE y BLANCO y haremos que la palabra vamos se muestre en rojo, las palabras a probar se muestren en cyan, la palabra diferentes se muestre en verde y por último la palabra colores se muestre en blanco.El código para lograr dicho sería el siguiente:

#!/bin/bash
###COMENZAMOS CREANDO VARIABLES CON COLORES###
ROJO='\e[0;31m'
CYAN='\e[0;36m'
VERDE='\e[0;32m'
BLANCO='\e[1;37m'
#PASAMOS A MOSTRAR EL TEXTO CON COLORES. MUY IMPORTANTE HACER ECHO CON EL PARAMETRO -e
echo -e "${ROJO}Vamos ${CYAN}a probar ${VERDE}diferentes ${BLANCO}colores"
Publicado en Unix - Linux | Deja un comentario

BASH -Script verificar correcta ejecución.-

El siguiente script intenta crear un subdirectorio tmp/project en el directorio actual. En la condición de la sentencia if verificamos si el valor de la variable $? es diferente de 0. Si ese es el caso, imprimimos un mensaje de error y salimos del script con el código de salida 1. La rama else imprime un mensaje exitoso y se ejecuta solo si el valor de $? es 0

#!/bin/bash
  
mkdir tmp/project

if [[ $? -ne 0 ]] ; then
    echo "Unable to create directory tmp/project"
    exit 1
else
    echo "Directory tmp/project created successfully"
fi
Publicado en Unix - Linux | Deja un comentario

BASH – LINUX ver fecha de caducidad de un certificado SSL (Plugin NAGIOS para renovar certificado SSL).-

Para la correcta ejecución debe tener instalado OPENSSL . El SCRIPT solicita 4 argumentos para su ejecución :

1 = Nombre servidor 2=Puerto 3=Días WARNING 4=Días CRITICAL

#!/bin/bash
servidor=$1
puerto=$2
warning=$3
critical=$4
hasta=`echo | openssl s_client -connect $servidor.dominio.cl:$puerto 2>/dev/null | openssl x509 -noout -dates | cut -d "=" -f2 | awk 'NR==2{print $0}'`
vence=`date -d "$hasta" +%Y%m%d`
START=`date -d $(date +"%Y%m%d") +%s`
END=`date -d $vence +%s`
((dife=$END-$START))
((dias=$dife/(60*60*24)))
if [ "$dias" -le "$warning" ] && [ "$dias" -ge "$critical" ]; then
     echo "WARNING - Quedan $dias para VENCER"
     exit 1
elif [ "$dias" -le "$critical" ]; then
     echo "CRITICAL - Quedan $dias para VENCER"
     exit 2
else
     echo "OK - Quedan $dias para VENCER"
     exit 0
fi
echo "UNKNOWN - Error Interno"
     exir 

Para ejecutarlo se debe dar permisos de ejecución :

chmod u+x check_cert.sh

Para ejecutarlo :

./check_cert.sh volcan01 443 20 10

Se obtiene el siguiente resultado :

OK – Quedan 129 días para VENCER

Publicado en Unix - Linux | Deja un comentario

BASH – Plugin NAGIOS memoria servidores AIX.

El SCRIPT solicita el valor WARNING y CRITICO del uso de memoria. Pasando estos umbrales, reportara en la consola NAGIOS según corresponda :

#!/bin/bash
# PORCENTAJES EJEMPLO 95 WARNING Y 98 CRITICAL
warning=$1
critical=$2
if [ -z "$critical" ] || [ -z "$warning" ]; then
   echo "UNKNOWN"
   exit 3
fi
# MEMORIA TOTAL USADA
um=`svmon -G | head -2|tail -1| awk {'print $3'}`
um=`expr $um / 256`
# MEMORIA TOTAL
tm=`lsattr -El sys0 -a realmem | awk {'print $2'}`
tm=`expr $tm / 1024`
# MEMORIA LIBRE Y PORCENTAJE
fm=`expr $tm - $um`
pt=`echo "scale=2;  $fm/$tm" | bc`
ps=`echo "scale=2;  $pt * 100" | bc`
# PORCENTAJE DE MEMORIA USADA
pa=`echo "scale=2;  $um/$tm" | bc`
pr=`echo "scale=2;  $pa * 100" | bc`
porusado=$pr
if [ "$porusado" -gt "$warning" ] && [ "$porusado" -lt "$critical" ]; then
     echo "WARNING - USADO $porusado% ${um}MB FREE $ps% ${fm}MB"
     exit 1
elif [ "$porusado" -ge "$critical" ]; then
     echo "CRITICAL - USADO $porusado% ${um}MB FREE $ps% ${fm}MB"
     exit 2
else
     echo "OK - USADO $porusado% ${um}MB FREE $ps% ${fm}MB"
     exit 0
fi

Publicado en Unix - Linux | Deja un comentario

BASH – Uso del comando «seq».-

Corresponde a herramienta de la línea de comandos. Sencilla, pero que combinada con otros comandos, puede ser de gran ayuda. Básicamente se encarga de imprimir una secuencia de números. Los siguientes comandos se pueden probar para ver lo que realizan :

seq 10                                               
   # Muestra del 1 al 10
seq 7 15                                             
   # Muestra del 7 al 15
seq 1 2 15                                           
   # Muestra del 1 al 15 saltándose de a 2  (1 3 5 .. 15)
seq -s, 1 9                                           
   # Se puede añadir un separador (1,2,3,4,5,6,7,8,9)
seq -f "%03g" 6                               
  # Se puede especificar un formato (001 002 .. 006)
expr `seq -s " + " 111 200`            
   # Muestra la suma desde el número 111 al 200 (13995)
echo $(seq -f "file%02g" 1 10)       
   # Muestra en pantalla file01 file02 file03 .. file10
touch $(seq -f "file%02g" 1 10)     
   # Igual que el anterior, pero aquí creara 10 archivos
Publicado en Unix - Linux | Deja un comentario

BASH – Operaciones y comparación de números con decimales en Scripts BASH.

En BASH no es posible ( de manera nativa) realizar operaciones con números decimales.  Para superar esta limitación de BASH, se utiliza el comando “bc”, con el cual se pueden realizar operaciones con números decimales, también se puede indicar la cantidad de números decimales que entregara en el resultado. Algunos ejemplos de código :

#!/bin/bash
# Cantidad de números pasados como argumentos
CANT_ARGUMENTOS=$#
# Separador de argumentos
IFS='+'
# Reunimos todos los argumentos incluyendo el separador
SUMA=$(echo "$(( $* ))")
# Calculamos el promedio
PROMEDIO=$(echo "scale=2; $SUMA/$CANT_ARGUMENTOS" | bc)
#Mostramos el mensaje por pantalla
echo "El promedio de los números ingresados es $PROMEDIO"

Otros ejemplos de linea de comandos :
echo "scale=4; 20/3" | bc -l
6.6666

Acá ingresaremos 2 valores, los cuales pueden ser positivos, negativo o decimal. El programa los valida que realmente correspondan a un número. Posterior a esto despliega el número menor ingresado :

#!/bin/bash
val1=$1
val2=$2
re='^[+-]?[0-9]+([.][0-9]+)?$'
if ! [[ $val1 =~ $re ]] || ! [[ $val2 =~ $re ]] ; then
   echo "error: Solo se aceptan numeros"
   exit
fi
min=$(echo $val1 $val2 | awk '{if ($1 < $2) print $1; else print $2}')
echo ""
echo "Valor minimo ingresado = $min"
exit

Ahora mostraremos la comparación de números decimales, para realizar esto, lo haremos con ayuda del lenguaje AWK (script adaptado para NAGIOS) , chequeo de UPTIME, el SCRIPT solicita se ingrese el WARNING y CRITICO de proceso y lo compara con el primer valor (Carga del sistema al minuto) :

#!/bin/bash
warning=$1
critical=$2
VARIABLE=`uptime`
IFS=',' read -ra datos <<< "$VARIABLE"
a=`echo "${datos[3]}" | cut -d ":" -f2`; b="${datos[4]}"; c="${datos[5]}"
up=`echo $a$b$c`
re='^[+]?[0-9]+([.][0-9]+)?$'
if ! [[ $warning =~ $re ]] || ! [[ $critical =~ $re ]] ; then
   echo "UNKNOWN - Load Average $up"
   exit 3
fi
if (( $(echo $a $warning $critical | awk '{if ($1 >= $2 && $1 < $3) print 1;}') )); then
     echo -e "WARNING - Load Average $up"
     exit 1
elif (( $(echo $a $critical | awk '{if ($1 >= $2) print 1;}') )); then
     echo -e "CRITICAL - Load Average $up"
     exit 2
else
     echo "OK - Load Average $up"
     exit 0
fi
AL EJECUTAR EL SCRIPT, MOSTRARIA ALGO COMO :

bash check_uptime.sh 20 50

WARNING  - Load Average  35.20  45.30  48.30

Publicado en Unix - Linux | Deja un comentario

BASH – Validar ingreso de un número (positivo, negativo o decimal).-

El siguiente código sirve para validar que el ingreso solicitado, corresponda a un número. Este puede ser positivo, negativo o decimal. Ejemplos de ingreso : +24 +24.324 12 12.22 -23 -23.45 etc….

#!/bin/bash
variable=$1
re='^[+-]?[0-9]+([.][0-9]+)?$'
if ! [[ $variable =~ $re ]] ; then
   echo "error: No es un numero"
else
   echo " Numero OK  :  $variable"
fi
Publicado en Unix - Linux | Deja un comentario

SCRIPTS – Variables especiales de BASH.-

$1, $2, $3, ... parámetros de posición que hacen referencia al primer, segundo, tercer, etc. parámetro pasado al script.
$_, el último argumento pasado al último comando ejecutado (justo después de arrancar la shell, este valor guarda la ruta absoluta del comando que inicio la shell).
$#, número total de argumentos pasados al script actual.
$*, la lista completa de argumentos pasados al script. Esta valor es una cadena de texto.
$@, la lista completa de argumentos pasados al script. Esta valor es una lista.
$-, la lista de opciones de la shell actual.
$$, el PID de la shell actual.
$IFS, el separador utilizado para delimitar los campos.
$?, el código de salida del pipe más reciente (es decir, de la última vez que se encadenaron varios comandos mediante el carácter pipe que se escribe como |).
$!, el PID del último comando ejecutado en segundo plano.
$0, el nombre de la shell o del script de shell.
Publicado en Unix - Linux | Deja un comentario

LINUX – Copia de directorios.

La copia recursiva incluye a una carpeta y todas sus subcarpetas. Por lo tanto, la estructura del directorio se copia entera. Esto no funciona con la copia sencilla del comando CP: si intentas copiar una carpeta sin el parámetro correspondiente, te saldrá un mensaje de error. El parámetro que debes usar es el ‘-r’, también conocido como ‘–recursivo’ o ‘-R’.

En nuestro ejemplo, queremos crear regularmente una copia de seguridad de una carpeta, incluyendo su contenido y subcarpetas. Para que no haya que copiar siempre todo el contenido del directorio, puedes utilizar el parámetro “update”.

cp -r -u /home/usuario/original/ /home/usuario/backups/

Cuando ejecutes el comando por primera vez, se te creará el directorio “original” dentro de la carpeta de backups. Todos los archivos y subdirectorios se te copiarán dentro de él. Si se trata de grandes cantidades de datos, esto puede llevar algún tiempo. Si utilizas el parámetro ‘-u’, solo copiarás los elementos modificados posteriormente.

Publicado en Unix - Linux | Deja un comentario

LINUX – Funciones especiales del comando CP.-

El comando CP de Linux también puede realizar otras tareas. Para ello, al comando se le puede añadir un término que contenga un parámetro:

cp [Parámetro(s)] [Origen(es)] [Destino]

Puedes introducir los siguientes parámetros (flags) en el campo para que el trabajo de copia sea más complejo o más fácil.

ParámetrosDescripciónEjemplo
-aCopia el archivo con la misma configuración de permisos y metadatos que el original.cp -a texto.txt /home/usuario/carpeta_de_destino/
–archiveCopia el archivo con la misma configuración de permisos y metadatos que el original.cp –archive texto.txt /home/usuario/carpeta_de_destino/
-bCrea una copia en la memoria intermedia (también llamada buffer) si el archivo original y el destino tienen el mismo nombre, pero diferente contenido.cp -b texto.txt /home/usuario/carpeta_de_destino/
–backupCrea una copia en la memoria intermedia (también llamada buffer) si el archivo original y el destino tienen el mismo nombre, pero diferente contenido.cp –backup texto.txt /home/usuario/carpeta_de_destino/
–backup=numberedCrea un nuevo archivo numerado si el archivo original y el de destino tienen el mismo nombre de archivo, pero diferente contenido.cp –backup==numbered texto.txt /home/usuario/carpeta_de_destino/
–backup=existingCrea un nuevo archivo numerado si el archivo original y el de destino tienen el mismo nombre de archivo, pero diferente contenido – y ya existen copias de seguridad numeradas.cp –backup==existing texto.txt /home/usuario/carpeta_de_destino/
-dCopia los enlaces simbólicos.cp -d texto.txt /home/usuario/carpeta_de_destino/
-fObliga a sobrescribir al copiar.cp -f texto.txt /home/usuario/carpeta_de_destino/texto.txt
–forceObliga a sobrescribir al copiar.cp –force texto.txt /home/usuario/carpeta_de_destino/texto.txt
-iPide permiso antes de sobrescribir archivos con el mismo nombre.cp -i texto.txt /home/usuario/carpeta_de_destino/
–interactivePide permiso antes de sobrescribir archivos con el mismo nombre.cp –interactive texto.txt /home/usuario/carpeta_de_destino/
-lCrea un enlace duro en lugar de una copia.cp -l texto.txt /home/usuario/carpeta_de_destino/
–linkCrea un enlace duro en lugar de una copia.cp –link texto.txt /home/usuario/carpeta_de_destino/
-nLos archivos existentes nunca se sobrescribirán.cp -n texto.txt /home/usuario/carpeta_de_destino/
–no-cobblerLos archivos existentes nunca se sobrescribirán.cp –no-cobbler texto.txt /home/usuario/carpeta_de_destino/
-pLos atributos del archivo original se heredan al copiar.cp -p texto.txt texto1.txt
–preserveLos atributos del archivo original se heredan al copiar.cp –preserve texto.txt texto1.txt
–preserve=modeEl modo del archivo original se hereda al copiar.cp –preserve==mode texto.txt texto1.txt
–preserve=ownershipLas propiedades del archivo original se heredan al copiar.cp –preserve==ownership texto.txt texto1.txt
–preserve=timestampLa marca de tiempo del archivo original se hereda al copiar.cp –preserve==timestamp texto.txt texto1.txt
–preserve=linksLos enlaces del archivo original se heredan al copiar.cp –preserve==links texto.txt texto1.txt
–preserve=contextEl contexto de seguridad del archivo original se hereda al copiar.cp –preserve==context texto.txt texto1.txt
–preserve=xattrLos atributos extendidos del archivo original se heredan al copiar.cp –preserve==xattr texto.txt texto1.txt
–preserve=allTodos los atributos del archivo original se heredan al copiar.cp –preserve==all texto.txt texto1.txt
-PLos enlaces simbólicos se guardan como tales al copiar.cp -P texto.txt /home/usuario/carpeta_de_destino/
–no-dereferenceLos enlaces simbólicos se guardan como tales al copiar.cp –no-dereference texto.txt /home/usuario/capeta_de_destino/
-rLos directorios, incluidos los subdirectorios, se copian de forma recursiva.cp -r /home/usuario/carpeta_de_origen/ /home/usuario/carpeta_de_destino/
-RLos directorios, incluidos los subdirectorios, se copian de forma recursiva.cp -R /home/usuario/carpeta_de_origen/ /home/usuario/carpeta_de_destino/
–recursiveLos directorios, incluidos los subdirectorios, se copian de forma recursiva.cp –recursive /home/usuario/carpeta_de_origen/ /home/usuario/carpeta_de_destino/
-sCrea un enlace simbólico para el archivo original.cp -s texto.txt /home/usuario/carpeta_de_destino/
–symbolic-linkCrea un enlace simbólico para el archivo original.cp –symbolic-link texto.txt /home/usuario/carpeta_de_destino/
-SSobrescribe un sufijo de backup al copiar con –backup.cp –backup=simple -S texto.txt /home/usuario/carpeta_de_destino/
–suffix=own_suffixSobrescribe con su propio sufijo el sufijo de backup al copiar con –backup.cp –backup=simple –suffix=own_suffix texto.txt /home/usuario/carpeta_de_destino/
-uCopia el archivo solamente si el archivo de destino es más antiguo que el original.cp -u texto.txt /home/usuario/carpeta_de_destino/texto.txt
–updateCopia el archivo solamente si el archivo de destino es más antiguo que el original.cp –update texto.txt /home/usuario/carpeta_de_destino/texto.txt
-vEmite un mensaje al terminar la copia.cp -v texto.txt texto1.txt
–verboseEmite un mensaje al terminar la copia.cp –verbose texto.txt texto1.txt
Publicado en Unix - Linux | Deja un comentario

BASH – Script para listar Directorios y Subdirectorios.

Script que lista todos los directorios y subdirectorios recursivamente de uno dado. El
directorio será introducido como argumento y el guion lo primero que hará será verificar si es
precisamente un directorio.

#!/bin/bash
if [ ! $# -eq 1 ] # Comprobar número de parámetros introducidos
then
 echo “¡¡ Error !! Uso: “$0” nom_dir”
 break
fi
 if [ -d “$1” ]
 then
 ls –lR “$1” | grep ’^d’
 else
 echo “No existe el directorio $1”
 fi 

Publicado en Unix - Linux | Deja un comentario

BASH – Script de automatización respuestas con EXPECT.

#!/bin/bash
#preguntas.sh
read -p "Cual es tu nombre: " nombre
read -p "Dime tu edad : " edad
read -p "Tu direccion actual : " direccion
read -p "Tu pais de residencia : " pais
echo ""
echo "$nombre tiene $edad y vive en $direccion de $pais"
echo ""
#!/bin/bash
#respuestas.sh
/usr/local/bin/expect <<EOF
spawn /usr01/home/monsyg/preguntas.sh
expect {
        "nombre" { send "Gonzalo\r" ; exp_continue }
        "edad" { send "57\r" ; exp_continue }
        "direccion" { send "Hernan Mery 1200\r" ; exp_continue }
        "pais" { send "chile\r" }
}
expect eof
EOF

El primer SCRIPT (preguntas.sh), al ejecutarlo solicita se ingresen lo datos por teclado. El segundo SCRIPT (respuestas.sh). Al ejecutarlo, lanza el SCRIPT preguntas.sh y ingresa las respuesta en forma automática. Esto mediante EXPECT. Pude obtener más información en esta misma WEB. A continuación se muestran los resultados obtenidos al ejecutar cada uno de los SCRIPTS :

moon@operadores $ ./preguntas.sh
Cual es tu nombre: Gonzalo Reiser
Dime tu edad : 57
Tu direccion actual : Hernan Mery 1200
Tu pais de residencia : Chile

Gonzalo Reiser tiene 57 y vive en Hernan Mery 1200 de Chile

moon@operadores $ ./respuestas.sh
spawn /usr01/home/monsyg/preguntas.sh
Cual es tu nombre: Gonzalo Reiser
Dime tu edad : 57
Tu direccion actual : Hernan Mery 1200
Tu pais de residencia : chile

Gonzalo Reiser tiene 58 y vive en Hernan Mery 1200 de chile

Publicado en Unix - Linux | Deja un comentario

BASH – Script para controlar espacio en disco.

           Script bash para vigilar en nuestros servidores linux el tamaño de disco de los sistemas operativos, para que nos advierta antes de que se llene.
#!/bin/bash
used=`df -h | grep usr02 | awk {'print $5'}`
USADO=${used/\%/}
if [ $USADO -gt 75 ];
then
echo "WARNING! El disco se est\341 llenando. El espacio utilizado = $USADO %" | mail -s "DISK" direccioemal@dominio.email
fi

Publicado en Unix - Linux | Deja un comentario

BASH – Creación de un bucle infinito.

#!/bin/bash
n=1
while :
do
         printf "The current value of n=$nn"
         if [ $n == 3 ]
         then
                   echo "good"
         elif [ $n == 5 ]
         then
                  echo "bad"
         elif [ $n == 7 ]
         then
                  echo "ugly"
         elif [ $n == 10 ]
         then
                   exit 0
         fi
         ((n++))
done
Publicado en Unix - Linux | Deja un comentario

BASH – Manipulación de cadenas de texto.-

Extraer subcadena

            Mediante ${cadena:posicion:longitud} podemos extraer una subcadena de otra cadena. Si omitimos :longitud, entonces extraerá todos los caracteres hasta el final de cadena.

            Por ejemplo en la cadena string=abcABC123ABCabc:

•	echo ${string:0} : abcABC123ABCabc
•	echo ${string:0:1} : a (primer caracter)
•	echo ${string:7} : 23ABCabc
•	echo ${string:7:3} : 23A (3 caracteres desde posición 7)
•	echo ${string:7:-3} : 23ABCabc (desde posición 7 hasta el final)
•	echo ${string: -4} : Cabc (atención al espacio antes del menos)
•	echo ${string: -4:2} : Ca (atención al espacio antes del menos)

             Borrar subcadena

             Hay diferentes formas de borrar subcadenas de una cadena:

•	${cadena#subcadena} : borra la coincidencia más corta de subcadena desde el principio de cadena
•	${cadena##subcadena} : borra la coincidencia más larga de subcadena desde el principio de cadena
Por ejemplo, en la cadena string=abcABC123ABCabc:
•	echo ${string#a*C} : 123ABCabc
•	echo ${string##a*C} : abc

Reemplazar subcadena

                También existen diferentes formas de reemplazar subcadenas de una cadena:

•	${cadena/buscar/reemplazar} : Sustituye la primera coincidencia de buscar con reemplazar
•	${cadena//buscar/reemplazar} : Sustituye todas las coincidencias de buscar con reemplazar
Por ejemplo, en la cadena string=abcABC123ABCabc:
•	echo ${string/abc/xyz} : xyzABC123ABCabc.
•	echo ${string//abc/xyz} : xyzABC123ABCxyz.

Publicado en BATCH - DOS | Deja un comentario

BASH – Algunos códigos obtenidos desde la WEB.-

#!/bin/bash
read -p "Please input the operation (create or delete ): " OPERATION   
// Ingrese la acción que desea realizar
case $OPERATION in
    create)              // El primer caso: crear
    read -p "Please input the userfile : "   USERFILE     // Solicitar archivo de entrada
    [ -e $USERFILE ] || {                                  // Determinar si existe
        echo "$USERFILE is not exist "
        exit 1
        }
    read -p "Please input the passwdfile :  " PASSFILE
    [ -e $PASSFILE ] || {
        echo "$PASSFILE is not exist "
        exit 1
        }
    USERLINE=`awk 'BEGIN{N=0}{N++}END{print N}' $USERFILE`  // Calcular el número de líneas de archivo de archivo de usuario
    for LINE_NUM in `seq 1 $USERLINE`  // usa loop para construir
    do
        USERNAME=`sed -n "${LINE_NUM}p" $USERFILE` // Intercepta la primera línea del archivo de archivo de usuario
        PASSWORD=`sed -n "${LINE_NUM}p" $PASSFILE` // Intercepta la primera línea del archivo de passfile
        useradd $USERNAME                                // Crear usuario
        echo $PASSWORD | passwd --stdin $USERNAME
    done
    ;;
    delete)      // La segunda situación: eliminar
    read -p "Please input the userfile : "   USERFILE
    [ -e $USERFILE ] || {
        echo "$USERFILE is not exist "
        exit 1
        }
    USERLINE=`awk 'BEGIN{N=0}{N++}END{print N}' $USERFILE`
    for LINE_NUM in `seq 1 $USERLINE`
    do
                USERNAME=`sed -n "${LINE_NUM}p" $USERFILE`
                userdel -r $USERNAME
    done
    ;;
    *)                       // La tercera situación: las diversas situaciones restantes
    echo Eorror!
    ;;
Esac
#!/bin/bash
/usr/bin/expect << EOF     // Cambiar al entorno esperado
spawn ssh root@$1        // IP de conexión ssh
expect {
    "yes/no" { send "yes\r";exp_continue }   // Confirma la conexión
    "password" { send "$2\r" }              // Ingrese la contraseña
}
Interact               // reservado
EOF                   // salir

#!/bin/bash
Auto_Connect()
{
/usr/bin/expect << EOF
set timeout 5
spawn ssh root@172.25.254.$IP_NUM hostname
expect {
    "yes/no" { send "yes\r";exp_continue }
    "password:" { send "westos\r" }
}
expect eof
EOF
}
for IP_NUM in {71..72}
do
    ping -c1 -w1 172.25.254.$IP_NUM &> /dev/null && {
    Host_Name=`Auto_Connect | grep -E "authenticity|fingerprint|connecting|password|spawn|Warning" -v`   // Filtrar advertencias y otras declaraciones
    }
    echo "      $Host_Name 172.25.254.$IP_NUM"
done

#!/bin/bash
Auto_Connect()
{
/usr/bin/expect << EOF
set timeout 5
spawn ssh root@172.25.254.$IP_NUM hostname
expect {
    yes/no { send "yes\r";exp_continue }
    password { send "redhat\r" }
}
expect eof
EOF
}
for IP_NUM in {226..227}
do
    ping -c1 -w1 172.25.254.$IP_NUM &> /dev/null && {
        Host_Name=`Auto_Connect | grep -E "authenticity|fingerprint|connecting|password|spawn|Warning" -v`
    }
    echo  "$Host_Name 172.25.254.$IP_NUM " | sed 's/\r//g'     // Reemplazar / r del texto completo con vacío.
Done

#!/bin/bash
Auto_Discuz()
{
/usr/bin/expect << EOF
set timeout 30
spawn ssh root@$1
expect {
    "yes/no" { send "yes\r";exp_continue }
    "password:" { send "westos\r" }
}
expect "]#" { send "yum install httpd -y\r" }
expect "]#" { send "yum install mariadb-server -y\r"}
expect "]#" { send "yum install php-mysql.x86_64 -y\r"}
expect "]#" { send "systemctl start httpd\r" }
expect "]#" { send "systemctl start mariadb\r" }
expect eof
EOF
}
Auto_Connect()
{
/usr/bin/expect  << EOF
set timeout 30
spawn ssh root@$1
expect {
    "yes/no" { send "yes\r";exp_continue }
    "password:" { send "westos\r" }
}
expect "]#" { send "cd /var/www/html/\r" }
expect "]#" { send "unzip /var/www/html/Discuz_X3.2_SC_UTF8.zip >> /dev/null \r" }
expect "]#" { send "chmod 777 /var/www/html/upload/ -R\r" }
expect "]#" { send "systemctl restart httpd\r" }
expect eof
EOF
}
Auto_Httpd()
{
/usr/bin/expect << EOF
set timeout 30
spawn ssh root@$1
expect {
    "yes/no" { send "yes\r";exp_continue }
    "password:" { send "westos\r" }
}
expect "]#" { send "sed "/^Listen/cListen 8080" -i /etc/httpd/conf/httpd.conf\r" }
expect "]#" { send "yum restart httpd -y\r" }
expect eof
EOF
}
yum install expect -y
Auto_Discuz $1
scp /home/kiosk/Downloads/Discuz_X3.2_SC_UTF8.zip root@$1:/var/www/html
Auto_Connect $1
firefox -new-tab $1/upload/install
Auto_Httpd $1

Publicado en Unix - Linux | Deja un comentario

LINUX – BASH script comando UNTIL.-

#!/bin/sh

CONTADOR=0
until [ $CONTADOR – ge 3]; do
    echo El contador es $CONTADOR
    CONTADOR=$(($CONTADOR+1))
done

Publicado en Unix - Linux | 2 comentarios

LINUX – Comandos Lsattr y chattr: leer y establecer atributos especiales (Bit Inmutable o Bit Append Only).

Además de los permisos de lectura, escritura, y de ejecución asociados con el dueño, el grupo propietario y el resto de los usuarios del sistema, Linux nos permite establecer otros atributos en archivos y directorios. Por muchos motivos, podemos necesitar que ciertos archivos dentro de un sistema Linux tengan una protección total ante su borrado, incluso para usuarios administradores (root) quienes por equivocación o descuido, pudieran borrar ese fichero.

El comando lsattr nos permite leer los atributos especiales que pudiese tener activado un directorio o un archivo en particular :

lsattr prueba.log
---------------- prueba.log

Para bloquear el borrado o modificación de un fichero para cualquier usuario de un sistema, necesitamos configurar el bit «immutable», +i del comando chattr (Esta acción se debe realizar con cuenta root). Para quitar el atributo se realiza con el parámetro -i :

chattr +i prueba.log
lsattr prueba.log
----i----------- prueba.log

Para evitar borrar o modificar información de un archivo, se realiza configurando el bit «append only». Esto es muy útil para proteger los archivos de log. Para quitar el atributo se realiza con el parámetro -a :

chattr +a prueba.log
lsattr prueba.log
-----a---------- prueba.log
Publicado en Unix - Linux | 3 comentarios