Ejemplo n.º 1
0
 def run(self):
     """ Beschreibung: Startet einen Thread, der laufend prüft (alle 10sek), ob eine Session
                       beendet werden kann. Wenn eine Session innerhalb des Timeouts
                       nicht mehr geantwortet hat, kann sie beendet werden.
         Parameter: self: Zeigt auf eigene Klasse
         Rückgabewert: Keiner
         Exceptions: wirft selbst keine
     """
     log.writeLogLV(config_backend.getLogfile(), "%s-Thread ist bereit...\n" % (self.name), log.LOGLEVEL["debug"])
     while not self.killEvent.isSet():
         try:
             time.sleep(10)
             
             # Wenn vorher keine Sessions existierten kann auch nichts geprüft werden
             counter = 0
             for session in self.sessionTable:
                 if (int(session[3])+config_backend.getSessionTimeout()) < int(datetime.now().strftime("%s")): # sessionzeit + timeout < aktuelle zeit? dann löschen
                     log.writeLogLV(config_backend.getLogfile(),
                             "%s: Lösche Session %s, weil sie zu lange inaktiv ist\n" % (self.name, session[0]),
                             log.LOGLEVEL["debug"])
                     del self.sessionTable[counter]
                     counter += 1
            
         except Exception as e:
             print "Error:", e
             if config_backend.getDebug():
                 print traceback.print_exc()
         
     log.writeLogLV(config_backend.getLogfile(), "%s: Beende Thread...\n" % (self.name), log.LOGLEVEL["info"])     
Ejemplo n.º 2
0
 def run(self):
     """ Beschreibung: Startet einen Thread. Der Thread wartet auf Einträge
                     in der Warteschlange (=eingehende Verbindungen). Wenn
                     eine eingehende Verbindung erkannt wurde, werden die
                     Verbindungsparameter an connectionHandler() übergeben.
                     Danach wird die Verbindung beendet.
         Parameter: self: Zeigt auf eigene Klasse
         Rückgabewert: Keiner
         Exceptions: wirft selbst keine
     """
     log.writeLogLV(config_backend.getLogfile(), "%s ist bereit...\n" % (self.name), log.LOGLEVEL["debug"])
     while not self.killEvent.isSet():
         try:
             # Timeout von 3 Sekunden muss eingebaut werden, damit
             # der Thread regelmäßig prüfen kann, ob er beendet werden
             # soll. Der Timeout wirft die Exception Queue.Empty nach
             # 3 Sekunden
             clientConnection = self.queue.get(True, 3)
             log.writeLogLV(config_backend.getLogfile(),
                             "%s: Bearbeite Verbindung: %s\n" % (self.name, clientConnection.getpeername()),
                             log.LOGLEVEL["debug"])
             
             # Verbindung wurde aus der Warteschlange geholt
             # und kann nun bearbeitet werden
             connectionHandler(clientConnection, self.connectionTable)
                                
             # Verbindung wird geschlossen
             log.writeLogLV(config_backend.getLogfile(),
                             "%s: Schließe Verbindung: %s\n" % (self.name, clientConnection.getpeername()),
                             log.LOGLEVEL["debug"])
             clientConnection.shutdown(SHUT_RDWR)
             clientConnection.close()
         except Queue.Empty:
             # OK, warte erneut auf die Warteschlange
             pass
         except Exception as e:
             print traceback.print_exc()
         
     log.writeLogLV(config_backend.getLogfile(), "%s: Beende Thread...\n" % (self.name), log.LOGLEVEL["info"])
