danigm's blog

Hoy en día todo el mundo confía en el correo electrónico, todos confiamos en que los correos que nos llegan vienen realemente de quien dice que viene. Para el que no lo sepa, el correo electrónico no va autenticado, un correo es igual que una carta, el remitente lo pone quien lo envía, y en ningún paso del proceso se verifica la identidad del mismo.

¿Cómo envíar un correo con la dirección que yo quiera?

Hacer esto en linux es extremadamente sencillo. Para el envío de correo se utiliza el protocolo SMTP. El correo se envía desde servidores SMTP, si escribes un correo desde gmail, por ejemplo, se utiliza para mandar el correo uno de los servidores smtp de google.

Por lo tanto si queremos envíar correo desde nuestro ordenador tenemos que instalar un servidor smtp, como por ejemplo postfix (en debian/ubuntu/etc apt-get install postfix).

Cuando lo ejecutamos tenemos en el puerto 25 de nuestra máquina el servicio corriendo:


$netstat -punta | grep -i LISTEN
tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN -


Con el servidor smtp hay muchas formas de envíar correos (telnet, mail, sendmail, cualquier cliente de correo, ...)

Voy a poner un ejemplo de script en python que envía un correo con una dirección de correo dada

#!/usr/bin/python
# pymail.py <a href="mailto:from@mail.com">from@mail.com</a> "to@mail.com;to2@mail.com;..." "subject" "message"
 
import sys
import smtplib
 
if len(sys.argv) < 5:
    print 'pymail.py <a href="mailto:from@mail.com">from@mail.com</a> "to@mail.com;to2@mail.com;..." "subject" "message"'
    sys.exit()
 
fromm = sys.argv[1]
to = sys.argv[2]
subject = sys.argv[3]
message = sys.argv[4]
 
msg = ('From: %(fromm)s\r\nTo: %(to)s\r\nSubject: '
    '%(subject)s\r\n%(message)s' % globals())
 
s=smtplib.SMTP("localhost")
s.sendmail(fromm, to.split(';'), msg)

Yo por ejemplo me he envíado un correo desde google@google.com

python pymail.py "Google INK <google@google.com>" "Daniel García Moreno <danigm@gmail.com>" "Te voy a decir hola" "Hello world"


Y aquí está en mi correo.

Cómo evitar esto
Si has recibido algún correo mío alguna vez habrás visto que casi siempre lleva un adjunto signature.asc, pues bien, eso es la firma del mensaje. Existen mecanismos como GnuPG para poder verificar que el mensaje viene de quien dice venir, incluso se puede cifrar el mensaje para que sólo el destinatario pueda leerlo (los correos van en claro de servidor a servidor por la red). Cualquier cliente de correo que se precie es capaz de firmar con pgp/gpg, verificar las firmas y cifrar (yo uso evolution). Si la firma es válida podemos estar seguros de que el mensaje viene de quien dice que viene, incluso podemos asegurar que no ha sido alterado.

Para crear y manejar tus claves gpg puedes utilizar seahorse en gnome.

Mi clave pública es: FE6A3613

Hoy he hecho un dibujo de un pingüino navideño y de paso lo he grabado, le he puesto un poquito de música y lo he colgado en youtube.

Para grabarlo he usado gtk-recordmydesktop y luego con mencoder lo he transformado, escalado y le he puesto música de Rob Costlow.

Lo he realizado en Archlinux con mi dell xps1210 dibujando con inkscape y mi touchpad.

Aquí el vídeo:

Aquí el resultado:

Hace ya algún tiempo comencé a versionar todos mis proyectos con bazaar. La mayoría de los cosillas que hago son pequeños proyectos que no tienen mucha continuidad en el tiempo y no tiene sentido que se publiquen en forjas al estilo de launchpad. Así que ya que tengo mi servidor virtual subo las ramas a mi servidor a través de bzr+ssh. Con bazaar montar un repositorio es tan fácil como hacer un bzr push a otra máquina en la que tengas una cuenta ssh.

Por lo tanto en mi servidor tengo una carpeta "/home/danigm/branchs" dentro de la cual están todos mis proyectos. Cada proyecto es una carpeta que es un repositorio bazaar o una rama. Con bazaar es posible hacer branch o checkout desde una rama cualquiera.

Por otra parte hace poco descubrí web.py que es lo que andaba buscando hace ya algún tiempo. Una forma simple de desarrollar páginas web en python, sin mega-framework que complican el trabajo más de lo que lo facilitan.

