#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Monitora se i computer dell'aula studenti sono accesi
# e restituisce delle statistiche a proposito.
#
#
#
#
#                 INIZIO DELLA CONFIGURAZIONE
#
# Questa cartella è dove verranno salvati i dati relativi ai client
# Deve esistere nel momento in cui lo script è lanciato per la prima
# volta e dovrebbe essere vuota. Serve lo slash alla fine, ad esempio:
#
# database_directory = '/home/pippo/phcstats/'
database_directory = '/home/robol/client_stats/'
 
# max_time controlla il massimo numero di secondi di cui possono
# essere "vecchie" le informazioni conservate dallo script.
max_time = 86400 * 30  # ~ 1 mese
 
# Questo è il gruppo di dsh da cui rilevare le informazioni sui client
# da monitorare. In realtà può essere un qualsiasi file di testo con
# il nome di un client su ogni riga. Sono accettati commenti nelle linee
# che cominciano con '#'
group = '/etc/dsh/group/all'
 
# Questa variabile imposta se lo script deve essere verboso, ma in
# realtà è attualmente ignorata. Il comportamento è gestito solo
# dal parametro -v o --verbose a linea di comando.
verbose = False
 
##                   FINE DELLA CONFIGURAZIONE
 
 
##                   INIZIO DEL CODICE
 
import subprocess, time, os, matplotlib
matplotlib.use ('Agg')
import numpy as np, pylab
from optparse import OptionParser
 
 
def Verbose(string):
    if verbose:
        print "\033[32;1m>\033[0m " + string
 
def LoadClients():
    """
    Ritorna una lista con tutti i client all'interno del
    gruppo group di dsh. Il default è 'all'
    """
    global group
    clients = []
    try:
        for client in open(group, 'r'):
            client = client.strip()
            if client.strip != '' and client[0] != '#':
                clients.append (client)
    except IOError:
        raise IOError('Il gruppo dsh \'%s\' non esiste, nessun client trovato!' %
                      group)
    Verbose ("Client list loaded from %s" % group)
    for client in clients:
        Verbose("Client: %s" % client)
    return clients
 
def IsAlive(client):
    """
    Ritorna True se il client è acceso e risponde ai ping
    """
    alive = subprocess.call(["fping", client], stdout = subprocess.PIPE,
                            stderr = subprocess.PIPE)
    return (alive == 0)
 
def IsLastAlive(client):
    """
    Ritorna True se il client era acceso durante l'ultimo check
    effettuato.
    """
    data = LoadClientData(client)
    data = data.items()
    data.sort()
    return data[-1:][0][1]
 
def LockDatabase():
    """
    Effettua il lock del database
    """
    lockfile = database_directory + ".lock"
    counter = 0
    while (os.path.exists(lockfile)):
        time.sleep(1000)
        counter +=1
        if (counter > 30):
            raise RuntimeError('Impossible to unlock database')
    f = open(lockfile, 'w')
    f.write(str(time.time()))
    f.close()
 
def UnlockDatabase():
    """
    Sblocca il database
    """
    lockfile = database_directory + ".lock"
    os.remove(lockfile)
 
def LoadClientData(client):
    """
    Carica i dati relativi a quel determinato client. Questi
    sono nella forma di un dizionario con gli oggetti time e
    Valori True o False
    """
 
    data = {}
    try:
        f = open(database_directory + client, 'r')
    except IOError:
        return data
    for line in f:
        if ":" in line:
            (time, alive) = line.split(":")
            alive = ("True" in alive)
            data[float(time)] = alive
    f.close()
 
    return data
 
 
def AppendClientData(client, t, alive):
    """
    Aggiunge in coda i dati sul client e controlla che
    non ci siano dati troppo vecchi, nel qual caso li
    elimina
    """
    LockDatabase()
 
    data = LoadClientData(client)
    filtered_data = filter(lambda i: i[0] > float(time.time()) - max_time, data.items())
    if len(filtered_data) < len(data):
        Verbose ("There are %d of %d records to delete" % (len(data) - len(filtered_data), len(data)))
        data = dict(filtered_data)
        f = open(database_directory + client, 'w')
        for (t, v) in data.items():
            f.write(str(t) + ":" + str(v) + "\n")
        f.close()
    f = open(database_directory + client, 'a')
    f.write(str(t) + ":" + str(alive) + "\n")
    f.close ()
    UnlockDatabase()
 
def UpdateClientsData(client, alive):
    """
    Aggiorna i dati relativi al client inserendo l'informazione
    che in questo momento è acceso.
    """
    n = " not"
    if alive:
        n = ""
    Verbose ("Appending new data: %s is%s alive" % (client, n))
    AppendClientData(client, time.time(), alive)
 
