tail -f | sysadmin » Python

Sencillo parser para Apache mod_status en Python

elbarto — Sun, 31 Jul 2011 01:01:46 +0000

Cuánto hace que no actualizo este blog!! Hoy estuve jugando un poco con Python y me puse a hacer un pequeño script que supongo que a otros les podrá servir como base para hacer algo más interesante. Precisamente, tengo planes para hacer algo más interesante, pero como recién están en veremos, les voy pasando esta pequeña base a ver si alguien me gana de mano

Como muchos sabrán, Apache (y otros web servers) tiene un módulo llamado mod_status que nos permite ver en tiempo real el estado del servidor (los requests que se están procesando, el uso del CPU, el estado de las conexiones, etc.). Esta información puede ser muy útil para hacer diagnósticos cuando está habiendo algún tipo de problema, para hacer monitoreo, etc. El módulo nos muestra una página web con la información y tiene dos interfaces: una está pensada para ser vista por seres humanos y otra para ser consultada por scripts (para ver esta segunda sólo hace falta pasarle el parámetro “?auto” en la URL). El problema es que esta segunda interfaz no nos muestra a qué dominios (virtual hosts) están dirigidos los requests que se están procesando (o si hay forma de que lo muestre yo no la encontré). Entonces me puse a hacer un sencillo script en Python para parsear la página “para seres humanos”.

Por suerte Python nos ofrece muchas herramientas muy útiles para este tipo de cosas, así que no me tuve que esforzar demasiado. En este caso utilicé urllib2 para acceder a la página de mod_status y BeautifulSoup para parsear el HTML. Por si no lo conocen, BeautifulSoup es un muy poderoso parser para XML/HTML hecho en Python. No viene con el código fuente sino que hay que instalarlo, pero hacerlo es muy fácil:

En Debian/Ubuntu:

apt-get install python-beautifulsoup

En CentOS/RedHat:

yum install python-BeautifulSoup

Con easy_install:

easy_install BeautifulSoup

El código tiene una clase Status que es la que hace la magia y una función main() que utiliza la clase para parsear una URL e imprimir algunos datos a modo de ejemplo.

import sys
import urllib2
from operator import itemgetter
from BeautifulSoup import BeautifulSoup

class Status (object):
_url = None

def __init__ (self, url):
self._url = url

def fetch (self):
return urllib2.urlopen(self._url).read()

def parse (self):
html = self.fetch()
soup = BeautifulSoup(html)
status = {}
status[‘server_info’] = [i.string.strip() for i in soup.findAll(‘dt’)]
status[‘requests’] = []
requests = soup.find(‘table’).findAll(‘tr’)
keys = [i.string for i in requests.pop(0)]
for tr in requests:
req = {}
for n, td in enumerate(tr):
req[keys[n]] = td.string
status[‘requests’].append(req)
return status

def main (argv):
if len(argv) < 2:
print "Usage %s "%argv[0]
return 1

status = Status(argv[1])
data = status.parse()
print "SERVER INFORMATION"
print "=================="
for v in data[‘server_info’]:
print v

print "REQUESTS BY VHOST"
print "================="
entries = [i[‘VHost’] for i in data[‘requests’]]
requests = sorted([(entries.count(i), i) for i in list(set(entries))], reverse=True)
print "\n".join(["%d: %s"%(a,b) for a,b in requests])

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

La forma de uso es:

python status.py "http://localhost/server-status"

Y en este caso la salida del script es algo así:

SERVER INFORMATION
==================
Server Version: Apache/2.2.19 (Unix) mod_ssl/2.2.19 OpenSSL/0.9.8e-fips-rhel5 DAV/2
Server Built: May 26 2011 15:14:47
Current Time: Sunday, 31-Jul-2011 00:53:59 ART
Restart Time: Saturday, 30-Jul-2011 12:07:12 ART
Parent Server Generation: 0
Server uptime:  12 hours 46 minutes 47 seconds
Total accesses: 407813 - Total Traffic: 3.7 GB
CPU Usage: u2.05 s3.23 cu52 cs0 - .125% CPU load
8.86 requests/sec - 85.0 kB/second - 9.6 kB/request
10 requests currently being processed, 8 idle workers
REQUESTS BY VHOST
=================
9: www.tail-f.com.ar
5: www.otro-dominio.com.ar
4: www.not-a-domain.com.ar
3: www.algunlado.com.ar
2: subdominio.dominio.com.ar
1: www.pepe.com.ar
1: www.no-votes-a-macri.com.ar
1: www.asd.com.ar
1: localhost

