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

Renombrar varios archivos a la vez, en lote, desde consola (linux).-

1) Añadir algo tras una parte del nombre del archivo que es común en todos los ficheros.
Ejemplo:
imagenXXXX.jpg por imagen_NEW_XXXX.jpg

# rename -v -n 's/imagen/imagen_NEW_/' *.jpg

2) Renombrar un grupo de imágenes con nombres diferentes. Si tenemos un grupo de imágenes (por ejemplo PNG) a las que les queremos añadir una información en la parte final del nombre de la imagen antes de la extensión.
Ejemplo:
nombreimagen.png por nombreimagen_150x150.png

# rename -v -n 's/\.png/\_150x150.png/' *.png

3) Vamos a suponer que queremos reemplazar los guiones bajos por guiones medios («_» por «-«) en los nombres de nuestros archivos de un directorio determinado.

# rename -v -n 's/_/-/' *.jpg

4) Añadir texto al inicio del nombre del fichero. Con el carácter ^ le indicamos al comando rename que se sitúe en el comienzo del nombre del fichero y ahí inserte o ejecute la segunda parte.
Ejemplo:
leccion 1.doc,
leccion 2.doc …
por
tema – leccion 1.doc,
tema – leccion 2.doc …

# rename -v -n 's/^/tema – /' *.doc

5) Si queremos eliminar varios caracteres antes de un punto de corte determinado.
Ejemplo:
texto1_abc_001_small.jpg,
texto2_abc_002_small.jpg,
texto3_abc_003_small.jpgpor
texto1_small.jpg,
texto2_small.jpg,
texto3_small.jpg
Utilizamos para el corte la cadena «_small» y le decimos que nos elimine los 8 caracteres (\w) anteriores, o los reemplace por lo que indiquemos en la segunda parte del comando rename.

# rename -v -n 's/\w{8}\_small/_small/' *.jpg

5b) Si queremos reemplazar desde un punto determinado de corte, pero respetando un número concreto de caracteres numéricos antes de la parte donde se produce el corte. Para este caso usamos el elemento «$1» en la cadena de la parte derecha, para que nos coja esa variable obtenida de la parte izquierda.  Viendo el ejemplo se entenderá mejor.
Ejemplo:
texto1_uno001_small.jpg,
texto2_otro002_small.jpg,
texto3_cualquiera003_small.jpg …por
texto1_uno_ADD-001_small.jpg,
texto2_otro_ADD-002_small.jpg,
texto3_cualquiera_ADD-003_small.jpg …

Utilizamos para el corte la cadena «_small» y le decimos que nos guarde los 3 caracteres numéricos (\d) anteriores (001, 002, 003…) utilizando el $1 en la segunda parte del comando (la expresión de la derecha) Nos añadirá o modificara lo indicado en la segunda parte del comando rename justo antes de esos 3 caracteres reservados antes del corte.

# rename -v -n 's/(\w{3})\_small/_ADD–$1_small/' *.jpg

6) Cambiar mayúsculas y minúsculas.
Ejemplo:
mi_fichero.txt por MI_FICHERO.TXT

# rename -v -n 'y/a-z/A-Z/' *.txt

7) Eliminar del nombre del fichero caracteres especiales que no están entre la letra a y la z (a-z) . Dejando en el nombre del fichero solo caracteres alfanuméricos.
Ejemplo:
mi-fichero.txt por mifichero.txt

# rename -v -n 'v/[^a-z]//' *.*

Para cambiar varios caracteres lo ejecutamos varias veces:
Ejemplo:
mi-fichero-con-varios-caracteres.txt por mificheroconvarioscaracteres.txt
Lo ejecutaremos 4 veces.

Publicado en Unix - Linux | Deja un comentario

BASH – Creador de directorios con bash scripting.-

Lo que queremos hacer es lo siguiente, primero comprobar si el directorio que nosotros indicamos ya existe, y si existe obviamente no lo vamos a crear, pero vamos a informar al usuario de que ya existe, con un texto personalizado. En caso contrario, si este directorio no existe, vamos a crearlo.

Como es una buena práctica controlar los procesos para saber si han funcionado bien o no, crearemos un mensaje personalizado para que el usuario tenga más información. Para ello evaluaremos si la ejecución anterior ha ido bien o mal, indicando al usuario con un texto personalizado si el directorio se ha creado con éxito o no.

