Widgets en Centreon

En estos momentos me encuentro implementando una version estable de Centreon 2.7.13 por lo que la finalidad de este post es únicamente presentar la funcionalidad widgets en centreon.

Nos van a servir para mostrar rápidamente el monitoreo de recursos que puedan ser mas críticos y de rápido acceso, los elementos a colocar en el widget son parametrizables, muchas veces con patrones de búsqueda, ordenamientos, clasificados por hostgroup, etc. Entre los widgets que se pueden agregar están los siguientes:

• Graph Monitoring: Mostrara las gráficas de algún recurso, nos da opción de parametrizar la frecuencia de actualización.
• Host Monitoring: Muestra el monitorio de un host o conjunto de hosts dentro del widget
• Hostgroup Monitoring: Muestra el monitoreo de un hostgroup definido previamente.
• Service Monitoring: Muestra el monitoreo de un grupo de servicios.

Por definición un widget debe incrustarse en una vista, podemos tener varias vistas (o tabs)  en cada una de estas vistas colocar uno o mas widgets. En la siguientes dos imágenes podemos ver dos vistas: "Servicios en linea" y "Servicios para atención".

En la primera vista de servicios para atención hemos colocado dos widgets, el primero del tipo Service Monitoring donde vemos los servicios con status de Critical y Warning únicamente. El segundo widget podemos ver uno del tipo Host Monitoring.

En la segunda vista de servicios en linea hemos colocado un par de widgets del tipo Graph Monitoring donde mostramos el monitoreo del web request de un servidor supuestamente critico.



¿Cómo agregamos un nuevo widget?

En el Menu "Home" -> "Custom View" podemos ver la barra de control para la manipulacion de widgets, la barra es muy intitiva y hemos leido desde el principio seguro tendremos muy buena idea de lo como hacer estas definiciones.



Lo primero es definir un la vista, en nuestro caso definiremos una vista llamada "Vista test", durante este proceso de definición podemos iniciarla con 1, 2 y 3 columnas para colocar widgets y darle orden a nuestros elementos. Ya una vez definida la vista nos colocamos sobre ella y ahora si, agregamos el widget.






Para incrustar un nuevo widget primero debemos indicar de que tipo sera, con las imágenes mostradas anteriormente podemos darnos una idea de los resultados que podemos tener. Una vez agregado el componente podemos parametrizarlo con la barra superior derecha del widget, la llave mecánica indica modificar.






Una observación importante es que estos widgets no vienen activos inicialmente por lo que hay que cargarlos al centreon en el menu "Administration" -> "Extensions" -> "Widgets". Los circulos rojos indican que el widget esta activo mientras que el engrane indica que no esta activo y si lo necesitamos debemos activarlo dandole clic.

Primer prototipo LoadBalancer con IPtables

El siguiente script en bash es el primer prototipo de LoadBalancer para un servicio TCP en dos o mas servidores simultaneamente utilizando iptables.

#!/bin/bash
local_ip="10.10.50.81"

ip1="10.10.96.50"
ip2="10.10.50.106"
tcp_port="80"


#Se valida que los servicios esten disponibles
nmap $ip1 -p $tcp_port | grep -i open >> /dev/null
service1=$?
nmap $ip2 -p $tcp_port | grep -i open >> /dev/null
service2=$?
let status=$service1+$service2
echo "Valor: $status"
let remakerules=10

