예제 #1
0
    def data_timeframe(self, uuid):
        """
        Returns the time frame (start and end date) for which data from the stream, identified by the UUID,
        is available.
        :param uuid:
        :return:
        """
        resp = JOb()
        resp.uuid = uuid
        try:
            if ThreadedTriplestoreAdapter.triplestore:
                sd = self.rm.getSensorDescriptionByUUID(uuid)
                if sd:
                    data = ThreadedTriplestoreAdapter.triplestore.getStreamMinMaxDate(sd.graphName, formatSensorID(sd))
                    resp.status = "Ok"
                    resp.message = ""
                    resp.data = data
                else:
                    raise Exception("no stream with given uuid known")
            else:
                resp.status = "Fail"
                resp.message = "Triplestore not activated."
        except Exception as e:
            resp.status = "Fail"
            resp.message = e.message

        return resp.dumps()
예제 #2
0
 def getAllLastQualities(self):
     from virtualisation.wrapper.abstractwrapper import AbstractWrapper, AbstractComposedWrapper
     qualities = []
     wrappers = self.rm.wrappers
     for wrapper in wrappers:
         if isinstance(wrapper, AbstractWrapper):
             if wrapper.qoiSystem.initialised:
                 qualities.append(wrapper.qoiSystem.getLastQoI())
                 qualities[-1].uuid = wrapper.getSensorDescription().uuid
             else:
                 resp = JOb()
                 resp.uuid = wrapper.getSensorDescription().uuid
                 resp.status = "Fail"
                 resp.message = "Quality System not initialised for given uuid"
                 qualities.append(resp)
         elif isinstance(wrapper, AbstractComposedWrapper):
             for aWrapper in wrapper.wrappers:
                 if aWrapper.qoiSystem.initialised:
                     qualities.append(aWrapper.qoiSystem.getLastQoI())
                     qualities[-1].uuid = aWrapper.getSensorDescription().uuid
                 else:
                     resp = JOb()
                     resp.uuid = aWrapper.getSensorDescription().uuid
                     resp.status = "Fail"
                     resp.message = "Quality System not initialised for given uuid"
                     qualities.append(resp)
     return JOb(qualities).dumps()
예제 #3
0
    def snapshot(self, uuid, start=None, end=None):
        """
        Get previous observations
        :param uuid: The uuid of the wrapper
        :param start: The start date in the format %Y-%m-%dT%H:%M:%S
        :param end: The end date in the format %Y-%m-%dT%H:%M:%S
        :return: a JSON answer
        """
        resp = JOb()
        resp.uuid = uuid
        try:
            from virtualisation.resourcemanagement.resourcemanagement import ResourceManagement
            if ResourceManagement.args.triplestore:
                sd = self.rm.getSensorDescriptionByUUID(uuid)
                if sd:
                    data = ThreadedTriplestoreAdapter.triplestore.getObservationGraph(sd.graphName, formatSensorID(sd), start, end, False)
                    resp.status = "Ok"
                    resp.message = ""
                    resp.data = data
                else:
                    raise Exception("no stream with given uuid known")
            else:
                raise Exception("Triplestore not enabled in Resource Management")

        except Exception as e:
            resp.status = "Fail"
            resp.message = e.message

        return resp.dumps()
예제 #4
0
 def get_static_stream_data(self, uuid):
     resp = JOb()
     resp.uuid = uuid
     if uuid in self.static_stream_data_cache:
         resp.status = "Ok"
         resp.message = ""
         resp.data = self.static_stream_data_cache[uuid]
     else:
         resp.status = "Fail"
         resp.message = "No sensor stream with uuid " + uuid + " known."
     return resp.dumps()