Obviamente esto no es una aplicación funcional, sino un ejemplo que espero que les sirva para hacer algo más copado. Yo seguiré jugando y si hago algo un poco más interesante, ya se los mostraré.

Ya salió PET: English Translation!

elbarto — Fri, 10 Sep 2010 12:12:39 +0000

Hace unos días comenté la salida del primer número de la revista PET: Python Entre Todos. Como también adelanté en esa oportunidad, se descubrió que se trataba de la única revista de Python en el mundo (activa por lo menos). Así que luego de varios días de esfuerzo se tradujo el primer número y salió PET: English Translation.

PET: English Translation

Los artículos de este número son:

Como también ya les había adelantado, en este número tuve oportunidad de participar traduciendo dos artículos. PyAr, The History de Facundo Batista y How is this magazine made? de Roberto Alsina.

Además, aprovechando la ampliación del público de la revista, se ha agregado la posibilidad de hacer donaciones para la comunidad PyAr, de manera de solventar futuras actividades como impresiones del tutorial de Python, compra de materiales, charlas, etc.

Notificaciones de mails Prioritarios de Gmail en nuestro escritorio

elbarto — Sat, 04 Sep 2010 18:21:46 +0000

GMail

En estos días GMail empezó a implementar la Priority Inbox, o Prioritarios en su versión en castellano. No es nada demasiado novedoso, en realidad es una etiqueta que define a un mensaje como prioritario. Lo más interesante es que Gmail no solamente te puede mostrar por separado los mails con prioridad de los otros, sino que nos promete ir “aprendiendo” a determinar cuáles son prioritarios y cuáles no.

En estos días estuve probando el feature y me viene bien. Yo recibo muchos mails por día, la mayoría de distintas listas de correo. Y como soy muy obsesivo, cada vez que tengo un mensaje nuevo voy a ver de qué se trata y “marcarlo como leído”. Este feature me permite perocuparme solamente por los prioritarios y dejar los menos importantes (como los de las listas) para más tarde.

Hoy pensé: “qué bueno estaría tener una aplicación que me notifique solamente de los mails importantes”. Ya existen varios notifiers para Gmail, tanto de Google o de terceros, para Firefox o para el Desktop. Pero supongo que todavía no habrán implementado esta posibilidad de solamente avisarte de los mensajes prioritarios. Así que lo que hice fue hacerlo en Python que es muuuy fácil.

En su versión simplificada, ver si hay mails “Importantes” y notificarlo es tan sencillo como esto:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import imaplib
import pynotify
from email.header import decode_header
from email.parser import Parser

host = ‘imap.gmail.com’
port = 993
username = ‘usuario@gmail.com’
password = ‘passwordsupersecreto’

def get_header (msg, header):
"""Gets a header from a message"""
header = decode_header(msg.get(header))
if (header[0][1]):
return unicode(header[0][0], header[0][1]).encode(‘utf8′)
else:
return header[0][0]

if not pynotify.init("GMail Important Messages"):
print "Failed to initialize pynotify"
sys.exit(1)

client = imaplib.IMAP4_SSL(host, port)
if not client.login(username, password):
print "Failed to login"
sys.exit(1)

status, data = client.select(‘[Gmail]/Important’)
if status != ‘OK’:
print "Failed to select Important label"
sys.exit(1)

status, data = client.search(None, ‘(UNSEEN)’)
if status == ‘OK’ and data[0] != ”:
for msg_id in sorted(data[0].split()):
if msg_id != ”:
status, data = client.fetch(msg_id, ‘(RFC822)’)
if status == ‘OK’:
msg = Parser().parsestr(data[0][1])
pynotify.Notification(get_header(msg, ‘From’), \
get_header(msg, ‘Subject’)).show()
else:
print "Failed to fetch message #%s" % str(msg_id)

Ese código lo que hace es inicializar pynotify, conectarse al servidor IMAP de GMail usando imaplib, autenticarse con el user y password provisto, seleccionar la etiqueta “[Gmail]/Important” y ver si hay mensajes sin leer. En caso de que haya itera sobre ellos, obtiene su contenido (para sacar el remitente y el asunto) y lanza un mensaje de notificación.

Para convertir eso en una aplicación básicamente hace falta meterlo en un while y corregir un detalle que es que el fetch del mensaje lo marca como leído (y eso no es algo que queramos en un simple notificador), así que hay que volver a marcarlo como no leído. Eso y algunos toques cosméticos es lo que hice en el script completo.