Juntando estas dos cosillas ayer me puse a desarrollar un pequeño visor de repositorios bzr basandome en la estructura que yo tengo en mi servidor y el resultado puede verse en http://repo.danigm.net:8000/projects.

bzr-viewer tiene las siguientes funcionalidades:

• Visión de un listado de proyectos (carpetas bzr) (http://repo.danigm.net:8000/projects)
• Visión de los ficheros versionados en cada proyecto por revisión (http://repo.danigm.net:8000/list/bzr-viewer/5)
• Visión de logs de cada proyecto (http://repo.danigm.net:8000/log/bzr-viewer)
• Exportación de cada proyecto y revisión a tgz para descarga (http://repo.danigm.net:8000/tgz/bzr-viewer/5)
• Visión de diferencias entre dos versiones cualesquiera de un proyecto (http://repo.danigm.net:8000/diff/bzr-viewer/4/5)
• Visión/descarga de ficheros de un proyecto en cualquier revisión (http://repo.danigm.net:8000/view/bzr-viewer/index.py/1)

Puedes echar un vistazo en mi repositorio y te puedes bajar el código para ver un ejemplo de applicación simple con web.py.

He añadido soporte para twitter en sweetgtk y arreglado una serie de bugs.

Ahora Se puede seguir twitter y/o sweetter al mismo tiempo y escribir comentarios en sweetter y/o twitter. He añadido unos checkbox y dependiendo de si tienes seleccionado sweetter o twitter o ambos se reciben los comentarios y se postea en la plataforma adecuada.

Aquí un screenshot de la nueva versión:

Además he arreglado el script install que era una guarrería y ahora se hacen las cosas de buena manera, llevando todo a /usr/share/sweetgtk y la configuración y la cache a $HOME/.sweetgtk de cada usuario, copiandose un skel si este directorio no existe.

Así pues todo aquel que intentó instalarse sweetgtk sin exito debe ejecutar el script ./uninstall de la versión que intentó instalar y borrar todo archivo que quede por ahí suelto, incluso $HOME/.sweetgtk, bajarse la nueva versión y ejecutar el nuevo script install como root que hará todo lo pertinente.

El script install debería funcionar en la mayoría de las distros GNU/linux y por tanto en el openmoko. Las dependencias y demás cosas están en el post anterior

sweetgk2.tgz

Por otro lado lo he empaquetado para debian/ubuntu y aquí está el paquete:
sweetgtk_2.0_i386.deb

Gracias por vuestra atención y a disfrutar del microblogging.

Hacía ya tiempo que tenía pensado hacer una aplicación de escritorio para poder interactuar con sweetter, pero hasta hoy no me había puesto a hacer nada serio.

Consiste en una aplicación hecha en pygtk que tira del módulo que ya hice antes pysweetter (que se conecta a sweetter a través de xmlrpc de forma transparente).

El código se puede conseguir así:
bzr branch http://repo.danigm.net/sweetgtk

Está bajo el control de versiones bazaar

Aquí una captura de pantalla de la aplicación:

Y como es pygtk también funciona en el openmoko neo freerunner:

Todavía estoy desarrollandolo, estoy teniendo problemas con los threads porque me da "segmentation faults" de forma "aleatoria", tengo que arreglar eso :P

Edito (23/11/2008 21:40):

Creo que ya he solucionado el problema de los threads, y además he hecho algunos arreglos para que funcione también en windows.

Aquí un screenshot funcionando en windows:

Para que funciones en windows vista hay que instalar una serie de cosas:

1. Instalar python 2.5: http://www.python.org/download/
2. Instalar GTK-runtime: http://sourceforge.net/project/showfiles.php?group_id=98754
   http://sourceforge.net/project/showfiles.php?group_id=98754&package_id=1...
3. Instalar pygtk: http://ftp.gnome.org/pub/GNOME/binaries/win32/pygtk/2.12/
4. Instalar gobject: http://ftp.gnome.org/pub/GNOME/binaries/win32/pygobject/2.14/
5. Instalar pycairo: http://ftp.gnome.org/pub/GNOME/binaries/win32/pycairo/1.4/

Y por cierto, para que funcione en linux también es necesario tener instalado todo lo anterior, pero normalmente en un escritorio gnome estará instalado, los paquetes para debian son:

python, python-gtk2, python-gobject, python-cairo, python-notify

Tengo pensado hacer un paquete un día de estos, mientras tanto se puede conseguir el código del repositorio o de aquí:
http://danigm.net/files/sweetgtk.tgz

Hace ya algún tiempo se me planteó el problema de tener una serie de funciones que se tienen que ejecutar cuando ocurre algo (un evento) y me hice un pequeño modulo en python para cubrir ese asunto.

Me basé en lo que conocía de pygtk, señales y eventos, así pues el funcionamiento básico es que tú declaras un evento, asignas funciones a ese evento, y cuando lances una señal, todas las funciones asociadas a ese evento se lanzan.

Se puede instalar de forma simple así:

sudo easy_install events

Aquí un ejemplo de uso:

from events import EventManager, Event
 
def func1(*args):
    print "Im the func1 with args: " + str(args)
 
def func2(*args):
    print "Im the func2 with args: " + str(args)
 
def func3(*args):
    print "Im the func3 with args: " + str(args)
 
# Creating the eventManager
em = EventManager()
 
# Create some events
event1 = Event('event1')
event2 = Event('event2')
 
em.add_event(event1)
em.add_event(event2)
 
# Connecting functions with events
em.connect('event1', func3, [1,2])
em.connect('event1', func2)
em.connect('event2', func1)
 
# Sending signals
print "sending event1..."
em.signal('event1')
print "sending event2..."
em.signal('event2')
 
# sending signal with arguments
print "sending event1 with arguments..."
em.signal('event1', [1,2,3])

Aquí está el código del módulo:

class Event:
    def __init__(self, name):
        self.name = name
        self.listeners = {}
 
    def add(self, function, data=None):
        self.listeners[function] = data
 
    def delete(self, function):
        self.listeners.pop(function)
 
    def called(self, data=None):
        for function, d in self.listeners.items():
            if data is None:
                if d is None:
                    function()
                else:
                    if type(d) == type([]):
                        function(*d)
                    elif type(d) == type({}):
                        function(**d)
                    else:
                        function(d)
            else:
                if type(data) == type([]):
                    function(*data)
                elif type(data) == type({}):
                    function(**data)
                else:
                    function(data)
 
 
class EventManager:
    def __init__(self):
        self.events = {}
 
    def add_event(self, Event):
        self.events[Event.name] = Event
 
    def del_event(self, Event):
        self.events.pop(Event.name)
 
    def connect(self, event, function, data=None):
        self.events[event].add(function, data)
 
    def disconnect(self, event, function):
        self.events[event].delete(function)
 
    def signal(self, event, data=None):
        if data is None:
            self.events[event].called()
        else:
            self.events[event].called(data)

Como todo ser humano tengo una gran lista de cosas por hacer, también llamada TO-DO list. Hace algún tiempo empecé a utilizar tomboy para tomar notas y tener apuntado cosas por hacer, pero nunca me acuerdo de mirarlo, por lo tanto el otro día decidí hacer un sencillo script que cada cierto tiempo me recordara mi TO-DO list.

Para conseguirlo he utilizado pynotify para mostrar un mensajito en el escritorio cada 10 minutos, y he realizado consultas al servicio DBUS que ofrece tomboy para encontrar la nota con título TODO y coger el texto que hay en esta.

La idea es lanzar este script al iniciar el escritorio para así tenerlo en segundo plano mostrando mensajitos cada cierto tiempo.

Luego pensé que podía hacer lo mismo con los TODO de sweetter.net. Así que lo he integrado con el script utilizando el modulo pysweetter que tira del servicio XML-RPC. Por otra parte he tenido que implementar una función especifica para el servicio xmlrpc de sweetter.

Aquí una imagen del tema en acción:

Y para quien esté interesado, aquí está el código:

#!/usr/bin/python
 
import gtk, pygtk
pygtk.require('2.0')
 
import dbus
import gobject
import time
import pynotify
 
from pysweetter import Sweetter
 
session_bus = dbus.SessionBus()
uri = 'org.gnome.Tomboy'
path = '/org/gnome/Tomboy/RemoteControl'
sleep_time = 10 * 60
 
pynotify.init("Tomboy TODO notification")
USER = 'danigm'
 
while True:
    try:
        tomboy = session_bus.get_object(uri, path)
        note_uri = tomboy.FindNote('TODO')
        all_text = tomboy.GetNoteContents(note_uri)
        all_text = all_text.split('\n')
    except:
        all_text = []
 
    try:
        s = Sweetter()
        todo_list = s.get_TODO_list(USER)
        all_text.append('\nSweetter TODO\n')
 
        for i, sweet in enumerate(todo_list):
            todo = '%d <a href="http://sweetter.net/%s?todo=1">%s</a>' % (i+1, USER, sweet.sweet)
            all_text.append(todo)
    except:
        pass
 
    note = pynotify.Notification("TODO list", 
                            '\n'.join(all_text[1:]))
 
    helper = gtk.Button()
    icon = helper.render_icon(gtk.STOCK_FILE, 
                               gtk.ICON_SIZE_DIALOG)
    note.set_icon_from_pixbuf(icon)
 
    note.set_timeout(30000)
    note.show()
 
    time.sleep(sleep_time)

Y para los más curiosos todavía aquí un repositorio del código:
bzr branch http://repo.danigm.net/todo-reminder

Los parches y comentarios son bienvenidos.

Cuando se trabaja en una empresa es un tema recurrente el cálculo de tiempo dedicado a cada proyecto por parte del desarrollador.

Hay diferentes formas de hacerlo. La más simple sería mirando el reloj y haciendo un cálculo apróximado, el problema es que no tienes un registro de lo que has hecho.

Para el tracking de tiempo dedicado a un proyecto hay diferentes herramientas. Yo conocía gnotime que vale para lo que es, pero que no acaba de convencer.

Luego conocí Hamster, que es mucho más amigable, hace gráficas, informes y muchas polladas.

Yo en mi escritorio siempre tengo una terminal abierta, y últimamente me estoy dando cuenta de que las interfaces gráficas quitan mucho tiempo cuando no las necesitas, así que ayer decidí implementarme un time tracker de estos pero para terminal.

¿Cómo? Cojo python + vim, un poquito de sqlobject, se agita y aquí tenemos "Terminal Time Tracker".

En realidad son tres ficheros, aunque le he un instalador y desinstalador y polladas para que sea más simple de usar.

tttdb.py Una tabla para la base de datos.

# Author: Daniel Garcia <dani@danigm.net>
# License: GPLv3
 
from sqlobject import *
import os
 
class Tracker(SQLObject):
    project = StringCol()
    task = StringCol()
    ticket = IntCol()
    start = DateTimeCol()
    end = DateTimeCol()
 
def get_hub():
    connection_string = 'sqlite://%s/devdata.sqlite' % os.getcwd()
    connection = connectionForURI(connection_string)
    sqlhub.processConnection = connection
 
    return sqlhub
 
def create_db():
    # You need to create the database before.
    sqlhub = get_hub()
 
    Tracker.createTable()

ttt.py Toda la chicha

#!/usr/bin/python
 
# Author: Daniel Garcia <dani@danigm.net>
# License: GPLv3
 
import datetime
import time
import sys
import tttdb as db
from tttdb import Tracker
 
sqlhub = db.get_hub()
 
def parse_time(time_seconds):
    hour = 0
    min = 0
    sec = time_seconds
    while sec >= 60:
        min += 1
        sec -= 60
    while min >= 60:
        hour += 1
        min -= 60
    time_str = '%02d:%02d:%02d' % (hour, min, sec)
    return time_str
 
def track(task, project='', ticket=0):
    today = datetime.datetime.now()
    tick = time.time()
    time_pass = 0
    try:
        while True:
            tick2 = time.time()
            time_pass = tick2 - tick
            cadena = '\rtracking: %(task)s %(project)s %(ticket)s %(time)s' % \
                {'time':parse_time(time_pass),
                 'task':task,
                 'project':project,
                 'ticket':ticket}
            sys.stdout.write(cadena)
            sys.stdout.flush()
            time.sleep(0.5)
    except:
        print '\n', 'Finalizando'
        end = datetime.datetime.now()
        db.Tracker(project=project,
                task=task,
                ticket=ticket,
                start=today,
                end=end)
 
def show(trackers):
    grouped = {}
    total = 0
    prev = ''
    for i in trackers:
        diff = i.end - i.start
        total += diff.seconds
        time_passed = parse_time(diff.seconds)
 
        key = (i.task, i.project)
        if grouped.has_key(key):
            grouped[key] += diff.seconds
 
        else:
            grouped[key] = diff.seconds
 
        to_show = '%s | %-20s | %-40s | #%-6d | %s'
        to_show = to_show % (i.start.ctime(), i.project, i.task, i.ticket, time_passed)
        if prev != to_show[0:3]:
            prev = to_show[0:3]
            print ''
        print to_show
 
    print ''
    for k,v in grouped.items():
        task, project = k
        time_passed = parse_time(v)
        print 'Tiempo para %-40s %s' % ('"'+task+'":', time_passed)
 
    print '\nTotal: %s' % parse_time(total)
 
def show_today(delta=0):
    today = datetime.datetime.now() - datetime.timedelta(delta)
    yesterday = datetime.datetime(today.year, today.month, today.day)
    today_trackers = Tracker.select(Tracker.q.start > yesterday)
    show(today_trackers)
 
def show_project(project):
    project_trackers = Tracker.select(Tracker.q.project == project)
    sum = 0
    for i in project_trackers:
        sum += (i.end - i.start).seconds
 
    print 'Tiempo para "%s": %s' % (project, parse_time(sum))
 
def show_all():
    all = Tracker.select()
    show(all)
 
def show_week():
    show_today(6)
 
def show_week_grouped():
    show_today_grouped(6)
 
def show_today_grouped(delta=0):
    today = datetime.datetime.now() - datetime.timedelta(delta)
    yesterday = datetime.datetime(today.year, today.month, today.day)
    today_trackers = Tracker.select(Tracker.q.start > yesterday)
    show_grouped(today_trackers)
 
def show_grouped(trackers):
    projects = {}
    total = 0
    for i in trackers:
        diff = (i.end - i.start).seconds
        total += diff
        if projects.has_key(i.project):
            projects[i.project] += diff
        else:
            projects[i.project] = diff
 
    print ''
    for k,v in projects.items():
        p = '"' + k + '":'
        print 'Tiempo para %-20s %s' % (p, parse_time(v))
 
    print '\nTotal: %s' % parse_time(total)
 
if __name__ == '__main__':
    help = '''
    %s tarea [proyecto] [ticket]
    '''
 
    task, project, ticket = '','',0
    args = sys.argv[1:]
    if ('-h' in args) or ('--help' in args) or (len(args) == 0):
        print help % sys.argv[0]
        sys.exit()
    if len(args) >= 1:
        task = args[0]
    if len(args) >= 2:
        project = args[1]
    if len(args) >= 3:
        ticket = int(args[2])
 
    track(task, project, ticket)

show.py Para ver el registro

#!/usr/bin/python
 
# Author: Daniel Garcia <dani@danigm.net>
# License: GPLv3
 
import sys
import ttt
 
if __name__ == '__main__':
    help = '''
    %s [opcion]
 
    opciones:
     -g muestra agrupados por proyecto
     -w muestra la ultima semana
     -gw muestra la ultima semana agrupado por proyecto
     -a muestra todo
 
     si no se especifica opcion muestra las tareas de hoy
    '''
    args = sys.argv[1:]
    if ('-h' in args) or ('--help' in args):
        print help % sys.argv[0]
 
    elif '-g' in args:
        # show grouped by project
        ttt.show_today_grouped()
    elif '-w' in args:
        ttt.show_week()
    elif '-gw' in args:
        # show grouped by project
        ttt.show_week_grouped()
    elif '-a' in args:
        ttt.show_all()
    else:
        ttt.show_today()

El código se puede pillar de mi repositorio personal:

  bzr branch http://repo.danigm.net/ttt

O del fichero tar.gz que adjunto aquí.

Para usarlo, tienes que tener instalado sqlobject y se instalaría ejecutando el script install.sh (hace una llamada a un comando con sudo). Esto te crea un directorio en $HOME/.ttt donde mete la base de datos y los scripts en python, y además copia t3 y t3show a /usr/local/bin para que puedas ejecutar los comandos sin modificar tu path.

Se usa de la siguiente manera:

  t3 "Escribiendo un post"

Y en la terminal se muestra el tiempo que vas dedicando a esta tarea. Para terminar tan solo hay que pulsar ctrl+c.
Además de una tarea se puede especificar un proyecto y un número para referenciarlo en el sistema de tickets que uses.

sintaxis:
  t3 tarea [proyecto] [ticket]
  t3 -h
ejemplo:
  t3 "plugin para jisko" "sweetter" 235879

Y para mostrar el resultado se usa t3show

Wed Sep 24 20:34:01 2008 | ttt                  | publicando                               | #0      | 00:00:06
Wed Sep 24 20:34:04 2008 | sweetter             | plugin para jisko                        | #235879 | 00:00:08
Wed Sep 24 20:34:18 2008 | ttt                  | publicando                               | #0      | 00:00:05

Tiempo para "plugin para jisko":                     00:00:08
Tiempo para "publicando":                            00:00:11

Total: