tail -f | sysadmin

Cmd: Creando una consola interactiva con Python

elbarto — Sat, 24 Jul 2010 20:42:50 +0000

Python

Siguiendo con los ejemplos de los grandes recursos que ofrece la standard library de Python, así como el otro día hablé sobre BaseHTTPServer, hoy voy a hablar de Cmd.

Cmd es un módulo que nos permite crear una consola interactiva, como la propia consola de Python, en unas pocas líneas. La consola incluye manejo de distintos prompts, hooks para la ejecución de comandos, manejo de historial, ayuda general y por comando, y autocompletado de comandos y parámetros, etc. Lo único que tenemos que hacer para implementarla es extender la clase cmd.Cmd e implementar métodos do_* para los distintos comandos que queramos definir.

Veamos las opciones disponibles con un ejemplo muy sencillo:

# -*- coding: utf-8 -*-
import cmd

class Console(cmd.Cmd):

prompt = "> "

_colors = {‘red’: ‘#FF0000′,
‘white’: ‘#FFFFFF’,
‘black’: ‘#000000′}

def __init__ (self):
"""Constructor"""
cmd.Cmd.__init__(self)

def do_hello (self, name):
"""Says hello to someone"""
print "Hello %s!" % name

def do_get_color (self, color):
"""Prints out the hex representation of a color"""
if color in self._colors:
print "%s: %s" % (color, self._colors[color])
else:
print "I don’t know: %s" % color

def complete_get_color (self, text, line, begidx, endix):
"""Complete function for get_color"""
return [i for i in self._colors if i.startswith(text)]

def do_quit (self, s):
print "Bye, bye…"
return True

def help_quit (self):
print "Quits the console"

do_EOF = do_quit
help_EOF = help_quit

if __name__ == "__main__":
console = Console()
try:
console.cmdloop("Hola!")
except KeyboardInterrupt:
console.do_quit(None)

Inicialización

Lo primero que hacemos es definir la clase Console que extiende cmd.Cmd. Luego definimos la propiedad pública “prompt”, que será el prompt de la consola (por default “(Cmd)”).

Un método básico

Luego tenemos el método do_hello que toma un argumento y le dice hola al argumento. Notesé que el texto que definimos en el comentario (“Says hello to someone”), además de ser la documentación de la función es tomada por Cmd para mostrarlo como ayuda del comando. Si en la consola ponemos “? hello” o “help hello”, se imprimirá esa cadena.

Autocompletado

A continuación tenemos el método do_get_colors que imprime el código hexadecimal de un color, según el diccionario _colors. Además de tener su texto de ayuda, a continuación tenemos el método complete_get_colors que lo que hace es manejar el autocompletado de los parámetros. Aquí lo que hacemos es ver el texto que se tipeó y devolver todas las claves del diccionario _colors que empiecen con ese texto.

Salir de la consola

Para salir del loop de la consola un método tiene que devolver True. Para ello definimos el método do_quit. Aquí imprimimos un saludo y salimos. Las novedades son, por un lado, la función help_quit que cumple la misma función que el docstring: imprime la ayuda del comando quit. Y además duplicamos la función do_quit como do_EOF (y help_quit como help_EOF). De esta forma, cuando la consola reciba EOF (es decir, Ctrl+D) ejecutará do_quit y saldrá.

Ejecutando la consola

Por último, al final del código instanciamos la clase Console y ejecutamos el método cmdloop() que inicia el loop de la consola. De paso agregamos el handling de la excepción KeyboardInterrupt (es decir, Ctrl+C) para que ejecute do_quit y cierre la consola adecuadamente.

Otro ejemplo

Así como hice la última vez, les dejo otro ejemplo más completo en el que anduve trabajando. En este caso es parte del código de mi modesto proyecto python-directadmin. Se trata de DAConsole, una pequeña consola interactiva para interactuar con Directadmin, donde implemento todas estas cosas vistas aquí, además de la posibilidad de crear consolas anidadas.

Ver código de DAConsole.

Referencias

Módulo Cmd en la documentación de Python
Módulo Cmd en la wiki de Python (con explicaciones y ejemplos más completos)
DAConsole

Probando nuevo diseño: zBench

elbarto — Sun, 18 Jul 2010 18:23:52 +0000

Me dieron ganas de probar un nuevo diseño para el blog, un poco más legible. Después de bastante tiempo usando themes negros, esta vez elegí uno más claro, con un mejor contraste que facilite la lectura.

Encontré zBench que me pareció que cumplía con los requisitos que buscaba. Además es un theme muy completo, que implementa la mayor parte de las funcionalidades de WordPress, define estilos para

 y  que acá uso bastante y me parece lindo.
Así que me tomé algunos minutos para traducirlo (algo que no había hecho con themes anteriores) y lo dejé andando. De paso también vi que el código es bastante prolijo, lo cual es otro punto a favor.
¿Qué les parece?

Pegá el folleto de las Charlas de Python en tu lugar de trabajo!

elbarto — Fri, 16 Jul 2010 17:39:29 +0000

Como les contaba hace unos días, el 24 de julio empieza el Ciclo de Charlas Abiertas de Python Argentina en la sede del Colectivo La Tribu, Lambaré 873.

Charlas Abiertas de Python el La Tribu

La entrada es libre y gratuita. Se pasará una gorra voluntaria durante los cursos para hacer frente a viáticos y gastos generales.
No hace falta registrarse, pero vengan temprano para asegurarse un lugar porque los cupos son limitados.

La gente de PyAr está invitando a pegar el folleto de las charlas en facultades y lugares de trabajo.

Mapa:

View Larger Map

Python BaseHTTPServer: un servidor HTTP en unas pocas líneas

elbarto — Thu, 15 Jul 2010 20:25:01 +0000

Python

Python es un lenguaje tan poderoso que me sorprende constantemente. Particularmente su librería standard incluye tantas cosas maravillosas que lleva tiempo ir descubriéndolas todas.

Hoy voy a hablar de BaseHTTPServer un módulo de Python 2.x (en 3.x se llama http.server) que nos permite implementar un servidor web en muy pocas líneas de código. Es la base de otros dos módulos muy interesantes, SimpleHTTPServer y CGIHTTPServer. El primero implementa un muy simple servidor web que sirve archivos y el segundo es un servidor que ejecuta script CGI en entornos Unix.

Por ejemplo, con SimpleHTTPServer podemos hacer algo tan maravilloso como esto:

$ cd ~/musica
$ python -m SimpleHTTPServer

Y con sólo eso tenemos montado un servidor web escuchando en 0.0.0.0:8000 y sirviendo todos nuestros archivos de la carpeta ~/musica.

Pero la clase BaseHTTPServer es más poderosa porque nos permite implementar nuestros propios RequestHandlers, es decir, clases que extiendan BaseHTTPRequestHandler y hagan lo que nosotros queramos en cada petición para cada método HTTP. Por ejemplo, para implementar el método GET solamente hace falta crear una clase que extienda BaseHTTPRequestHandler y sobrecargar el método do_GET.

Por ejemplo, si yo quisiera implementar un muy básico servidor que me diga el load average del sistema sería tan sencillo como poner:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
import BaseHTTPServer

class RequestHandler (BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET (self):
self.send_response(200)
self.end_headers()
self.wfile.write(self._get_status())
return
def _get_status (self):
return "Status:\n" \
"——-\n" \
"Load average: %s\n" % \
("%01.2f, %01.2f, %01.2f" % \
os.getloadavg())

def main (args):
httpd = BaseHTTPServer.HTTPServer((‘localhost’, 8000), RequestHandler)
httpd.serve_forever()

if __name__ == "__main__":
sys.exit(main(sys.argv))

Y al entrar a http://localhost:8000 vería algo así:

Status:
-------
Load average: 0.26, 0.35, 0.40

A esta altura creo que se hace bastante evidente el potencial de esta clase BaseHTTPServer. Piensen lo sencillo que sería hacer un servidor para un web service REST (RESTful web service) implementando métodos do_GET, do_DELETE, do_POST etc.

Para jugar un poco hice una versión un poco más completa de este servidor de status. Al correrlo lanza el servidor HTTP, al cual podemos acceder para pedirle un status general del sistema en tres formatos: texto plano (plain), HTML y JSON. También le agregué un OptionParser para poder configurar el host y puerto en el cual el servidor deberá escuchar. Con comentarios y todo ocupa 149 líneas.

Pueden ver el código aquí: http://pastebin.com/G5FgTDiv

Ciclo de Charlas Abiertas de Python Argentina en La Tribu

elbarto — Sat, 10 Jul 2010 20:38:07 +0000

Python Argentina

PyAr, la comunidad de Python Argentina presenta el Ciclo de Charlas Abiertas de Python 2010 en la sede del Colectivo La Tribu.

Se trata de una serie de presentaciones que tendrán lugar los días sábados, a lo largo de la segunda mitad del año, desarrollando distintos temas relacionados con Python desde los más básicos a algunos bastante avanzados. Las charlas estarán a cargo de miembros de la comunidad PyAr, destacados desarrolladores con un profundo dominio del lenguaje en cuestión.

Las charlas comienzan el sábado 24 de julio, su entrada es libre y gratuita (sin necesidad de registrarse) y tendrán lugar en la sede del Colectivo La Tribu, sito en Lambaré 873, Capital Federal [ver mapa].

A continuación una versión resumida del cronograma de charlas. La versión completa con descripciones y horarios pueden consultarla en la página de PyAr.

Cronograma

Día 1: Sábado 24 de Julio
Tema: Introducción a la Programación
Disertante: Facundo Batista

Día 2: Sábado 31 de Julio
Tema: Introducción a Python
Disertantes: Tomás Zulberti y Facundo Batista

Día 3: Sábado 21 de Agosto
Tema: Introducción al Desarrollo Web I
Disertantes: Mariano Reingart y Alejandro J. Cura
Tema: FooBar (virtualenv, buildout, nose)
Disertante: Roberto Alsina

Día 4: Sábado 11 de Septiembre
Tema: Introducción al Desarrollo Web II
Disertantes: Mariano Reingart y Alejandro J. Cura
Tema: Django
Disertante: Manuel Kauffman

Día 5: Sábado 25 de Septiembre
Tema: Introducción a las Interfaces Gráficas de Escritorio I
Disertante: Roberto Alsina
Tema: Plone
Disertante: Roberto Allende

Día 6: Sábado 2 de Octubre
Tema: Introducción a las Interfaces Gráficas de Escritorio II
Disertante: Roberto Alsina
Tema: wxPython
Disertante: Mariano Reingart

Día 7: Sábado 30 de Octubre
Tema: Optimizando Python
Disertante: Gabriel Genellina
Tema: PyQt
Disertante: Roberto Alsina

Día 8: Sábado 13 de Noviembre
Tema: Python 3000
Disertante: Facundo Batista
Tema: Twisted
Disertante: Lucio Torre

Día 9: Sábado 27 de Noviembre
Tema: Taller de Programación de Juegos
Disertantes: Alejandro J. Cura y Hector Sanchez

Obtener listado de link rotos con wget

elbarto — Mon, 28 Jun 2010 15:03:44 +0000

Esas cosas por las que uno ama Linux. Encontré este post en DiarioLinux que me pareció genial.

$  wget --spider  --no-parent -r -o log.txt http://tuweb.com

Parámetros:

–spider : recorrer la web que le digas, pero SIN descargar nada. Sólo recorrerla.
- r : recursivo, como si fuera el robotito de Google
- o fichero : la salida de ejecutar el comando que salga por pantalla
–no-parent : si le pasamos como parámetro un nombre de directorio, no queremos que suba hacia los directorios padre.

La lista de enlaces rotos estará en log.txt (parte final)

Tomado de DiarioLinux.

Y agrego otro muy útil. Cómo descargar todos los contenidos de un sitio FTP con wget.

wget -r -q -b -P /home/myuser/destination ftp://mydomain.com --ftp-user=myuser --ftp-password=mypass

Parámetros:

-r: recursivo
-q: quiet/silencioso, no imprime mensajes en la consola
-b: background, para que se ejecute en background y nos devuelva el prompt.
-P: directorio donde queremos que se guarde todo lo que bajamos
–ftp-user=: usuario FTP
–ftp-password=: password FTP

Arreglar: ‘Failed to load magic database’

elbarto — Mon, 31 May 2010 02:04:22 +0000

PHP

Cada tanto nos topamos con esos errores molestos y dificiles de solucionar, y la solución la encontramos en un comentario perdido en php.net.

El error de hoy es el siguiente:

Warning: finfo::finfo() [finfo.finfo]: Failed to load magic database
at ‘/usr/share/misc/magic’

El archivo /usr/share/misc/magic existe, tiene permisos, etc. PHP estaba actualizado, fileinfo también, todo.

¿Cuál era el problema? libmagic le agrega “.mime” al archivo y por eso PHP no lo encuentra, ni tampoco muestra un mensaje de error que se entienda.

Solución

Creamos un link simbólico para el archivo que libmagic va a buscar.

# ln -s /usr/share/misc/magic /usr/share/misc/magic.mime

Instalar Monit: monitoreo de servicios para servidores Unix

elbarto — Sun, 04 Apr 2010 14:40:47 +0000

Hoy voy a explicar cómo instalar Monit, un software muy completo para monitoreo de servicios (locales y remotos) de cualquier sistema Unix. Con él podremos estar atentos ante posibles problemas en alguno de nuestros servidores y realizar algunas tareas automaticamente.

¿Qué es Monit?

De acuerdo con su propia definición, Monit es una utilidad gratuita y Open Source para administrar y monitorear procesos, archivos, directorios y filesystems en un sistema Unix. Realiza tareas automáticas de mantenimiento y reparación y puede ejecutar acciones significativas durante situaciones de error.

Está desarrollado en C (pueden ver el código fuente en Google Code) y su demonio corre de manera casi imperceptible para el sistema, en tanto consume muy pocos recursos.

Para más información, se puede consultar el sitio oficial de Monit y su manual online (ambos en inglés).

Instalación

La instalación de Monit es muy sencilla.

# cd /usr/src
# wget http://mmonit.com/monit/dist/monit-5.1.1.tar.gz
# tar zxvf monit-5.1.1.tar.gz
# cd monit-5.1.1
# ./configure --prefix=/usr
# make && make install

Luego, si estamos instalando en CentOS o algún Linux similar, vamos a querer copiar el archivo rc.

# cp contrib/rc.monit /etc/init.d/monit
# chown root:root /etc/init.d/monit
# chmod 755 /etc/init.d/monit
# chkconfig --add monit
# chkconfig monit on

Configuración

Una vez instalado podemos pasar a la configuración, que será lo más importante del proceso. Para ello yo suelo crear un archivo inicial /etc/monitrc que tiene la configuración general del Monit, y luego dentro de una carpeta /etc/monit creo un archivo por cada servicio que quiero monitorear.

Les dejo aquí mi configuración.

Archivo: /etc/monitrc

set daemon  120
set logfile syslog facility log_daemon
set mailserver localhost

set alert administrator@domain.com                      # receive all alert
set alert anotheradmin@domain2.com

set httpd port 2812 and
   use address localhost  # only accept connection from localhost
    allow localhost        # allow localhost to connect to the server and
#    allow admin:monit      # require user 'admin' with password 'monit'
#
#
###############################################################################
## Services
###############################################################################
##
## Check general system resources such as load average, cpu and memory
## usage. Each test specifies a resource, conditions and the action to be
## performed should a test fail.
#
  check system fqdn.domain.com
    if loadavg (1min) > 5 then alert
    if loadavg (5min) > 10 then alert
    if loadavg (1min) > 20 then exec "/bin/bash /root/handle_high_load.sh"
    if memory usage > 75% then alert
    if cpu usage (user) > 70% for 3 cycles then alert
    if cpu usage (system) > 30% for 3 cycles then alert
    if cpu usage (wait) > 20% for 3 cycles then alert

include /etc/monit/*.monitrc

Algunas cosas para anotar de esta primera parte. El daemon va a revisar cada 120 segundos los servicios, va a loguear en Syslog y va enviar mails usando el mailserver local. Cuando haya alguna alerta, la enviará a administrador@domain.com y anotheradmin@domain2.com. Luego habilito el servicio web que ofrece monit para que escuche en la IP local (esto es para poder utilizar todas las opciones del comando `monit`). Por último defino las reglas para el chequeo del sistema, cuyo FQDN es fqdn.domain.com (acá iría el hostname de su servidor). Las reglas son bastante sencillas. En algunos casos lo que hago es enviar una alerta y si el loadavg es más de 20 ejecuto un script para controlarlo.

La última línea incluye todos los archivos *.monit del directorio /etc/monit. Que es lo que vamos a ver ahora.

Archivo: /etc/monit/httpd.monitrc

#
# Monitor Apache (httpd)
#
check process httpd with pidfile /var/run/httpd.pid
    start program = "/sbin/service httpd start"
    stop program  = "/sbin/service httpd stop"
    if cpu > 80% for 3 cycles then alert
    if totalmem > 1500.0 MB for 5 cycles then alert
    if children > 250 then alert
    if children > 255 for 5 cycles then stop
    if cpu usage > 95% for 3 cycles then restart
    if failed port 80 protocol http then restart

check file httpd.conf with path /etc/httpd/conf/httpd.conf
    if changed checksum then alert

Aquí defino un proceso de nombre “httpd” con un pidfile en /var/run/httpd.pid. Luego defino los comandos para iniciar y detener el proceso. Y luego las acciones a realizar según el evento. En algunos casos será “alert” (enviar aviso por mail), en otros “restart” (reinicar el proceso). Hay otras opciones que podrán ver en la documentación. Por último agrego una verificación del archivo httpd.conf. Si se modifica me notificará por mail.

De la misma forma, en el directorio /etc/monit tengo archivos similares para MySQL, SMTP, POP3, IMAP, SSH, etc. Y además tengo archivos para controlar algunos servicios externos. Esto es por una cuestión básica: hasta ahora estamos haciendo todos chequeos locales, si el servidor se cae o por alguna razón no puede enviarme las alertas, podría nunca enterarme de qué pasa. Entonces voy a agregar este otro archivo para controlar un servidor externo que me diga si los servicios están accesibles.

Archivo: server1.monitrc

# server1.domain.com check
check host server1.domain.com with address 1.2.3.4
      if failed icmp type echo count 10 with timeout 15 seconds
         then alert
      if failed port 21 proto ftp then alert
      if failed port 25 proto smtp then alert
      if failed port 80 proto http then alert
      if failed port 110 proto pop then alert

Aquí estoy monitreando el servidor server1.domain.com con IP 1.2.3.4 (este archivo debería estar en otro servidor con Monit, por ejemplo, servidor2.domain.com). Lo primero que intento es hacer un Echo ICMP. Lamentablemente Monit no soporta hacer ping, pero un echo ICMP es lo más cercano que nos permite. Si falla 10 veces seguidas, le pido que me avise (la cantidad de veces tan alta es para asegurarme de no recibir una alerta por un paquete perdido y llenar mi mail de alertas inútiles que no me permitan ver las importantes). Luego agrego que testee los principales puertos a través de los protocolos correspondientes y que si falla me avise.

Iniciando Monit

Una vez que tenemos la configuración, ya podemos probarlo. Para ello iniciaremos el servicio, veremos si se inicia correctamente en el log y veremos el status.

Iniciamos:

# service monit start

Luego vemos en syslog:

Apr  4 11:35:23 fqdn monit[24820]: Starting monit daemon with http interface at [localhost:2812]
Apr  4 11:35:23 fqdn monit[24822]: Starting monit HTTP server at [localhost:2812]
Apr  4 11:35:23 fqdn monit[24822]: monit HTTP server started
Apr  4 11:35:23 fqdn monit[24822]: 'fqdn.domain.com' Monit started

Monit inició y tiene su servidor HTTP escuchando en localhost:2812. Ahora veamos el resumen del status de los servicios.

# monit status
The Monit daemon 5.0.3 uptime: 1m 

System 'fqdn.domain.com' running
Process 'sshd'                      running
File 'sshd_config'                  accessible
Process 'exim'                      running
File 'exim.conf'                    accessible
Process 'mysqld'                    running
File 'my.cnf'                       accessible
Process 'httpd'                     running
File 'httpd.conf'                   accessible
Remote Host 'fqdn.domain.com' online with all services

Para ver los comandos disponibles:

# monit -h

Al mismo tipo de información podremos acceder por vía web si accedemos a http://localhost:2812. También, si queremos acceder desde afuera, podemos configurar Monit para que escuche en otra IP (por ejemplo, 0.0.0.0) y definir un método de autenticación (para que no pueda acceder cualquiera).

Python: Ver dominios de Apache que más transferencia consumen

elbarto — Thu, 11 Mar 2010 01:47:12 +0000

Hace un rato publiqué un post con un script para ver qué dominios de Apache consumen mayor transferencia. El script en BASH toma unos 7 segundos en procesar 750 archivos de uno de mis servidores. Ahora hice una versión en Python, para la que me dieron algunos consejos los chicos de PyAr, y toma aproximadamente 4 segundos en procesar los mismos archivos. Aquí les dejo el código:

#!/usr/bin/env python
""" Access Log Parser

Parses all the files in a directory
treating them as access_log files
and outputs the list of files sorted
by transfered megabytes. Useful for
identifying heavy users.

Usage:
./access_log_parser.py
base_dir = directory where the access_log files are
"""
import sys
import os
import time
from operator import itemgetter

def main (args):
"""Main

Main function of the script.
This is where the magic happens.
It takes the script arguments
and returns an exit code.
"""

# Parameter checking
if len(args) < 2:
print "Usage: %s " % args[0]
return 1

if os.path.isdir(args[1]):
base_dir = args[1]
else:
print "%s is not a directory" % args[1]
return 2

# Init vars
t1 = time.time()
mbyte = 1048576.0
domains = []

# Start processing files
for item in os.listdir(args[1]):
path = os.path.join(base_dir, item)
if os.path.isfile(path) and \
os.path.getsize(path) > 0:

bytes = 0
init_date = None
data = None

# Process file lines
for line in open(path, ‘r’):
data = line.split(" ")
if init_date is None:
init_date = data[3][1:]
try:
bytes += long(data[9])
except ValueError:
pass
domains.append({‘domain’: item, \
‘mbytes’: bytes / mbyte, \
‘init_date’: init_date, \
‘end_date’: data[3][1:] })

# Print out sorted information
for domain in sorted(domains, key=itemgetter(‘mbytes’)):
print "%.2f MB | From: %s | To: %s | %s" % \
(domain[‘mbytes’], \
domain[‘init_date’], \
domain[‘end_date’], \
domain[‘domain’])

print "Generated in %d seconds" % (time.time() – t1)
return 0

if __name__ == "__main__":
sys.exit(main(sys.argv))

Para ejecutarlo:

./access_log_parser.py /tmp/domain_logs
...
544.30 MB | From: 10/Mar/2010:02:48:33 | To: 10/Mar/2010:18:13:25 | dominio1.com.ar.log
602.34 MB | From: 10/Mar/2010:00:23:09 | To: 10/Mar/2010:23:39:45 | dominio2.com.ar.log
944.03 MB | From: 10/Mar/2010:00:49:35 | To: 10/Mar/2010:23:39:57 | dominio3.com.ar.log
Generated in 3 seconds

Ver dominios de Apache que más transferencia consumen

elbarto — Wed, 10 Mar 2010 19:07:44 +0000

Frecuentemente me encuentro ante la necesidad de saber qué dominios de los que tengo alojados en mis servidores consumen más tráfico HTTP. Como éste es el tipo de tráfico más importante y que más incide en el desempeño general de mis servidores, saber qué dominios transfieren más datos por HTTP me orienta en la búsqueda de heavy users. Para ello hice un script hace algún tiempo, y ahora lo estuve revisando, retocando y simplificando, y decidí compartirlo.

En el entorno de Directadmin, los logs de Apache se encuentran en /var/log/httpd. Allí hay una carpeta “domains” que guarda los logs de cada dominio. Por cada dominio hay tres logs: dominio.com.log, dominio.com.error.log y dominio.com.bytes. El primero es el access_log, el segundo el error_log y el tercero solamente guarda la cantidad de bytes de cada request. La opción más sencilla es trabajar con este último tipo de logs, pero el problema que tienen es que no indican la fecha. Si bien se supone que los logs de Directadmin rotan una vez por día, alguna vez me ha pasado que por razones que nunca pude descubrir, algunos logs no rotaban y generaban ciertas confusiones. Por lo tanto, el script que dejo usa los access_logs. Además esta opción es reutilizable en otras implementaciones de Apache que no tengan archivos de bytes.

El código:

# Access Log Parser
#
# Parses all the files in a directory
# treating them as access_log files
# and outputs the list of files sorted
# by transfered megabytes. Useful for
# identifying heavy users.
#
# Usage:
# ./access_log_parser.sh
# base_dir = directory where the access_log files are

if [ -z $1 ]; then
echo "Usage: $0 "
exit 1
fi

BASE_DIR=$1
T1=`date +%s`
for file in $BASE_DIR/*;
do
size=`stat -c %s $file`
if [ $size -gt 0 ]; then
from=`head -1 $file | awk ‘{print($4)}’ |sed ‘s/^\[//’`
to=`tail -1 $file | awk ‘{print($4)}’ |sed ‘s/^\[//’`
bytes=`cat $file | awk ‘{a+=$10}END{print a}’`
mbytes=`echo $bytes | awk ‘{print $1 / 1048576}’`
echo "$mbytes MB ($bytes bytes) | From: $from | To: $to | ${file:${#BASE_DIR}+1}"
fi
done \
| sort -nb
T=`date +%s`

Un detalle importante: el script levanta todos los archivos de un directorio que se especifica por parámetro. Esto es así porque yo lo invoco desde otro script:

#!/bin/bash
LOG_DIR=/var/log/httpd/domains/
TMP=/tmp/domain_logs
if [ ! -d $TMP ]; then
mkdir -p $TMP
fi

rm -f $TMP/*

cd $LOG_DIR
for i in `ls *.log |grep -v error`; do
ln $i $TMP/$i
done
/root/access_log_parser.sh $TMP

Este último script lo que hace es crear un directorio temporal (si no existe). Vaciar su contenido. Y luego generar hardlinks a todos los access_logs de /var/log/httpd/domains. De esta forma, no me tengo que preocupar por si los logs son modificados mientras yo estoy ejecutando el script. Por último, ejecuta mi primer script (access_log_parser.sh) y le pasa como parámetro el directorio temporal donde están los access_logs.

Por último, la salida del script sería algo así:

...
186.995 MB (196078184 bytes) | From: 10/Mar/2010:00:27:47 | To: 10/Mar/2010:16:51:09 | dominio1.com.ar.log
187.096 MB (196184596 bytes) | From: 10/Mar/2010:03:24:55 | To: 10/Mar/2010:16:51:24 | dominio2.com.ar.log
245.692 MB (257626221 bytes) | From: 10/Mar/2010:02:53:50 | To: 10/Mar/2010:16:39:54 | dominio3.com.log
273.46 MB (286743390 bytes) | From: 10/Mar/2010:02:48:33 | To: 10/Mar/2010:14:59:29 | dominio4.com.ar.log
306.344 MB (321224473 bytes) | From: 10/Mar/2010:00:23:09 | To: 10/Mar/2010:16:51:20 | dominio5.com.ar.log
444.097 MB (465669066 bytes) | From: 10/Mar/2010:00:49:35 | To: 10/Mar/2010:16:51:20 | dominio6.com.ar.log
Generated in 6 seconds

Les dejo, de yapa, la opción del script utilizando los logs de bytes. Como dije, esta opción es un poco más sencilla y veloz, pero no nos dice las fechas de los logs.

#!/bin/bash

if [ -z $1 ]; then
echo "Usage: $0 "
exit 1
fi

BASE_DIR=$1
T1=`date +%s`
for file in $BASE_DIR/*.bytes;
do
size=`stat -c %s $file`
if [ $size -gt 0 ]; then
bytes=`cat $file | awk ‘{a+=$1}END{print a}’`
mbytes=`echo $bytes | awk ‘{print $1 / 1048576}’`
echo "$mbytes MB ($bytes bytes) ${file:${#BASE_DIR}+1}"
fi
done \
| sort -nb
T=`date +%s`
echo "Generated in $(($T-$T1)) seconds"

Y la salida sería así:

# ./parser.sh /var/log/httpd/domains
...
181.716 MB (190543470 bytes) dominio1.com.bytes
187.115 MB (196203973 bytes) dominio2.com.ar.bytes
189.093 MB (198278283 bytes) dominio3.com.ar.bytes
245.692 MB (257626221 bytes) dominio4.com.bytes
273.472 MB (286756234 bytes) dominio5.com.ar.bytes
314.32 MB (329588717 bytes) dominio6.com.ar.bytes
444.516 MB (466108759 bytes) dominio7.com.ar.bytes
Generated in 2 seconds