daemon.py

Aller à la documentation de ce fichier.

#!/usr/bin/python
# -*- coding: utf-8 -*-

import libvirt
#import string
import socket
import struct
import json
import time
import sys
import os
import re


## Classe de communication réseau.
#
#  Cette classe est la classe de base permettant d'envoyer les données via le réseau.
class NetworkCommunication(object):
    
    ## Nom du fichier contenant la liste des collecteurs.
    FILENAME = 'collecteurs.conf.txt'
    
    ## Port par défaut
    DEFAULTPORT = int(55000)
    
    ## Liste contenant l'adresse et le port des collecteurs.
    collecteurs = list()

    ## Constructeur.
    #  Il exécute la méthode recupCollecteurs().
    def __init__(self):
        self.recupCollecteurs()

    ## Méthode qui envoie les données msg aux collecteurs.
    #  Cette méthode est purement virtuelle et doit être réimplémentée par les classes filles.
    def envoyer(self, msg):
        pass

    ## Récupère la liste des collecteurs depuis le fichier de configuration.
    #  Cette méthode récupère la list des collecteurs depuis le fichier de configuration et les stocke dans la liste 'collecteurs' sous la forme d'un dictionnaire avec comme champ 'ip' et 'port'.
    def recupCollecteurs(self):
        try:
            file = open(self.FILENAME, 'r')
            t = file.read()
            file.close()
        except IOError:
            print '''Vous devez créer un fichier "%s" qui contient la liste des collecteurs sous la forme ip/host[:port]''' % self.FILENAME
            sys.exit(1)
        liste = str(t).splitlines()
        for collecteur in liste:
            tmp = collecteur.split(':')
            c = dict()
            c['ip'] = tmp[0]
            if len(tmp) < 2:
                c['port'] = self.DEFAULTPORT
            else:
                c['port'] = int(tmp[1])
            self.collecteurs.append(c)


## Classe de communication réseau UDP.
#
#  Cette classe implémente la communication réseau via un socket UDP.
class UDPScoketCommunication(NetworkCommunication):

    ## Constructeur.
    #  Il appelle le constructeur de la classe parente puis ajoute un champs seqNb contenant le numéro de séquence courant pour chaque collecteur.
    #  Ce numéro est initialisé à 0.
    def __init__(self):
        super(UDPScoketCommunication, self).__init__()
        for c in self.collecteurs:
            c['seqNb'] = int(0)

    ## Méthode qui envoie les données msg aux collecteurs via un socket UDP.
    #  Cette méthode envoie les données à chaque collecteur de la liste et incrémente le numéro de séquence.
    #  @param msg données à envoyer.
    def envoyer(self, msg):
        for c in self.collecteurs:
            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            s.connect((c['ip'], c['port']))
            msg2 = struct.pack('>1I'+str(len(msg))+'s', int(c['seqNb']), msg)
            if len(msg2) != s.send(msg2):
                print "Erreur lors de l'envois à %s:%d." % (c['ip'], c['port'])
            #else:
                #print "Envoyé à %s:%d." % (c['ip'], c['port'])
            c['seqNb'] = c['seqNb'] + 1
            s.close()


## Classe de base pour les classes récoltant des informations.
#
#  Cette classe est la classe de base pour les classes récoltant des informations.
#  Chaque classe fille doit implémenter la méthode infos.
class AbstractInfos(object):

    ## Constructeur.
    def __init__(self):
        pass

    ## Méthode qui renvoie des informations sous la forme d'une liste ou d'un dict.
    #  Cette méthode est purement virtuelle et doit être réimplémentée par les classes filles.
    #  @return des informations sous la forme d'une liste ou d'un dict.
    def infos(self):
        pass


