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']))
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']))
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']))
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']))