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