Blogs

He hecho un pequeño diagrama de la arquitectura de GECO:

Pulsa sobre la imágen para verlo más grande :P

Intro

GECO pretende ser un gestor de contraseñas y ficheros de configuración distribuido con diferentes interfaces de comunicación con el usuario. Presentanto tanto una interfaz de escritorio en GTK como una interfaz web desarrollada con python y cherrypy.

GeCo es un proyecto presentado a la tercera edición del Concurso Universitario de Software Libre y nace de la necesidad de tener contraseñas aleatorias y diferentes para cada servicio web (o no) en el cual estás registrado.

Problema

Hoy en día la mayoría de la gente que navega con regularidad tiene multitud de cuentas creadas en diferentes páginas webs, estas cuentas, normalmente, están basadas en usuario y contraseña. Las contraseñas se almacenan de diferentes formas en las bases de datos de los diferentes servicios, de tal forma que no podemos saber si el administrado o un intruso puede llegar a ver nuestra contraseña.

Por tanto es realmente importante hoy en día utilizar claves diferentes (y aleatorias) para cada aplicación, pero memorizar 5,10,20 claves seguras es realmente complicado y para esto están los gestores de contraseñas.

Puesto que el uso de gestores de contraseñas implica que no recuerdes tus contraseñas estás perdiendo la movilidad y la libertad de usar diferentes máquinas en las cuales no tengas instalado tu gestor de contraseñas con tu base de datos de contraseñas.

Además en el caso de rotura de tu disco duro puedes llegar a perder la base de datos de tu gestor de contraseñas perdiendo así para siempre muchas contraseñas que no podrás recuperar.

Solución

GeCo pretende dar solución a los problemas que presentan los gestores de contraseñas de escritorio dando un paso más allá y prestando un servicio de almacenamiento y gestión de contraseñas distribuido (o centralizado) con diferentes interfaces de administración (línea de comandos, escritorio, web, móvil, etc).

No voy a poner TODAS mis contraseñas en ningún servidor
Por supuesto la seguridad y privacidad es uno de los objetivos de este proyecto, por tanto toda información que salga del cliente irá cifrada con una clave maestra, y por tanto en el servidor no se almacenará información recuperable sin esta contraseña.

Arquitectura

GeCo implementará una arquitectura clásica cliente-servidor, de tal forma que habrá un servidor GeCo al cual se podrán conectar clientes GeCo, para administrar contraseñas, y también otros servidores GeCo para sincronizar datos.

De esta forma un usuario puede tener su servidor GeCo en su máquina y utilizarlo normalmente como un gestor de contraseñas normal, pero además puede sincronizar su servidor con otro sevidor en una máquina remota, de tal forma que si el usuario se mueve pueda tirar de la interfaz web del servidor de la máquina remota para administrar sus contraseñas.

¿Algo más?

Además de todo esto GeCo ofrecerá la posibilidad de almacenar ficheros de configuración (todo cifrado), de tal forma que en un linux con un cliente GeCo puedas utilizar tu fichero de configuración de Pidgin sólo durante la sesión y posteriormente se eliminaría todo rastro de tus ficheros de configuración y el sistema quedaría tal y como estaba.

Licencia y otras polladas legales

Todo lo que se desarrolle será bajo licencia GPLv3 y todo el artwork y documentación será totalmente libre con la licencia "úsalo cómo quieras y para lo que quieras".

La idea de este proyecto es hacerme un gestor de contraseñas para mí, y si le sirve a otra persona pues mejor. Además quiero hacerlo de forma didactica para que a partir de este proyecto salgan diferentes manuales y charlas sobre python y desarrollo.

• Proyecto en la forja

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: 00:00:19

Con las opciones -g -w -gw -a que muestran agrupado por proyecto, la última semana, por proyecto en la última semana y todo respectivamente. Además de mostrar el día actual si no se le pasa ningún parametro y la ayuda con el comando -h.

Para el que no lo sepa, soy el principal desarrollador de sweetter, que es un sistema de microbloggin al estilo de twitter pero mejor. No voy a entrar en detalles técnicos ahora que no es el tema.

El caso es que no se por qué razón (bueno sí, por su calidad, estabilidad y usabilidad) llegó a salir en el periódico "El País", en un artículo en el cual se decía poco sobre sweetter, siendo destacado por ser el servicio más geek.

Ahora a aparecido otra vez en el mismo periódico y aquí unas fotos que lo demuestran:

Pero esto no es nada comparado con lo próximo, que vendrá cuando sweetter de el gran salto y empiece a utilizarse en la empresa como herramienta interna para coordinación y otras cosas. Ya se están moviendo los hilos necesarios para motivar este camino hacia la dominación mundial.

El último libro que me he leido se llama "los propios dioses" y tras leerlo me ha venido a la mente un tema sobre el que tratan en el libro y que se puede aplicar al calentamiento global y lo que hacemos hoy en día con nuestro planeta.

[spoiler del libro, si te lo vas a leer lo mismo esto te molesta]

En el libro se relata la historia de un futuro en el cual se ha conseguido una máquina que genera energía sin coste alguno aparente. Pero un científico se da cuenta de que esta máquina está cambiando las reglas físicas de nuestro universo y por tanto lo está llevando a una destrucción inmediata.

Este científico "demuestra" que la "bomba de electrones" puede hacer que el sol explote en un plazo de tiempo corto, pero la gente está tan acomodada a la energía "gratis" que sus demostraciones son criticadas y puestas en duda.

