def update_module_data(self, module_data):
"""
Updates module data
:param module_data: Module data to update. It contains the module id, request origin address and parsed
module data
:return: (iot_error) a status indicating if the module data was updated or not
"""
assert isinstance(module_data, dict)
# status code
status = iot_error.FAILED
# get module name
module_name = module_data.get("id")
# module instance
module = Module(name=module_name)
# get module type
module_type = module.get_module_type()
# check if module is registered
if self.check_module_registration(
module).code == iot_error.SUCCESS.code:
# check module support
if self.check_module_support(
module).code == iot_error.SUCCESS.code:
# check for ilm module
if module_type == "ilm":
status = ilm_data_update.update(module_data)
# check for acm module
elif module_type == "acm":
status = acm_data_update.update(module_data)
# check for fpm module
elif module_type == "fpm":
status = fpm_data_update.update(module_data)
# unsupported module
else:
status = iot_error.UNSUPPORTED_MODULE
# module is not registered before
else:
status = iot_error.UNREGISTERED_MODULE
return status
def process_request(self, request):
"""
Process a given request
:param request: (iot_message) request message with an operation to perform
:return: (iot_error)
iot_error: request processing status
"""
assert isinstance(request, iot_message.IOTMessage)
# status
status = iot_error.FAILED
# build response message
response = iot_message.IOTMessage()
response.set_source(iot_message.TCP_SERVER)
# get request type
request_type = request.get_operation()
# get request data
request_data = request.get_data()
# get module name
module_name = request_data.get("id")
# module instance
module = Module(name=module_name)
# get module type
module_type = module.get_module_type()
# get module directory
module_directory = os.path.join(self._modules_dir, module_name)
# get module data file
module_data_file = os.path.join(self._modules_dir, module_name,
module_type + ".json")
# get module html file
module_html_file = os.path.join(self._modules_dir, module_name,
module_type + ".html")
# add module files to request data
request_data["module_directory"] = module_directory
request_data["module_data_file"] = module_data_file
request_data["module_html_file"] = module_html_file
# update request data
request.set_data(request_data)
# get module address (to send response to it)
module_address = request_data.get("ip")
# check for node add request
if request_type == iot_message.ADD_NODE:
status = self.add_module(request_data)
# check for node remove request
elif request_type == iot_message.REMOVE_NODE:
status = self.remove_module(request_data)
# check for data update request
elif request_type == iot_message.UPDATE_DATA:
status = self.update_module_data(request_data)
""" build response message """
if (request_type
== iot_message.ADD_NODE) or (request_type
== iot_message.REMOVE_NODE):
# get module address
module_address = request_data.get("ip")
# complete response message
response.set_message_type(iot_message.RESPONSE)
response.set_source(iot_message.TCP_SERVER)
response.set_operation(status.string)
response.set_data({
"reason": status.string,
})
elif request_type == iot_message.UPDATE_DATA:
# get module IP from local data file
module_data_file = os.path.join(self._modules_dir, module_name,
module_type + ".json")
# load module data
with open(module_data_file, 'r') as fh:
module_data = json.loads(fh.read().strip())
# get request source
request_source = request.get_source()
# check request source
# (WEB_SERVER means that the request was sent by a CGI script, so
# the IP passed with the request is the web server's IP and not the module's actual IP)
if request_source == iot_message.WEB_SERVER:
module_address = module_data.get("ip")
del request_data["module_data_file"]
del request_data["module_html_file"]
del request_data["module_directory"]
del request_data["ip"]
# build response
response.set_message_type(iot_message.REQUEST)
response.set_operation(iot_message.UPDATE_DATA)
response.set_data(request_data)
else:
response.set_message_type(iot_message.RESPONSE)
response.set_operation(status.string)
response.set_data({
"reason": status.string,
})
module_address = request_data.get("ip")
# build response string
response_validation, response_string = response.stringfy()
# build TCP message for response
response = TCPMessage(
address=module_address,
message=response_string,
)
# send response
self.send_message(response)
return status
def add_module(self, module_data):
"""
Add a module to the server
:param module_data: Module to add
:return: (iot_error) status indicating if module was added or not
"""
assert isinstance(module_data, dict)
self._logger.debug("Adding module: {}".format(module_data))
# return status
status = iot_error.FAILED
# get module name
module_name = module_data["id"]
# get module address
module_address = module_data["ip"]
# make module instance
module = Module(name=module_name)
# check module_data registration
if self.check_module_registration(
module).code == iot_error.UNREGISTERED_MODULE.code:
# check module_data support
if self.check_module_support(
module).code == iot_error.SUCCESS.code:
# get module_data type
module_type = module.get_module_type()
# get module html template file
module_temp_html_file = os.path.join(
self._templates_dir, module_type,
module_type + "_html_temp.html")
# get module data template file
module_temp_data_file = os.path.join(
self._templates_dir, module_type,
module_type + "_data_temp.json")
# get module directory
module_directory = module_data["module_directory"]
# get module html file
module_html_file = module_data["module_html_file"]
# get module data file
module_data_file = module_data["module_data_file"]
# make module_data directory
os.mkdir(module_directory)
# make module_data html file
with open(module_temp_html_file, 'r') as fh:
module_html = fh.read().strip()
with open(module_html_file, 'w') as fh:
fh.write(
module_html.format(module_type=module_type,
module_id=module_name))
# make module_data data file
with open(module_temp_data_file, 'r') as fh:
module_data = json.loads(fh.read().strip())
# update module address
module_data["ip"] = module_address
with open(module_data_file, 'w') as fh:
fh.write(json.dumps(module_data))
status = iot_error.SUCCESS
# unsupported module_data
else:
status = iot_error.UNSUPPORTED_MODULE
# module_data is already registered
else:
# # TODO:: Test module volatility
#
# # check module volatility
#
# # get module type
# module_type = module.get_module_type()
#
# # get module info file
# module_info_file = os.path.join(self._templates_dir, module_type, "info.json")
#
# # check if module info file exists
# if os.path.exists(module_info_file) and os.path.isfile(module_info_file):
#
# # get module info
# with open(module_info_file, 'r') as fh:
# module_info = json.loads(fh.read().strip())
#
# # get module volatility info
# module_volatility = module_info["volatile"]
#
# # check if module is volatile
# if module_volatility:
#
# # remove module
# self.remove_module(module_data=module_data)
#
# # add module
# status = self.add_module(module_data=module_data)
#
# # module is not volatile
# else:
# status = iot_error.SUCCESS
#
# # module info file doesn't exist
# else:
# status = iot_error.MISSING_MODULE_INFO_FILE
status = iot_error.SUCCESS
return status