## Classe de base pour les classes récoltant des informations.
#
#  Cette classe est la classe de base pour les classes récoltant des informations.
#  Chaque classe fille doit implémenter la méthode infos.
class HostInfos(AbstractInfos):
    ## Temps CPU.
    CPUTime = int()
    ## Date de la dernière mesure de la charge CPU.
    CPUMesureTime = float()
    ## Temps CPU passé dans les accès disques.
    DisqueTime = int()
    ## Date de la dernière mesure de la charge disque.
    DisqueMesureTime = float()
    ## Température du CPU.
    temperatureCPU = float(0)
    ## Température de la carte mère.
    temperatureMB = float(0)

    ## Constructeur.
    #  Le constructeur initialise diverses valeurs.
    def __init__(self):
        self.CPUInfos()
        self.disqueInfos()
        self.nomHyperviseur = self.nomMachine()

    ## Renvoie le nom de la machine.
    #
    #  @return le nom de la machine.
    def nomMachine(self):
        file = open('/etc/sysconfig/network', 'r')
        t = file.read()
        file.close()
        return re.findall('HOSTNAME=(.+)', t)[0]

    ## Lit la température du cpu et de la carte mère.
    #  Cette méthode lit la température du cpu et de la carte mère puis elle les stocke dans les propriétés temperatureCPU et temperatureMB.
    def temperatures(self):
        buff = os.popen('sensors | grep Temperature | awk \'{print $3}\'')
        res = str(buff.read())
        buff.close()
        temps = re.findall('[0-9]+\.[0-9]*', res)
        if len(temps) >= 2:
            self.temperatureCPU = float(temps[0])
            self.temperatureMB = float(temps[1])

    ## Renvoie l'utilisation de la mémoire RAM en pourcents.
    #  Cette méthode calcule l'utilisation de la mémoire RAM grâce aux informations contenues dans /proc/meminfo.
    #  @return l'utilisation de la mémoire RAM en pourcents.
    def RAMInfos(self):
        file = open('/proc/meminfo', 'r')
        t = file.read()
        file.close()
        total = int(re.findall('MemTotal: *?([0-9]+) kB', t)[0])
        free = int(re.findall('MemFree: *?([0-9]+) kB', t)[0])
        buffers = int(re.findall('Buffers: *?([0-9]+) kB', t)[0])
        cached = int(re.findall('Cached: *?([0-9]+) kB', t)[0])
        return float(total - free - buffers - cached) / float(total) * 100.0

    ## Renvoie le temps pendant lequel le CPU était innactif depuis le démarrage du système.
    #  La valeur est obtenue gâce au fichier /proc/stat.
    #  @return la valeur du temps CPU passé en innactivité.
    def CPUIdleTime(self):
        buff = os.popen('cat /proc/stat | grep -m1 cpu | awk \'{print $5}\'')
        res = int(buff.read())
        buff.close()
        return res

    ## Retourne l'utilisation du CPU en pourcents.
    #  Cette méthode calcule la moyenne du pourcentage d'utilisation du CPU depuis son dernier appel.
    #  @return l'utilisation du CPU en pourcents.
    def CPUInfos(self):
        LastCPUMesureTime = self.CPUMesureTime
        LastCPUTime = self.CPUTime
        self.CPUTime = self.CPUIdleTime()
        self.CPUMesureTime = time.time()
        deltaCPU = float(self.CPUTime-LastCPUTime)
        deltaT = float(self.CPUMesureTime-LastCPUMesureTime)
        coeff = float(os.sysconf_names['SC_CLK_TCK'])
        return (1 - deltaCPU / (100.0 * deltaT * coeff)) * 100

    ## Retourne la valeur du temps CPU passé dans les accès disques.
    #  La valeur est obtenue grâce au fichier /proc/diskstats.
    #  @return la valeur du temps CPU passé dans les accès disques.
    def disqueTime(self):
        buff = os.popen("cat /proc/diskstats | grep -m 1 da | awk '{print $13}'")
        res = int(buff.read())
        buff.close()
        return res

    ## Retourne l'utilisation du disque en pourcents.
    #  Cette méthode calcule la moyenne du pourcentage d'utilisation du disque depuis son dernier appel.
    #  @return l'utilisation du disque en pourcents.
    def disqueInfos(self):
        LastDisqueMesureTime = self.DisqueMesureTime
        LastDisqueTime = self.DisqueTime
        self.DisqueTime = self.disqueTime()
        self.DisqueMesureTime = time.time()
        deltaDisqueT = float(self.DisqueTime-LastDisqueTime)
        deltaT = float(self.DisqueMesureTime-LastDisqueMesureTime)
        return (deltaDisqueT/1000.0) / deltaT * 100.0

    ## Retourne les informations sur l'hôte sous la forme d'un dict.
    #  Cett méthode appelle les autres méthodes de la classe pour récupérer les informations sur l'hôte.
    #  @n Elle crée ensuite le dict et y stocke les informations.
    #  @return les informations sur l'hôte sous la forme d'un dict.
    def infos(self):
        res = dict()
        self.temperatures()
        res['name'] = self.nomHyperviseur
        res['time'] = time.time()
        res['cputemp'] = self.temperatureCPU
        res['mbtemp'] = self.temperatureMB
        res['cpu'] = self.CPUInfos()
        res['ram'] = self.RAMInfos()
        res['disk'] = self.disqueInfos()
        #res['network'] =
        return res


