Beispiel #1
0
def main():
    logging.basicConfig()
    dicConfig={}
    # ---- Sacamos las variables mínimas necesarias del fichero de los parámetros pasados al arrancar el proceso
    dicConfig,procID = usefulLibrary.loadArguments()
    dbHost,keyspace = loadBasicConfiguration(dicConfig)
    # ---- Creamos el objeto para trabajar con la BD
    client = cassandraDBconnection.connectionCassandra()
    client.connect([dbHost])
    # ---- Comprobamos la conexión contra la BD
    client.checkDBconnection(keyspace)
    # ---- Cargamos todas la variables COMUNES necesarias de la BD
    dicDBvariables={}
    usedVariablesCom(dicDBvariables)
    client.loadConfiguration(keyspace,dicDBvariables)
    hdlr = logging.FileHandler(str(dicDBvariables['logPath'])+'/'+str(procID)+'.log')
    log.addHandler(hdlr)
    if dicDBvariables['tracesLevel'] == 'DEBUG':
        log.setLevel(logging.DEBUG)
    elif dicDBvariables['tracesLevel'] == 'INFO':
        log.setLevel(logging.INFO)
    elif dicDBvariables['tracesLevel'] == 'WARNING':
        log.setLevel(logging.WARNING)
    elif dicDBvariables['tracesLevel'] == 'ERROR':
        log.setLevel(logging.ERROR)
    elif dicDBvariables['tracesLevel'] == 'CRITICAL':
        log.setLevel(logging.CRITICAL)
    # ---- Cargamos todas la variables del PROCESO necesarias de la BD
    dicDBvarProc={}
    usefulLibrary.usedVariablesProc(dicDBvarProc)
    client.loadConfigurationProc(keyspace,dicDBvarProc,procID) 
    # ---- Registramos en la BD el histórico para este proceso
    insertHist,valuesList,historyID=usefulLibrary.createRecordHistory(procID,keyspace)
    client.executeDBinsert(insertHist,valuesList)
    # ----
    dicAgentProcess={}    # es un diccionario de objetos subprocess
    dicClientsClassification={}
    client.extractClientsFeatures(keyspace,dicClientsClassification)
    usefulLibrary.applyAlgorithmDistribution(dicDBvariables,dicAgentProcess,dicClientsClassification.keys(),procID)
    # ---- EXECUTION LOOP
    while True:
        # ---- Comprobamos si ha habido algún cambio en la configuración de la BD
        dicDBvariables2={}
        usedVariablesCom(dicDBvariables2)
        client.loadConfiguration(keyspace,dicDBvariables2)
        # --
        dicDBvarProc2={}
        usefulLibrary.usedVariablesProc(dicDBvarProc2)
        client.loadConfigurationProc(keyspace,dicDBvarProc2,procID) 
        changes1=usefulLibrary.checkVariables(dicDBvariables,dicDBvariables2)
        changes2=usefulLibrary.checkVariables(dicDBvarProc,dicDBvarProc2)
        if changes1:
            # Re-reading:
            dicDBvariables=dicDBvariables2
        if changes2:
            # Re-reading:
            dicDBvarProc=dicDBvarProc2
        if changes1 or changes2:        
            lastReading=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            valuesList[5]=lastReading
            client.executeDBinsert(insertHist,valuesList)
            if dicDBvarProc['stoppedflag']:
                log.info('Proccess stopped by DB configuration.')
                if len(dicAgentProcess.keys()) > 0: # significa que hemos arrancando agentes de logstash
                    usefulLibrary.killAgents(dicAgentProcess,procID)
                sys.exit(0)
                break
        # Añadimos a la variable de configuración que fija el directorio de entrasada el nombre del proceso
        # para dar lugar a la ruta completa: ej -> /Users/jorgelozano/Monmalev1.0/initial + /SNT000
        # La carpeta final para este proceso es la carpeta de inicial del siguiente
        pathF=dicDBvariables['finalPath']
        pathB=dicDBvariables["backupPath"]+"/"+procID
        pathE=dicDBvariables["errorPath"]+"/"+procID
        for CL in dicClientsClassification.keys():
            pathI=dicDBvariables["initialPath"]+"/"+procID+"/"+str(CL)+"/"
            newFile=""
            exist=False
            newFile,exist=usefulLibraryFiles.searchFilesIN(pathI,"*.json",procID)
            if exist:
                error=False
                lines=0
                if "_Alarms.json" in newFile: # significa que es un JSON de Alarmas creado por el proceso MINER
                    destFile=str(CL)+"_Alarms.log"
                elif "_Dataset.json" in newFile:
                    destFile=str(CL)+"_DataSet.log"
                error,lines=usefulLibraryFiles.checkAgentOUTfile(pathF,destFile,procID)
                # Si se dio algún error al leer la cabecera descartaremos el fichero
                if error:
                    # Si hay error movemos el fichero
                    er=usefulLibraryFiles.moveFile(pathI,pathE,newFile)
                    if er:
                        # Si al intentar mover el fichero tenemos error salimos de la ejecución.
                        sys.exit(1)
                    # Si no tenemos error al mover el fichero continuamos la ejecución buscando nuevo ficheros.                    
                else:
                    log.info(procID+ " <main> Agent OUT file has: "+str(lines)+" lines")
                    # Continuamos tratando el fichero
                    if lines >= dicDBvariables["maxLinesAgentFile"]:
                        log.info(procID+ " <main> Agent OUT file big.")
                        e=False
                        e = usefulLibraryFiles.maintenanceLogFile(pathF,destFile,lines-int(dicDBvariables["maxLinesAgentFile"]),procID)
                        if e:
                            E=usefulLibraryFiles.moveFile(pathI,pathE,newFile)
                            if E:
                                sys.exit(1)
                    e=False
                    log.info(procID+ " <main> Adding new Dataset....")
                    e = usefulLibraryFiles.addNewJSONInFile(pathI,newFile,pathF,destFile,procID)
                    log.info(procID+ " <main> Moving in file to backup.")
                    usefulLibraryFiles.moveFile(pathI,pathB,newFile)
            else:
                log.info("Applied variable filesWait, sleeping:"+str(dicDBvariables['filesWait'])+" s")
                time.sleep(float(dicDBvariables['filesWait']))
