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