Ejemplo n.º 3
0
def LCMPRequestHandler(connection, lcmpPacket, connectionTable, sessionID):
    """ Beschreibung: wird von connectionHandler() aufgerufen und bearbeitet
                        LCMP-Pakete mit "Request"-Typ. Der OpType des Pakets
                        wird mit geprüft und je nach Wert, werden andere Aktionen
                        ausgeführt. Diese Aktionen generieren mind. einen Fehler-
                        code und oft auch Daten. Beides wird am Ende an den Client
                        zurückgesendet (als "Answer"-Typ und mit dem gleichen
                        OpType, wie der, der Request-Anforderung)
        Parameter: (socket)connection: Enthält die Verbindungsinformationen des
                    Client.
                    (tuple)lcmpPacket: Enthält die Daten eines LCMP-Paketes
                    (list)connectionTable: Enthält alle noch aktiven Verbindungen
                    (int)sessionID: Die aktuelle ID der Session
                    
        Rückgabewert: Keiner
        Exceptions: LCMPError
    """
    
    
    errorcode = 0
    data = ""
    opType = lcmp.OPTYPES_REVERSE[lcmpPacket[lcmp.LCMP_INDICES["OpType"]]]
    
    sessionName = ""
    connectionTable_sessionIDs = getSessionIDs(connectionTable)

    # Hat die Session schon einen zugehörigen Computernamen? Dann zeige ihn an.
    if connectionTable[connectionTable_sessionIDs.index(sessionID)][2] == "":
        sessionName = "Session %s" % sessionID
    else:
        sessionName = connectionTable[connectionTable_sessionIDs.index(sessionID)][2]
    
    log.writeLogLV(config_backend.getLogfile(),
                    "%s: %s: Client requests: %s with data: %s\n" % (threading.currentThread().name,
                        sessionName,
                        lcmp.OPTYPES_REVERSE[lcmpPacket[lcmp.LCMP_INDICES["OpType"]]],
                        lcmpPacket[lcmp.LCMP_INDICES["Data"]]),
                    log.LOGLEVEL["info"])

    # Dieser Try-Block soll alle Fehler abfangen, die innerhalb des Data-Backends auftreten
    # natürlich können damit auch andere Fehler abgefangen werden, die dann gesondert behandelt
    # werden müssen
    try:
        if (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["quitConnection"]):
            errorcode = 0
            data = "Goodbye"
            connectionTable_sessionIDs = getSessionIDs(connectionTable)
            
            # Entferne sessionID aus connectionTable, wenn der Client die Verbindung beendet.
            connectionTable.remove(connectionTable[connectionTable_sessionIDs.index(sessionID)])
            
        # Client Operationen
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["addClient"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
                
                # Setze interne Optionen und überschreibe benutzerdefinierte Optionen, wenn jemand versucht
                # die internen Optionen so zu überschreiben
                options["last-seen"] = "never"
                options["created-on"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                if "scriptmember" in options:
                    del options["scriptmember"]
        
                if errorcode == 0:
                        errorcode = data_backend.addClient(name, options)
                else: # parseNameAndOptions() hat nicht funktioniert
                    pass
                    # der errorcode von parseNameAndOptions wird im LCMP-Errorfeld
                    # zurückgesendet und muss nicht mehr gesetzt werden
                data = "" # Es müssen keine Nutzdaten zurückgesendet werden, also kann das Feld leer bleiben
                
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["removeClient"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
                
                if errorcode == 0:
                    errorcode = data_backend.removeClient(name)

                else: # parseNameAndOptions() hat nicht funktioniert
                    pass
                    # der errorcode von parseNameAndOptions wird im LCMP-Errorfeld
                    # zurückgesendet und muss nicht mehr gesetzt werden
                data = "" # Es müssen keine Nutzdaten zurückgesendet werden, also kann das Feld leer bleiben
                
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
       
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["modifyClient"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
        
                if errorcode == 0:
                        errorcode = data_backend.modifyClient(name, options)
                else: # parseNameAndOptions() hat nicht funktioniert
                    pass
                    # der errorcode von parseNameAndOptions wird im LCMP-Errorfeld
                    # zurückgesendet und muss nicht mehr gesetzt werden
                data = "" # Es müssen keine Nutzdaten zurückgesendet werden, also kann das Feld leer bleiben
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
    
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["getClients"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                
                errorcode, data = data_backend.getClients()
            
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        # Gruppen Operationen
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["addGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
                
                # Wenn keine Parent-Gruppe angegeben ist, nehme die 'root'-Gruppe
                if not 'parent' in options:
                    options["parent"] = "root"
                else:
                    # Prüfen, ob die parentGruppe existiert
                    if not options["parent"] in data_backend.getGroupNames()[1]:
                        errorcode = error.ERRORS["ParentGroupDoesNotExist"]
        
                # Lösche interne Optionen, wenn jemand versucht, die internen Optionen so zu überschreiben
                if "member" in options:
                    del options["member"]
                if "scriptmember" in options:
                    del options["scriptmember"]
                
                if errorcode == 0:
                        errorcode = data_backend.addGroup(name, options)
                data = ""
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                           
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["removeGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
        
                if errorcode == 0:
                        errorcode = data_backend.removeGroup(name)
                else: # parseNameAndOptions() hat nicht funktioniert
                    pass
                    # der errorcode von parseNameAndOptions wird im LCMP-Errorfeld
                    # zurückgesendet und muss nicht mehr gesetzt werden
                data = "" # Es müssen keine Nutzdaten zurückgesendet werden, also kann das Feld leer bleiben

            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["modifyGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
        
                if errorcode == 0:
                        errorcode = data_backend.modifyGroup(name, options)
                else: # parseNameAndOptions() hat nicht funktioniert
                    pass
                    # der errorcode von parseNameAndOptions wird im LCMP-Errorfeld
                    # zurückgesendet und muss nicht mehr gesetzt werden
                data = "" # Es müssen keine Nutzdaten zurückgesendet werden, also kann das Feld leer bleiben
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["getGroups"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.getGroups()
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
        
        # Script Operationen
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["addScript"]):
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
        
                if errorcode == 0:
                    if 'path' in options:
                        if not core.doesFileExist(options['path']):
                            errorcode = error.ERRORS['ScriptDoesNotExistInFilesystem']
                        else:
                            options["md5"] = core.getMD5(options['path'])
                            if not 'active' in options:
                                options['active'] = "true"
                            elif options['active'] == "true" or\
                                 options['active'] == "yes" or\
                                 options['active'] == "1":
                                options['active'] = "true"
                            elif options['active'] == "false" or\
                                 options['active'] == "no" or\
                                 options['active'] == "0":
                                options['active'] = "false"
                            else:
                                options['active'] = "true"
                            
                            errorcode = data_backend.addScript(name, options)
                    else:
                        errorcode = error.ERRORS['IllegalNumberOfParameters'] # TODO: Neuen Errorcode
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
            
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["removeScript"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
        
                if errorcode == 0:
                        errorcode = data_backend.removeScript(name)
                else: # parseNameAndOptions() hat nicht funktioniert
                    pass
                    # der errorcode von parseNameAndOptions wird im LCMP-Errorfeld
                    # zurückgesendet und muss nicht mehr gesetzt werden
                data = "" # Es müssen keine Nutzdaten zurückgesendet werden, also kann das Feld leer bleiben
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
            
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["modifyScript"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
        
                if errorcode == 0:
                    errorcode = data_backend.modifyScript(name, options)
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
            
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["getScripts"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.getScripts()
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["getScripts"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.getScriptsFull()
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
           
        # Client & Gruppen Operationen
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["addClientToGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode = data_backend.addClientToGroup(lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[0], lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[1])   
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["removeClientFromGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode = data_backend.removeClientFromGroup(lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[0], lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[1])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["showClientsOfGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.showClientsOfGroup(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["showGroupsOfClient"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.showGroupsOfClient(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
            
        # Client & Skript Operationen
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["addScriptToClient"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode = data_backend.addScriptToClient(lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[0], lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[1])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["removeScriptFromClient"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode = data_backend.removeScriptFromClient(lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[0], lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[1])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["showScriptsOfClient"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.showScriptsOfClient(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["showClientsOfScript"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.showClientsOfScript(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        # Gruppen & Skript Operationen
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["addScriptToGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode = data_backend.addScriptToGroup(lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[0], lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[1])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["removeScriptFromGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode = data_backend.removeScriptFromGroup(lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[0], lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[1])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["showScriptsOfGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.showScriptsOfGroup(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
        
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["showGroupsOfScript"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.showGroupsOfScript(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
    
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["sendScript"]):
            # prüfe zuerst ob der Hostname in der Verbindungstabelle verfügbar ist
            connectionTable_sessionIDs = list()
            for i in connectionTable:
                connectionTable_sessionIDs.append(i[0])
            hostname = connectionTable[connectionTable_sessionIDs.index(sessionID)][2]
            if  hostname != "":
                # Es ist ein Hostname vorhanden, fahre fort
                scripts = data_backend.getScriptsForClient(hostname)[1]
                
                if lcmpPacket[lcmp.LCMP_INDICES["Data"]] in scripts:
                    errorcode, scriptpath = data_backend.getScriptpath(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
                    
                    if errorcode == 0:
                        if data_backend.getScriptActive(lcmpPacket[lcmp.LCMP_INDICES["Data"]]):
                            if core.doesFileExist(scriptpath):
                                scriptFd = open(scriptpath)
                                scriptcontent = ""
                                for line in scriptFd:
                                    scriptcontent += line
                                
                                log.writeLogLV(config_backend.getLogfile(),
                                                "%s: %s: Sende Skript '%s' (%s) an Client\n" % 
                                                    (threading.currentThread().name,
                                                     sessionName,
                                                     lcmpPacket[lcmp.LCMP_INDICES["Data"]],
                                                     scriptpath),
                                                log.LOGLEVEL["info"])
                            
                                errorcode = 0
                                data = scriptcontent
                            else:
                                log.writeLogLV(config_backend.getLogfile(),
                                            "%s: %s: Das Skript wurde im Dateisystem nicht gefunden\n" % 
                                                (threading.currentThread().name,
                                                 sessionName),
                                            log.LOGLEVEL["warning"])
                                errorcode = error.ERRORS["ScriptDoesNotExistInFilesystem"]
                                data = ""                       
                        else:
                            log.writeLogLV(config_backend.getLogfile(),
                                            "%s: %s: Das Skript wurde von einem Administrator deaktiviert\n" % 
                                                (threading.currentThread().name,
                                                 sessionName),
                                            log.LOGLEVEL["warning"])
                            errorcode = error.ERRORS["ScriptIsDeactivated"]
                            data = ""
                            
                    else:
                        log.writeLogLV(config_backend.getLogfile(),
                                        "%s: %s: Das Skript ist in der Datenbank des Servers nicht vorhanden\n" % 
                                            (threading.currentThread().name,
                                             sessionName),
                                        log.LOGLEVEL["warning"]) 
                        errorcode = error.ERRORS["ScriptNotRegistered"]
                        data = ""
                else:
                    log.writeLogLV(config_backend.getLogfile(),
                                    "%s: %s: Das Skript ist diesem Client nicht zugewiesen\n" % 
                                        (threading.currentThread().name,
                                         sessionName),
                                    log.LOGLEVEL["warning"])
                    errorcode = error.ERRORS["ScriptDoesntBelongToClient"]
                    data = ""
            else:
                core.writeLogLV(config_backend.getLogfile(),
                              "%s: %s: Dem Server ist der Hostname dieses Clients noch nicht bekannt" % 
                                (threading.currentThread().name,
                                 sessionName),
                              log.LOGLEVEL["warning"])
                errorcode = error.ERRORS["NoHostnameGiven"]
                data = ""
                    
            
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["getScriptsForClient"]):
            # Berechne Skripte für Client (Achtung: scriptsForClient ist eine Liste!!
            errorcode, scriptsForClient = data_backend.getScriptsForClient(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
            
            # Ist der Client überhaupt registriert? Data_Backend gibt Fehler wenn Client nicht vorhanden ist
            if errorcode == error.ERRORS["ClientNotRegistered"]:
                log.writeLogLV(config_backend.getLogfile(),
                                "%s: %s: Client ist nicht im Data-Backend vorhanden\n" % 
                                    (threading.currentThread().name,
                                     sessionName),
                                log.LOGLEVEL["warning"])
                errorcode = error.ERRORS["ClientNotRegistered"] # TODO: überflüssig?
                data = "[]"
                
            # sind überhaupt scripte für den client vorhanden?
            elif scriptsForClient == list(): # leere Liste
                log.writeLogLV(config_backend.getLogfile(),
                                "%s: %s: Dem Client sind keine Skripte zugewiesen:\n" % 
                                    (threading.currentThread().name,
                                     sessionName),
                                log.LOGLEVEL["warning"])
                errorcode = error.ERRORS["NoScriptsForClient"]
                data = "[]"
                
                # aktualisiere das Feld 'last-seen' beim Client
                data_backend.modifyClient(lcmpPacket[lcmp.LCMP_INDICES["Data"]], {'last-seen':datetime.now().strftime("%Y-%m-%d %H:%M:%S")})
                
            else:
                log.writeLogLV(config_backend.getLogfile(), 
                                "%s: %s: Dem Client sind diese Skripte zugewiesen: %s\n" % 
                                    (threading.currentThread().name, sessionName, scriptsForClient),
                                log.LOGLEVEL["info"])
                
                # Hostnamen in ConnectionTable eintragen
                connectionTable_sessionIDs = list()
                for i in connectionTable:
                    connectionTable_sessionIDs.append(i[0])
                connectionTable[connectionTable_sessionIDs.index(sessionID)][2] = lcmpPacket[lcmp.LCMP_INDICES["Data"]]
                
                # aktualisiere das Feld 'last-seen' beim Client
                data_backend.modifyClient(lcmpPacket[lcmp.LCMP_INDICES["Data"]], {'last-seen':datetime.now().strftime("%Y-%m-%d %H:%M:%S")})
                
                data = str(scriptsForClient)
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["sendReturnCode"]):
            
            connectionTable_sessionIDs = list()
            for i in connectionTable:
                connectionTable_sessionIDs.append(i[0])
                
            scriptname = lcmpPacket[lcmp.LCMP_INDICES["Data"]]
            rc = lcmpPacket[lcmp.LCMP_INDICES["Errorcode"]]
            clientname = connectionTable[connectionTable_sessionIDs.index(sessionID)][2]
            
            log.writeLogLV(config_backend.getLogfile(), 
                            "%s: %s: Client %s hat das Skript %s mit Code %s ausgeführt\n" % 
                                (threading.currentThread().name, sessionName, clientname, scriptname, rc),
                            log.LOGLEVEL["info"])
            
            errorcode = 0
            data = "thx"
        
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["printSessions"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                print connectionTable
                errorcode = 0
                data = ""
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""        
        
        # Wenn OpType nicht bekannt ist
        else:
            errorcode = error.ERRORS["NotImplemented"]
            data = lcmp.OPTYPES_REVERSE[lcmpPacket[lcmp.LCMP_INDICES["OpType"]]]
            
    except error.DataBackendReturnTypeError as e:
        errorcode = error.ERRORS["DataBackendReturnTypeError"]
        log.writeLogLV(config_backend.getLogfile(),
                       "%s: %s: "\
                       "%s hat einen falschen Rückgabetypen zurückgegeben "\
                       "(%s; erwartet wurde %s), "\
                       "eventuell liegt im Data-Backend-Modul eine fehlerhafte Implementierung von %s "\
                       "vor. Die aktuelle Operation wird abgebrochen!\n" % 
                           (threading.currentThread().name, sessionName, opType, e.getWrongType(), e.getRightType(), opType),
                           log.LOGLEVEL["error"])
        
        if config_backend.getDebug():
            print traceback.print_exc()
            
    except error.DataBackendReturnValueError as e:
        errorcode = error.ERRORS["DataBackendReturnValueError"]
        log.writeLogLV(config_backend.getLogfile(),
                       "%s: %s: "\
                       "'%s' hat einen falschen Rückgabewert zurückgegeben(%s). "\
                       "Eventuell liegt im Data-Backend-Modul eine fehlerhafte Implementierung von '%s' "\
                       "vor. Die aktuelle Operation wird abgebrochen!\n" % 
                           (threading.currentThread().name, sessionName, opType, e.getValue(), opType),
                           log.LOGLEVEL["error"])
        
        if config_backend.getDebug():
            print traceback.print_exc()
                            
    except error.DataBackendInternalError as e:
        errorcode = error.ERRORS["DataBackendInternalError"]
        log.writeLogLV(config_backend.getLogfile(),
                       "%s: %s: "\
                       "%s wurde nicht ordnungsgemäß ausgeführt, "\
                       "die Fehlermeldung lautet: '%s'. "
                       "Eventuell liegt im Data-Backend-Modul eine fehlerhafte Implementierung von %s "\
                       "vor. Die aktuelle Operation wird abgebrochen!\n" % 
                           (threading.currentThread().name, sessionName, opType, e.getValue(), opType),
                           log.LOGLEVEL["error"])

        if config_backend.getDebug():
            print traceback.print_exc()
            
    except Exception as e:
        errorcode = error.ERRORS["InternalServerError"]
        log.writeLogLV(config_backend.getLogfile(),
                       "%s: %s: "\
                       "Bei der Bearbeitung von '%s' ist ein Fehler aufgetreten (%s). "\
                       "Die aktuelle Operation wird abgebrochen!\n" % 
                           (threading.currentThread().name, sessionName, lcmp.OPTYPES_REVERSE[lcmpPacket[lcmp.LCMP_INDICES["OpType"]]], e.args),
                           log.LOGLEVEL["error"])
        
        if config_backend.getDebug():
            print traceback.print_exc()

    # Statusmeldung ausgeben
    log.writeLogLV(config_backend.getLogfile(),
                            "%s: %s: %s executed with Code %s [%s]\n" %
                                (threading.currentThread().name,
                                 sessionName,
                                 lcmp.OPTYPES_REVERSE[lcmpPacket[lcmp.LCMP_INDICES["OpType"]]],
                                 errorcode,
                                 error.ERRORS_REVERSE[errorcode]),
                            log.LOGLEVEL["debug"])

    # sende Paket (immer von Type: Answer, OpType ist derselbe wie beim eigentlichen Request, errorcode und data ist variabel
    answer = lcmp.genLCMPPacket(int(sessionID),
                                    "Answer", 
                                    lcmp.OPTYPES_REVERSE[lcmpPacket[lcmp.LCMP_INDICES["OpType"]]],
                                    errorcode,
                                    data)
    
    log.writeLogLV(config_backend.getLogfile(),
                    "%s: %s: sending this lcmpPacket: %s\n" %
                        (threading.currentThread().name,
                        sessionName,
                        answer),
                    log.LOGLEVEL["debug"])
    
    network.send(connection, answer)
# Ende: RequestHandler()
Ejemplo n.º 4
0
def connectionHandler(socket, connectionTable):
    """ Beschreibung: wird direkt aufgerufen, nachdem eine Verbindung aus der
                        Warteschlange geholt worden ist. connectionHandler() 
                        wertet das eingehende Paket in Bezug auf die Gültigkeit
                        aus und reicht das Paket an LCMPRequestHandler() weiter.
        Parameter: (socket)connection: Enthält die Verbindungsinformationen zum
                    Client.
        Rückgabewert: Keiner
        Exceptions: Wirft selbst keine
    """
    
    try:
        # hole LCMP Paket
        data = network.recv(socket)
        
        # wandle Paket in Tuple um
        lcmpPacket = ast.literal_eval(data) 
        
        log.writeLogLV(config_backend.getLogfile(),
                "%s: LCMP-Paket: %s\n" % (threading.currentThread().name, lcmpPacket),
                log.LOGLEVEL["debug"])
        
        # Prüfe Paket auf Gültigkeit, wirft Exceptions bei Fehlern
        lcmp.isLCMPPacket(lcmpPacket)
        
        # Prüfen, ob der Client bereits eine offene Verbindung hat
        sessionID = "%s" % (lcmpPacket[lcmp.LCMP_INDICES["ID"]])
        
        connectionTable_sessionIDs = list()
        for i in connectionTable:
            connectionTable_sessionIDs.append(i[0])
            
        if sessionID in connectionTable_sessionIDs:
            log.writeLogLV(config_backend.getLogfile(),
                          "%s: Session-ID OK (%s)\n" % (threading.currentThread().name, sessionID),
                          log.LOGLEVEL["debug"])
            # Aktualisiere SessionZeitstempel der Session
            connectionTable[connectionTable_sessionIDs.index(sessionID)][3] = datetime.now().strftime("%s")

            # Server bearbeit nur Requests, alles andere wird ignoriert
            if not lcmpPacket[lcmp.LCMP_INDICES["Type"]] == lcmp.TYPES["Request"]:
                log.writeLogLV(config_backend.getLogfile(),
                              "%s: Server bearbeitet nur Requests. Anforderung war: %s...\n" % 
                                (threading.currentThread().name, lcmpPacket[1]),
                              log.LOGLEVEL["warning"])
            
            # Paket zum Auswerten an LCMPTypeHandler geben
            LCMPRequestHandler(socket, lcmpPacket, connectionTable, sessionID )
            
        else: # Client ist noch nicht in Verbindungstabelle
            # wenn Client nocht nicht in der Verbindungstabelle ist, kann er 
            # nur durch einen "openConnection"-Request hinzugefügt werden
            
            if  (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["openConnection"]) and (lcmpPacket[lcmp.LCMP_INDICES["Type"]] == lcmp.TYPES["Request"]):           
                # TODO: prüfe Version                
                connectionTable.append([sessionID,socket.getpeername()[0],'', datetime.now().strftime("%s")])
                log.writeLogLV(config_backend.getLogfile(), 
                                "%s: Session-ID (%s) wurde zur Session-Tabelle hinzugefügt\n" % 
                                (threading.currentThread().name, sessionID),
                                log.LOGLEVEL["info"])
                
                # Antworte Client, dass die Verbindung erfolgreich hergestellt ist und die Session ID eingetragen ist
                network.send(socket, lcmp.genLCMPPacket(sessionID, "Answer", "openConnection", 0, ""))
            else:
                network.send(socket, lcmp.genLCMPPacket(sessionID, "Answer", "openConnection", error.ERRORS["NoValidConnection"], ""))
                raise error.LCMPError("Client hat kein \"openConnection\" gesendet")
            
        log.writeLogLV(config_backend.getLogfile(), 
                        "%s: Verbindungstabelle: %s\n" % (threading.currentThread().name, connectionTable),
                        log.LOGLEVEL["debug"])
            
    except error.LCMPError as e:
        log.writeLogLV(config_backend.getLogfile(),
                        "%s: Kein gültiges LCMP-Paket (%s)\n" % (threading.currentThread().name, e.value),
                        log.LOGLEVEL["error"])
        if config_backend.getDebug():
            print traceback.print_exc()

    except Exception as e:
        log.writeLogLV(config_backend.getLogfile(),
                        "Fehler in Abarbeitung des LCMP-Paketes:", e.args,
                        log.LOGLEVEL["error"])
        if config_backend.getDebug():
            traceback.print_exc()