path: root/RecolectarDatos.activity/pippy_app.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
# Copyright (c) 2010 - Sebastian Silva <sebastian@somosazucar.org>
# Equipo de desarrollo de Sugar Labs Global.

from sugar.datastore import datastore
from sugar import profile 
import sys,csv,os,gtk,shutil
from time import localtime, strftime, time, ctime, altzone
from subprocess import Popen,PIPE,STDOUT
try:
    from sqlite3 import dbapi2 as sqlite
except:
    try: 
        from pysqlite2 import dbapi2 as sqlite
    except:
        print "Advertencia: Imposible encontrar bilbiotecas pysqlite."

version = "13"

######################################################
# Aquí intentamos determinar la versión de Sugar
# el atributo "config.version" contendrá la versión
try:
    # Ubicación estándar (Sugar 0.84+)
    from jarabe import config
    got_config = True
except:
    got_config = False 

if not got_config:
    try:
        # OLPC XO build 802
        sys.path.insert(0, '/usr/share/sugar/shell')
        import config
    except:
        # Builds viejos no tienen este dato (703)
        class dummy_configuration:
            def __init__(self):
                self.version = "n/d"
        config = dummy_configuration()
#######################################################

def wait(time_lapse):
    """ Implementa un "sleep timer" compatible con GTK """
    time_start = time()
    time_end = (time_start + time_lapse)
 
    while time_end > time():
        while gtk.events_pending():
            gtk.main_iteration()