while [ 0 -eq 0 ]; do

        if [ "$remakerules" != "$status" ]; then
                # You need these system settings.
                echo 1 > /proc/sys/net/ipv4/ip_forward
                for f in /proc/sys/net/ipv4/conf/*/rp_filter ; do echo 1 > $f ; done

                # Clear iptables/netfilter settings.
                iptables -F
                iptables -X
                iptables -t nat -F
                iptables -t nat -X
                iptables -t filter -F
                iptables -t filter -X
                iptables -t mangle -F
                iptables -t mangle -X


                iptables -P INPUT ACCEPT
                iptables -P OUTPUT ACCEPT
                iptables -P FORWARD ACCEPT
                iptables -t nat -P PREROUTING ACCEPT
                iptables -t nat -P POSTROUTING ACCEPT

                if [ "$service1" == "0" -a "$service2" == "0" ]; then
                        #Los dos servicios estan disponibles
                        iptables -t nat -A PREROUTING -p tcp -d $local_ip --dport $tcp_port -m state --state NEW -m statistic --mode random --probability .5 -j DNAT --to $ip1:$tcp_port
                        iptables -t nat -A PREROUTING -p tcp -d $local_ip --dport $tcp_port -m state --state NEW -m statistic --mode random --probability .5 -j DNAT --to $ip2:$tcp_port
                else
                        if [ "$service2" == "0" ]; then
                                #Unicamente el servicio2 esta arriba
                                iptables -t nat -A PREROUTING -p tcp -d $local_ip --dport $tcp_port -m state --state NEW -m statistic --mode nth --every 1 --packet 0 -j DNAT --to $ip2:$tcp_port
                        else
                                if [ "$service1" == "0" ]; then
                                        #Unicamente el servicio1 esta arriba
                                        iptables -t nat -A PREROUTING -p tcp -d $local_ip --dport $tcp_port -m state --state NEW -m statistic --mode nth --every 1 --packet 0 -j DNAT --to $ip1:$tcp_port
                                else
                                        echo "CRITICAL: Los dos Servicios estan abajo"
                                fi
                        fi
                fi


                iptables -A INPUT -j ACCEPT
                iptables -A OUTPUT -j ACCEPT
                iptables -A FORWARD -j ACCEPT
                iptables -A INPUT -j LOG --log-prefix "iptables: " --log-level 4
                iptables -A OUTPUT -j LOG --log-prefix "iptables: " --log-level 4
                iptables -A FORWARD -j LOG --log-prefix "iptables: " --log-level 4

                iptables -t nat -A POSTROUTING  -j MASQUERADE
                echo "Cambio de reglas..."
        fi

        #sleep 1200
        sleep 1

        #Se valida que los servicios esten disponibles
        nmap $ip1 -p $tcp_port | grep -i open >> /dev/null
        service1=$?
        nmap $ip2 -p $tcp_port | grep -i open >> /dev/null
        service2=$?
        let remakerules=$status
        let status=$service1+$service2
        echo "Valor: $status"

done

Enviar y recibir correo desde nuestro GNU Shell con fetchmail y ssmtp

En este ultimo par de días, me ha tocado realizar algunas pruebas de correo electrónico, por lo que creo que tengo un poco de información agrupada aquí que les puede servir para manejar básicamente un correo electrónico desde nuestro shell (en mi caso mis pruebas son con bash).

Para enviar correo electrónico usamos el protocolo smtp, por lo tanto requerimos un servidor que ofrezca este servicio. Por otro lado, en cuanto a la recepción de correo nos apoyamos de los servidores pop. Conocer un poco mas de estos detalles es importante a la hora de comenzar nuestro trabajo de configurar un cliente de correo cualquiera que este sea. En nuestra practica vamos a configurar una cuenta de Gmal. A continuación les dejo un muy breve listado con algunos servidores.

Propietario	Servidor	Protocolo	Cifrado	Puerto
Gmail	imap.googlemail.com	imap	ssl	993
Gmail	pop.googlemail.com	pop3	ssl	995
Gmail	smtp.googlemail.com	smtp	ssl	465
Yahoo	imap.mail.yahoo.com	imap	ssl	993
Yahoo	pop.mail.yahoo.com	pop3	ssl	995
Yahoo	smtp.mail.yahoo.com	smtp	ssl	465
Hotmail	pop3.live.com	pop3	ssl/tls	995
Hotmail	smtp.live.com	smtp	starttls	587

1. Enviar correo
En el envió de correo vamos ocupar instalar un agente de envió: ssmtp. Es un paquete muy básico y simple: ssmtp. Primero hacemos la instalación y luego modificamos su archivo de configuración.

user@localhost:~$ sudo apt-get install ssmtp
user@localhost:~$ sudo vim /etc/ssmtp/ssmtp.conf

En la configuración tenemos que especificar correo electrónico, contraseña para identificarnos, servidor smtp, tipo de cifrado, etc. A continuación les muestro parcialmente mi archivo ssmtp.conf.

root=martingmail@gmail.com
mailhub=smtp.gmail.com:587
AuthUser=martingmail
AuthPass=xxxxxxxxxx
UseSTARTTLS=YES
FromLineOverride=YES
rewriteDomain=
hostname=martingmail@gmail.com

Una vez configurado los datos de la cuenta, asociamos el correo con una cuenta local de nuestro sistema en el archivo /etc/ssmtp/revaliases, eso lo hacemos colocando la siguiente linea "martin:martingmail@gmail.com:smtp.gmail.com:587".

Si nuestra configuracion y atutentificacion es correcta ya podemos enviar correos con mail command.

#Envio de correo, con redaccion interactiva
mail -s "Mi primer correo" miamigo@sudominio.org
#Envio de correo con redaccion desde el mismo shell
echo "Hola" | mail -s "Mi primer correo" miamigo@sudominio.org
cat miarchivo.txt | mail -s "Mi primer correo" miamigo@sudominio.org
#Enviar correo con archivo adjunto
uuencode ~/mifoto.png mifoto.png | mail -s "Mi foto" milindaamiga@sudominio.org
#Enviar correo con archivo adjunto y texto
( cat declaraciondeamor.txt ; uuencode ~/mifoto.png mifoto.png ) | mail -s "Mi foto" milindaamiga@sudominio.org

Para el caso donde adjuntamos archivos el comando uuencode lo encontramos en el paquete sharutils, por lo que tendríamos que instalarlo también.

2. Recibir correo

Fetchmail es un programa que nos ayuda a traer los nuestros correos de un mail server remoto, por lo tanto es el que no va a traer los correos de nuestro buzón gmail. El siguiente paso es instalar fechtmail y configurar su archivo:

user@localhost:~$ sudo apt-get install fetchmail
user@localhost:~$ sudo vim ~/fetchmailrc

El siguiente es mi archivo de configuración parcial (¿Por que parciales?, por que no puedo mostrar mis datos personales)

#Cada 600 segundos actualizar
set daemon 600
set logfile fetchmail.log
poll pop.googlemail.com proto POP3
user "martingmail@gmail.com" pass "xxxxxxxxx" is "martin"
ssl
mda "/usr/bin/procmail -f %F -d %T"

Ya configurado esto, podemos leer los correos con el mail command, y hacer las operaciones básicas que este nos ofrece, principalmente la redacción y respuesta de correos. El uso de comandos internos del mail command, no lo voy a tratar aquí ya que es un tema muy extenso y no lo domino ampliamente, por lo que en ese aspecto les tocara investigar.

OTRS y Nagios/Centreon

Como les había comentado antes, había estado trabajando un poco en OTRS para el control de servicios dentro de una unidad organizacional. Por simple curiosidad se me ocurrió agregar dos características al monitoreo para que se generen gráficas estadistas del los servicios que se realizan.

¿Por que construir un propio plugin y no usar los mecanismos que otrs nos ofrece para integrarse con Nagios? Primeramente por cuestiones de facilidad de implementación, la documentación de estos mecanismos no son muy claros (al menos para mi), sobre todo por que otrs ha cambiado entre versiones. La otra razón es por que los mecanismos de otrs tienen la limitante de trabajar únicamente en un entorno donde conviven en un mismo servidor Otrs/Nagios.

El script es muy básico, para este post, soporta  únicamente el monitoreo de tickets abiertos y tickets creados por día:

#!/bin/bash

dbHostname="127.0.0.1"
dbUser="otrsguest"
dbPasswd="qwerty"
dbName="otrs"
dbWhere=""

WARNING=10
CRITICAL=15
TYPE=""

# Plugin return codes
STATE_OK=0
STATE_WARNING=1
STATE_CRITICAL=2
STATE_UNKNOWN=3

function report {
        val=`mysql -h $dbHostname -u $dbUser -p$dbPasswd --database=$dbName --execute="select count(*) as open from ticket $dbWhere" | awk 'BEGIN{FS="\n"; RS="\n\n";}{print $2}'`
        if [ "$val" -le "$WARNING"  ]; then
                echo "Tickets $TYPE: $val [ OK ] | value=$val"
                exit $STATE_OK
        else
                if [ "$val" -le "$CRITICAL" ]; then
                        echo "Tickets $TYPE: $val [ WARNING ] | value=$val"
                        exit $STATE_WARNING
                else
                        echo "Tickets $TYPE: $val [ CRITICAL ] | value=$val"
                        exit $STATE_CRITICAL
                fi
        fi
}

function phelp {
        echo -e "Usage: $0 -t  -w  -c  | -h"
        echo -e "  -t Tipo de tickets a consultar"
        echo -e "  -c Valor critico"
        echo -e "  -w Valor warning"
        echo -e "  -h Help, this message.\n"
}

while getopts t:w:c:h OPT
do
        case $OPT in
                t) TYPE="$OPTARG" ;;
                w) WARNING="$OPTARG" ;;
                c) CRITICAL="$OPTARG" ;;
                h)
                        phelp
                        exit $STATE_UNKNOWN
                ;;
        esac
done


if [ "$TYPE" = "abiertos" ]; then
        dbWhere="where ticket_state_id='4'"
        report
else
        if [ "$TYPE" = "creados" ]; then
                date=`date +"%Y-%m-%d"`
                dbWhere="where create_time like '$date%'"
                report
        else
                echo "Carecteristica a monitorear desconocida. Conocidas: abiertos, creados"
                exit $STATE_UNKNOWN
        fi
fi

La siguiente gráfica nos representa la actividad de tickets abiertos para los últimos dos días.

 La siguiente gráfica nos representa la actividad de tickets creados por día, en los últimos tres días.

Construcción de Plugin Nagios/Centreon para HP Printer

Hace unas horas termine un script en bash para monitorear los consumibles de unas impresoras HP, la idea de agregarlas a centreon es para darnos conocer en buen momento cuando uno de los consumibles se están por terminar así como un histórico (usando las graficas) de cuanto se esta consumiendo. A posteriori, este script se tendría que poder usar en cualquier impresora HP con SNMP activado, los modelos de impresoras que tenemos son las siguientes:

• HP LaserJet 4700 Color
• HP LaserJet 4600 Color
• HP LaserJet 4250

Requerimientos del script:

• awk
• snmpwalk
• A nivel de red, acceso al segmento de las impresoras.
• bash
• etc.

#!/bin/bash
# Martin Barriga 2012

# Default options
COMMUNITY="public"
HOSTNAME="127.0.0.1"
CONSUMMABLE="black"
WARNING=20
CRITICAL=10
SNMPVERSION=2c
SHEETCOUNT="0"
sheetcount=""

#used MIBs
MAINMIB="mib-2.43.11.1.1.6.1"
SHEETMIB="enterprises.11.2.3.9.4.2.1.4.1.10.5.1.1"

# Plugin return codes
STATE_OK=0
STATE_WARNING=1
STATE_CRITICAL=2
STATE_UNKNOWN=3

# Option processing
function phelp {
  echo -e "Usage: $0 -H  -C  -v  -o  -w  -c   [ -l | -s ] | -h "
  echo -e "  -H IP Addres HP Printer"
  echo -e "  -C SNMP Community. Default 'public'"
  echo -e "  -v SNMP Version. Default '2c'"
  echo -e "  -o Color Tonner: black, cyan, magenta, yellow, transfer, fuser. Default 'black'"
  echo -e "  -w Warning Value. Default '80'"
  echo -e "  -c Critical Value. Default '90'"
  echo -e "  -l List consumible support."
  echo -e "  -s Print with sheet count available."
  echo -e "  -h Help, this message.\n"
}

function list {
        allinfo=`snmpwalk -c $COMMUNITY -v $SNMPVERSION $HOSTNAME $MAINMIB`;
        echo "$allinfo" | ( while read line; do
                echo $line | cut -d "\"" -f2;
        done )
}

function withsheetcount {
        index=`echo "$1" | cut -d "." -f8`;
        count=`snmpwalk -c $COMMUNITY -v $SNMPVERSION $HOSTNAME $SHEETMIB.$index | cut -d " " -f4`;
        sheetcount=", Sheet Available: $count";
}

while getopts H:C:v:o:w:c:slh OPT
do
  case $OPT in
    H) HOSTNAME="$OPTARG" ;;
    C) COMMUNITY="$OPTARG" ;;
    v) SNMPVERSION="$OPTARG" ;;
    o) CONSUMMABLE="$OPTARG" ;;
    w) WARNING=$OPTARG ;;
    c) CRITICAL=$OPTARG ;;
    s) SHEETCOUNT="1" ;;
    l)
       list
       exit $STATE_UNKNOWN
    ;;
    h)
       phelp
       exit $STATE_UNKNOWN
    ;;
    #V)
    #  print_version
    #  exit $STATE_UNKNOWN
    #  ;;
   esac
done

info=`snmpwalk -c $COMMUNITY -v $SNMPVERSION $HOSTNAME $MAINMIB | grep -i $CONSUMMABLE`
if [ "$info" != "" ]; then
        name=`echo "$info" | cut -d "\"" -f 2`;
        mib=`echo "$info" | cut -d " " -f 1 | cut -d ":" -f 3`;
        newmib=`echo "$info" | cut -d " " -f 1 | cut -d ":" -f 3 | awk -F. -v OFS=. '{$6=8}1'`;
        size=`snmpwalk -c $COMMUNITY -v $SNMPVERSION $HOSTNAME $newmib | cut -d " " -f4`;
        newmib=`echo "$info" | cut -d " " -f 1 | cut -d ":" -f 3 | awk -F. -v OFS=. '{$6=9}1'`;
        value=`snmpwalk -c $COMMUNITY -v $SNMPVERSION $HOSTNAME $newmib | cut -d " " -f4`;
        let porcent=($value*100)/$size;

        #If sheet count is required
        if [ "$SHEETCOUNT" = "1" ]; then
                withsheetcount $mib
        fi

        if [ "$porcent" -le "$CRITICAL" ]; then
                echo "$name: Status: $value/$size $porcent% available [ CRITICAL ] | size=$size used=$value";
                exit $STATE_CRITICAL;
        else
                if [ "$porcent" -le "$WARNING" ]; then
                        echo "$name: Status: $value/$size $porcent% available [ WARNING ] | size=$size used=$value";
                        exit $STATE_WARNING;
                else
                        echo "$name: Status: $value/$size $porcent% available [ OK ] | size=$size used=$value";
                        exit $STATE_OK;
                fi
        fi
else
        echo "No se encuentra consumible $CONSUMMABLE en $HOSTNAME [ UNKNOW ]"
        exit $STATE_UNKNOWN
fi

[ Información relacionada ]

LPIC en México

Debo comentar que me encuentro en los pasos finales de alcanzar el nivel 1 de LPIC (Linux Professional Institute Certification). Para lograr la certificación LPIC-1, es necesrio la acreditacion de dos examenes 101 y 102.

Hace meses mis dudas eran ¿Cuanto cuesta? ¿Donde me certifico? ¿Cuanto se tardan los resultados en llegar?. Despues de enviar varios correos en algunas empresas de México e instituciones LPI fuera de México y basandonos en mi propia experiencia les dejo mis propias respuestas.

¿Cuanto cuesta?

El precio por cada examen es $160 dolares, en este momento es algo asi como $2,100 pesos. En algunas empresas de México me llegaron a cotizar en $3,500 + iva, no voy a decir nombres. El pago se realiza con tarjeta.

¿Donde me certifico?

Amablemente personas de LPI España recomendaron que todo aspirante debera registrarse en algunos de los dos centros de certificacion internacional VUE y Prometric, en ambos casos se requiere un registro previo en la pagina Oficial de LPI, para que se genere un LPI ID. En los centros de certificacion, el aspirante debera de buscar un lugar donde pueda aplicar el examen mas cercano a su region o donde el quiera.

¿Cuanto se tardan los resultados en llegar?

Las empresas de México me comentaron que los paquetes se tenia que enviar a Brasil y que los resultados eran de 2 a 3 meses. En la Universidad donde realize el examen, me lo aplicaron en linea, y los resultados fueron inmediatamente despues de mi ultimo clic en el boton de finalizar.

¿Recomendaciones?

Estudiar mucho.

Exportando M$ Active Directory a MySQL

El siguiente script me ayudo para exportar las cuentas de Active Directoy a una base de datos en MySql. El problema y/o interés surgió debido a la implementación de otrs, una solución para la gestión de servicios IT y help desk, donde se pretendía centralizar las cuentas locales de Active Directory como clientes en el contexto de la aplicación (otrs).

Para la solución de este problema (pensando en la automatización) había que hacer dos cosas, llenar la tabla de clientes con los datos de cada cuenta en la base de datos y cambiar el tipo de autentificación usando ldap.

Requisitos:

• awk
• openLdap
• mysql-client

Script: ldap2mysql.sh

#!/bin/bash
# Martin Edmundo 2012
# Orden del listado AD: sn, givename, userPrincipalName

#Inicialización de variables
dbUser="otrs";
dbPasswd="/Gvxsn1CFaj5Q";
dbName="otrs";
let _i=0;

searchBase="DC=PGJ,DC=MICH";
bindDistinguishedName="account@domain";
ldapPasswd="AcbjdaIQ6P/9g";
ldapHost="ldap://172.16.1.2";

apellido="";
nombre="";
user="";

#Leemos el arbol completo de usuarios
tree=`ldapsearch -x -z 0 -b $searchBase -D $bindDistinguishedName -w $ldapPasswd "(objectclass=user)" -H $ldapHost | egrep "userPrincipalName|givenName|sn\: "`

#Leemos el ultimo customer_id que se tiene en la BD, sobre ese se incrementaran los siguientes INSERT
let lastCustomer=`mysql -u $dbUser -p$dbPasswd --database=$dbName --execute="select max(customer_id) as a from customer_user" | awk 'BEGIN{FS="\n"; RS="\n\n";}{print $2}' `

echo "$tree" | (
     while read linea;
             do
             te_conozco=`echo $linea | cut -c1-2`
             if [ "$te_conozco" = "sn" ]; then
                     apellido=`echo $linea | cut -f2 -d" "`;
             fi
             if [ "$te_conozco" = "gi" ]; then
                     nombre=`echo $linea | cut -f2 -d" "`;
             fi
             if [ "$te_conozco" = "us" ]; then
                     user=`echo $linea | cut -f2 -d" "`;
                     if [ "$apellido" != "" -a "$nombre" != "" ]; then
                             let lastCustomer+=1;
                             uid=`echo $user | cut -f1 -d"@"`
                             daleDale=`mysql -u $dbUser -p$dbPasswd --database=$dbName --execute="select login from customer_user where login='$uid'" | awk 'BEGIN{FS="\n"; RS="\n\n";}{print $2}'`

                             #Si la cuenta no esta ya registra en DB, se hace el INSERT
                             if [ "$daleDale" == "" ]; then
                                     let _i+=1;
                                     sqlStm="INSERT INTO customer_user (login, email, customer_id, pw, title, first_name, last_name, valid_id, create_time, create_by, change_time, change_by)  VALUES ('$uid', 'informaticapgjmich@gmail.com',$lastCustomer, '', 'Importado por openLdap', '$nombre', '$apellido', 1, '2012-03-23 20:00:00', 1, '2012-03-23 20:00:00', 1)";
                                     #echo "$sqlStm"
                                     mysql -u $dbUser -p$dbPasswd --database=$dbName --execute="$sqlStm";
                                     echo "*** Importado ($_i): $uid"
                             fi

                     fi
                     apellido="";
                     nombre="";
             fi
     done
)

Construcción de Plugin Nagios/Centreon para inodos

En esta ocación quiero compartir con ustedes un plugin muy básico para revisar el estado de los inodos en un FileSystem remoto a nuestro servidor de monitorio Nagios vía SNMP.

Para conseguir que el agente SNMP, nos pueda regresar información de los i-nodos de su sistema se requiere autorización, eso lo hacemos con el atributo "disk" y como parámetro se me envía cada uno de los FileSystem que deseamos monitorear. Esto seria agregando por ejemplo unas lineas al archivo snmpd.conf como las que siguen:

disk /

disk /home

Ya con este cambio solo queda reiniciar el servicio. Se puede verificar con el comando snmpwalk o el plugin que tenemos, desde el servidor de monitoreo o NMS.

#!/bin/bash
#check_snmp_inodes.sh
# Argumentos:
# 1. Community
# 2. Version
# 3. IP Address
# 4. FS
# 5. warning
# 6. critical
if [ $# -eq  6 ]; then
       #Se localiza el indice del FS
       isExist=`snmpwalk  -c $1 -v $2 $3 dsktable | grep  -e  "$4$" | wc -l`
       if [ $isExist -eq 1 ]; then
               index=`snmpwalk  -c $1 -v $2 $3 dsktable | grep  -e  "$4$" | awk 'BEGIN{FS="."}{print $2}' | awk '{print $1}'`
               uso=`snmpwalk  -c $1 -v $2 $3 .1.3.6.1.4.1.2021.9.1.10.$index | awk '{print $4}'`
               valor=""
               #Menor que
               if [ $uso -lt $5 ]; then
                       echo "I-nodos OK $4 Esta usando $uso% de sus inodos | size=100 used=$uso"
                       exit 0
               else
                       if [ $uso -lt $6 ]; then
                               echo "I-nodos WARNING $4 Esta usando $uso% de sus inodos | size=100 used=$uso"
                               exit 1
                       else
                               echo "I-nodos CRITICAL $4 Esta usando $uso% de sus inodos | size=100 used=$uso"
                               exit 2
                       fi
               fi
               echo "I-nodos $valor: $4 Esta usando $uso% de sus inodos | size=100 used=$uso"
               exit 0
       else
               echo "No existe el FileSystem $4"
               exit 3
       fi

else
       echo "Error en el paso de parametros"
       exit 3
fi

Sintesis: Exploring Linux Command-Line Tools

Brevemente solo quiero presentar una sintesis del primer capitulo de la Guía LPI Exploring Linux Command-Line Tools. Son algunos comandos para manupulación de archivos de texto.

cat:
-E final de linea con $
-n numero de linea (incluso lineas vacias)
-b numero de linea

join: combina dos archivos por algun campo en común.
join listing1.1.txt listing1.2.txt (defecto campo 1)
join -1 3 -2 2 people.txt numbers.txt (archivo 1 campo 3)

paste: combina dos archivos (linea a linea).
paste listing1.1.txt listing1.2.txt

expand: cambia los tabs a espacios en blanco

od: nuestra un archivo en formato octal
od listing1.2.txt

sort: Ordena listados.
-i Ignora si son mayusculas o munisculas.
-r Orden invertido
-k ¿por cual campo hacemos el ordenamiento?
sort -k 3 listing1.1.txt

split: Divide un archivo en dos o mas archivos. Se le pasa el prefix.
-b Los divide por tamaño en bytes
-l Por lineas
split -l 2 listing1.1.txt numbers

tac: concantena archivos pero con lineas en orden invertidos. Aplicando tac a cada archivo y despues concantena.

tr: Remplaza caracteres los del SET1 con el equivalente del SET2
-t Trunca el SET1 al SET2
-d Elimina los caracteres del SET1
[:alnum:] (all numbers and letters)
[:upper:] (all uppercase letters)
[:lower:] (all lowercase letters)
[:digit:] (all digits).
tr BCJ bc < listing1.1.txt

unexpand: Convierte los multiples espacios a tabs.

uniq: Elimina elementos duplicados de una lista.

fmt: Formato para archivos con lineas muy largas o irregulares.

nl: Enumerar las lineas.

pr: Formato para imprimir

head: Muestra el encabezado de archivos
head -n 10 file.txt

tail: Muestra la cola de un archivo.
tail -n 10 file.txt
tail -f file.txt

cut: Extrae porciones de texto de la su STDIN y lo manda a su STDOUT, por columnas

cat file1.txt | cut -c 2-
ifconfig eth0 | grep HW | cut -d " " -f 11

wc: Contador de palabras.
-l Lineas.
-w Palabras.
-c Bytes.
-m Caracteres.
-L Longitud de la linea mas larga.

Limitando los recursos de Tomcat.

Hace unos meses trabajando con OpenLaszlo 4.9 y Tomcat 5.0 en mi vieja notebook Compaq v2617la de 512Mb Ram, dramáticamente me estaba quedando sin memoria muy seguido, esto debido a los procesos que podemos ver en la siguiente expresión:

Mysqld + browser (iceweasel) + Apache + Laszlo = Frustración, tristeza y desesperación.

El proceso Tomcat que inicialmente era propiedad del root, causaba que al terminarse la Ram, comenzara a tener una gran demanda en el uso del SWAP al extremo de provocarme síntomas parecidos a los provocados en DoS, por el uso intensivo del disco. Las medidas que aplicamos fueron:

• Aumentar la memoria Swap ( ver ).
• Cambiar a un browser mas ligero (google-chrome).
• Cambiar a un windowmanager mas ligero (Fluxbox).
• Cambiar a un reproductor mp3 mas ligero (mpg123).
• Limitar los umbrales de recursos disponibles de Tomcat ( ver ).
• Crear el usuario "tomcat", limitarlo en el uso de consumo de memoria, y entregarle permisos sobre el servicio Tomcat.

Los umbrales para la configuración de recursos de tomcat los ajuste en uno de los scripts de inicio del mismo tomcat $CATALINA_HOME/bin/catalina.sh.

Cambiando el parámetro export JAVA_OPTS="-Xms128m -Xmx512m $JAVA_OPTS" por export JAVA_OPTS="-Xms128m -Xmx256m $JAVA_OPTS".

Para limitar los recursos del sistema usados por el usuario tomcat, en su archivo ~.bashrc colocarle ulimit -m 200000, para que solo tome 200mb como memoria maxima.

Estos ajustes los realize como ambiente de pruebas, mismos que hasta ahora me han ayudado a trabajar mas feliz.

Agregando mas SWAP en Volumen Logico

En últimos días el trabajo en mi viejo equipo portátil se ha vuelto un poco pesado por lo escaso de mi memoria Ram, para mi desgracia DDR (costosa y un poco mas difícil de conseguir).

Como alternativa de prueba, se me ocurrió aumentar tamaño de mi memoria swap. Vamos a ver como esta la situacion actual:

Tenemos 512Mb en Ram y 256Mb en Swap (Aun sigo reprochándome por que deje tan poco). Afortunadamente como medida preventiva cuando me instale este sistema deje un Volumen Lógico con algunos sistemas de archivos y espacio libre en el volumen.

Algoritmo:

1. Por cuestiones de seguridad en la integridad de datos, se recomienda desmontar todos los sistemas de archivos usados para realizar cambios en el volumen. Así que la recomendación es reiniciar, login como root, detener todos los servicios, desmontar sistemas de archivos en el volumen. Para esto nos podemos apoyar del comando lsof buscando procesos haciendo uso de directorios.

2. Crear el espacio que necesitamos adentro del volumen. En mi caso definimos un espacio de 512Mb en el volumen volgrp01:

Poseidon:~# lvcreate -L 512M volgrp01

3. Verificar el tamaño creado y el dispositivo asignado, solo mostraremos un resumen de la salida:

Poseidon:~# lvdisplay

...

--- Logical volume ---

LV Name /dev/volgrp01/lvol0

VG Name volgrp01

LV Write Access read/write

LV Size 512.00 MB

4. Crear y activar la nueva swap:

Poseidon:~# mkswap /dev/volgrp01/lvol0

Poseidon:~# swapon /dev/volgrp01/lvol0

5. Verificar que las estadísticas de la memoria en el sistema y confirmamos que tenemos (512+512+256)Mb.

Liberación de recursos & | dispositivos ocupados en GNU/Linux

Tengo que reconocer que cuando comenze a dar mis primeros pasos en GNU/Linux y que tenia necesidad de liberar algun recurso me encontre con la siguiente leyenda:

En aquellos años penosamente tenia que reiniciar para liberar. Lo que en aquellos años no sabia es que con la ayuda del comando lsof, podemos apoyarnos para revisar archivos abiertos. Este comando nos muestra en columnas los siguientes campos relacionados a un proceso:

• Comando.
• Id del Proceso ( PID )
• Usuario.
• Nombre del nodo.
  

Aqui lo que nos puede resultar util es el nombre del nodo y el PID. Por ejemplo, supongamos que queremos liberar el lector optico para leer otro disco y a pesar de que cerramos nuestras aplicaciones no podemos desmontar. El cdrom estara asociado al nodo /dev/cdrom y montado en /media, nosotros podriamos hacer lo siguiente:

lsof | grep /media

El cual nos mostrara los procesos que estan haciendo uso de este recurso y asi podriamos matarlos con kill, para cada proceso y subproceso que se muestren. ¿y si son muchos? Podemos usar el nuevo juguete que me paso mi amigo Daniel Mtz.

for cadauno in ` lsof | grep /media | awk '{ print $1 }' `; kill $cadauno 2> /dev/null ; done

Con esto automatizamos para que cada proceso encontrado sea eliminado. Este comando y sus parámetros pueden hacer muchas cosas por nosotros, para concluir veamos algunos ejemplos:

#Archivos abiertos del PID 1
lsof -p 1

#Procesos que estan usado el puerto TCP 22 y UDP 53
lsof -i :22
lsof -i UDP:53

Installing glibc2.4, but faill :(

Hace unas semanas me vi en la necesidad de actualizar mi viejo flashplayer plugin de la version 8 a la 10, ya que no podia ver las video conferencias de mis amigos en servicios como ustream, videos en facebook, etc.

En principio ese era el problema, siguiendo el procedimiento coloque el libflashplayer.so en el directorio de plugins del browser, al tratar de cargar los videos podemos ver un mensaje de error, donde los requerimientos de libflashplayer son glibc2.4. En mi lap con Debian etch la es glibc2.3.6. Tambien estamos corriendo Linux 2.6.23.1.

De el problema de actualizar flashplayer, tendríamos que pasar entonces a actualizar glibc, que es una libreria base del sistema. A pesar de contar con glibc mas nuevos en la web del proyecto, se descargo la 2.4. No me pregunten por que..., solo lo hice así. A continuación escribo el procedimiento que seguí para conseguir mas problemas.

Descargar el archivo de glibc2.4 y desempaquetarlo dentro de
/usr/gnu/glibc-2.4

La recomendación de los desarrolladores es crear un directorio donde construiremos el paquete, de esta manera solo borramos el directorio de construcción y listo, podemos repetir los pasos.
/usr/gnu/glibc-build

Entrar en este segundo directorio y configurarlo, para eso corriendo el script, en esta parte cambiamos el prefix, ya que con el que tiene por defecto se presentaron problemas. Así que ejecutamos la siguiente linea:
../glibc-2.4/configure --prefix=/usr

Para la compilacion se requiere el awk de gnu, gawk, y sobre todo las herramientas de compilación como make y gcc. Para eso ejecutar:
../glibc-2.4/make && ../glibc-2.4/make check

Hasta aquí todo en orden la compilación, solo falta la instalación de esta nueva biblioteca, esa instalación es el "paso de la muerte", y debería hacerse en supervision de un adulto :)

Siguiendo las recomendaciones debemos iniciar en modo monouser, para evitar el rompimiento de algunas bibliotecas (LOL), y una vez ahí instalar con la siguiente linea:
env LANGUAGE=C LC_ALL=C make install

En ese momento el sistema se pone a instalar, pero en mi caso, después de un rato de felicidad viendo que todo iva en orden, se detiene en el siguiente mensaje

GLIBC_PRIVATE not defined
Kernel Panic - not syncing: Attempted to kill init!

WTF! seguramente no son buenas noticias por que después de eso, ningún comando funciona, reiniciar tampoco sirve de mucho, por que el Kernel panic persiste. Al momento de escribir este post lo hago desde mi debian, logre arreglarlo siguiendo el siguiente [ tip ], al parecer es un bug de glib. Por los problemas que tengo en mi sistema, flashplayer, espacio insuficiente, problemas de montaje con ntfs. Por estas razones y por que viene un ano nuevo, comenzaremos con un distro nuevo... Lenny :)

Enviando mensajes SMS desde la consola

Hace algunos días he tenido la necesidad de enviar mensajes SMS desde mi compu, esto para que sea ella misma la que de manera automatizada la que me mande el mensaje cuando yo ande en la calle paseando, trabajando o en algún antro pasando la noche, todo esto cuando mi computadora se entere de algún suceso emergente y anómalo que ha ocurrido, en mi caso eran notificaciones de Nagios.

Para esto ocupamos 3 cosas, eeemmmm mejor 4,
1. Un celular preferentemente listado [ aquí ]
2. Una compu, con soporte para USB, IRA, o algún medio de comunicación con el cel
3. Software Gnokii
4. Actitud positiva y ganas de aprender. :)

Gnokii es un sofware que nos sirve para tener una muy amplia comunicación con el celular: llamadas, agenda de contactos, mensajes, etc. Lo descargamos e instalamos, cuanta con interfaces de linea de comando y gráfico.

En mi caso, tengo un celular modelo Sony Ericsson K790 (el cual me patrocino mi papá), y lo conecte por medio del USB, y me dio como resultado los siguientes archivos:

/dev/ACM0
/dev/ACM1

Como podemos ver en este caso era necesario tener soporte para ACM en el kernel (mm ¿ya dije que instale en Debian etch con 2.6.23.1?? ). Leyendo un poco la documentación, me he creado un archivo en archivo de configuración local en mi home:

$HOME/.gnokiirc

El cual básicamente en sus lineas mas importantes me quedo así:
[ global ]
port=/dev/ACM0
mode=AT
connection=serial

Finalmente el envio de mensajes podemos hacerlo con una linea como la que sigue:

$echo Hola como estan, envio desde gnokii | gnokii --sendsms xxxxxxxxxx

donde:
xxxxxxxxxx, es el numero de teléfono

Una observación importante es notar que echo no tiene la doble comilla, me dio problemas.

Installing statusmap supply to Nagios

Commonly i don't write ideas than know as important less, but in this moment i wanna do because tomorrow may be i forget it (i don't know what append with my mind) and the way from resolve it. When i installed Nagios sources, guess that there was a mistake in this process, Nagios is run correctly but i don have cgi statusmap supply that built informative maps.

The statusmap cgi need gd library to built maps and graphics flows, this library is a little bit leave. Gd can to built jpeg, gif, png, xpm format. But i was not lucky because my system don't had jpeg supply, OMG!. The next step? install it please xD

i used the default configuration from jpeg lib, and after do 'make install', it installed over /usr/local/include, copying files as jpeglib.h, jconfig.h, jmorecfg.h and jerror.h. Once ready the library and provided her supply, we're ready to install. After from excute the configure script, a good report is the next:

Support for PNG library: yes
Support for JPEG library: yes
Support for Freetype 2.x library: yes
Support for Fontconfig library: yes
Support for Xpm library: no
Support for pthreads: yes

Now, i must continue with a tip that a lot of developers put in his documentacion "enjoy!!", only the xpm supply that i not use, was not installed :) then gd was installed and also jpeg supply. In fact the files was copying to /usr/local/include directory gd.h, gd_io.h and somebody else.

Then with Nagios, we must configure it, compile it and after the statusmap.cgi is ready :)