Beispiel #2
0
def main():
    logging.basicConfig()
    dicConfig={}
    # ---- Sacamos las variables mínimas necesarias del fichero de los parámetros pasados al arrancar el proceso
    dicConfig,procID = usefulLibrary.loadArguments()
    dbHost,keyspace = loadBasicConfiguration(dicConfig)
    # ---- Creamos el objeto para trabajar con la BD
    client = cassandraDBconnection.connectionCassandra()
    client.connect([dbHost])
    # ---- Comprobamos la conexión contra la BD
    client.checkDBconnection(keyspace)
    # ---- Cargamos todas la variables COMUNES necesarias de la BD
    dicDBvariables={}
    usedVariablesCom(dicDBvariables)
    client.loadConfiguration(keyspace,dicDBvariables)
    hdlr = logging.FileHandler(str(dicDBvariables['logPath'])+'/'+str(procID)+'.log')
    log.addHandler(hdlr)
    if dicDBvariables['tracesLevel'] == 'DEBUG':
        log.setLevel(logging.DEBUG)
    elif dicDBvariables['tracesLevel'] == 'INFO':
        log.setLevel(logging.INFO)
    elif dicDBvariables['tracesLevel'] == 'WARNING':
        log.setLevel(logging.WARNING)
    elif dicDBvariables['tracesLevel'] == 'ERROR':
        log.setLevel(logging.ERROR)
    elif dicDBvariables['tracesLevel'] == 'CRITICAL':
        log.setLevel(logging.CRITICAL)
    # ---- Cargamos todas la variables del PROCESO necesarias de la BD
    dicDBvarProc={}
    usefulLibrary.usedVariablesProc(dicDBvarProc)
    client.loadConfigurationProc(keyspace,dicDBvarProc,procID) 
    # ---- Registramos en la BD el histórico para este proceso
    insertHist,valuesList,historyID=usefulLibrary.createRecordHistory(procID,keyspace)
    client.executeDBinsert(insertHist,valuesList)
    # ---- EXECUTION LOOP
    while True:
        # ---- Comprobamos si ha habido algún cambio en la configuración de la BD
        dicDBvariables2={}
        usedVariablesCom(dicDBvariables2)
        client.loadConfiguration(keyspace,dicDBvariables2)
        # --
        dicDBvarProc2={}
        usefulLibrary.usedVariablesProc(dicDBvarProc2)
        client.loadConfigurationProc(keyspace,dicDBvarProc2,procID) 
        changes1=usefulLibrary.checkVariables(dicDBvariables,dicDBvariables2)
        changes2=usefulLibrary.checkVariables(dicDBvarProc,dicDBvarProc2)
        if changes1:
            # Re-reading:
            dicDBvariables=dicDBvariables2
        if changes2:
            # Re-reading:
            dicDBvarProc=dicDBvarProc2
        if changes1 or changes2:        
            lastReading=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            valuesList[5]=lastReading
            client.executeDBinsert(insertHist,valuesList)
            if dicDBvarProc['stoppedflag']:
                log.info(procID+'- Proccess stopped by DB configuration.')
                sys.exit(0)
                break
        # Añadimos a la variable de configuración que fija el directorio de entrasada el nombre del proceso
        # para dar lugar a la ruta completa: ej -> /Users/jorgelozano/Monmalev1.0/initial + /SNT000
        pathI=dicDBvariables["initialPath"]+"/"+procID
        # La carpeta final para este proceso es la carpeta de inicial del siguiente
        pathF=dicDBvariables["initialPath"]+"/ACT000"
        pathB=dicDBvariables["backupPath"]+"/"+procID
        pathE=dicDBvariables["errorPath"]+"/"+procID
        newFile=""
        exist=False
        newFile,exist=usefulLibraryFiles.searchFilesIN(pathI,"*.txt",procID)
        if exist:
            dateInitial=datetime.now()
            dicHeader={}
            error=False
            dicHeader,error=usefulLibraryFiles.readHeaderFile(pathI,newFile)
            # Si se dio algún error al leer la cabecera descartaremos el fichero
            if error:
                # Si hay error movemos el fichero
                er=usefulLibraryFiles.moveFile(pathI,pathE,newFile)
                if er:
                    # Si al intentar mover el fichero tenemos error salimos de la ejecución.
                    sys.exit(1)
                # Si no tenemos error al mover el fichero continuamos la ejecución buscando nuevo ficheros.                    
            else:
                # Continuamos tratando el fichero
                # Hemos quitado la comprobación de buscar al cliente en la BD, ya que esta comprobación se hace en la fase anterior
                # y hacerlo nuevamente es repetir.
                # CHANGE: 11.09.14 -- Quitamos lo referente a búsqueda de alarma reciente
                # lisAlarm=[]
                # client.searchRecentAlarm(keyspace,dicHeader['clientID'],dicDBvariables['recentAlarm'],lisAlarm,procID)
                # if len(lisAlarm)==0:
                    # No hay alarma reciente
                #    log.info(procID+" - There is not recent alarm.")
                #
                # Después de insertar el nuevo DataSet en la BD tendremos que generar el fichero JSON en el cual será introducida
                # la lista del punto anterior con la posible alarma previa o en caso contrario la lista nula
                #
                dicClientsClassif={}
                client.extractClientsFeatures(keyspace,dicClientsClassif)
                #
                # La función anterior nos devuelve un diccionario con todos los clientes y sus características
                # Llamaremos a la siguiente función con las caracterísricas especificas de nuestro cliente
                #
                L1,L2,dicL,dicWrongValues = usefulLibrary.cleanNewDataSet(dicClientsClassif[dicHeader['clientID']],pathI,newFile,procID)
                #
                # Una vez tenemos el nuevo dataSet limpio de strings debemos cargar desde la BD los 'maxTrainDataSet' dataSet anteriores para 
                # usarlos como set de entrenamiento, por otro lado usaremos el nuevo dataSet como set de testeo quitando en cada momento la 
                # muestra que queremos "validar" (predecir)
                #
                L_train=[]         # En esta variable cargaremos los valores de los dataSet de entrenamiento
                features_train=[]  # En esta variable cargaremos los nombres de las columnas del array de entrenamiento.
                order=[]
                for index in dicL['L2'].keys():
                    order.append(int(index))
                for o in sorted(order):
                    features_train.append("col"+str(o))   # en la BD las columnas en la tabla de dataSet no tienen nombre, son "col1",....
                log.info(procID+" - Features Train: "+str(features_train))
                client.loadTrainDataSetv2(keyspace,dicDBvariables['maxTrainDataSet'],dicDBvariables['minTrainDataSet'],L_train,features_train,dicHeader['clientID'],"",False,False,procID)                
                # backup 11.09.04 --> client.loadTrainDataSet(keyspace,dicDBvariables['maxTrainDataSet'],dicDBvariables['minTrainDataSet'],L_train,features_train,dicHeader['clientID'],"",False,False,procID)
                # En este punto ya tenemos:
                #   - L2         --> array que usaremos como test y a predecir
                #   - L_train    --> array que usaremos como train
                # por lo que ya podemos aplicar los algoritmos de ML.
                #
                analysis=False
                dicAlarmsRegr={}
                score=0
                log.info(procID+" <main> L_train is --> "+str((len(L_train)*100)/(len(L_train)+len(L2)))+"%")
                if len(L_train) == 0: #or (len(L_train)*100)/(len(L_train)+len(L2)) < int(dicDBvariables['test_size']): # no hay suficientes dataset anteriores en la BD
                    log.info(procID+" - There are not enough datasets in DB, the regression execution will not be executed.")
                else:
                    analysis=False
                    machineLearningLibrary.applyRegression(dicWrongValues,L2,dicL["L2"],L_train,dicDBvariables['coefVaration'],dicAlarmsRegr,score,dicDBvariables['test_size'],analysis,procID)
                    # IMPORTANTE: el diccionario dicAlarmsRegr nos marca los registros con alarma sobre el array L2, por lo que antes de insertarlas
                    # en la BD debemos de encontrar las coordenadas correctas.
                    # De la llamada anterior obtenemos:
                    #      - L2 --> con los valores wrong rectificados
                    #      - dicAlarmsRegr --> diccionatio con las coordenadas de las muestras con alarma.
                    # Para insertar en la BD además de estos elementos necesitamos:
                    #      - L1
                    #      - dicL
                    #      - dicHeader
                L_union=[]
                dicAlarmReal={}
                dicAlarmReal=usefulLibrary.realCoord(dicAlarmsRegr,dicL,procID)
                L_union = usefulLibrary.unionArrays(L1,L2,dicL,procID)
                log.info(procID+" - Num columns L_union: "+str(len(L_union[0])))
                log.info(procID+" - Num rows L_union: "+str(len(L_union)))
                # NOTA: habría que comprobar el número de columna que hay, puede ser necesario crear alguna mas
                dateFinal=datetime.now()
                timeProcessing=dateFinal-dateInitial
                log.info(procID+" - Time processing: "+str(timeProcessing.seconds)+" s")
                # CHANGE: 04.09.14 --> client.insertNewDataSet(keyspace,dicHeader,L_union,dicL["L0"],dicAlarmsRegr,procID) 
                client.insertNewDataSetCheck(keyspace,dicHeader,L_union,dicL["L0"],dicAlarmsRegr,procID) 
                # NEW: 11.09.14
                client.insertSummaryData(keyspace,dicHeader['clientID'],dicHeader['datasetID'],len(L_union),newFile,procID)
                client.insertResult(keyspace,dicHeader,timeProcessing.seconds,score,analysis,procID)
                if len(dicAlarmsRegr.keys()) >0:
                    # En este proceso sólo se puede dar un tipo de alarma que es la de valor incorrecto mediante REGRESIÓN
                    #  Tipo Alarma 1
                    # la variable "alarmed" hace referendia a las posibles alarmas que puede tener un mismo registro, como en el punto en el que estamos sabemos que la alarma es nueva
                    # sólo puede terner como máximo la alarma detectada en este punto. cuando el proceso "miner" trabaje puede encontrar alguna alarma mas
                    alarmed=[]
                    alarmed.append(1)
                    client.insertAlarmS(keyspace,dicHeader,dicAlarmReal,dicL["L0"],alarmed,procID)
                # CHANGE: 03.09.14 --> usefulLibraryFiles.createJSONDataset(dicAlarmReal,dicHeader,dicL["L0"],L_union,pathF,lisAlarm,procID)
                # CHANGE: 04.09.14 --> usefulLibraryFiles.createJSONDatasetWithoutAlarm(dicAlarmReal,dicHeader,dicL["L0"],L_union,pathF,lisAlarm,procID)
                usefulLibraryFiles.moveFile(pathI,pathB,newFile)
        else:
            log.info(procID+" - Applied variable filesWait, sleeping:"+str(dicDBvariables['filesWait'])+" s")
            time.sleep(float(dicDBvariables['filesWait']))