예제 #5
0
 def avg_processing_time(self, uuid = None, category = None):
     job = JSONObject()
     if uuid:
         uuid = uuid.split(",")
         for u in uuid:
             stats = Stats.getOrMake(u)
             job[u] = []
             pTimes = stats.getAverageProcessingTimes()
             if pTimes:
                 job[u].extend(pTimes)
             else:
                 failJob = JSONObject()
                 failJob.status = "Fail"
                 failJob.message = "UUID not found"
                 job[u] = failJob
     elif category:
         category = category.split(",")
         avgList = {}
         for c in category:
             uuidList = self.rm.getUUIDsForCategory(c)
             statList = []
             valueMap={}
             for uuid in uuidList:
                 stats = Stats.getOrMake(uuid)
                 self.test(valueMap, stats.getAverageProcessingTimes())
                 statList += stats.getAverageProcessingTimes()
             for key, value in valueMap.items():
                 valueMap[key] = value / len(uuidList)
             
             avgList[c] = []
             self.valueMapToJson(valueMap, avgList[c], None, None)
         job = JSONObject()
         for element in avgList:
             job[element] = []
             pTimes = avgList[element]
             if pTimes:
                 job[element].extend(pTimes)
             else:
                 failJob = JSONObject()
                 failJob.status = "Fail"
                 failJob.message = "Category not found"
                 job[element] = failJob
     else:
         statList = Stats.getAllStats()
         for s in statList:
             job[s.name] = []
             job[s.name].extend(s.getAverageProcessingTimes())
     return job.dumps()
예제 #6
0
 def deploy(self, deployunit):
     resp = JOb()
     if deployunit.filename.endswith(".zip"):
         from virtualisation.resourcemanagement.resourcemanagement import ResourceManagement
         trg = os.path.join(ResourceManagement.deployfoldername, deployunit.filename)
         dst = open(trg, "w")
         dst.write(deployunit.file.read())
         dst.close()
         try:
             resp.status, resp.message, resp.sensordescriptions = self.rm.deploy(trg, True)
         except Exception as e:
             resp.status = "Fail"
             resp.message = e.message
     else:
         resp.status = "Fail"
         resp.message = "Wrong file type."
     return resp.dumps()
예제 #7
0
 def get_description(self, uuid):
     resp = JOb()
     sd = self.rm.getSensorDescriptionByUUID(uuid)
     if sd:
         resp.status = "Ok"
         resp.message = ""
         resp.data = sd
     else:
         ed = self.rm.getEventDescriptionByUUID(uuid)
         if ed:
             resp.status = "Ok"
             resp.message = ""
             resp.data = ed
         else:
             resp.status = "Fail"
             resp.message = "no stream with given uuid known"
     return resp.dumps()
예제 #8
0
 def deactivate_fault_recovery(self, uuid):
     """
     Disable the fault recovery for a wrapper
     :param uuid: UUID identifying the wrapper
     :return:
     """
     resp = JOb()
     resp.uuid = uuid
     w = self.rm.getWrapperByUUID(uuid)
     if w:
         w.deactivateFaultRecovery()
         resp.status = "Ok"
         resp.message = ""
     else:
         resp.status = "Fail"
         resp.message = "no stream with given uuid known"
     return resp.dumps()
예제 #9
0
 def register_event(self, eventdescription):
     resp = JOb()
     if eventdescription.filename.endswith(".json"):
         from virtualisation.resourcemanagement.resourcemanagement import ResourceManagement
         trg = os.path.join(ResourceManagement.eventdescriptionfoldername, eventdescription.filename)
         dst = open(trg, "w")
         dst.write(eventdescription.file.read())
         dst.close()
         try:
             resp.status, resp.message = self.rm.registerEvent(trg)
         except Exception as e:
             resp.status = "Fail"
             resp.message = e.message
     else:
         resp.status = "Fail"
         resp.message = "Wrong file type."
     return resp.dumps()
예제 #10
0
 def snapshot_last(self, uuid):
     """
     Get previous observations
     :param uuid: The uuid of the wrapper
     :param start: The start date in the format %Y-%m-%dT%H:%M:%S
     :param end: The end date in the format %Y-%m-%dT%H:%M:%S
     :return: a JSON answer
     """
     resp = JOb()
     resp.uuid = uuid
     if uuid in self.observation_cache:
         resp.status = "Ok"
         resp.message = ""
         resp.data = self.observation_cache[uuid]
     else:
         resp.status = "Fail"
         resp.message = "No observation with the UUID " + uuid + " cached."
     return resp.dumps()
예제 #11
0
    def data_timeframe_sql(self, uuid):
        """
        Returns the time frame (start and end date) for which data from the stream, identified by the UUID,
        is available.
        :param uuid:
        :return:
        """
        resp = JOb()
        resp.uuid = uuid
        try:
            if self.rm.sql:
                data = self.rm.sql.data_timeframe(uuid)
                resp.status = "Ok"
                resp.message = ""
                resp.data = data
            else:
                resp.status = "Fail"
                resp.message = "SQL feature not activated."
        except Exception as e:
            resp.status = "Fail"
            resp.message = e.message

        return resp.dumps()