def Availability(client):
    """
    Return availability of the client
    """
    data = LoadClientData(client)
    d = data.items()
    d.sort()
    ss = 0
    old_time = d[0][0]
 
    # Un piccolo integrale sul tempo della funzione
    # up(client)
    for (time_entry, up) in d[1:]:
        if up:
            ss += (time_entry - old_time)
        old_time = time_entry
    ss = ss / (d[-1:][0][0] - d[0][0])
 
    uptime = 100.0 * ss
    return uptime
 
 
def PrintStats(client):
    """
    Stampa le statistiche sul client prescelto
    """
    uptime = Availability(client)
    if IsLastAlive(client):
        is_online = "yes"
    else:
        is_online = "no"
    print "Client: %s" % client
    print "IsOnline: %s" % is_online
    print "Uptime: %3.2f %% " % uptime
    print "----------------------------------------------------"
 
def UptimePlot(filename, days):
    """
    Crea un png con l'uptime dei vari client
    """
 
    clients = LoadClients()
    samples = 100
 
    # Mi interesso solo dell'ultima days giorni, e prendo un sample
    # ogni 10 minuti.
    plot_time = np.linspace(0, (-1) * days, samples)
 
    # Mi servono i dati in secondi, ma cominciamo da un'ora fa
    # per evitare che il grafico vada a 0 per mancanza di dati.
    plot_time = 86400 * plot_time + float(time.time()) - 360
 
    # Inizializziamo i dati a zero
    plot_data = np.zeros(samples)
 
    for client in clients:
        client_data = ClientUptime(plot_time, client)
        plot_data += client_data
 
    # Plot vero e proprio
    pylab.title("Client accesi negli ultimi %d giorni" % days)
    pylab.xlabel("Giorni passati")
    pylab.ylabel("Numero di client")
    pylab.plot (np.linspace(0,(-1) * days,samples)[::-1], plot_data)
    pylab.axis([-0.5 - days, 0, -0.5, len(clients) + 1])
    f = open(filename, "w")
    pylab.savefig(f, format='png')
    f.close()
 
def AvailabilityPlot(filename):
    """
    Plot an histogram of the availability of the clients
    """
    clients = LoadClients()
    av = []
    for client in clients:
        av.append (Availability(client))
 
    # Istogramma con i dati
    pylab.title("Uptime dei client")
    pylab.xticks(3 * np.array(range(0,len(av))) + 1.7, clients)
    pylab.xlabel("")
    pylab.ylabel("% of uptime")
    pylab.bar(3 * np.array(range(0, len(av))) + 1, av, width=0.8)
    pylab.axis([0 , 2*len(av), 0, 102])
    f = open(filename, "w")
    pylab.savefig(f, format='png')
    f.close()
 
 
def ClientUptime(times, client):
    """
    Ritorna un vettore della stessa lunghezza di times con
    il valore 1 se il client era acceso e 0 se era spento
    """
    data = LoadClientData(client)
    data = data.items()
    data.sort()
    iterator = data.__iter__()
    item = iterator.next()
    values = np.zeros(len(times))
    i = 0
    for t in times[::-1]:
        if item[0] > t:
            values[i] = 0
            i += 1
            continue
        try:
            while (item[0] < t):
                item = iterator.next()
        except StopIteration:
            return values
        if (item[1] == True):
            values[i] = 1
        else:
            values[i] = 0
        i += 1
    return values
 
 
 
if __name__ == "__main__":
 
    parser = OptionParser()
    parser.add_option("-c", "--check", dest="check",
                      help = "Check if clients are up and update database",
                      action = "store_true", default=False)
    parser.add_option("-s", "--stats", dest="stats",
                      help = "Print stats about collected informations",
                      action = "store_true", default = False)
    parser.add_option("-g", "--group-file", dest="group_file",
                      help="The dsh group file to use", default='/etc/dsh/group/all')
    parser.add_option("-v", "--verbose", dest="verbose", action="store_true",
                      help="Be verbose", default=False)
    parser.add_option("-p", "--plot", dest="plot", action="store_true",
                      help="Plot the data to a png file", default=False)
    parser.add_option("-a", "--availability", dest="availability", action="store_true",
                      help="Plot the data of availability a png file", default=False)
 
 
    (options, args) = parser.parse_args()
    group = os.path.expanduser(options.group_file)
    verbose = options.verbose
 
    # Se non mi chiedi di fare niente non hai capito
    # come funziono, molto probabilmente.
    if not (options.check or options.stats or
            options.plot or options.availability):
        parser.print_help()
 
    if options.check:
        for client in LoadClients():
            UpdateClientsData(client, IsAlive(client))
 
    if options.plot:
        UptimePlot("/home/robol/public_html/files/up-clients.png", 5)
 
    if options.availability:
        AvailabilityPlot("/home/robol/public_html/files/av-clients.png")
 
    if options.stats:
        try:
            for client in LoadClients():
                PrintStats(client)
        except Exception, e:
            print "Errore durante l'esecuzione!\n ==> %s" % e