Beispiel #3
0
def main():
    logging.basicConfig()
    dicConfig={}
    # ---- Sacamos las variables mínimas necesarias del fichero de los parámetros pasados al arrancar el proceso
    dicConfig,procID = usefulLibrary.loadArguments()
    dbHost,keyspace = loadBasicConfiguration(dicConfig)
    # ---- Creamos el objeto para trabajar con la BD
    client = cassandraDBconnection.connectionCassandra()
    client.connect([dbHost])
    # ---- Comprobamos la conexión contra la BD
    client.checkDBconnection(keyspace)
    # ---- Cargamos todas la variables COMUNES necesarias de la BD
    dicDBvariables={}
    usedVariablesCom(dicDBvariables)
    client.loadConfiguration(keyspace,dicDBvariables)
    hdlr = logging.FileHandler(str(dicDBvariables['logPath'])+'/'+str(procID)+'.log')
    log.addHandler(hdlr)
    if dicDBvariables['tracesLevel'] == 'DEBUG':
        log.setLevel(logging.DEBUG)
    elif dicDBvariables['tracesLevel'] == 'INFO':
        log.setLevel(logging.INFO)
    elif dicDBvariables['tracesLevel'] == 'WARNING':
        log.setLevel(logging.WARNING)
    elif dicDBvariables['tracesLevel'] == 'ERROR':
        log.setLevel(logging.ERROR)
    elif dicDBvariables['tracesLevel'] == 'CRITICAL':
        log.setLevel(logging.CRITICAL)
    # ---- Cargamos todas la variables del PROCESO necesarias de la BD
    dicDBvarProc={}
    usefulLibrary.usedVariablesProc(dicDBvarProc)
    client.loadConfigurationProc(keyspace,dicDBvarProc,procID) 
    # ---- Registramos en la BD el histórico para este proceso
    insertHist,valuesList,historyID=usefulLibrary.createRecordHistory(procID,keyspace)
    client.executeDBinsert(insertHist,valuesList)
    # ---- EXECUTION LOOP
    while True:
        # ---- Comprobamos si ha habido algún cambio en la configuración de la BD
        dicDBvariables2={}
        usedVariablesCom(dicDBvariables2)
        client.loadConfiguration(keyspace,dicDBvariables2)
        # --
        dicDBvarProc2={}
        usefulLibrary.usedVariablesProc(dicDBvarProc2)
        client.loadConfigurationProc(keyspace,dicDBvarProc2,procID) 
        changes1=usefulLibrary.checkVariables(dicDBvariables,dicDBvariables2)
        changes2=usefulLibrary.checkVariables(dicDBvarProc,dicDBvarProc2)
        if changes1:
            # Re-reading:
            dicDBvariables=dicDBvariables2
        if changes2:
            # Re-reading:
            dicDBvarProc=dicDBvarProc2
        if changes1 or changes2:        
            lastReading=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            valuesList[5]=lastReading
            client.executeDBinsert(insertHist,valuesList)
            if dicDBvarProc['stoppedflag']:
                log.info(procID+'- Proccess stopped by DB configuration.')
                sys.exit(0)
                break
        # Añadimos a la variable de configuración que fija el directorio de entrasada el nombre del proceso
        # para dar lugar a la ruta completa: ej -> /Users/jorgelozano/Monmalev1.0/initial + /SNT000
        # La carpeta final para este proceso es la carpeta de inicial del siguiente
        pathF=dicDBvariables["initialPath"]+"/ACT000"
        # Continuamos tratando el fichero
        dicPendingData={} # será un diccionario del tipo:
        # datasetID: 2323-sdsdsd-2323
        # clientID: 3
        client.searchDatasetNoAnalysed(keyspace,dicPendingData,procID)
        if len(dicPendingData.keys())!= 0:
            log.info(procID+" <main> There are recent datasets pending for analyze.")
            for datasetID in dicPendingData.keys():
                clientID=dicPendingData[datasetID]
                dicClientsClassifOrder={}
                client.extractClientsFeaturesOrder(keyspace,dicClientsClassifOrder)
                dicLspecial={} # a diferencia del dicL usado en el CLN este sólo será un diccionario del mismo tipo donde las keys
                # que representaban el orden no tendrán el orden correcto
                usefulLibrary.createDicL(dicClientsClassifOrder,clientID,dicLspecial,procID)
                #
                # La función anterior nos devuelve un diccionario con todos los clientes y sus características
                # Llamaremos a la siguiente función con las caracterísricas especificas de nuestro cliente
                #
                order,features=[],[]
                for index in dicLspecial['L2'].keys():
                    order.append(int(index))
                for o in sorted(order):
                    features.append("col"+str(o))   # en la BD las columnas en la tabla de dataSet no tienen nombre, son "col1",....
                L_predict=[]
                L_train=[]         # En esta variable cargaremos los valores de los dataSet de entrenamiento
                features_predict=features
                features_train=features
                #backup 11.09.14 --> client.loadTrainDataSet(keyspace,dicDBvariables['maxTrainDataSet'],0,L_predict,features_predict,clientID,datasetID,True,True,procID)                
                client.loadTrainDataSetv2(keyspace,dicDBvariables['maxTrainDataSet'],0,L_predict,features_predict,clientID,datasetID,True,True,procID)                
                log.info(procID+" <main> Features Train: "+str(features_train))
                #backup 11.09.14 --> client.loadTrainDataSet(keyspace,dicDBvariables['maxTrainDataSet'],dicDBvariables['minTrainDataSet'],L_train,features_train,clientID,datasetID,False,True,procID)
                client.loadTrainDataSetv2(keyspace,dicDBvariables['maxTrainDataSet'],dicDBvariables['minTrainDataSet'],L_train,features_train,clientID,datasetID,False,True,procID)
                # En este punto ya tenemos:
                #   - L_predict  --> array que usaremos como a predecir
                #   - L_train    --> array que usaremos como train y test
                # por lo que ya podemos aplicar los algoritmos de ML.
                #
                # Tenemos que realizar la validación contra la BD de conocimiento externo para las alarmas de la Regresión Lineal
                # ---- NEW : 05.09.14
                lisInformationDB = []
                lisInformationDB = client.extractDatasetInformation(keyspace,clientID,datasetID,dicLspecial,procID) 
                listAlarmsDB = []
                listAlarmsDB = client.searchAlarmsByDataSet(keyspace,clientID,datasetID,procID) 
                dicAlarmsLinealRegresion={}
                usefulLibrary.convertListToDicAlarm(lisInformationDB,listAlarmsDB,dicAlarmsLinealRegresion,dicLspecial,procID)  
                dicExternalKnow={}
                if len(dicAlarmsLinealRegresion.keys()) > 0:
                    client.searchExternalKnow(keyspace,dicExternalKnow,clientID,procID)
                    if len(dicExternalKnow.keys()) > 0:
                        dicAlarmsLRePRec={}
                        usefulLibrary.validateExternalKnow(L_predict,dicLspecial,dicAlarmsLinealRegresion,dicExternalKnow,dicAlarmsLRePRec,procID)
                        client.updateAlarm(keyspace,clientID,datasetID,dicAlarmsLRePRec,dicLspecial['L2'],procID)
                # ---- NEW : 05.09.14
                dicAlarmsClusT={}
                dicAlarmsClusP={}
                score=0
                analysis=False
                # El array de entrenamiento puede ser demasiado pequeño comparado con el que deseamos predecir, en tal caso no podremos aplicar
                # el algoritmo de clustering, como norma general, el array de entrenamiento debe suponer el 75% del total
                log.info(procID+" <main> L_train is --> "+str((len(L_train)*100)/(len(L_train)+len(L_predict)))+"%")
                if (len(L_train)) == 0 or (len(L_train)*100)/(len(L_train)+len(L_predict)) < int(dicDBvariables['test_size']): # no hay suficientes dataset anteriores en la BD
                    log.info(procID+" <main> There are not enough datasets in DB, the clustering execution will not be executed.")
                else:
                    machineLearningLibrary.applyClusteringTotal(L_predict,features,L_train,dicDBvariables,dicAlarmsClusT,score,procID)
                    machineLearningLibrary.applyClusteringPartial(L_predict,features,L_train,dicDBvariables,dicAlarmsClusP,score,procID)
                    # dicAlarmsClusP es un diccionario por columna, es decir contiene X subdiccionarios del tipo dicAlarmsClusT (X=num columnas)                
                    analysis=True
                    if len(dicAlarmsClusT.keys()) > 0 or len(dicAlarmsClusP.keys()) > 0: # Hay alarmas
                        log.info(procID+" <main> There are new alarms.")
                        dicAlarmsClusPRec={} # diccionario con las alarmas rectificadas por el conocimiento externo
                        if len(dicAlarmsClusP.keys()) > 0: # Solo en el caso de el CLustering parcial (por columna) se usará la BD de conocimiento externo
                            # NEW --> 05.09.14 -- > ya lo hemos ejecutado antes --> client.searchExternalKnow(keyspace,dicExternalKnow,clientID,procID)
                            if len(dicExternalKnow.keys()) > 0:
                                usefulLibrary.validateExternalKnow(L_predict,dicLspecial,dicAlarmsClusP,dicExternalKnow,dicAlarmsClusPRec,procID) 
                            else:
                                log.info(procID+" <main> There are not external knowedge for this client.")
                            client.insertAlarmsClusCol(keyspace,clientID,datasetID,dicAlarmsClusP,dicAlarmsClusPRec,dicLspecial['L2'],procID)
                        client.insertAlarmsClusRow(keyspace,clientID,datasetID,dicAlarmsClusT,dicLspecial['L2'],procID)
                    else:
                        log.info(procID+" <main> There are not new alarms.")   
                # Actualizar la tabla DATASET con las alarmas.
                listAlarmsDB = client.searchAlarmsByDataSet(keyspace,clientID,datasetID,procID) 
                client.updateDatasetWithAlarms(keyspace,clientID,datasetID,listAlarmsDB,procID)                    
                #OLD --> usefulLibraryFiles.createJSONAlarms(datasetID,clientID,listAlarmsDB,pathF,procID)
                #
                # NEW: 04.09.14 -- Se cambia la generación de los ficheros JSON, ya no tendremos dos diferentes: 
                #                        * uno con el dataset generado por el proceso CLN
                #                        * otro con las alarmas de cada dataset generaro por el MNR
                #                  Ahora el proceso MNR creará un único fichero JSON en el que incluirá tanto el dataset como las alarmas asociadas a el 
                # 
                # Generamos los ficheros
                lisInformationDB = client.extractDatasetInformation(keyspace,clientID,datasetID,dicLspecial,procID) 
                # backup --> usefulLibraryFiles.createJSONAlarmsANDdataset(datasetID,clientID,listAlarmsDB,pathF,lisInformationDB,analysis,procID)
                usefulLibraryFiles.createJSONAlarmsANDdatasetv2(datasetID,clientID,listAlarmsDB,pathF,lisInformationDB,analysis,procID)
                log.info(procID+" <main> File Alarms&Dataset JSON created.")
                client.insertAnalysisInResult(keyspace,clientID,datasetID,analysis,procID)
                log.info(procID+" <main> Dataset updated as analyzed.")
        else:
            # No hay dataSet reciente reciente
            log.info(procID+" <main> There aren't recent dataset for analyzed.")
            log.info(procID+" <main> Applied variable searchWait, sleeping:"+str(dicDBvariables['searchWait'])+" s")
            time.sleep(float(dicDBvariables['searchWait']))
