482 lines
18 KiB
Python
482 lines
18 KiB
Python
import os
|
|
import time
|
|
from uuid import uuid4
|
|
import uuid
|
|
from flask import jsonify
|
|
import json
|
|
|
|
from marshmallow import EXCLUDE, ValidationError
|
|
#from vrpmdvcreatemoncmd import VRPMDV_CreateMonCmd
|
|
#from vrpmdvcreatemonschema import VRPMDV_CreateMonSchema
|
|
#from vrpmdvdeletemoncmd import VRPMDV_DeleteMonCmd
|
|
#from vrpmdvdeletemonschema import VRPMDV_DeleteMonSchema
|
|
from vrpmdvmonfilescompleteschema import VRPMDV_MonfilesCompleteSchema
|
|
from vrpmdvmonfilter import VRPMDV_MonFilter
|
|
from vrpmdvmonfilterschema import VRPMDV_MonFilterSchema
|
|
from vrpmdvmonsensorschema import VRPMDV_MonSensorSchema
|
|
from vrpmdvmonchannelschema import VRPMDV_MonChannelSchema
|
|
from vrpmdvmonfilesschema import VRPMDV_MonfilesSchema
|
|
from vrpmdvmonitoring import VRPMDV_Monitoring
|
|
from vrpmdvmonitoringschema import VRPMDV_MonitoringSchema
|
|
from vrpmdvmonreqschema import VRPMDV_MonReqSchema
|
|
# from vrpmdvntlink import trySend
|
|
|
|
from extensions.rt_service import rt_service as rts
|
|
from vrpmdvmonitoringState import VRPMDVMonitoringState
|
|
#from vrpmdvlogging import createCoproLoggingTask
|
|
import logging
|
|
|
|
|
|
class VRPMDV_Data:
|
|
|
|
def __init__(self):
|
|
#self.loaded = False
|
|
format = "%(asctime)s: %(message)s"
|
|
logging.basicConfig(format=format, level=logging.INFO, datefmt="%H:%M:%S")
|
|
self.mons:list = []
|
|
#TODO ML: uncomment this lines
|
|
self.rtservice = None #rts.RT_Service()
|
|
if (self.rtservice != None):
|
|
self.rtservice.initCoproFW("home/root/elffile","zephyr_openamp_rsc_table.elf")
|
|
self.logTask = None #createCoproLoggingTask()
|
|
self.loaded = self.loadFile()
|
|
self.monfilespath = '/home/root/monfiles/'
|
|
#start the monitorings
|
|
time.sleep(1)
|
|
self.startMons();
|
|
|
|
|
|
|
|
def loadFile(self):
|
|
try:
|
|
with open('./mons.json', 'r') as f:
|
|
fmons = f.read()
|
|
|
|
if not fmons:
|
|
# return no Item
|
|
return True
|
|
else:
|
|
# data = json.loads(fmons)
|
|
schema = VRPMDV_MonitoringSchema(many=True)
|
|
#res = schema.loads(fmons) # data
|
|
self.mons = schema.loads(fmons) # .append(res)
|
|
return True
|
|
except:
|
|
#nothing todo ML we should create a file later the database
|
|
print("file not found")
|
|
|
|
def saveFile(self):
|
|
try:
|
|
with open('./mons.json', 'w') as f:
|
|
schema = VRPMDV_MonitoringSchema()
|
|
result = schema.dumps(self.mons, many=True)
|
|
f.write(result)
|
|
return True
|
|
except:
|
|
#nothing todo
|
|
print("could not write file")
|
|
|
|
def startMons(self):
|
|
try:
|
|
logging.info("MainThread: startMons")
|
|
# for i, val in enumerate(self.mons):
|
|
# if (val.status == 'started') :
|
|
# val.startMonitoring()
|
|
except:
|
|
print("could not start monitorings")
|
|
|
|
|
|
|
|
def findMon(mon):
|
|
return mon
|
|
|
|
def getMonitorings(self):
|
|
# 1st time read file
|
|
# if not self.loaded :
|
|
# self.loaded = self.loadFile()
|
|
|
|
schema = VRPMDV_MonitoringSchema()
|
|
result = schema.dumps(self.mons, many=True)
|
|
return result
|
|
|
|
def getMonitoring(self, vrpmid):
|
|
try:
|
|
matched_obj = next(x for x in self.mons if str(x.id) == vrpmid)
|
|
except:
|
|
return "no Item found"
|
|
|
|
# we find it and we return it
|
|
schema = VRPMDV_MonitoringSchema()
|
|
return schema.dumps(matched_obj)
|
|
|
|
|
|
|
|
def setMonitoring(self, id, request):
|
|
try:
|
|
matched_obj = next(x for x in self.mons if str(x.id) == id)
|
|
except:
|
|
return "no Item found"
|
|
|
|
if 'name' in request : matched_obj.name = request['name']
|
|
if 'samplerate' in request : matched_obj.samplerate = request['samplerate']
|
|
if 'sampleperiod' in request : matched_obj.sampleperiod = request['sampleperiod']
|
|
if 'downtime' in request : matched_obj.downtime = request['downtime']
|
|
if 'status' in request :
|
|
if (request['status'] == 'started'):
|
|
if (matched_obj.status == VRPMDVMonitoringState.STOPPED):
|
|
logging.info("MainThread: started %s", matched_obj.id)
|
|
matched_obj.startMonitoring()
|
|
# matched_obj.setStatus(self.createMonOnDevice(matched_obj))
|
|
elif (matched_obj.status == 'started') :
|
|
logging.info("MainThread: stopped %s", matched_obj.id)
|
|
# matched_obj.setStatus(self._stopMonitoring(matched_obj))
|
|
matched_obj.stopMonitoring()
|
|
self.saveFile()
|
|
|
|
# we find it and we return it
|
|
schema = VRPMDV_MonitoringSchema()
|
|
return schema.dumps(matched_obj)
|
|
|
|
|
|
def createMonitoring(self, request):
|
|
id = uuid.uuid4()
|
|
createjson = request.get_json()
|
|
vrpmreq = VRPMDV_MonReqSchema().load(createjson)
|
|
|
|
mon = VRPMDV_Monitoring(0, id, vrpmreq.name, vrpmreq.samplerate, vrpmreq.sampleperiod, vrpmreq.downtime, vrpmreq.status, vrpmreq.owner)
|
|
logging.info("Monitoring %s: creating", str(id))
|
|
|
|
# create Monitoring on the realtime side
|
|
if (vrpmreq.status == 'started'):
|
|
logging.info("Monitoring %s: createMonOnDevice", str(id))
|
|
mon.startMonitoring()
|
|
# status = self.createMonOnDevice(mon)
|
|
# logging.info("Monitoring %s: _start executed. status:%s", str(id), str(status))
|
|
# mon.status = status
|
|
|
|
self.mons.append(mon)
|
|
#save to file
|
|
self.saveFile()
|
|
#create result Object in json
|
|
schema = VRPMDV_MonitoringSchema()
|
|
return schema.dumps(mon)
|
|
|
|
|
|
def deleteMonitoring(self, vrpmid):
|
|
# if not self.loaded :
|
|
# self.loaded = self.loadFile()
|
|
|
|
# find monitoring with uuid
|
|
#result = filter(lambda mon: str(mon.uuid) == vrpmid["uuid"], self.mons)
|
|
try:
|
|
matched_obj = next(x for x in self.mons if str(x.id) == vrpmid)
|
|
except:
|
|
return "no Item found"
|
|
|
|
|
|
# we find it, delete on realtime side and now remove from list
|
|
matched_obj.stopMonitoring()
|
|
self.mons.remove(matched_obj)
|
|
#save the list
|
|
self.saveFile()
|
|
#make result
|
|
schema = VRPMDV_MonitoringSchema()
|
|
return schema.dump(matched_obj)
|
|
|
|
|
|
# internal helper function
|
|
|
|
# ML: transfer to Monitoring class
|
|
# def createMonOnDevice(self, monitoring):
|
|
# #call the start API of the c++ driver
|
|
# try:
|
|
|
|
# logging.info("MainThread: createMonOnDevice => before vrpmdCreateCmd samplerate:%d, samplerate:%d, samplerate:%d", monitoring.samplerate, monitoring.sampleperiod, monitoring.downtime)
|
|
# vrpmdCreateCmd = VRPMDV_CreateMonCmd(monitoring.samplerate, monitoring.sampleperiod, monitoring.downtime)
|
|
# logging.info("MainThread: createMonOnDevice => before schemaCreateCmd")
|
|
# schemaCreateCmd = VRPMDV_CreateMonSchema()
|
|
# logging.info("MainThread: try send start monitoring starting %s", schemaCreateCmd.dumps(vrpmdCreateCmd))
|
|
# #res = trySend(schemaCreateCmd.dumps(vrpmdCreateCmd))
|
|
# #logging.info("MainThread: try send start monitoring done %s", res)
|
|
# self.status = "started"
|
|
# # set status if we have a success TODO
|
|
# except:
|
|
# self.status = "stopped"
|
|
# return "stopped"
|
|
# return "started"
|
|
|
|
|
|
# def _stopMonitoring(self, monitoring):
|
|
# #call the stop API of the c++ driver
|
|
# try:
|
|
# logging.info("MainThread: stop monitoring")
|
|
# vrpmdDeleteCmd = VRPMDV_DeleteMonCmd(2, monitoring.id)
|
|
# schemaDeleteCmd = VRPMDV_DeleteMonSchema()
|
|
|
|
# #trySend(schemaDeleteCmd.dumps(vrpmdDeleteCmd))
|
|
# self.status = "stopped"
|
|
# logging.info("MainThread: stop monitoring done")
|
|
|
|
# except:
|
|
# self.status = "started"
|
|
# return "started"
|
|
|
|
# return monitoring.status
|
|
|
|
|
|
# old impl ML
|
|
#
|
|
# def createMonitoring(self, request):
|
|
# id = uuid.uuid4()
|
|
|
|
# createjson = request.get_json()
|
|
# vrpmreq = VRPMDV_MonReqSchema().load(createjson)
|
|
# vrpmdCreateCmd = VRPMDV_CreateMonCmd(1, id , vrpmreq.samplerate, vrpmreq.sampleperiod, vrpmreq.downtime, vrpmreq.status)
|
|
# schemaCreateCmd = VRPMDV_CreateMonSchema()
|
|
|
|
# valstr = schemaCreateCmd.dumps(vrpmdCreateCmd)
|
|
# trySend(schemaCreateCmd.dumps(vrpmdCreateCmd))
|
|
|
|
# mon = VRPMDV_Monitoring(id, vrpmreq.name, vrpmreq.samplerate, vrpmreq.sampleperiod, vrpmreq.downtime, vrpmreq.status, vrpmreq.owner)
|
|
# logging.info("Monitoring %s: starting", str(id))
|
|
# mon.startMonitoring()
|
|
|
|
# self.mons.append(mon)
|
|
# #save to file
|
|
# self.saveFile()
|
|
# #create result Object in json
|
|
# schema = VRPMDV_MonitoringSchema()
|
|
# return schema.dumps(mon)
|
|
|
|
|
|
|
|
|
|
# def createMonitoring(self, request):
|
|
# id = uuid.uuid4()
|
|
|
|
# createjson = request.get_json()
|
|
# vrpmreq = VRPMDV_MonReqSchema().load(createjson)
|
|
# vrpmdCreateCmd = VRPMDV_CreateMonCmd(1, id , vrpmreq.samplerate, vrpmreq.sampleperiod, vrpmreq.downtime, vrpmreq.status)
|
|
# schemaCreateCmd = VRPMDV_CreateMonSchema()
|
|
|
|
# valstr = schemaCreateCmd.dumps(vrpmdCreateCmd)
|
|
# trySend(schemaCreateCmd.dumps(vrpmdCreateCmd))
|
|
|
|
# mon = VRPMDV_Monitoring(id, vrpmreq.name, vrpmreq.samplerate, vrpmreq.sampleperiod, vrpmreq.downtime, vrpmreq.status, vrpmreq.owner)
|
|
# logging.info("Monitoring %s: starting", str(id))
|
|
# mon.startMonitoring()
|
|
|
|
# self.mons.append(mon)
|
|
# #save to file
|
|
# self.saveFile()
|
|
# #create result Object in json
|
|
# schema = VRPMDV_MonitoringSchema()
|
|
# return schema.dumps(mon)
|
|
|
|
|
|
# def deleteMonitoring(self, vrpmid):
|
|
# # if not self.loaded :
|
|
# # self.loaded = self.loadFile()
|
|
|
|
# # find monitoring with uuid
|
|
# #result = filter(lambda mon: str(mon.uuid) == vrpmid["uuid"], self.mons)
|
|
# try:
|
|
# matched_obj = next(x for x in self.mons if str(x.id) == vrpmid)
|
|
# except:
|
|
# return "no Item found"
|
|
|
|
|
|
# # we find it, delete on realtime side and now remove from list
|
|
# #matched_obj.deleteMonitoring()
|
|
# self.mons.remove(matched_obj)
|
|
# #save the list
|
|
# self.saveFile()
|
|
# #make result
|
|
# schema = VRPMDV_MonitoringSchema()
|
|
# return schema.dump(matched_obj)
|
|
|
|
|
|
# def startMonitoring(self, vrpmid):
|
|
# # if not self.loaded :
|
|
# # self.loaded = self.loadFile()
|
|
|
|
# #call the start API of the c++ driver
|
|
# try:
|
|
# matched_obj = next(x for x in self.mons if str(x.id) == vrpmid)
|
|
|
|
# except:
|
|
# return "no Item found"
|
|
|
|
# if matched_obj.startMonitoring() :
|
|
# #TODO ML return the state
|
|
# return "started"
|
|
|
|
# return "created"
|
|
|
|
# def stopMonitoring(self, vrpmid):
|
|
# # if not self.loaded :
|
|
# # self.loaded = self.loadFile()
|
|
|
|
# #call the stop API of the c++ driver
|
|
# try:
|
|
# matched_obj = next(x for x in self.mons if str(x.id) == vrpmid)
|
|
# logging.info("MainThread: stop monitoring starting")
|
|
# vrpmdDeleteCmd = VRPMDV_DeleteMonCmd(2, matched_obj.id)
|
|
# schemaDeleteCmd = VRPMDV_DeleteMonSchema()
|
|
# valstr = schemaDeleteCmd.dumps(vrpmdDeleteCmd)
|
|
# trySend(schemaDeleteCmd.dumps(vrpmdDeleteCmd))
|
|
# logging.info("MainThread: stop monitoring done")
|
|
|
|
# except:
|
|
# return "no Item found"
|
|
|
|
# matched_obj.stopMonitoring()
|
|
# return matched_obj.monstate.name
|
|
|
|
|
|
def setStatus(self, id, vrpmStatus):
|
|
if 'status' in vrpmStatus :
|
|
# matched_obj = self.findMonitoring(id)
|
|
#call the start API of the c++ driver
|
|
if (vrpmStatus['status'] == 'started'):
|
|
return self.startMonitoring(id)
|
|
else :
|
|
return self.stopMonitoring(id)
|
|
|
|
# return matched_obj.status
|
|
|
|
# return ""
|
|
|
|
def findMonitoring(self, id):
|
|
try:
|
|
return next(x for x in self.mons if str(x.id) == id)
|
|
except:
|
|
return None #"no Item found"
|
|
|
|
def getMonitoring2files(self):
|
|
#search in the given directory
|
|
dirs = [d for d in os.listdir(self.monfilespath) if os.path.isdir(d)]
|
|
#return for the filter
|
|
|
|
|
|
def getMonitoringfiles(self, id, params):
|
|
#search in the given directory
|
|
monId = params.get('monId')
|
|
logging.basicConfig(format=format, level=logging.INFO, datefmt="%H:%M:%S")
|
|
logging.info("getMonitoringfiles: monId:%s", monId)
|
|
|
|
if (monId == None):
|
|
return None
|
|
|
|
complete = False
|
|
|
|
mons = self.getMonofMonfiles(monId)
|
|
logging.info("getMonitoringfiles: mons.length:%d", len(mons))
|
|
if (len(mons) == 0) :
|
|
return None
|
|
else :
|
|
#TODO ML: only one monitoring
|
|
monId = mons[0].id
|
|
|
|
#TODO ML change to array
|
|
#for file in files:
|
|
filename = self.monfilespath + str(monId) + '/'
|
|
monfiles = self.loadMonfiles(filename, complete)
|
|
schema = VRPMDV_MonfilesSchema()
|
|
result = schema.dumps(monfiles, many=True)
|
|
return result
|
|
|
|
def loadMonfiles(self, id, complete):
|
|
#files = [f for f in os.listdir() if os.path.isfile(f)]
|
|
logging.info("loadMonfiles: monId:%s", id)
|
|
completeMonPath = os.path.dirname(id)
|
|
monfiles = []
|
|
for f in os.listdir(completeMonPath) :
|
|
# if (os.path.isfile(f)) :
|
|
try:
|
|
completeFilepath = id + str(f)
|
|
with open(completeFilepath, 'r') as f:
|
|
logging.info("loadMonfiles: before fmonfile:%s", completeFilepath)
|
|
fmonfile = f.read()
|
|
logging.info("loadMonfiles: after fmonfile:%s", completeFilepath)
|
|
if fmonfile:
|
|
# if (complete):
|
|
# schema = VRPMDV_MonfilesCompleteSchema()
|
|
# else :
|
|
logging.info("loadMonfiles: before schemaload")
|
|
schema = VRPMDV_MonfilesSchema()
|
|
try:
|
|
monfile = schema.loads(fmonfile, unknown=EXCLUDE)
|
|
except ValidationError as err:
|
|
logging.info("SchemaError: %s",err.messages) # => {"email": ['"foo" is not a valid email address.']}
|
|
logging.info("Data: %s",err.valid_data) # => {"name": "John"}
|
|
monfiles.append(monfile)
|
|
except:
|
|
#nothing todo ML we should create a file later the database
|
|
print("file not found")
|
|
logging.info("loadMonfiles: file not found:%s", completeFilepath)
|
|
return monfiles
|
|
|
|
|
|
def getMonsDFAvalable(self):
|
|
monfilters = []
|
|
mons = self.getMonofMonfiles(0)
|
|
if (len(mons) == 0):
|
|
return None
|
|
else:
|
|
schema = VRPMDV_MonFilterSchema()
|
|
for mon in mons:
|
|
monfilter = VRPMDV_MonFilter(str(mon.id), mon.name)
|
|
monfilters.append(monfilter)
|
|
return schema.dumps(monfilters, many=True)
|
|
|
|
def getMonofMonfiles(self, monId) :
|
|
dirname = os.path.dirname(self.monfilespath)
|
|
dirs = []
|
|
for d in os.listdir(dirname) :
|
|
path_file = self.monfilespath + d #os.sep.join([self.monfilespath, d])
|
|
if os.path.isdir(path_file) :
|
|
dirs.append(d)
|
|
mons = []
|
|
for dir in dirs:
|
|
mon = self.findMonitoring(dir)
|
|
if ((mon != None) and ((monId == 0 ) or (monId == str(mon.id)))):
|
|
mons.append(mon)
|
|
# monId = mon.id
|
|
# else:
|
|
# return None
|
|
|
|
return mons
|
|
|
|
|
|
def getMFDownload(self, params):
|
|
#search in the given directory
|
|
monId = params.get('monId')
|
|
if (monId == None):
|
|
return None
|
|
|
|
fileId = params.get('fileid')
|
|
mons = self.getMonofMonfiles(monId)
|
|
|
|
#TODO ML change to array
|
|
#for file in files:
|
|
filename = self.monfilespath + str(monId) + '/'
|
|
monfiles = self.loadMonfiles(filename, True)
|
|
schema = VRPMDV_MonfilesCompleteSchema()
|
|
result = schema.dumps(monfiles, many=True)
|
|
return result
|
|
|
|
|
|
|
|
# This is to get the directory that the program
|
|
# is currently running in.
|
|
# dir_path = os.path.dirname(os.path.realpath(__file__))
|
|
|
|
# for root, dirs, files in os.walk(dir_path):
|
|
# for file in files:
|
|
|
|
# # change the extension from '.mp3' to
|
|
# # the one of your choice.
|
|
# if file.endswith('.mp3'):
|
|
# print (root+'/'+str(file))
|