def handleActuatorCommandResponse(self, data: ActuatorData) -> bool: logging.info("handleActuatorCommandResponse called") #pass data to handler super().handleActuatorCommandResponse(data) #translate data to json and set updstream du = DataUtil() self._handleUpstreamTransmission(ResourceNameEnum.CDA_ACTUATOR_RESPONSE_RESOURCE.value, du.actuatorDataToJson(data))
def handleSensorMessage(self, data: SensorData) -> bool: logging.info("handleSensorMessage called") super().handleSensorMessage(data) # translate sensor data to json and handle it du = DataUtil() self._handleUpstreamTransmission(ResourceNameEnum.CDA_SENSOR_MSG_RESOURCE.value, du.sensorDataToJson(data)) self._handleSensorDataAnalysis(data)
def setUpClass(self): logging.basicConfig(format = '%(asctime)s:%(module)s:%(levelname)s:%(message)s', level = logging.DEBUG) logging.info("Testing DataUtil class...") encodeToUtf8 = False self.dataUtil = DataUtil(encodeToUtf8) self.adName = "FooBar ActuatorData" self.sdName = "FooBar SensorData" self.spdName = "FooBar SystemPerformanceData" self.sampleSpdJson = "{\"name\": \"" + self.spdName + "\", \"timeStamp\":\"2019.01.16 21:32:34.123123\",\"cpuUtil\":0.0,\"diskUtil\":0.0,\"memUtil\":0.0}" self.sampleAdJson = "{\"name\": \"" + self.adName + "\", \"timeStamp\": \"2019-01-20 15:38:35.123123\", \"hasError\": false, \"command\": 0, \"statusCode\": 0, \"stateData\": null, \"curValue\": 0.0}" self.sampleSdJson = "{\"name\": \"" + self.sdName + "\", \"timeStamp\":\"2019.01.16 21:32:34.123123\",\"curValue\":0.0}"
def setUpClass(self): logging.basicConfig(format = '%(asctime)s:%(module)s:%(levelname)s:%(message)s', level = logging.DEBUG) logging.info("Running DataIntegrationTest test cases...") encodeToUtf8 = False self.dataUtil = DataUtil(encodeToUtf8) self.cdaDataPath = ConfigUtil().getProperty(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TEST_CDA_DATA_PATH_KEY) self.gdaDataPath = ConfigUtil().getProperty(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TEST_GDA_DATA_PATH_KEY) if not os.path.exists(self.cdaDataPath): logging.info("================================================") logging.info("DataIntegrationTest - path needs to be created: " + self.cdaDataPath) os.makedirs(self.cdaDataPath, exist_ok = True)
def testStartAndStopManagerWithMqtt(self): """ NOTE: Be sure to enable CoAP by setting the following flag to True within PiotConfig.props enableMqttClient = True enableCoapClient = False """ ddMgr = DeviceDataManager() ddMgr.startManager() mqttClient = MqttClientConnector() mqttClient.connectClient() ad = ActuatorData() ad.setCommand(1) adJson = DataUtil().actuatorDataToJson(ad) mqttClient.publishMessage(ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE, msg=adJson, qos=1) sleep(10) mqttClient.disconnectClient() ddMgr.stopManager()
def testActuatorCmdPubSub(self): qos = 1 # NOTE: delay can be anything you'd like - the sleep() calls are simply to slow things down a bit for observation delay = self.cfg.getInteger(ConfigConst.MQTT_GATEWAY_SERVICE, ConfigConst.KEEP_ALIVE_KEY, ConfigConst.DEFAULT_KEEP_ALIVE) actuatorData = ActuatorData() payload = DataUtil().actuatorDataToJson(actuatorData) listener = DefaultDataMessageListener() self.mcc.setDataMessageListener(listener) self.mcc.connectClient() sleep(5) self.mcc.publishMessage( resource=ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE, msg=payload, qos=qos) sleep(delay) self.mcc.disconnectClient()
def handleSystemPerformanceMessage(self, data: SystemPerformanceData) -> bool: logging("handleSystemPerformanceMessage method is called...") self._handleUpstreamTransmission( ResourceNameEnum.CDA_SYSTEM_PERF_MSG_RESOURCE, DataUtil.systemPerformanceDataToJson(self, data)) pass
def _onGetResponse(self, response): logging.info('[COAP_CALLBACK] GET response received.') if response: logging.info('Token: ' + str(response.token)) logging.info(str(response.location_path)) logging.info(str(response.payload)) # # NOTE: This next section is optional if you want to send a callback to the self.dataMsgListener instance # # TODO: get the URI and convert to ResourceNameEnum resource = ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE msg = str(response.payload) if response.payload: ad = DataUtil.jsonToActuatorData(self, msg) if ad.getActuatorType() == 4: resource = ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE else: resource = ResourceNameEnum.CDA_CLOUD_ACTUATOR_CMD_RESOURCE if self.dataMsgListener and response.payload: self.dataMsgListener.handleIncomingMessage(resource, msg)
def testActuatorCmdPubSub(self): qos = 0 delay = self.cfg.getInteger(ConfigConst.MQTT_GATEWAY_SERVICE, ConfigConst.KEEP_ALIVE_KEY, ConfigConst.DEFAULT_KEEP_ALIVE) actuatorData = ActuatorData() actuatorData.setCommand(7) self.mcc.setDataMessageListener(DefaultDataMessageListener()) payload = DataUtil().actuatorDataToJson(actuatorData) self.mcc.connectClient() sleep(5) self.mcc.publishMessage( resource=ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE, msg=payload, qos=qos) sleep(delay + 5) self.mcc.disconnectClient()
def __init__(self): self.dataUtil = DataUtil() self.configUtil = ConfigUtil() self.host = self.configUtil.getProperty( ConfigConst.DATA_GATEWAY_SERVICE, ConfigConst.HOST_KEY) self.port = self.configUtil.getInteger( ConfigConst.DATA_GATEWAY_SERVICE, ConfigConst.PORT_KEY) self.enableCrypt = self.configUtil.getBoolean( ConfigConst.DATA_GATEWAY_SERVICE, ConfigConst.ENABLE_CRYPT_KEY) if self.enableCrypt: self.credFilePath = self.configUtil.getProperty( ConfigConst.DATA_GATEWAY_SERVICE, ConfigConst.CRED_FILE_KEY) # TODO: init redis with encryption logging.info("Redis client setting: host = {0}, port = {1}.".format( self.host, self.port)) # Init with no connection established self.curConnection: redis.client.Redis = None
def onActuatorCommandMessage(self, client, userdata, msg): logging.info('[Callback] Actuator command message received. Topic: %s.', msg.topic) if self.dataMsgListener: try: actuatorData = DataUtil().jsonToActuatorData(msg.payload) self.dataMsgListener.handleActuatorCommandMessage(actuatorData) except: logging.exception("Failed to convert incoming actuation command payload to ActuatorData: ")
def setUpClass(self): logging.basicConfig( format='%(asctime)s:%(module)s:%(levelname)s:%(message)s', level=logging.DEBUG) logging.info("Testing DataUtil class...") encodeToUtf8 = False self.dataUtil = DataUtil(encodeToUtf8) self.adName = "FooBar ActuatorData" self.sdName = "FooBar SensorData" self.spdName = "FooBar SystemPerformanceData" self.sampleSpdJson = "{\"name\": \"" + self.spdName + "\", \"timeStamp\":\"2019-01-16T21:32:34.123123\",\"cpuUtil\":0.0,\"diskUtil\":0.0,\"memUtil\":0.0}" self.sampleAdJson = "{\"name\": \"" + self.adName + "\", \"timeStamp\": \"2019-01-20T15:38:35.123123\", \"hasError\": false, \"command\": 0, \"statusCode\": 0, \"stateData\": null, \"curValue\": 0.0}" self.sampleSdJson = "{\"name\": \"" + self.sdName + "\", \"timeStamp\":\"2019-01-16T21:32:34.123123\",\"curValue\":0.0}" self.sampleAd2Json = "{\"actuatorType\":0,\"command\":1,\"value\":12.5,\"isResponse\":false,\"stateData\":\"\",\"name\":\"DataUtilTestName\",\"timeStamp\":\"2021-01-03T02:21:25.163507800Z\",\"statusCode\":1,\"typeID\":0,\"locationID\":\"gatewaydevice001\",\"latitude\":0.0,\"longitude\":0.0,\"elevation\":0.0,\"timeStampMillis\":1609640485163}"
def onActuatorCommandMessage(self, client, userdata, msg): ##logging.info('[MQTT_CALLBACK] Actuator command message received. Topic: %s.', msg.topic) jsonData = str(msg.payload, encoding="utf-8") if self.dataMsgListener: try: actuatorData = DataUtil().jsonToActuatorData(jsonData) self.dataMsgListener.handleActuatorCommandMessage(actuatorData) except: logging.exception( "Failed to convert incoming actuation command payload to ActuatorData: " )
def _handleIncomingDataAnalysis(self, msg: str): """ Call this from handleIncomeMessage() to determine if there's any action to take on the message. Steps to take: 1) Validate msg: Most will be ActuatorData, but you may pass other info as well. 2) Convert msg: Use DataUtil to convert if appropriate. 3) Act on msg: Determine what - if any - action is required, and execute. """ logging("_handleIncomingDataAnalysis method is called...") self.actuatorAdapterManager.sendActuatorCommand( DataUtil.jsonToActuatorData(self, msg)) pass
def handleSystemPerformanceMessage(self, data: SystemPerformanceData) -> bool: """ handle the SystemPerformanceMessage @return bool """ logging.info( "[CDA_CALLBACK]----->>>The handleSystemPerformanceMessage method is being called" ) spmJson = DataUtil.systemPerformanceDataToJson(self, data) self._handleUpstreamTransmission( ResourceNameEnum.CDA_SYSTEM_PERF_MSG_RESOURCE, spmJson)
def handleIncomingMessage(self, resourceEnum: ResourceNameEnum, msg: str) -> bool: """ handle the IncomingMessage @return bool """ logging.info( "[CDA_CALLBACK]----->>>The handleIncomingMessage method is being called" ) # Use the DataUtil class to convert the msg content (which should be JSON) to an ActuatorData instance ad = DataUtil.jsonToActuatorData(self, msg) self._handleIncomingDataAnalysis(msg)
def _execTestPost(self, maxTestRuns: int, useCon: bool): sensorData = SensorData() payload = DataUtil().sensorDataToJson(sensorData) startTime = time.time_ns() for seqNo in range(0, maxTestRuns): self.coapClient.sendPostRequest(resource=ResourceNameEnum.CDA_SENSOR_MSG_RESOURCE, enableCON=useCon, payload=payload) endTime = time.time_ns() elapsedMillis = (endTime - startTime) / self.NS_IN_MILLIS print("POST message - useCON = " + str(useCon) + " [" + str(maxTestRuns) + "]: " + str(elapsedMillis) + " ms")
def handleActuatorCommandResponse(self, data: ActuatorData) -> bool: """ handle the ActuatorCommandResponse @return bool """ # Use the DataUtil class to convert the ActuatorData to JSON. logging.info( "[CDA_CALLBACK]----->>>The handleActuatorCommandResponse method is being called" ) adJson = DataUtil.actuatorDataToJson(self, data) self._handleUpstreamTransmission( ResourceNameEnum.CDA_ACTUATOR_RESPONSE_RESOURCE, adJson)
def handleSensorMessage(self, data: SensorData) -> bool: """ handle the SensorMessage @return bool """ logging.info( "[CDA_CALLBACK]----->>>The handleSensorMessage method is being called" ) # Use the DataUtil class to convert the SensorData to JSON sdJosn = DataUtil.sensorDataToJson(self, data) self._handleUpstreamTransmission( ResourceNameEnum.CDA_SENSOR_MSG_RESOURCE, sdJosn) self._handleSensorDataAnalysis(data) if self.enableRedis: self.redisClient.storeData( ResourceNameEnum.CDA_SENSOR_MSG_RESOURCE, data)
def _execTestPublish(self, maxTestRuns: int, qos: int): self.assertTrue(self.mqttClient.connectClient()) sensorData = SensorData() payload = DataUtil().sensorDataToJson(sensorData) startTime = time.time_ns() for seqNo in range(0, maxTestRuns): self.mqttClient.publishMessage( resource=ResourceNameEnum.CDA_SENSOR_MSG_RESOURCE, msg=payload, qos=qos) endTime = time.time_ns() elapsedMillis = (endTime - startTime) / self.NS_IN_MILLIS self.assertTrue(self.mqttClient.disconnectClient()) logging.info("Publish message - QoS " + str(qos) + " [" + str(maxTestRuns) + "]: " + str(elapsedMillis) + " ms")
def _execTestPublish(self, maxTestRuns: int, qos: int): self.assertTrue(self.mqttClient.connectClient()) sensorData = SensorData() payload = DataUtil().sensorDataToJson(sensorData) payloadLen = len(payload) startTime = time.time_ns() for seqNo in range(0, maxTestRuns): self.mqttClient.publishMessage( resource=ResourceNameEnum.CDA_SENSOR_MSG_RESOURCE, msg=payload, qos=qos) endTime = time.time_ns() elapsedMillis = (endTime - startTime) / self.NS_IN_MILLIS self.assertTrue(self.mqttClient.disconnectClient()) logging.info( \ "\n\tTesting Publish: QoS = %r | msgs = %r | payload size = %r | start = %r | end = %r | elapsed = %r", \ qos, maxTestRuns, payloadLen, startTime / 1000, endTime / 1000, elapsedMillis / 1000)
def handleIncomingMessage(self, resourceEnum: ResourceNameEnum, msg: str) -> bool: logging.info("handleIncommingMessage called") #translate json to object and pass it to analysis du = DataUtil() du.jsonToActuatorData(msg) self._handleIncomingDataAnalysis(msg)
class DataIntegrationTest(unittest.TestCase): """ This test case class contains very basic integration tests for DataUtil and data container classes for use between the CDA and GDA to verify JSON compatibility. It should not be considered complete, but serve as a starting point for the student implementing additional functionality within their Programming the IoT environment. """ @classmethod def setUpClass(self): logging.basicConfig(format = '%(asctime)s:%(module)s:%(levelname)s:%(message)s', level = logging.DEBUG) logging.info("Running DataIntegrationTest test cases...") encodeToUtf8 = False self.dataUtil = DataUtil(encodeToUtf8) self.cdaDataPath = ConfigUtil().getProperty(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TEST_CDA_DATA_PATH_KEY) self.gdaDataPath = ConfigUtil().getProperty(ConfigConst.CONSTRAINED_DEVICE, ConfigConst.TEST_GDA_DATA_PATH_KEY) if not os.path.exists(self.cdaDataPath): logging.info("================================================") logging.info("DataIntegrationTest - path needs to be created: " + self.cdaDataPath) os.makedirs(self.cdaDataPath, exist_ok = True) def setUp(self): logging.info("================================================") logging.info("DataUtil test execution...") logging.info("================================================") pass def tearDown(self): pass #@unittest.skip("Ignore for now.") def testWriteActuatorDataToCdaDataPath(self): logging.info("\n\n----- [ActuatorData to JSON to file] -----") dataObj = ActuatorData() dataStr = self.dataUtil.actuatorDataToJson(dataObj) fileName = self.cdaDataPath + '/ActuatorData.dat' logging.info("Sample ActuatorData JSON (validated): " + str(dataStr)) logging.info("Writing ActuatorData JSON to CDA data path: " + fileName) fileRef = Path(fileName) fileRef.write_text(dataStr, encoding = 'utf-8') #@unittest.skip("Ignore for now.") def testWriteSensorDataToCdaDataPath(self): logging.info("\n\n----- [SensorData to JSON to file] -----") dataObj = SensorData() dataStr = self.dataUtil.sensorDataToJson(dataObj) fileName = self.cdaDataPath + '/SensorData.dat' logging.info("Sample SensorData JSON (validated): " + str(dataStr)) logging.info("Writing SensorData JSON to CDA data path: " + fileName) fileRef = Path(fileName) fileRef.write_text(dataStr, encoding = 'utf-8') #@unittest.skip("Ignore for now.") def testWriteSystemPerformanceDataToCdaDataPath(self): logging.info("\n\n----- [SystemPerformanceData to JSON to file] -----") dataObj = SystemPerformanceData() dataStr = self.dataUtil.sensorDataToJson(dataObj) fileName = self.cdaDataPath + '/SystemPerformanceData.dat' logging.info("Sample SystemPerformanceData JSON (validated): " + str(dataStr)) logging.info("Writing SystemPerformanceData JSON to CDA data path: " + fileName) fileRef = Path(fileName) fileRef.write_text(dataStr, encoding = 'utf-8') #@unittest.skip("Ignore for now.") def testReadActuatorDataFromGdaDataPath(self): logging.info("\n\n----- [ActuatorData JSON from file to object] -----") fileName = self.gdaDataPath + '/ActuatorData.dat' fileRef = Path(fileName) dataStr = fileRef.read_text(encoding = 'utf-8') dataObj = self.dataUtil.jsonToActuatorData(dataStr) logging.info("ActuatorData JSON from GDA: " + dataStr) logging.info("ActuatorData object: " + str(dataObj)) #@unittest.skip("Ignore for now.") def testReadSensorDataFromGdaDataPath(self): logging.info("\n\n----- [SensorData JSON from file to object] -----") fileName = self.gdaDataPath + '/SensorData.dat' fileRef = Path(fileName) dataStr = fileRef.read_text(encoding = 'utf-8') dataObj = self.dataUtil.jsonToSensorData(dataStr) logging.info("SensorData JSON from GDA: " + dataStr) logging.info("SensorData object: " + str(dataObj)) #@unittest.skip("Ignore for now.") def testReadSystemPerformanceDataFromGdaDataPath(self): logging.info("\n\n----- [SystemPerformanceData JSON from file to object] -----") fileName = self.gdaDataPath + '/SystemPerformanceData.dat' fileRef = Path(fileName) dataStr = fileRef.read_text(encoding = 'utf-8') dataObj = self.dataUtil.jsonToSystemPerformanceData(dataStr) logging.info("SystemPerformanceData JSON from GDA: " + dataStr) logging.info("SystemPerformanceData object: " + str(dataObj))
class DataUtilTest(unittest.TestCase): """ This test case class contains very basic unit tests for DataUtil. It should not be considered complete, but serve as a starting point for the student implementing additional functionality within their Programming the IoT environment. """ @classmethod def setUpClass(self): logging.basicConfig( format='%(asctime)s:%(module)s:%(levelname)s:%(message)s', level=logging.DEBUG) logging.info("Testing DataUtil class...") encodeToUtf8 = False self.dataUtil = DataUtil(encodeToUtf8) self.adName = "FooBar ActuatorData" self.sdName = "FooBar SensorData" self.spdName = "FooBar SystemPerformanceData" self.sampleSpdJson = "{\"name\": \"" + self.spdName + "\", \"timeStamp\":\"2019.01.16 21:32:34.123123\",\"cpuUtil\":0.0,\"diskUtil\":0.0,\"memUtil\":0.0}" self.sampleAdJson = "{\"name\": \"" + self.adName + "\", \"timeStamp\": \"2019-01-20 15:38:35.123123\", \"hasError\": false, \"command\": 0, \"statusCode\": 0, \"stateData\": null, \"curValue\": 0.0}" self.sampleSdJson = "{\"name\": \"" + self.sdName + "\", \"timeStamp\":\"2019.01.16 21:32:34.123123\",\"curValue\":0.0}" def setUp(self): logging.info("================================================") logging.info("DataUtil test execution...") logging.info("================================================") pass def tearDown(self): pass # @unittest.skip("Ignore for now.") def testActuatorDataConversionsFromJson(self): logging.info("\n\n----- [ActuatorData Conversions from JSON] -----") adObj1 = self.dataUtil.jsonToActuatorData(self.sampleAdJson) adObj1Str = self.dataUtil.actuatorDataToJson(adObj1) adObj2 = self.dataUtil.jsonToActuatorData(adObj1Str) logging.info("Sample JSON: " + str(self.sampleAdJson)) logging.info("JSON to ActuatorData: " + str(adObj1)) logging.info("ActuatorData back to JSON: " + str(adObj1Str)) self.assertEqual(self.adName, adObj1.getName()) self.assertEqual(self.adName, adObj2.getName()) self.assertEqual(adObj1.getTimeStamp(), adObj2.getTimeStamp()) # @unittest.skip("Ignore for now.") def testActuatorDataConversionsFromObject(self): logging.info("\n\n----- [JSON Conversions from ActuatorData] -----") adName = "FooBar2 Actuator" adObj1 = ActuatorData() adObj1.setName(adName) adObj1Str = self.dataUtil.actuatorDataToJson(adObj1) adObj2 = self.dataUtil.jsonToActuatorData(adObj1Str) adObj2Str = self.dataUtil.actuatorDataToJson(adObj2) logging.info("Sample ActuatorData: " + str(adObj1)) logging.info("ActuatorData to JSON: " + str(adObj1Str)) logging.info("JSON back to ActuatorData: " + str(adObj2)) logging.info("ActuatorData back to JSON: " + str(adObj2Str)) self.assertEqual(adName, adObj1.getName()) self.assertEqual(adObj1.getName(), adObj2.getName()) self.assertEqual(adObj1.getTimeStamp(), adObj2.getTimeStamp()) self.assertEqual(adObj1Str, adObj2Str) # @unittest.skip("Ignore for now.") def testSensorDataConversionsFromJson(self): logging.info("\n\n----- [SensorData Conversions from JSON] -----") sdObj1 = self.dataUtil.jsonToSensorData(self.sampleSdJson) sdObj1Str = self.dataUtil.sensorDataToJson(sdObj1) sdObj2 = self.dataUtil.jsonToSensorData(sdObj1Str) logging.info("Sample JSON: " + str(self.sampleSdJson)) logging.info("JSON to SensorData: " + str(sdObj1)) logging.info("SensorData back to JSON: " + str(sdObj1Str)) self.assertEqual(self.sdName, sdObj1.getName()) self.assertEqual(self.sdName, sdObj2.getName()) self.assertEqual(sdObj1.getTimeStamp(), sdObj2.getTimeStamp()) # @unittest.skip("Ignore for now.") def testSensorDataConversionsFromObject(self): logging.info("\n\n----- [JSON Conversions from SensorData] -----") sdName = "Foobar2 Sensor" sdObj1 = SensorData() sdObj1.setName(sdName) sdObj1Str = self.dataUtil.sensorDataToJson(sdObj1) sdObj2 = self.dataUtil.jsonToSensorData(sdObj1Str) sdObj2Str = self.dataUtil.sensorDataToJson(sdObj2) logging.info("Sample SensorData: " + str(sdObj1)) logging.info("SensorData to JSON: " + str(sdObj1Str)) logging.info("JSON back to SensorData: " + str(sdObj2)) logging.info("SensorData back to JSON: " + str(sdObj2Str)) self.assertEqual(sdName, sdObj1.getName()) self.assertEqual(sdObj1.getName(), sdObj2.getName()) self.assertEqual(sdObj1.getTimeStamp(), sdObj2.getTimeStamp()) self.assertEqual(sdObj1Str, sdObj2Str) # @unittest.skip("Ignore for now.") def testSystemPerformanceConversionsFromJson(self): logging.info( "\n\n----- [SystemPerformanceData Conversions from JSON] -----") spdObj1 = self.dataUtil.jsonToSystemPerformanceData(self.sampleSpdJson) spdObj1Str = self.dataUtil.systemPerformanceDataToJson(spdObj1) spdObj2 = self.dataUtil.jsonToSystemPerformanceData(spdObj1Str) logging.info("Sample JSON: " + str(self.sampleSpdJson)) logging.info("JSON to SystemPerformanceData: " + str(spdObj1)) logging.info("SystemPerformanceData back to JSON: " + str(spdObj1Str)) self.assertEqual(self.spdName, spdObj1.getName()) self.assertEqual(self.spdName, spdObj2.getName()) self.assertEqual(spdObj1.getTimeStamp(), spdObj2.getTimeStamp()) # @unittest.skip("Ignore for now.") def testSystemPerformanceDataConversionsFromObject(self): logging.info( "\n\n----- [JSON Conversions from SystemPerformanceData] -----") spdName = "Foobar2 SystemPerformanceData" spdObj1 = SystemPerformanceData() spdObj1.setName(spdName) spdObj1Str = self.dataUtil.systemPerformanceDataToJson(spdObj1) spdObj2 = self.dataUtil.jsonToSystemPerformanceData(spdObj1Str) spdObj2Str = self.dataUtil.systemPerformanceDataToJson(spdObj2) logging.info("Sample SystemPerformanceData: " + str(spdObj1)) logging.info("SystemPerformanceData to JSON: " + str(spdObj1Str)) logging.info("JSON back to SystemPerformanceData: " + str(spdObj2)) logging.info("SystemPerformanceData back to JSON: " + str(spdObj2Str)) self.assertEqual(spdName, spdObj1.getName()) self.assertEqual(spdObj1.getName(), spdObj2.getName()) self.assertEqual(spdObj1.getTimeStamp(), spdObj2.getTimeStamp()) self.assertEqual(spdObj1Str, spdObj2Str)
def handleActuatorCommandResponse(self, data: ActuatorData) -> bool: logging("handleActuatorCommandResponse method is called...") self._handleUpstreamTransmission( ResourceNameEnum.CDA_ACTUATOR_RESPONSE_RESOURCE, DataUtil.actuatorDataToJson(self, data)) pass
def handleIncomingMessage(self, resourceEnum: ResourceNameEnum, msg: str) -> bool: logging("handleIncomingMessage method is called...") self._handleIncomingDataAnalysis(DataUtil.jsonToActuatorData( self, msg)) pass
def handleSensorMessage(self, data: SensorData) -> bool: logging("handleSensorMessage method is called...") self._handleUpstreamTransmission( ResourceNameEnum.CDA_SENSOR_MSG_RESOURCE, DataUtil.sensorDataToJson(self, data)) pass
def handleSystemPerformanceMessage(self, data: SystemPerformanceData) -> bool: logging.info("handleSystemPerformanceMessage called") #translate sys perf data to json and set upstream du = DataUtil() self._handleUpstreamTransmission(ResourceNameEnum.CDA_SYSTEM_PERF_MSG_RESOURC.value, du.systemPerformanceDataToJson(data))
class RedisPersistenceAdapter: def __init__(self): self.dataUtil = DataUtil() self.configUtil = ConfigUtil() self.host = self.configUtil.getProperty( ConfigConst.DATA_GATEWAY_SERVICE, ConfigConst.HOST_KEY) self.port = self.configUtil.getInteger( ConfigConst.DATA_GATEWAY_SERVICE, ConfigConst.PORT_KEY) self.enableCrypt = self.configUtil.getBoolean( ConfigConst.DATA_GATEWAY_SERVICE, ConfigConst.ENABLE_CRYPT_KEY) if self.enableCrypt: self.credFilePath = self.configUtil.getProperty( ConfigConst.DATA_GATEWAY_SERVICE, ConfigConst.CRED_FILE_KEY) # TODO: init redis with encryption logging.info("Redis client setting: host = {0}, port = {1}.".format( self.host, self.port)) # Init with no connection established self.curConnection: redis.client.Redis = None def connectClient(self) -> bool: if self.curConnection is None: logging.info("Redis client connecting to server...") try: self.curConnection = redis.client.Redis(host=self.host, port=self.port) logging.info("Redis client successfully connect to server.") except BaseException as be: self.curConnection = None logging.error( "Cannot connect to Redis server, meet exception: " + be.__str__()) return False return True else: logging.warning("Redis client has already connected!") return True def disconnectClient(self) -> bool: if self.curConnection is None: logging.warning("Redis client has already disconnected!") return True else: logging.info("Redis client disconnecting...!") self.curConnection.close() self.curConnection = None logging.info("Redis client disconnect successfully.") return True def storeData( self, data: SensorData, resource: ResourceNameEnum = ResourceNameEnum.CDA_SENSOR_MSG_RESOURCE ) -> bool: topicName: str = resource.value jsonStr = self.dataUtil.sensorDataToJson(data) if self.curConnection: subNums = self.curConnection.publish(channel=topicName, message=jsonStr) logging.debug( "Published msg:\n{0}\nto {1} with {2} subscribers.".format( jsonStr, topicName, subNums)) return True else: logging.error( "Cannot store data to Redis, because client has not connected to server yet!" ) return False pass