LuAuF » Bash

Ayuda memoria: loops infinitos en el shell

Luciano — Fri, 27 Jan 2012 01:44:47 +0000

Este blog, me ha sido en más de una ocasión, mi ayuda memoria ideal. En otras tantas ocasiones, un link al mismo me permitió “ayudar al prójimo”, más bien, ahorrarme tiempo de utilización de cuerdas vocales y ahorrar al otro el fastidio de escucharme.

Por tal motivo, y ante un requerimiento del primer tipo (como “ayuda memoria”) quiero publicar algo que frecuentemente utilizo (o que cuando no es tan frecuente mi fragil memoria olvida):

¿Cómo hacer un loop infinito en un intérprete de comandos (sh, ksh o similar)?

Pongamos unas comillas al “infinito”, todo concluye al fin, nada puede escapar a un Ctrl+C o a un break (produce un abandono inmediato) dentro del bucle.

while :; do
  # Todo lo que quieras repetir infinitas veces
  echo "Hola Mundo"
  sleep 2
done

No olvides el sleep, sino pasarán cosas muy rápido

Otras opciones son utilizar las palabras especiales true (indica que una condición en verdadera) y false (indica que una condición es falsa) de bash:

while true; do
  ...
  ...
done

until false; do
  ...
  ...

done

¿Como conocer mi IP privada y mi IP pública?

Luciano — Sun, 25 Apr 2010 02:07:31 +0000

¿Como conocer mi IP privada y mi IP pública?, esa es la cuestión.

Vamos a ver un pequeño script para lograr este propósito utilizando algunos comandos ya vistos y utilizados en la historia de este blog con varios distintos propósitos (ifconfig, grep, cut, awk, wget, sed)

Primero, para obtener mi IP local (privada) puedo hacerlo mediante ifconfig, ahora, con la ayuda de grep, awk y cut quitaré todo lo que sobra para obtener solo la IP.

ifconfig | grep 'inet:'| grep -v '127.0.0.1' | cut -d: -f2 | awk '{print $1}'

Segundo, con la ayuda de un sitio web y wget obtendré mi IP pública, IP otorgada por el servidor de Internet al conectarme, por lo general es dinámica (a menos que paguemos a nuestro ISP por una IP fija). Al resultado obtenido con la ayuda de sed le dejaré tan solo la IP.

wget -q -O - checkip.dyndns.org|sed -e 's/.*Current IP Address://' -e 's/<.*$//'

Finalmente, el script:

#!/bin/sh
echo "IP privada: "$(ifconfig | grep 'inet:'| grep -v '127.0.0.1' | cut -d: -f2 | awk '{print $1}')
echo "IP pública: "$(wget -q -O - checkip.dyndns.org|sed -e 's/.*Current IP Address://' -e 's/<.*$//')

Vía: Be Linux my Friend

Enviar tweets desde la terminal

Luciano — Mon, 19 Apr 2010 11:00:30 +0000

Casi dos meses después de la última publicación, es necesario dar "señales de vida" del blog, que nunca fue discontinuado... pero que se mantuvo en "pausa" por falta de "inspiración" Y para volver, que mejor que con un clásico: hacer "cosas" desde la terminal (hoy estoy muy "comillero")

A las publicaciones de tiempo atrás de Center IM, mp3blaster y Lynx hoy aprenderemos a enviar tweets desde la terminal utilizando cURL-

cURL es una herramienta, que muy probablemente tengas instalado en tu GNU/Linux o BSD, que nos permite enviar a una datos a una URL utilizando los protocolos HTTP, HTTPS, FTP, FTPS, etc.

Bien, enviar un tweet desde la terminal es realmente muy sencillo, basta copiar la siguiente línea:

curl -u usuario:password -d status="Mi primer tweet desde la terminal" http://twitter.com/statuses/update.xml

Donde:

Usuario: es tu nombre de usuario
Contraseña: es tu clave de acceso
status: es el texto del tweet
http://twitter.com/statuses/update.xml: es la URL de la API que ofrece Twitter para el envio y recepción de datos. Verás que los tweets escritos de esta forma dirán debajo "hace 'tanto tiempo' via API"

Algo que obviamente puede no gustarnos de esto es escribir, a la vista de todos, la contraseña por terminal y lo que puede ser peor, que quede en el histórico. Para lo segundo, podemos borrar el history (history -c)

That's all folks.

Vía: 120% Linux

Reemplazar cadenas en archivos con sed