Beispiel #4
0
def main():
    logging.basicConfig()
    dicConfig={}
    # ---- Sacamos las variables mínimas necesarias del fichero de los parámetros pasados al arrancar el proceso
    dicConfig,procID = usefulLibrary.loadArguments()
    dbHost,keyspace = loadBasicConfiguration(dicConfig)
    # ---- Creamos el objeto para trabajar con la BD
    client = cassandraDBconnection.connectionCassandra()
    client.connect([dbHost])
    # ---- Comprobamos la conexión contra la BD
    client.checkDBconnection(keyspace)
    # ---- Cargamos todas la variables COMUNES necesarias de la BD
    dicDBvariables={}
    usedVariablesCom(dicDBvariables)
    client.loadConfiguration(keyspace,dicDBvariables)
    hdlr = logging.FileHandler(str(dicDBvariables['logPath'])+'/'+str(procID)+'.log')
    log.addHandler(hdlr)
    if dicDBvariables['tracesLevel'] == 'DEBUG':
        log.setLevel(logging.DEBUG)
    elif dicDBvariables['tracesLevel'] == 'INFO':
        log.setLevel(logging.INFO)
    elif dicDBvariables['tracesLevel'] == 'WARNING':
        log.setLevel(logging.WARNING)
    elif dicDBvariables['tracesLevel'] == 'ERROR':
        log.setLevel(logging.ERROR)
    elif dicDBvariables['tracesLevel'] == 'CRITICAL':
        log.setLevel(logging.CRITICAL)
    # ---- Cargamos todas la variables del PROCESO necesarias de la BD
    dicDBvarProc={}
    usefulLibrary.usedVariablesProc(dicDBvarProc)
    client.loadConfigurationProc(keyspace,dicDBvarProc,procID) 
    # ---- Registramos en la BD el histórico para este proceso
    insertHist,valuesList,historyID=usefulLibrary.createRecordHistory(procID,keyspace)
    client.executeDBinsert(insertHist,valuesList)
    # ---- EXECUTION LOOP
    while True:
        # ---- Comprobamos si ha habido algún cambio en la configuración de la BD
        dicDBvariables2={}
        usedVariablesCom(dicDBvariables2)
        client.loadConfiguration(keyspace,dicDBvariables2)
        # --
        dicDBvarProc2={}
        usefulLibrary.usedVariablesProc(dicDBvarProc2)
        client.loadConfigurationProc(keyspace,dicDBvarProc2,procID) 
        changes1=usefulLibrary.checkVariables(dicDBvariables,dicDBvariables2)
        changes2=usefulLibrary.checkVariables(dicDBvarProc,dicDBvarProc2)
        if changes1:
            # Re-reading:
            dicDBvariables=dicDBvariables2
        if changes2:
            # Re-reading:
            dicDBvarProc=dicDBvarProc2
        if changes1 or changes2:        
            lastReading=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            valuesList[5]=lastReading
            client.executeDBinsert(insertHist,valuesList)
            if dicDBvarProc['stoppedflag']:
                log.info('Proccess stopped by DB configuration.')
                sys.exit(0)
                break
        # Añadimos a la variable de configuración que fija el directorio de entrasada el nombre del proceso
        # para dar lugar a la ruta completa: ej -> /Users/jorgelozano/Monmalev1.0/initial + /SNT000
        pathI=dicDBvariables["initialPath"]+"/"+procID
        # La carpeta final para este proceso es la carpeta de inicial del siguiente
        pathF=dicDBvariables["initialPath"]+"/CLN000"
        pathB=dicDBvariables["backupPath"]+"/"+procID
        pathE=dicDBvariables["errorPath"]+"/"+procID
        newFile=""
        exist=False
        newFile,exist=usefulLibraryFiles.searchFilesIN(pathI,"*.txt",procID)
        if exist:
            dicHeader={}
            error=False
            dicHeader,error=usefulLibraryFiles.readHeaderFile(pathI,newFile)
            # Si se dio algún error al leer la cabecera descartaremos el fichero
            if error:
                # Si hay error movemos el fichero
                er=usefulLibraryFiles.moveFile(pathI,pathE,newFile)
                if er:
                    # Si al intentar mover el fichero tenemos error salimos de la ejecución.
                    sys.exit(1)
                # Si no tenemos error al mover el fichero continuamos la ejecución buscando nuevo ficheros.                    
            else:
                # Continuamos tratando el fichero
                exists=False
                exists=client.searchClient(keyspace,dicHeader["clientID"])
                # Buscamos el ID del cliente de la cabecera en la BD
                if exists:
                    # Si el cleinte ID existe sacamos el resto de elementos de fichero de entrada para
                    # validar que estos pertenecen realmente al cliente especificado.
                    # No se aplicará ningún algoritmo de MA, se aplicarán tres comprobaciones para "clasificar" el fichero de entrada
                    # mas una extra: que el cliente ID de la cabecera corresponda con el "calculado"
                    dicClientsClassification={}
                    client.extractClientsFeatures(keyspace,dicClientsClassification)
                    e=False
                    decoded={}
                    e,decoded=usefulLibraryFiles.readNomFieldFile(pathI,newFile)
                    if e:
                        # si al leer los campos del fichero hemos tenido algún error
                        sys.exit(1)
                    clientID=""
                    classify,clientID=usefulLibrary.applyClassification(dicClientsClassification,decoded)
                    if classify==False:
                        # Si hay error movemos el fichero
                        pathE=dicDBvariables["errorPath"]+"/"+procID
                        er=usefulLibraryFiles.moveFile(pathI,pathE,newFile)
                        if er:
                            # Si al intentar mover el fichero tenemos error salimos de la ejecución.
                            sys.exit(1)
                        # Si no tenemos error al mover el fichero continuamos la ejecución buscando nuevo ficheros. 
                    else:
                        log.info("ClientID of file -->"+str(dicHeader["clientID"]))
                        log.info("ClientID of clas -->"+str(clientID))
                        if dicHeader["clientID"] == clientID:
                            #significa que el clientID del fichero de entrada corresponde con el mismo calculado por la clasificación
                            # Si la clasificación fue bien continuamos
                            # en el diseño original llegados a este punto existía una función que dado el cliente buscaba el último dataSet
                            # almacenado para incrementar en 1 su ID y usarlo para el nuevo, esto se susstituyo por un UUID aleatorio con el
                            # fin de agilizar la operación.
                            # 1.Creara un nuevo DataSetID
                            # 2.Copiará el fichero de entrada
                            # 3.Insertará el nuevo DataSetID en el fichero copiado.
                            # 4. Moverá los ficheros:
                            #    - Original --> a la ruta de backup
                            #    - Copiado  --> a la ruta de salida
                            newDataSetID=usefulLibrary.createUUID()
                            extension=usefulLibrary.extensionDate()
                            # NEW: 09.09.14
                            newFinalPath = client.searchMLFinalpathForClient(keyspace,clientID,procID)
                            log.info(procID+" <main> search new final path for clientTrack -->"+str(newFinalPath))
                            # -----
                            E,fileWithExt=usefulLibraryFiles.createCopyFile(pathI,newFile,extension)
                            if E:
                                # Ha habido algún error al crear el nuevo fichero
                                sys.exit(1)
                            else:
                                if usefulLibraryFiles.addNewDataID(pathI,fileWithExt,newDataSetID):
                                    # Ha habido algún error al editar el fichero
                                    sys.exit(1)
                                else:
                                    if usefulLibraryFiles.moveFile(pathI,pathB,newFile)==True:
                                        # ha habido un error
                                        sys.exit(1)
                                    if usefulLibraryFiles.moveFile(pathI,newFinalPath,fileWithExt)==True:
                                        # ha habido un error
                                        sys.exit(1)
                        else:
                            #significa que el clientID que viene en el fichero no es el correcto
                            pathE=dicDBvariables["errorPath"]+"/"+procID
                            er=usefulLibraryFiles.moveFile(pathI,pathE,newFile)
                            if er:
                                # Si al intentar mover el fichero tenemos error salimos de la ejecución.
                                sys.exit(1)
                            # Si no tenemos error al mover el fichero continuamos la ejecución buscando nuevo ficheros.   
                else:
                    pathE=dicDBvariables["errorPath"]+"/"+procID
                    er=usefulLibraryFiles.moveFile(pathI,pathE,newFile)
                    if er:
                        # Si al intentar mover el fichero tenemos error salimos de la ejecución.
                        sys.exit(1)
                    # Si no tenemos error al mover el fichero continuamos la ejecución buscando nuevo ficheros.   
            #sys.exit(0) -> lo marco porque no se que hace aquí
        else:
            log.info("Applied variable filesWait, sleeping:"+str(dicDBvariables['filesWait'])+" s")
            time.sleep(float(dicDBvariables['filesWait']))