Más tarde, otro científico, desde la Luna, retoma la investigación del anterior, pero se da cuenta de una cosa, no se puede convencer a la gente de que la "bomba de electrones" es mala y esperar que dejen de usarla, hay que ofrecerle una alternativa mejor y entonces todo el mundo aceptará el cambio.

Pues bien, comparando con lo que estamos viviendo hoy en día podemos darnos cuenta de que hay mucha gente intentando luchar contra todo lo que provoca el calentamiento global y estas cosas, pero nadie ha propuesto una alternativa mejor que permita reemplazar las energías actuales.

Esto me ha llevado a pensar que nos iremos autodestruyendo viviendo en la comodidad hasta que algún génio descubra algo que cambie todo nuestro sistema energético y entonces seguiremos viviendo en la comodidad, pero respetando algo más el entorno. Mientras tanto creo que no se puede esperar que nadie esté dispuesto a abandonar la comodidad a la que hemos llegado hoy en día, y se seguirá negando la posibilidad de que acabemos con el planeta, porque siempre es más fácil creer lo que se quiere creer y tachar de mentirosos o refutar de alguna forma a los que traten de arrebatarnos la comodidad.

Si es así como están las cosas es posible que nadie consiga algo realmente revolucionario que nos haga cambiar sin pensarlo, y acabemos autodestruyendonos por no haber sabido renunciar a una comodidad no merecida.

Asimov fue todo un visionario de comportamiento de masas

¿Qué es un "sistema de control de versiones" (vcs)? Pues es una herramienta que utilizan normalmente los programadores para versionar los cambios realizados sobre el código fuente y trabajar en equipo.

Básicamente funciona así:
Tú tienes una serie de ficheros en tu ordenador, modificas, añades, o haces algo, y haces "commit". Sigues trabajando tan normal y cada vez que te parezca que haces un cambio importante haces "commit". Con esto tienes varias ventajas, lo más importante es que puedes volver cualquier fichero a una revisión anterior. También puedes ver un log de los cambios realizados y otras operaciones.

¿Entonces qué tenemos? pues podemos modificar los ficheros sin miedo porque después de romper algo siempre se puede volver a una versión anterior.

Aparte de eso, los vcs, ofrecen una forma fácil de colaboración entre varias personas. Estos repositorios se pueden publicar, otras personas pueden descargarselos y actualizar su repositorio, e incluso subir cambios que se mezclarán con los tuyos de manera automática.

No lo he explicado muy bien, pero estos sistemas ofrecen la posibilidad de que varias personas trabajen modificando un mismo fichero y que con un par de comandos tengan la versión unificada sin necesidad de enviarse ficheros ni parches ni nada.

BZR

Pues bien, bazaar es un vcs distribuido, fácil de usar y multiplataforma (está en python).

Que sea distribuido quiere decir que cada usuario tendrá su repositorio local en el cual hace los commits, a diferencia de subversion que es centralizado, todos los commits se hacen sobre un repositorio central.

Pero aún siendo distribuido bzr ofrece la posibilidad de utilizarse de manera centralizada, prácticamente igual que svn.

Vamos a lo práctico:

• Crear un repositorio: crear el repositorio es tan fácil como ejecutar "bzr init" dentro del directorio
  
  
  
• Añadir/mover/etc ficheros: para añadir/mover/etc es tan fácil como "bzr add fichero" o "bzr mv fichero1 fichero2" y más comandos similares a los comandos unix.
  
  
  
• Hacer commits: para guardar los cambios en una revisión se utiliza el comando "bzr commit" o "bzr ci" y te abrirá tu editor favorito para que escribas lo que ha cambiado para el log.
  
  
  
• Ver el log: para ver el log "bzr log"
  
  
  
• Volver a una revisión anterior: "bzr revert -r2 fichero fichero2" esto devuelve la lista de ficheros a la revisión 2, si quieres volver completamente deberías usarlo sin los nombres de ficheros.
  
  
  
• Publicar un repositorio (ssh): "bzr push ssh://usuario@dominio/ruta". Esto modificará el repositorio en el dominio/ruta, o lo creará si no existe. Antes de hacer un push hay que hacer un commit de los cambios realizados.
  
  
  
• Descargar un repositorio: "bzr branch ruta destino". Donde ruta puede ser la ruta anterior, si vamos por ssh, y destino es la carpeta que creará para alojar el repositorio.
  
  
  
• Actualizar un repositorio: Una vez que tengamos el repositorio descargado con branch podemos actualizarlo a la última versión con "bzr pull" desde dentro del directorio del repositorio.
  
  
  
• Utilizar cómo subversion: Para poder utilizarlo de modo centralizado hay que utilizar el comando "bzr bind ruta" desde dentro del directorio. Una vez hecho esto se puede actualizar con "bzr update", y desde este momento cada commit no será local, sino que también se hará sobre el servidor.
  
  
  
• Y un montón de cosas más, para más información man bzr
  
  
  

Otra cosa chachi que tiene bzr es que es el sistema utilizado por defecto en launchpad, dónde puedes crear todas las ramas que quieres para tener tu código en un servidor. Algún proyecto tengo yo por ahí.

Y para finalizar decir que no sólo se utiliza para código, yo por ejemplo lo he utilizado para versionar la documentación de mi proyecto fin de carrera.

Viajando en estos aviones de hoy en día no se puede ni dormir, con lo apretado que se va, así que me dediqué en mi viaje a dibujar, y este es el resultado.

Hay que ver lo bonito y práctico que puede quedar un escritorio con esto de gnome+emerald+compiz+awn.

Los temas que tengo:

- gtk2 -> Aurora green peace
- emerald -> lucidity
- screenlets -> ringsensors
- avant-window-navigator es la barra tipo dock parecido a la de macosx