Luciano — Mon, 01 Mar 2010 11:00:28 +0000

sed es un "editor de textos" para el filtrado y la transformación de textos. Escribo "editor de texto" entre comillas pues en realidad sed no trabaja con cadenas de caracteres sino con "flujos", la diferencia con los editores de textos clásicos (interactivos) es que sed acepta como entrada estándar un archivo o cualquier otro stream; resultado que es procesado y devuelto a la salida estándar (vea más acerca de stdin, stdout y stderr aquí)

Veamos un ejemplo muy sencillito:

$ cat saludo.txt
hola
maldito
mundo

$ sed '2d' saludo.txt
hola
mundo

No hace mucha explicación ¿no?, el comando d recibe el número de línea a eliminar. Esto es muy sencillo y es el ejemplo más básico del uso de sed; simplemente para que te vayas amigando.

Ahora veamos un ejemplo similar, pero reemplazando palabras:

$ sed 's/maldito/bendito/' saludo.txt
hola
bendito
mundo

Ahora usamos el comando s, éste recibe una cadena a buscar y una cadena por la que se reemplazarán las coincidencias en todos sus archivos.

Finalmente, para cerrar esta breve introducción a sed veamos un ejemplito propuesto en Feelinfo ¿Cómo reemplazar textos en varios archivos en Linux?:

Sabiendo que "sed -i '/s/palabra-vieja/palabra-nueva/g' *.txt" reemplaza todas las ocurrencias de la palabra vieja por palabra nueva en todos los archivos:

sed -i 's/Pepe/Jose/g' *.txt
sed -i 's/Manolo/Manuel/g' *.txt
sed -i 's/Nacho/Ignacio/g' *.txt
sed -i 's/Inma/Inmaculada/g' *.txt

Bien, esto es todo por ahora. Una observación para mi como para ustedes, no nos creamos que sed se limita a solo esto... manipulando flujos podemos dominar el mundo (¿no me crees? mira este rudimentario tetris escrito con sed, sedtris.sed)

Script para purgado de logs o archivos temporales

Luciano — Mon, 08 Feb 2010 11:00:45 +0000

Este es otro de mis pequeños scripts que suelo utilizar y/o adaptar para diferentes circunstancias. Un script sencillo, escrito para Korn Shell pero fácilmente portable a Bash u otro similar.

Para ser ciertos, más que scripting, este ejemplo es una clase de find, un comando tan potente que casi que nos permite "programar" con find

Antes de pasar a ver el código, comento un poco la necesidad que dió origen a este pequeño ejemplar para que tu puedas interpretarlo y, por que no, adaptarlo a tu necesidad.

La cuestión es así, mis aplicaciones y procesos sin logs no tienen razón de ser, todo se loguea, con fines de detectar anomalías, ver errores de software e incluso para hacer auditorias.

El uso excesivo de logs nos lleva a la necesidad de la existencia de una rotación o depuración de los mismos; para esa ocasión, tan solo con un find bien robusto podemos hacer esta purga.

Veamos el ejemplo y analicemos brevemente el código:

MantenimientoLogs.sh:

#!/bin/ksh

Log()
{
date "+%Y/%m/%d %H:%M:%S, $0, $1"
}

echo
Log "*** $0 Init ***"

cfgFile=$1

if test -z "$"; then
Log "No se especifico archivo de configuracion"
Log "Termina!"
exit 1
fi

if test ! -f "$cfgFile"; then
Log "No se encuentra el archivo de configuracion: [$cfgFile]"
Log "Termina!"
exit 3
fi

. $cfgFile # include

Log "Purgo logs ($datePurge dias)"
find $pathLogs $ -name "*.*~" -o -name "*.log" $ -ctime +$datePurge -exec "rm -v {}"

Log "Terminamos!"

MantenimientoLogs.cfg

# path del directorio de logs
pathLogs=/var/log/myapp/

typeset -i datePurge
# tiempo que mantengo los logs
datePurge=30*3 #tres meses

El primero de los archivos es el que hace el trabajo, el segundo es solamente de configuración. El primero recibe como argumento el segundo. El único motivo de este desacople es que cuando haya algo de configuración que modificar, se haga en el archivo cfg y no en el script de mantenimiento que es el que tiene la lógica.

En MantenimientoLogs.cfg solo configuro el directorio que quiero purgar, y la cantidad de días que pretendo mantener los logs.

MantenimientoLogs.sh tiene la "lógica", entre comillas ya que no hay mucho que decir de la misma sino más bien del find. En este script lo primero que vemos es una función Log, que hace de echo pero que agrega la fecha a cada línea. Luego se hace una especie de "include" del archivo de configuración (recibido como parámetro), previo chequeo de la existencia del argumento y la existencia del archivo. Y luego viene todo el trabajo, que lo hace el find.

El find en el caso del script busca todos los archivos .sql o .*~ cuya fecha de modificación sea más de N días (donde N es $datePurge y $datePurge lo habiamos configurado en el cfg). Y finalizando esta línea, a los resultados del find les ejecuta la acción "rm -v".

Este script es muy sencillo, no tiene nada de otro mundo, pero fue escrito para una situación muy particular que me surgió. Para mi, con una experiencia en escritura de shell scripts muy pobre, este es un buen inicio y cumplió mi cometido. Para quienes les resulte insuficiente sepan disculpar, algo es algo, al menos no es un Hola Mundo

Breve script para buscar en la Wikipedia desde la consola

Luciano — Thu, 22 Oct 2009 03:01:04 +0000

Esta publicación es pequeña pero muy efectiva, básicamente se trata de un script para buscar en la wikipedia desde la consola, valiéndose simplemente del comando dig.

A continuación el script y un ejemplo.

El script:

$ cat buscaWikipedia.sh
#!/bin/sh
dig +short txt ${1}.wp.dg.cx

Asignación de permiso de ejecución:

chmod +x buscaWikipedia.sh

Ejecución y salida:

./buscaWikipedia.sh spanglish
"Spanglish refers to the code-switching of \"English\" and \"Spanish\", in the speech of the Hispanic population of the United States, Gibraltar and most of the spanish holiday resorts, who are exposed to both Spanish and English. http://en.wikipedia.org/wiki/" "Spanglish"

Vía: Pain Dev

Trappear Ctrl+C en bash

Luciano — Wed, 24 Jun 2009 08:00:30 +0000

En alguna ocasión, puede resultar útil trappear señales en los shell scripts. Un ejemplo clásico de señal a trapear es el famoso Ctrl+C (^C).

Trappear una señal es fácil, simplemente debemos definir una acción (o función) que se ejecutará al momento de recibir la señal, y luego definir las señales a trappear con el comando trap.

Un ejemplo sencillo:

#!/bin/bash

function trapper {
echo "Signal trapped"
}

trap trapper EXIT

while true;
do
echo "I'm alive"
sleep 1
done

Realicemos un análisis rapido. El script imprime en la salida estándar un mensaje "I'm alive" cada segundo. La ejecución no termina a menos que enviemos una señal (while true;). Al presionar Ctrl+C estamos enviando la señal de EXIT, esta señal es interceptada y dirigida la ejecución a la función trapper, esto gracias a que antes con trap definimos la acción a tomar ante la señal.

Así como trapeamos la señal EXIT, podemos trapear varias señales, puedes consultar el comando kill para consultar las distintas señales que se pueden enviar sobre un proceso en ejecución.

El uso del trapeo de señales se utiliza en los scripts para no dejar el sistema de archivos en un estado inconsistente; cosas como archivos de bloqueo, archivos temporales o archivos que has actualizado y no puedes asegurar su integridad. Ante casos como éstos, es común encontrar scripts que ante señal de EXIT (como en el ejemplo) eliminan archivos temporales o de lockeo o crean una suerte de "rollback" de las acciones ejecutadas.

Si quieres escribir un script robusto, es muy probable que requieras de trapear, por lo tanto, agéndalo.

Declaración de variables en Bash

Luciano — Fri, 12 Jun 2009 09:00:38 +0000

No suele ser costumbre utilizar la instrucción declare en Bash, de echo, hasta algunos quizás no la conozcan. Lo cierto es que Bash, al no ser un lenguaje fuertemente tipado y no requerir la declaración explícita de variables, nos permite prescindir de su utilización.

No obstante esto, si declaramos las variables podemos lograr algunos beneficios para casos puntuales, hasta incluso evitar errores de ejecución.

A continuación veremos algunos ejemplos para saber de que estamos hablando con esto de declarar las variables en Bash.

En el primer ejemplo veremos como forzar a una variable para que sea de lectura, por lo tanto invariable:

declare -r variable

Así, un ejemplo como el siguiente:#!/bin/bash

v=6
declare -r v
echo $v
a=0
echo $v