Por supuesto se trata solo de una prueba de concepto y a una aplicación completamente funcional deberían hacersele algunas correcciones más. Pero creo que es una idea divertida como para que otros puedan hacer algo mejor.

PET: Python Entre Todos, primera revista de Python

elbarto — Sun, 22 Aug 2010 14:41:03 +0000

A esta altura ya es una noticia vieja, pero quizás alguno no se haya enterado de que la semana pasada salió publicada la revista PET: Python Entre Todos.

La revista es una producción colaborativa de la Comunidad PyAr, con artículos de muy alto nivel de distintos participantes de la lista y el esfuerzo especial de sus dos editores, Roberto Alsina y Emiliano Dalla Verde Marcozzi.

PET: Python Entre Todos Num. 1

Los artículos incluidos en la revista son:

PET First Shot
Cómo contribuir a PET
PyAr, la historia
from gc import commonsense – Finish Him!
Concurrencia Indolora: el módulo processing
Introducción a Unit Testing con Python
Taint Mode en Python
Dinamismo Aplicado
Decorando Código (Parte 1)
Web2Py Para Todos
¿Cómo Está Hecha Esta Revista?
Desafío PET
Un poco de xkcd

La publicación fue todo un éxito porque se dinfundió rápidamente por Internet con la ayuda de diversos medios: blogs, twitter, barrapunto, etc. En mi opinión esta buena recepción se debió dos factores clave: la calidad del contenido que es realmente muy alta y que gracias a las tecnologías de software libre utilizadas para la edición de la revista, la misma pudo ser publicada en múltiples formatos: HTML online, PDF en distintos layouts y para e-book readers en ePub y Mobi. A todos ellos se puede acceder en la página del primer número de la revista.

Además, al poco tiempo de publicada la revista, Roberto descubrió que PET es la primera revista de Python… en el mundo!. Esto animó a la comunidad a crear una versión en inglés para poder difundirla a un mayor público. Personalmente tuve la opotunidad de colaborar traduciendo dos artículos, “PyAr, la historia” de Facundo Batista y “¿Cómo Está Hecha Esta Revista?” de Roberto Alsina. De esta manera, si no puedo aportar con un artículo interesante, por lo menos puedo colaborar para que las cosas interesantes que escriben otros puedan llegar a un público más amplio.

Así que seguramente pronto estemos anunciando la versión en inglés del número 1 de PET. Y en el futuro, según entiendo, la idea es poder incorporar artículos de colaboradores internacionales en ambas versiones de la revista.

Una vueltita por las Charlas Abiertas de Python en La Tribu

elbarto — Sat, 21 Aug 2010 18:21:00 +0000

Charlas Abiertas de Python en La Tribu

Hoy pude darme una vuelta, por primera vez, por las Charlas Abiertas de Python en La Tribu. Le robé un tiempo al estudio y me dirigí a Lambaré 873 junto a un amigo, a ver qué tal estaban esas charlas.

No esperaba encontrar grandes revelaciones porque la charla a la que iba era la de Introducción al Desarrollo Web I, a cargo de Alejandro Cura, y yo ya trabajo en el rubro hace algunos años. Sin embargo me interesaba verle las caras a algunos miembros de la comunidad por quienes tengo un gran respeto.

Me encontré con un ámbito muy amigable, lleno de gente deseosa de aprender. Me alegró mucho encontrar algunas personas “mayores” (por lo menos mayores al tipo de gente que uno suele conocer en este acotado segmento del mercado laboral), muy interesadas y participativas. La charla estuvo muy bien, era una introducción para quienes no tienen idea de en qué consiste hacer un sitio web (y preparatoria para la próxima charla que dará algunos conceptos básicos de Web2Py). Me pareció muy copado que se le diera un poco de bola al protocolo HTTP y cómo funciona, porque en mi experiencia laboral me he encontrado con desarrolladores que pueden manejar muy bien algunos lenguajes como PHP, Javascript o HTML pero no tienen idea de cómo llegan esas cosas “a la mesa” del browser.

Incluso me encontré aprendiendo una cosita de CSS que no sabía y era la posibilidad de incluir tipografías externas (que quisiera ver qué tan compatible es con la bosta de IE, pero que me resultó muy útil).

Me hubiera gustado quedarme a la charla siguiente del eminente Roberto Alsina, pero lamentablemente tenía que volver a la cueva a estudiar.

Felicito desde este humilde lugar el enorme trabajo que está realizando la comunidad PyAr organizando estas charlas que permiten acercar herramientas a la sociedad para conocer y apropiarse de las nuevas tecnologías asociadas a la informática e Internet.

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

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

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