def execute_cmd(cmd):
    """ Ejecuta un comando de la terminal y retorna el 
    output del comando.
    """
    p = Popen(cmd, shell=True, bufsize=0,
              stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
    (child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout)
    
    return child_stdout_and_stderr.read()

def responseToDialog(entry, dialog, response):
    dialog.response(response)
def getText(markup, markup2=""):
    """ 
    Presenta un diálogo que pregunta algo al usuario.
    Retorna lo que el usuario ingresó.
    """
    dialog = gtk.MessageDialog(
        None,
        gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
        gtk.MESSAGE_QUESTION,
        gtk.BUTTONS_OK,
        None)
    dialog.set_markup(markup)
    entry = gtk.Entry()
    #allow the user to press enter to do ok
    entry.connect("activate", responseToDialog, dialog, gtk.RESPONSE_OK)
    #create a horizontal box to pack the entry and a label
    hbox = gtk.HBox()
    hbox.pack_start(gtk.Label("Name:"), False, 5, 5)
    hbox.pack_end(entry)
    #some secondary text
    dialog.format_secondary_markup(markup2)
    #add it and show it
    dialog.vbox.pack_end(hbox, True, True, 0)
    dialog.show_all()
    #go go go
    dialog.run()
    text = entry.get_text()
    dialog.destroy()
    return text

def load_journal_table():
    """
    Carga la metadata del Diario de Sugar
    Retorna una lista de objetos de datastore
    """
    ds_mounts = datastore.mounts()
    mountpoint_id = None
    if len(ds_mounts) == 1 and ds_mounts[0]['id'] == 1:
        query = { 'sorting':'timestamp' }
    else:
        # we're in sugar 0.82
        query = { 'order_by':'-timestamp' }
        for mountpoint in ds_mounts:
            id = mountpoint['id']
            uri = mountpoint['uri']
            if uri.startswith('/home'):
                mountpoint_id = id

    if mountpoint_id is not None:
        query['mountpoints'] = [ mountpoint_id ]

    ds_objects, num_objects = datastore.find(
        query, properties=['title_set_by_user','activity',
            'title', 'mime_type', 'mtime', 'share-scope','uid',
            'keep', 'tags', 'description'])

    print "Listo! Ingrese los datos que se piden a continuación."
    return ds_objects

def get_media_mountpoint():
    """
    Retorna la URI del primer
    dispositivo USB que encontremos
    """
    ds_mounts = datastore.mounts()
    mountpoint_id = None
    if len(ds_mounts) == 1 and ds_mounts[0]['id'] == 1:
        from gio import VolumeMonitor
        vm = VolumeMonitor()
        mounts = vm.get_mounts()
        for mountpoint in mounts:
            uri = mountpoint.get_root().get_path()
            if uri.startswith('/media'):
                return(uri+"/"), False
        return "", False
    else:
        # we're in sugar 0.82
        for mountpoint in ds_mounts:
            id = mountpoint['id']
            uri = mountpoint['uri']
            if uri.startswith('/media'):
                return(uri+"/"), id
        return "", True 

def _read_file(path):
    """
    Esta función lee y retorna el contenido
    de archivos de texto
    """
    if os.access(path, os.R_OK) == 0:
        return "n/d" 

    fd = open(path, 'r')
    value = fd.read()
    fd.close()
    if value:
        value = value.strip('\n')
        return value
    else:
        print "Error leyendo "+path
        return None

class Data_general:
    """
    Obtenemos y almacenamos datos para registrar
    """
    def __init__(self):
        self.retrieved = False
        self.events = {}

    def abrir_csv(self, file_suffix = ""):
        """
        Crea un archivo CSV en el USB (si se encuentra)
        retorna el objeto CSV para continuar la escritura.
        Guarda en atributos del objeto los parametros
        para no consultarlos nuevamente.
        """
        if not self.retrieved:
            self.retrieved = True
            # Preparamos el encabezado
            self.nick = profile.get_nick_name()
            self.serial_no = _read_file('/ofw/serial-number')
            self.build_no = str(_read_file('/boot/olpc_build'))
            self.firmware_no = _read_file('/ofw/openprom/model')
            self.sugar_no = config.version
            self.escuela = str(getText("Porfavor indique el código modular de la IE"))
            while len(self.escuela) != 7:
                self.escuela = str(getText("Porfavor indique el <b>código modular</b> de IE",
                                        "El código debe ser de 7 dígitos. Intente nuevamente."))
            self.alumno = str(getText("Porfavor ingrese el código de alumno"))
            while len(self.alumno) != 3:
                self.alumno = str(getText("Porfavor indique el <b>código de alumno</b>",
                                        "El código debe ser de 3 dígitos. Intente nuevamente."))
            self.fecha = strftime("%Y-%m-%d %H:%M:%S", localtime())
            self.fecha_encuestador = str(getText("Porfavor indique la fecha de HOY (en formato DD/MM/AAAA)"))
            self.hora_encuestador= str(getText("Porfavor indique la hora ACTUAL (en formato HH:MM AM/PM)"))
      
        self.media, self.mount_id = get_media_mountpoint()
        if self.media=="":
            self.usb_media = False 
            print "ADVERTENCIA: No se encontró una unidad USB!"
            try:
                self.media=os.environ['SUGAR_ACTIVITY_ROOT']+"/data/"
            except:
                pass
        else:
            self.usb_media = True

        filename = os.path.join(self.media, self.escuela+"_"+self.alumno+file_suffix+".csv")
        if os.path.exists(filename):
            filename = os.path.join(self.media, self.escuela+"_"+self.alumno+file_suffix+"-re.csv")
        fd = open(filename,"wb")
        writer = csv.writer(fd, dialect='excel')

        writer.writerow(['Usuario:', self.nick])
        writer.writerow(['Azucar:', self.sugar_no])
        writer.writerow(['Serie:', self.serial_no])
        writer.writerow(['Ensamble:', self.build_no])
        writer.writerow(['Firmware:', self.firmware_no])
        writer.writerow(['Escuela:', self.escuela])
        writer.writerow(['Alumno:', self.alumno])
        writer.writerow(['Fecha interna:', self.fecha])
        writer.writerow(['Fecha medicion:', self.fecha_encuestador])
        writer.writerow(['Hora medicion:', self.hora_encuestador])
        writer.writerow([])

        return writer, filename, fd

    def write_csv_diario(self, objetos):
        """
        Interroga al usuario
        carga datos de la máquina XO / Sugar
        guarda en un archivo CSV la info del diario.
        """
        writer, filename, fd = self.abrir_csv("-diario")

        # Ordenamos los atributos
        propiedades = {'activity': 'ACTIVIDAD',
                'title_set_by_user': 'TITULADO POR USUARIO',
                'title': 'TITULO',
                'mime_type': 'TIPO',
                'mtime': 'FECHA',
                'share-scope': 'COMPARTIDO',
                'keep': 'FAVORITO',
                'tags': 'ETIQUETAS',
                'description': 'DESCRIPCION'}
        props = propiedades.keys()
        props.sort()
        row=[]
        for p in props:
            row.append(propiedades[p])
        writer.writerow(row)

        for obj in objetos:
            metadata = obj.metadata.get_dictionary()
            row = []
            for p in props:
                try:
                    row.append(metadata[p])
                except:
                    row.append("")
            writer.writerow(row)
            obj.destroy()
            
        fd.close()
        print "Archivo creado en "+filename

    def try_to_unmount(self):
        if self.usb_media:
            activity_bundle_file = self.media+"RecolectarDatos-"+version+".xo"
            if os.path.exists(activity_bundle_file):
                execute_cmd('touch '+activity_bundle_file)
                print "Se actualizó la fecha de " + activity_bundle_file
            execute_cmd('sync')                
            try:
                if self.mount_id!=False:
                    datastore.unmount(self.mount_id)
                    output = execute_cmd('umount ' + self.media[:-1])
                    if len(output)>1:
                        datastore.mount(self.media, "")
                        raise NameError('Imposible desmontar')
                else:
                    from gio import VolumeMonitor
                    vm = VolumeMonitor()
                    mounts = vm.get_mounts()
                    for mountpoint in mounts:
                        uri = mountpoint.get_root().get_path()
                        if uri.startswith('/media'):
                            result = mountpoint.unmount(lambda x,y: None)
                wait(3)
                print "Se ha desmontado automaticamente la memoria USB."
            except:
                print "No olvide desmontar la memoria USB desde el Diario!"

    def event(self, hora, texto):
        try:
            if self.events[hora]:
                self.events[hora+1] = [ctime(hora), texto ]
        except KeyError:
            self.events[hora] = [ctime(hora), texto ]

    def collect_logs(self):
        """
        guarda en un archivo CSV la info de los logs de de los historiales.
        """
        log_dir = os.environ['HOME']+"/.sugar/default/logs"
        if not os.path.exists(log_dir):
            log_dir = "/home/olpc/.sugar/default/logs"        
        if not os.path.exists(log_dir):
            return None
        
        # Navegar recursivamente los directorios de logs
        stack = [log_dir]
        mtime = 0
        while stack:
            directory = stack.pop()
            for base in os.listdir(directory):
                name = os.path.join(directory, base)
                if os.path.isdir(name):
                    if not os.path.islink(name):
                        stack.append(name)
                else:
                    mtime = os.path.getmtime(name)
                    # creation_time = os.path.getctime(name)
                    # nota: creation time no es correcto pq los logs han sido movidos a subcarpetas
                    this_dir = os.path.split(os.path.dirname(name))[1]
                    if this_dir == "logs":
                        this_dir = ""
                        continue
                    if base == "shellservice.log":
                        self.event(mtime, "LOG: *** Se inició nueva sesión de Sugar." )
                    elif base == "shell.log":
                        pass
                    elif base == "presenceservice.log":
                        pass
                    elif base == "datastore.log":
                        pass
                    else:
                        self.event(mtime, "LOG: Ultima actividad en log de " + base[:-4])

        # Ahora vamos a iterar por todos los historiales de Navegador / Wikipedia
        isolation_dir = "/home/olpc/isolation/1/gid_to_data_dir"
        if not os.path.exists(isolation_dir):
            print "Imposible encontrar directorio isolation."
            return None
        stack = [isolation_dir]
        while stack:
            directory = stack.pop()
            try:
                subdirs = os.listdir(directory)
            except:
                subdirs = []
            for base in subdirs: 
                name = os.path.join(directory, base)
                if os.path.isdir(name):
                    if not os.path.islink(name):
                        stack.append(name)
                else:
                    if base == "places.sqlite":
                        shutil.copy (name, "/tmp")
                        tmpname = os.path.join("/tmp", base)
                        con = sqlite.connect(tmpname)
                        cur = con.cursor()
                        results = cur.execute ("select visit_date, url from moz_historyvisits,moz_places where place_id == moz_places.id")
                        for r in results:
                            item_timestamp = float(str(r[0])[:10]) 
                            if r[1][:27] == 'http://localhost:8000/wiki/':
                                self.event(item_timestamp, "WEB: Articulo Wikipedia: " + r[1][27:])
                            elif r[1][:31] == 'http://localhost:8000/search?q=':
                                self.event(item_timestamp, "WEB: Búsqueda en Wikipedia: " + r[1][31:])
                            elif r[1][:29] == 'http://localhost:8000/static/':
                                self.event(item_timestamp, "WEB: Índice de Wikipedia.")
                            else:
                                self.event(item_timestamp, "WEB: Navega a: " + r[1])
                        con.close()
                        os.unlink(tmpname)

        # Vamos a mirar por redes conocidas
        nm_file = '/home/olpc/.sugar/default/nm/networks.cfg'
        if not os.path.exists(nm_file):
            print "Imposible encontrar info de Network Manager."
        else:
            try:
                contents = _read_file(nm_file)
                for line in contents.splitlines():
                    if line[:1]=='[':
                        net = line[1:-1]
                    elif line[:9]=='timestamp':
                        timestamp = float(line[12:])
                        self.event(timestamp, "RED: Se ha asociado a la red WIFI " + net)
            except:
                print "Advertencia: Imposible leer info de Network Manager."

        
        return True

    def write_csv_logs(self):
        if self.collect_logs():
            # Finalmente escupimos todo
            writer, filename, fd = self.abrir_csv("-historial")
            for ev in sorted(self.events):
                writer.writerow(self.events[ev])
            
            fd.close()
            print "Archivo creado en "+filename
            return True
        else:
            print "Ejecutando como actividad."
            return False

    def install_logger(self):
        #copiamos el ejecutable
        logdir =  "/home/olpc/.logger"

        if not os.path.exists(logdir):
            execute_cmd("mkdir -p "+logdir)
        
        logprog = os.path.join(logdir, "logger.py")
        shutil.copy (sys.argv[0], logprog)

        #lo hacemos autoiniciar
        already_installed = False
        xsession = "/home/olpc/.xsession"
        if os.path.exists(xsession):
            contents = _read_file(xsession)
            for line in contents.splitlines():
                if line == "python /home/olpc/.logger/logger.py &":
                    already_installed = True

        if not already_installed:
            execute_cmd("echo 'python /home/olpc/.logger/logger.py &' >> " + xsession)

    def update_logger(self):
        if self.collect_logs():
            logdir =  "/home/olpc/.logger"
            logfile = "historial.csv"

            logpath = os.path.join(logdir, logfile)

            if not os.path.exists(logpath):
                execute_cmd("mkdir -p "+logdir)
                mtime = 0
            else:
                lastlog = execute_cmd("tail -n1 "+logpath)
                lastlog = lastlog.strip('\n')
                try:
                    mtime = float(lastlog[-11:-1])
                except:
                    mtime = 0

                size = os.path.getsize(logpath)
                # poor mans logrotate
                if size>262144: #limit 256k
                    if os.path.exists(logpath+"-3"):
                        execute_cmd("mv "+logpath+"-3 "+logpath+"-4")
                    if os.path.exists(logpath+"-2"):
                        execute_cmd("mv "+logpath+"-2 "+logpath+"-3")
                    if os.path.exists(logpath+"-1"):
                        execute_cmd("mv "+logpath+"-1 "+logpath+"-2")
                    execute_cmd("mv "+logpath+" "+logpath+"-1")

            s = os.statvfs(logdir)
            free_disk_in_mb = (s.f_bsize * s.f_bavail)/(1024*1024)

            if free_disk_in_mb > 30:
                fd = open(logpath,"a")
                writer = csv.writer(fd, dialect='excel')
                for ev in sorted(self.events):
                    if ev > mtime:
                        writer.writerow(self.events[ev])
                        #print self.events[ev]
                writer.writerow([ctime(time()), "LOGGER: Se actualizó registro de seguimiento *** " + str(int(time()))])
                #print ctime() + " updated " + str(int(time()))
                #print ctime(mtime) + " :last log " + str(int(mtime))
                fd.close()
        else:
            print "Imposible cargar logs."
        

# Aquí comienza la ejecución
if os.path.split(sys.argv[0])[-1:][0]=='logger.py':
    # Somos el sistema de seguimiento
    dg = Data_general()
    wait(30)
    dg.update_logger()
elif os.path.split(sys.argv[0])[-1:][0]=='instalar.py':
    print "Instalador."
    dg = Data_general()
    dg.install_logger()
    dg.update_logger()
    print "Se ha instalado el programa de seguimiento."
elif os.path.split(sys.argv[0])[-1:][0]=='monitor.py':
    # Somos el instalador-recolector
    print """Progama Recolectar Datos. 
Copyright (c) 2010 - Sebastian Silva <sebastian@somosazucar.org>
Miembro de Equipo Sugar Labs Global.
--
Inicio: Cargando los datos de los registros, la navegación y diario ahora! Porfavor espere...
"""
    diario = load_journal_table()
    dg = Data_general()
    dg.write_csv_diario(diario)
    message = gtk.MessageDialog(None, gtk.DIALOG_MODAL, gtk.MESSAGE_QUESTION, gtk.BUTTONS_NONE, u"¿Desea instalar Ud. la aplicacion de seguimiento de uso de la Laptop XO?")
    message.add_button('SI', gtk.RESPONSE_YES)
    message.add_button('No gracias', gtk.RESPONSE_NO)
    resp = message.run()
    if resp == gtk.RESPONSE_YES:
        dg.install_logger()
        dg.update_logger()
    else:
        print "Advertencia: NO se ha instalado el programa de seguimiento!"
    if dg.write_csv_logs():
        dg.try_to_unmount()
    md = gtk.MessageDialog(None, 
        gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_INFO, 
            gtk.BUTTONS_CLOSE, 'Ha ejecutado correctamente el programa python.\nQue tenga un buen día. :-)')
    md.run()
    md.destroy()
    print 'Ha ejecutado correctamente el programa python.\nQue tenga un buen día. :-)'
else:
    # Vamos a recolectar datos pero somos la actividad
    print """Actividad Recolectar Datos. 
Copyright (c) 2010 - Sebastian Silva <sebastian@somosazucar.org>
Miembro de Equipo Sugar Labs Global.
--
Inicio: Cargando los datos del Diario ahora! Porfavor espere...
"""
    diario = load_journal_table()
    dg = Data_general()
    dg.write_csv_diario(diario)
    md = gtk.MessageDialog(None, 
        gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_INFO, 
            gtk.BUTTONS_CLOSE, 'Ha ejecutado correctamente Recolectar Datos.\nNo olvide ejecutar ahora el comando de python.')
    md.run()
    md.destroy()
    print 'Ha ejecutado correctamente Recolectar Datos.\nNo olvide ejecutar ahora el comando de python.'