#!/bin/bash

for dir in $@
do
  if [ -d $dir ]
  then
    echo “La capeta $dir ya existe.”
Else
    mkdir $dir
    if [ $? -eq 0 ]
    then
      echo “$dir se ha creaco con éxito”
    else
      echo “Ups! Algo ha fallado al crear $dir”
    fi
  fi
done

Publicado en Unix - Linux | Deja un comentario

LINUX – Comando cp de Linux. Un par de trucos útiles.-

El comando cp en GNU/Linux sirve para copiar un archivo o carpeta trabajando en la línea de comandos. Pero esconde muchas opciones.

cp -r -u -v Fotos_movil /run/media/Datos
o
cp -ruv Fotos_movil /run/media/Datos

A la opción ya conocida de -r (recursive) para que copie la carpeta Fotos_movil y todo el contenido de la misma, hemos añadido la opción -u (“update“) para que actualice el contenido en la carpeta destino y sólo copie aquellas fotos o datos que no estuvieran ya en el destino. Y con la opción -v (“verbose“) el comando muestra en pantalla las tareas que va realizando.

cp --force --backup=numbered texto.md texto.md

Imaginemos que estamos trabajando en un archivo llamado texto.md y lo estamos modificando, pero queremos tener una copia de seguridad o backup, de los distintos archivos antes de ir modificándolos, es aquí cuando el comando cp hace su magia.

En el comando lo que hacemos es copiar el mismo archivo encima de sí mismo. Esto con el comando cp no se puede hacer, pero en este caso especial queremos que sea así por tanto forzamos al comando que lo haga con la opción –force

La opción –backup=numbered le dice al comando que quiero hacer un backup del archivo indicado, y que las sucesivas copias de seguridad que haga quiero que estén numeradas consecutivamente. La primera será la 1, la segunda la 2, etc…

Ahora modificamos nuestro archivo texto.md una vez guardado volvemos a ejecutar el comando anterior para tener un nuevo archivo de respaldo. Si listamos los archivos que tenemos en nuestro equipo con el comando ls veremos que tenemos algo similar a esto:

texto.md texto.md.~1~ texto.md.~2~
Publicado en Unix - Linux | Deja un comentario

BASH _ Ejecutar comando remoto mediante SSH sin Password.-

Estamos acostumbrados a ejecutar comando en nuestra maquina local de manera sencilla. Esto también se hace sencillo utilizando la herramienta EXPECT, a continuación unos pequeños ejemplos de uso :

#!/bin/bash
HOST="aqui_pon_la_maquina_remota"
USER="aqui_pon_el_usuario_remoto"
PASS="aqui_pon_el_password_remoto"
CMD=$@
VAR=$(expect -c "
spawn ssh -o StrictHostKeyChecking=no $USER@$HOST $CMD
match_max 100000
expect \"*?assword:*\"
send -- \"$PASS\r\"
send -- \"\r\"
expect eof
")
echo "==============="
echo "$VAR"

Le damos permisos de jecución : chmod +x execute.sh y ya podremos utilizarlo : ./execute.sh “ls -l” Con esto te mostrara el listado del servidor en donde hayas lanzado el comando. Otros ejemplos para bajar o subir archivos a un servidor mediante el comando SCP :

#!/bin/bash
 
HOST="aqui_servidor"
USER="aqui_usuario"
PASS="aqui_password"
CMD=$@
 
VAR=$(expect -c "
spawn scp -r $USER@$HOST:$CMD . 
match_max 100000
expect \"*?assword:*\"
send -- \"$PASS\r\"
send -- \"\r\"
expect eof
")
echo "==============="
echo "$VAR"
#!/bin/bash
 
HOST="aqui_servidor"
USER="aqui_usuario"
PASS="aqui_password"
FICHEROS=$1
DIRECTORIO_REMOTO=$2
 
VAR=$(expect -c "
spawn scp -r $FICHEROS $USER@$HOST:$DIRECTORIO_REMOTO 
match_max 100000
expect \"*?assword:*\"
send -- \"$PASS\r\"
send -- \"\r\"
expect eof
")
echo "==============="
echo "$VAR"
Publicado en Unix - Linux | Deja un comentario