## Classe de base pour les classes récoltant des informations.
#
#  Cette classe est la classe de base pour les classes récoltant des informations.
#  Chaque classe fille doit implémenter la méthode infos.
class VMInfos(AbstractInfos):
    Conn = None
    VMs = list()
    nbpCPU = int()
    CPUTime = dict()
    pCPUInfos = float()
    pCPUIdleTime = dict()
    Mesuretime = dict()
    hostinf = HostInfos()

    ## Constructeur.
    #  Le constructeur initialise diverses valeurs.
    def __init__(self):
        self.connexion()
        self.nbpCPU = self.Conn.getInfo()[2]
        self.pCPUInfos = self.hostinf.CPUInfos()
        self.listeVM()
        self.infos()

    ## Se connecte à libvirt.
    #  Cette méthode ouvre une connexion avec l'API libvirt.
    def connexion(self):
        self.Conn = libvirt.openReadOnly(None)
        if self.Conn == None:
            print 'Impossible de se connecter à l\'hyperviseur'
            sys.exit(1)

    ## Génère la liste des machines virtuelles.
    #  Utilise libvirt pour lister les machines virtuelles démarrées et arrêtées, puis stocke la liste dans la propriété VMs.
    def listeVM(self):
        self.VMs = list()
        for name in self.Conn.listDefinedDomains():
            self.VMs.append(self.Conn.lookupByName(name))
        for id in self.Conn.listDomainsID():
            self.VMs.append(self.Conn.lookupByID(id))

    ## Retourne l'utilisation du CPU en pourcents pour la VM passée en paramètre.
    #  Cette méthode calcule la moyenne du pourcentage d'utilisation du CPU d'une machine virtuelle depuis son dernier appel.
    #  @return l'utilisation du CPU en pourcents.
    def utilisationCPU(self, VM):
        if VM.name() not in self.Mesuretime:
            self.Mesuretime[VM.name()] = 1
            self.CPUTime[VM.name()] = 1
        LastMesuretime = self.Mesuretime[VM.name()]
        LastCPUTime = self.CPUTime[VM.name()]
        self.Mesuretime[VM.name()] = time.time()
        self.CPUTime[VM.name()] = VM.info()[4]
        deltaCPU = float(self.CPUTime[VM.name()]-LastCPUTime)
        deltaT = float(self.Mesuretime[VM.name()]-LastMesuretime)
        nbvCPU = float(VM.info()[3])
        return deltaCPU/(1000000000.0*deltaT*float(self.nbpCPU))/nbvCPU*100.0

    ## Cette méthode a la même fonction que la méthode utilisationCPU() mais utilise un algorithme différent.
    #  Cette méthode calcule le pourcentage d'utilisation du CPU de la VM en prenant en compte le temps qu'elle avait à disposition.
    #  @n En résumé elle soustrait le temps utilisé par l'hôte et les autres VMs.
    #  @return l'utilisation du CPU en pourcents.
    def utilisationCPUv2(self, VM): # Expérimental
        if VM.name() not in self.Mesuretime:
            self.Mesuretime[VM.name()] = 1
            self.CPUTime[VM.name()] = 1
        LastMesuretime = self.Mesuretime[VM.name()]
        LastCPUTime = self.CPUTime[VM.name()]
        self.Mesuretime[VM.name()] = time.time()
        self.CPUTime[VM.name()] = VM.info()[4]
        deltaCPU = float(self.CPUTime[VM.name()]-LastCPUTime)
        deltaT = float(self.Mesuretime[VM.name()]-LastMesuretime)
        nbvCPU = float(VM.info()[3])

        if self.pCPUInfos > 90:
            if VM.name() not in self.pCPUIdleTime:
                self.pCPUIdleTime[VM.name()] = 1
            LastpCPUIdleTime = self.pCPUIdleTime[VM.name()]
            self.pCPUIdleTime[VM.name()] = self.hostinf.CPUIdleTime()
            coeff = float(os.sysconf_names['SC_CLK_TCK'])
            deltapCPUIdleTime = (self.pCPUIdleTime[VM.name()] - LastpCPUIdleTime) / (100*coeff)
            deltavCPU = float(float(deltaCPU) / (1000000000.0*float(self.nbpCPU)))
            if (deltaCPU + deltapCPUIdleTime) > 0:
                return deltavCPU / float(deltapCPUIdleTime + deltavCPU) *100.0
        return deltaCPU/(1000000000.0*deltaT*float(self.nbpCPU))/nbvCPU*100.0

    ## Retourne les informations sur les machines virtuelles sous la forme d'une liste contenant des dict.
    #  Cett méthode appelle, pour chaque VM, les autres méthodes de la classe pour récupérer les informations.
    #  @n Elle crée ensuite le dict et y stocke les informations de la VM.
    #  @n Elle ajoute ensuite ce dict à la liste.
    #  @return les informations sur l'hôte sous la forme d'un dict.
    def infos(self):
        self.listeVM()
        res = list()
        self.nbpCPU = self.Conn.getInfo()[2]
        self.pCPUInfos = self.hostinf.CPUInfos()
        for VM in self.VMs:
            inf = dict()
            inf["name"] = VM.name()
            inf["uuid"] = VM.UUIDString()
            inf["state"] = VM.info()[0]
            inf["cpu"] = self.utilisationCPU(VM)
            inf["ram"] = int(VM.info()[2])
            inf["maxram"] = int(VM.info()[1])
            #inf["network"] =
            res.append(inf)
        return res


## Point d'entrée du logiciel
#  Cette fonction crée les instances des objets et appelle les méthodes infos().
#  @n Elle crée ensuite la chaîne JSON et l'envoie aux collecteurs.
#  @n Puis elle attend un certain temps avant de recommencer.
#  @return 
if __name__ == "__main__":
    print "debut"

    hosti = HostInfos()
    vmi = VMInfos()
    comm = UDPScoketCommunication()

    while(1):
        time.sleep(1)
        infos = hosti.infos()
        infos['vms'] = vmi.infos()
        jsonData = json.dumps(infos)
        comm.envoyer(jsonData)
        #print jsonData

    #sys.exit(0)

print "fin"