Devolvería:

6
line 6: v: variable de solo lectura

Para tipar datos, por ejemplo, declarar una variable como numérica entera, utilizamos:
declare -i variable

Así:

#!/bin/bash

declare -i n
n=30
echo $a
a=veinte
echo $a

Devolvería:

30
0

La instrucción declare tiene un alcance mucho mayor, por ejemplo con el argumento -a se pueden declarar arrays, con -f se pueden crear funciones, con -x se pueden exportar variables de entorno, etc. Por lo pronto, el objetivo está cumplido: saber que existe.

Vía: Noticias Interesantes de Linux

Ejemplos de loops en Bash

Luciano — Thu, 25 Dec 2008 01:31:33 +0000

Muchas veces el poco conocimiento acerca de la programación de shell scripts y el propio intérprete de comandos hace que hagamos el doble de trabajo para trabajos simples que se pueden resolver con un sencillo script.

Por tal motivo y con ánimo a conocer un poco más acerca de algún shell de Unix, veremos algunos ejemplos cuidadosamente explicados de como hacer loops en Bash (el shell sucesor del Bourne y escrito para el proyecto GNU).

'for loop' es una declaración del leguaje de programación de scripts Bash que permite ejecutar un loop repetidamente. Por ejemplo, para ejecutar una tarea o comando cinco veces puedes hacer algo como lo siguiente:

#!/bin/bash
for i in 1 2 3 4 5
do
echo "Welcome $i times"
done

En este tipo de loop se ve que los valores que tomará la variable i están especificados luego del in. El loop ejecuta una secuencia de comandos de cada uno de los miembros de la lista de items. Los miembros de la lista no tienen por que ser siempre números, se puede escribir algo así:

#!/bin/bash
for i in "Juan" "Pepe" "Jose"
do
echo "Welcome $i times"
done

O así también, combinando distintos tipos de datos:

#!/bin/bash
for i in "Juan" 1 "Jose" 2 "Pepe"
do
echo "Welcome $i times"
done

Ahora, si queremos especificar un rango de valores, podemos requerir los servicios del comando seq y combinarlo con el for loop de la siguiente forma:

#!/bin/bash
for i in $(seq 1 2 20)
do
echo "Welcome $i times"
done

De esta forma, el for se hace en una lista de elementos que devuelve el seq. Pero no puedo dejar el tema aquí si no explico brevemente el uso de este comando. La función de seq es básicamente imprimir un listado de números. seq recibe uno, dos o tres parámetros e imprime el listado desde el primero al último según un incremento dado (o no)

seq LAST
seq FIRST LAST
seq FIRST INCREMENT LAST

Por ejemplo:

$ seq 2
1
2
$ seq 2 6
2
3
4
5
6
$ seq 0 2 10
0
2
4
6
8
10
$

Volviendo al tema que nos compete, "for loops", veremos la sintaxis de tres expresiones, sintaxis que viene heredada del queridisimo C. Donde las tres expresiones utilizadas por el for representan, un inicializador, una condición de loop y un contador.

#!/bin/bash
for ((i=0;i<3;i++));
do
echo "Welcome $i times"
done

En el anterior ejemplo, se inicializa la variable i en 0, la misma se va incrementando en uno en cada pasada y el loop se realizará siempre y cuando i sea menor que tres.

Con esta estructura de control también se puede realizar un loop infinito, por ejemplo:

#!/bin/bash
for ((;;)); do
echo "infinite loops [ hit CTRL+C to stop]"
done

Para quienes vienen de C, también será facil de explicar con el siguiente ejemplo, el funcionamiento del break para salir del loop o el continue para forzar una continuación del loop:

for I in 1 2 3 4 5
do
statements1
statements2

if (disaster-condition)
then
break #Abandon the loop.
fi

if (condition)
then
continue #Go to next iteration of I in the loop and skip
fi

statements3
done

Finalizando y para no aburrirlos más, antes de que te pongas a escribir tus primeros for en bash, veremos que el uso del for también puede ser aplicado sobre un listado de archivos de un directorio. El siguiente scritp recorre los archivo guardados en el directorio /etc hasta encontrar el archivo resolv.conf

#!/bin/bash
for file in /etc/*
do
if [ "${file}" == "/etc/resolv.conf" ]
then
countNameservers=$(grep -c nameserver /etc/resolv.conf)
echo "Total ${countNameservers} nameservers defined in ${file}"
break
fi
done

Vía: mixCraft