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)
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)
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
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 handleSensorMessage(self, data: SensorData) -> bool:
logging("handleSensorMessage method is called...")
self._handleUpstreamTransmission(
ResourceNameEnum.CDA_SENSOR_MSG_RESOURCE,
DataUtil.sensorDataToJson(self, data))
pass