예제 #12
0
    def getQualityValues(self, uuid=None, types=None, avg=None, minimum=None, maximum=None):
        if types:
            types = types.split(",")
        if uuid:
            uuid = uuid.split(",")
        else:   #get all uuids from wrapper list
            from virtualisation.wrapper.abstractwrapper import AbstractWrapper, AbstractComposedWrapper
            uuid = []
            wrappers = self.rm.wrappers
            for wrapper in wrappers:
                if isinstance(wrapper, AbstractWrapper):
                    uuid.append(wrapper.getSensorDescription().uuid)
                elif isinstance(wrapper, AbstractComposedWrapper):
                    for aWrapper in wrapper.wrappers:
                        uuid.append(aWrapper.getSensorDescription().uuid)

        qualities = []
        for _uuid in uuid:
            wrapper = self.rm.getWrapperByUUID(_uuid)
            message = ""
            if wrapper:
                if wrapper.qoiSystem.initialised:
                    avgQualities = []
                    avgQualities.append(wrapper.qoiSystem.getLastQoI(types=types, avg=valueToBoolean(avg), minimum=valueToBoolean(minimum), maximum=valueToBoolean(maximum)))
                    avgQualities[-1].uuid = wrapper.getSensorDescription().uuid
                    qualities.extend(JOb(avgQualities))
                else:
                    message = "AVG Quality System not initialised for given uuid"
            else:
                message = "no stream with given uuid known"
            if message:
                resp = JOb()
                resp.uuid = _uuid
                resp.status = "Fail"
                resp.message = message
                qualities.append(resp)
        return JOb(qualities).dumps()
예제 #13
0
    def snapshot_quality(self, uuid, start=None, end=None):
        """
        Get previous quality annotations
        :param uuid: The uuid of the wrapper/stream
        :param start: The start date in the format %Y-%m-%dT%H:%M:%S
        :param end: The end date in the format %Y-%m-%dT%H:%M:%S
        :return: a JSON answer
        """
        resp = JOb()
        resp.uuid = uuid
        resp.result = []
        uuid = uuid.split(",")
        
        try:
            from virtualisation.resourcemanagement.resourcemanagement import ResourceManagement
            if ResourceManagement.args.triplestore:
                graphMap = {}
                working_uuids = []
                for _id in uuid:
                    sd = self.rm.getSensorDescriptionByUUID(_id)
                    if sd is not None:
                        if not graphMap.has_key(sd.graphName):
                            graphMap[sd.graphName] = [formatSensorID(sd)]
                        else:
                            graphMap[sd.graphName].append(formatSensorID(sd))
                        working_uuids.append(_id)
                    else:
                        d = JOb()
                        d.message = "Wrong UUID"
                        resp.result.append(JOb({"uuid": _id, "error": d}))    
                resp.status = "Ok"
                
                sortedReturn = {}
                for graph in graphMap:
                    tmpData = ThreadedTriplestoreAdapter.triplestore.getLastQoIData_List(graph, graphMap[graph], start, end)
                    if tmpData is None:
                        raise Exception("Virtuoso Exception or no data for given start/end date")
                    else:
                        if len(tmpData["results"]["bindings"]) == 0:
                            pass
                        else:
                            for key in tmpData["results"]["bindings"]:
                                sensorUUID = key["sensor"]["value"].replace("http://ict-citypulse.eu/SensorID-", "")
                                if sensorUUID in sortedReturn:
                                    sortedReturn[sensorUUID].append(key)
                                else:
                                    sortedReturn[sensorUUID] = []
                                    sortedReturn[sensorUUID].append(key)
                
                for _id in working_uuids:
                    if _id in sortedReturn:
                        data = []
                        for tmp in sortedReturn[_id]:
                            d = JOb()
                            d.time = tmp["resultTimeValue"]["value"]
                            d.data = tmp
                            data.append(d) 
                        data.sort(cmp=lambda x, y: cmp(x.time, y.time))
                        resp.result.append(JOb({"uuid": _id, "dataset": data}))
                    else:
                        d = JOb()
                        d.message = "No data available"
                        resp.result.append(JOb({"uuid": _id, "error": d}))    
                    
                resp.result.sort(cmp=lambda x, y: uuid.index(x.uuid) - uuid.index(y.uuid))    
            else:
                raise Exception("Triplestore not enabled in Resource Management")

        except Exception as e:
            resp.status = "Fail"
            resp.message = e.message

        return resp.dumps()