def send_create(self, ): sleep(10) self.logger.info("Sending create info to DM server") server_ip = self.lwm2m_server_ip server_port = self.lwm2m_server_port endpoint_name = "emulated_device_nb_0" object_id = 3 object_inst_id = 4 res_id = 0 res_inst_id = 0 res_value = "fokus" res_id_res_inst_id = str(res_id) + "_" + str(res_inst_id) payload = {} res_id_res_inst_id = str(res_id) + "_" + str(res_inst_id) payload[res_id_res_inst_id] = { "res_id": res_id, "res_inst_id": res_inst_id, "res_value": res_value } content_type = "application/json" request = lwm2m_api() response = request.create_object_instance( server_ip, server_port, endpoint_name, object_id, json.dumps(payload), content_type, object_inst_id=object_inst_id, client_port=self.generate_client_port())
def send_specific_observation1(self, ): sleep(20) self.logger.info("Sending specific observation to DM server") app_ip = "localhost" app_port = "1115" server_ip = self.lwm2m_server_ip server_port = self.lwm2m_server_port endpoint_name = "gscl_PulseOximeter" object_id = 4200 object_inst_id = 0 res_id = 0 res_inst_id = 0 request = lwm2m_api() response = request.observe_resource( server_ip, server_port, app_ip=app_ip, app_port=app_port, endpoint_name=endpoint_name, object_id=object_id, object_inst_id=object_inst_id, res_id=res_id, res_inst_id=res_inst_id, client_port=self.generate_client_port()) def _handle_response(response): self.logger.info("response token: %s", response.token) response.then(_handle_response)
def send_cancel_observation(self, ): sleep(22) self.logger.info("Sending Cancel Observation to DM server") app_ip = "localhost" app_port = "1111" server_ip = self.lwm2m_server_ip server_port = self.lwm2m_server_port endpoint_name = "gscl/attachedDevices/PulseOximeter" object_id = 4200 object_inst_id = 0 res_id = 1 res_inst_id = 0 request = lwm2m_api() response = request.cancel_observe_resource( server_ip, server_port, app_ip, app_port, endpoint_name, object_id, object_inst_id=object_inst_id, res_id=res_id, res_inst_id=res_inst_id, client_port=self.generate_client_port()) def _handle_response(response): self.logger.info("response token: %s", response.token) self.logger.info("response %s", response.payload) response.then(_handle_response)
def send_general_observation(self, registered_client_location): if registered_client_location is not None: payload = dumps(self.set_general_observation_params()) endpoint_object = self.lwm2m_resources.return_endpoint_object( endpoint_location=registered_client_location) client_listener_ip = endpoint_object.listener_ip client_listener_port = endpoint_object.listener_port request = lwm2m_api() response = request.observe_resource(client_listener_ip, client_listener_port, \ payload=payload, client_port=self.generate_client_port())
def send_total_resources(self, ): #Not used currently self.logger.info("Sending Updates on the Resources") path = self.location_address query_params = "" payload = json.dumps(self.total_resources) request = lwm2m_api() response = request.client_registration_update(self.lwm2m_dm_server_ip, self.lwm2m_dm_server_port, \ path, query_params, payload, \ client_port=self.local_client_port) self.total_resources = {}
def forward_request(self, path, remote, payload, content_type, client_port): endpoint_name, object_id, object_inst_id, res_id, res_inst_id, \ _, _ = self.find_elements(path, remote) endpoint = self.lwm2m_resources.return_endpoint_object(endpoint_name=endpoint_name) listener_ip = endpoint.listener_ip listener_port = endpoint.listener_port payload = dumps(payload) request = lwm2m_api() response = request.write_attributes(listener_ip, listener_port, endpoint_name, object_id, \ payload, content_type, object_inst_id=object_inst_id, \ res_id=res_id, res_inst_id=res_inst_id, client_port=client_port)
def send_discover_resources(self, ): sleep(20) self.logger.info("Sending discover request to Dm server") server_ip = self.lwm2m_server_ip server_port = self.lwm2m_server_port payload = "/.well-known/core" request = lwm2m_api() response = request.discover_resources( server_ip, server_port, payload=payload, client_port=self.generate_client_port()) discover = Discovery() payload = json.loads(response.payload) discover.display_all_resources(payload)
def notify(self, event): for element1, element2 in event.data.iteritems(): object_id_object_inst_id = element1 endpoint_name = element2["endpoint_name"] for element3, element4 in element2["resources"].iteritems(): res_id = element3 res_value = element4["res_value"] res_inst_id = element4["res_inst_id"] if res_inst_id == "" or res_inst_id == None: res_inst_id = 0 res_id_res_inst_id = str(res_id) + "_" + str(res_inst_id) resource_object = self.lwm2m_resources.endpoint_dict[endpoint_name][ "object"].objects_dict[object_id_object_inst_id][ "object"].resources_id_dict[res_id_res_inst_id]["object"] client_ip = resource_object.observe_info.local_ip client_port = resource_object.observe_info.local_port last_time = datetime.datetime.now( ) - resource_object.observe_info.specific_observers[ self.token_id]["initial_time"] #ToDO: rsh: deal with hours, minutes too self.logger.info("Sending Notification after %s sec", last_time.seconds) payload = { endpoint_name: { object_id_object_inst_id: { "resources": { res_id_res_inst_id: res_value } } }, "observer_ip": self.observer_ip, "observer_port": self.observer_port } content_type = "application/json" request = lwm2m_api() response = request.send_notification(self.server_ip, self.server_port, self.token_id, payload, content_type=content_type, time_elapse=last_time.seconds, client_ip=client_ip, client_port=client_port)
def forward_request(self, path, remote, client_port): endpoint_name, object_id, object_inst_id, res_id, res_inst_id, \ _, _ = self.find_elements(path, remote) endpoint = self.lwm2m_resourcrs.return_endpoint_object( endpoint_name=endpoint_name) if endpoint is not None: listener_ip = endpoint.listener_ip listener_port = endpoint.listener_port request = lwm2m_api() response = request.discover_resources(listener_ip, listener_port, endpoint_name=endpoint_name, object_id=object_id, \ object_inst_id=object_inst_id, res_id=res_id, res_inst_id=res_inst_id, client_port=client_port) return response else: self.logger.error("Invalid Endpoint Name") return
def forward_write_request(self, path, payload, content_type, remote, client_port): endpoint_name, object_id, object_inst_id, res_id, \ res_inst_id, sender_ip, sender_port = self.find_elements(path, remote) self.logger.info("Forwarding Write Resource Request to Endpoint %s", endpoint_name) endpoint_object = self.lwm2m_resources.return_endpoint_object( endpoint_name=endpoint_name) listener_ip = endpoint_object.listener_ip listener_port = endpoint_object.listener_port request = lwm2m_api() response = request.write_resource(listener_ip, listener_port, endpoint_name, object_id, \ payload, content_type, object_inst_id=object_inst_id, \ res_id=res_id, res_inst_id=res_inst_id, client_port=client_port)
def handle_transport_mgmt_policy(self, instance, mgmtobj_name): res_value_exists = False resources_dict = {} total_dict = {} endpoint_dict = {} generate_endpoint = instance.path.split("/")[3:-2] endpoint_name = "/".join(generate_endpoint) object_name = mgmtobj_name.split("_")[0] object_id = lwm2m_reverse_dict_objects[object_name]["object_id"] object_inst_id = mgmtobj_name.split("_")[1] for key, value in instance.flex_values.iteritems(): res_name = key.split("_")[0] try: res_inst_id = key.split("_")[1] except: res_inst_id = 0 res_value = value res_id = lwm2m_reverse_dict_objects[object_name]["resource_list"][ res_name]["resId"] resources_dict.update( {res_id: { "res_inst_id": res_inst_id, "res_value": res_value }}) if res_value != "" and not res_value_exists: res_value_exists = True if res_value_exists: self.logger.info("Sending the Resource Updates to LWM2M Server") payload = json.dumps(resources_dict) content_type = "application/json" request = lwm2m_api() self.sem.acquire() client_port = self.generate_client_port() response = request.write_resource(self.lwm2m_server_ip, self.lwm2m_server_port, endpoint_name, object_id, payload, content_type, object_inst_id=object_inst_id, client_port=client_port) self.sem.release()
def send_execute_resource(self, endpoint_name, object_id, object_inst_id, res_id, res_inst_id, payload=None): self.logger.info("Sending execution to DM server") server_ip = self.lwm2m_server_ip server_port = self.lwm2m_server_port payload = None request = lwm2m_api() response = request.execute_resource( server_ip, server_port, endpoint_name, object_id, object_inst_id, res_id, res_inst_id=res_inst_id, payload=payload, client_port=self.generate_client_port()) self.logger.info("Updating M2M Resource Tree") resources_dict = {} object_id_res_id = str(object_id) + "/" + str(res_id) if object_id_res_id in action_mapping: res_id = action_mapping[object_id_res_id]["target_res_id"] res_value = action_mapping[object_id_res_id]["target_action"] res_name = lwm2m_dict_objects[str(object_id)]["resource_list"][str( res_id)]["resName"] is_multi_inst = lwm2m_dict_objects[str( object_id)]["resource_list"][str(res_id)]["multiInst"] if not is_multi_inst: resources_dict.update({res_name: res_value}) else: resources_dict.update( {res_name + "_" + str(res_inst_id): res_value}) self.handle_m2m_server(endpoint_name, object_id, object_inst_id, res_id, res_inst_id, res_name, res_value, resources_dict)
def send_update_registration(self, endpoint_location, endpoint_local_location, objects, dm_server_ip, dm_server_port): path = endpoint_location endpoint = self.lwm2m_resources.return_endpoint_object(endpoint_location=endpoint_local_location) query_params = "" for param, value in endpoint.param_dict.iteritems(): query_params += param + "=" + str(value) + "&" query_params += "local_ip=" + endpoint.local_ip + "&" + "local_port=" + str(endpoint.local_port) + "&" query_params += "listener_ip=" + endpoint.listener_ip + "&" + "listener_port=" + str(endpoint.listener_port) if objects == "" or objects is None: payload = "" else: payload = json.dumps(objects) request = lwm2m_api() response = request.client_registration_update(dm_server_ip, dm_server_port, path, query_params, payload, client_port=endpoint.local_port)
def send_write_attributes(self, ): sleep(10) self.logger.info("Sending attributes info to DM server") server_ip = self.lwm2m_server_ip server_port = self.lwm2m_server_port endpoint_name = "emulated_device_nb_0" object_id = 3 object_inst_id = 0 res_id = 1 res_inst_id = 0 pmax = 50 pmin = 10 gt = None lt = None st = None cancel = None content_type = "application/json" payload = json.dumps({ "pmax": pmax, "pmin": pmin, "gt": gt, "lt": lt, "st": st, "cancel": cancel }) request = lwm2m_api() response = request.write_attributes( server_ip, server_port, endpoint_name, object_id, payload, content_type, object_inst_id=object_inst_id, res_id=res_id, res_inst_id=res_inst_id, client_port=self.generate_client_port())
def send_add_resources(self, object_and_resources, endpoint_name, mgmt_obj_id_inst_id): if self.ep_location_mapping.has_key(endpoint_name): location_address = self.ep_location_mapping[endpoint_name] else: location_address = None if location_address == None: self.logger.warning( "Location couldn't be fetched !! Saving the Resources") self.res_dict[mgmt_obj_id_inst_id] = object_and_resources self.total_resources[endpoint_name] = self.res_dict else: self.logger.info("Sending Updates on the Resources..") path = location_address query_params = "" payload = json.dumps(object_and_resources) request = lwm2m_api() response = request.client_registration_update(self.lwm2m_dm_server_ip, self.lwm2m_dm_server_port, \ path, query_params, payload, \ client=self.client)
def forward_request(self, path, remote, payload, client_port): self.logger.info("Forwarding Execution Request") endpoint_name, object_id, object_inst_id, res_id, res_inst_id, \ _, _ = self.find_elements(path, remote) if (endpoint_name or object_id or object_inst_id or res_id) is None: self.logger.warn("Missing Parameter(s). Cannot perform Execution.") return else: if endpoint_name is not None: endpoint = self.lwm2m_resources.return_endpoint_object( endpoint_name=endpoint_name) if endpoint is not None: listener_ip = endpoint.listener_ip listener_port = endpoint.listener_port payload = payload request = lwm2m_api() response = request.execute_resource(listener_ip, listener_port, endpoint_name, \ object_id, object_inst_id, res_id, res_inst_id=res_inst_id,\ payload=payload, client_port=client_port)
def send_client_registration(self, endpoint, registration_params, \ dm_server_ip, dm_server_port, listener_ip, listener_port, client_port): """ Client registration request to the LWM2M server """ self.logger.debug("Client port is %s", client_port) self.logger.info("Sending Endpoint Registration request to the LWM2M Server") query_params = "ep=" + endpoint.endpoint_name for param, value in registration_params.iteritems(): #endpoint.param_dict.iteritems(): query_params += "&" + param + "=" + str(value) query_params += "&" + "listener_ip=" + listener_ip + "&" + "listener_port=" + str(listener_port) query_params += "&" + "local_ip=" + "localhost" + "&" + "local_port=" + str(client_port) payload = None #endpoint.objects #unique_client_port = self.generate_unique_random_port(client_port_start, client_port_stop) request = lwm2m_api() client, response = request.client_registration(dm_server_ip, dm_server_port, query_params, payload, client_port=client_port) return client, response
def forward_request(self, path, remote, observe_value, server_ip, server_port, app_ip, app_port, token, client_port): """ Forwards the Observation/Cancel Observation requests """ self.logger.info("Forwarding the Observation Request") request = lwm2m_api() payload = { "server_ip": server_ip, "server_port": server_port, "app_ip": app_ip, "app_port": app_port } content_type = "application/json" endpoint_name, object_id, object_inst_id, res_id, res_inst_id, \ _, _ = self.find_elements(path, remote) endpoint = self.lwm2m_resources.return_endpoint_object( endpoint_name=endpoint_name) if endpoint is not None: listener_ip = endpoint.listener_ip listener_port = endpoint.listener_port if (listener_ip and listener_port) is not None: if observe_value == 0: response = request.send_observe_request(listener_ip, listener_port, app_ip, app_port, endpoint_name, \ object_id, observe_value, payload=payload, object_inst_id=object_inst_id, \ res_id=res_id, res_inst_id=res_inst_id, content_type=content_type, token=token, \ client_port=client_port) return response elif observe_value == 1: response = request.send_observe_request(listener_ip, listener_port, app_ip, app_port, endpoint_name, \ object_id, observe_value, payload=payload, object_inst_id=object_inst_id, \ res_id=res_id, res_inst_id=res_inst_id, content_type=content_type, token=token, \ client_port=client_port) return response else: response = None return response
def subscribe_dm_server(self, ): self.logger.info( "Trying to subscribe to LWM2M DM Server for General Subscription") payload = json.dumps({"listener_ip": self.nscl_dm_adapter_listener_ip, "listener_port": \ self.nscl_dm_adapter_listener_port}) content_type = "application/json" request = lwm2m_api() response = request.observe_resource( self.lwm2m_server_ip, self.lwm2m_server_port, payload=payload, content_type=content_type, client_port=self.generate_client_port()) def _handle_response(response): self.logger.info( "Successfully subscribed to LWM2M DM Server for General Subscription" ) self.general_notification_token = response.token def _handle_error(*args): self.subscribe_dm_server() response.then(_handle_response, _handle_error)
def process(self, rx_record, remote, uri_query): """ Processes various requests like CON (POST, PUT, GET) or NON. POST requests : Generally used for Registration and Execution PUT requests : Generally used for Updating the resources GET requests : Generally used for Discovery, Observation, Cancel Observation """ msg = rx_record.message self.uri_query = uri_query if msg.transaction_type == connection.Message.CON: if constants.POST == msg.code: method = None try: method = uri_query[0].value.split("=")[1] except: pass if method == "create": path = msg.findOption(URI_PATH_VALUE) content_type_number = msg.findOption(options.ContentType) if content_type_number is None: content_type = "text/plain" else: content_type = constants.media_types[ content_type_number.value] self.create_object_instance.create_instance( path, remote, content_type, loads(msg.payload)) resources = loads(msg.payload) msg = connection.Message(connection.Message.ACK, code=constants.CREATED, payload="Resource Created") self.dm_server.sendto(msg._pack(rx_record.transaction_id), remote) client_port = self.generate_client_port() self.create_object_instance.forward_request( path, remote, resources, content_type, client_port) elif method == "execute": path = msg.findOption(URI_PATH_VALUE) content_type_number = msg.findOption(options.ContentType) if content_type_number is None: content_type = "text/plain" else: content_type = constants.media_types[ content_type_number.value] self.execution.execute_resource(path, remote, msg.payload) execute_payload = msg.payload msg = connection.Message(connection.Message.ACK, code=constants.CHANGED, payload="Resource Executed") self.dm_server.sendto(msg._pack(rx_record.transaction_id), remote) client_port = self.generate_client_port() self.execution.forward_request(path, remote, execute_payload, client_port) elif method == "notify": self.logger.info("Notification Received") client_port = self.generate_client_port() for item1, item2 in loads(msg.payload).iteritems(): if item1 == "observer_ip": observer_ip = item2 elif item1 == "observer_port": observer_port = item2 elif item1 != "observer_ip" and item1 != "observer_port": endpoint_name = item1 for item3, item4 in item2.iteritems(): for item5, item6 in item4[ "resources"].iteritems(): pass res = { item3: { "resources": { item5.split("_")[0]: { "res_value": item6, "res_inst_id": item5.split("_")[1] } } } } payload = {} payload = self.update_resource(res, endpoint_name=endpoint_name) payload["observer_ip"] = observer_ip payload["observer_port"] = observer_port token_id = msg.token observe_value = msg.findOption(options.Observe).value self.logger.info("Forwarding Notification") content_type = "application/json" request = lwm2m_api() response = request.send_notification(self.general_observation.listener_ip, self.general_observation.listener_port, token_id, payload, \ content_type=content_type, time_elapse=observe_value, client_port=client_port) msg = connection.Message(connection.Message.ACK, code=constants.CREATED, payload="Notification Received") self.dm_server.sendto(msg._pack(rx_record.transaction_id), remote) else: """ Handles the Client Registration Request """ self.logger.info( "Registering Client Endpoint in the LWM2M DM Server") endpoint = self.registration.process_registration( msg, uri_query) response = self.registration.register_client(endpoint) registered_client_location = response if registered_client_location is not None: self.logger.info( "Client Endpoint Registration Successful for Endpoint : %s", endpoint.endpoint_name) self.logger.info("The registered location is %s", registered_client_location) payload = self.set_general_observation_params() else: self.logger.info("Client Endpoint Registration Failed") msg = connection.Message( connection.Message.ACK, code=constants.CREATED, location=registered_client_location) self.dm_server.sendto(msg._pack(rx_record.transaction_id), remote) #Send the General Observation to the Registered Client #self.send_general_observation(registered_client_location) elif constants.PUT == msg.code: """ It consists of Normal Update, Write Operation, Write Attribute Operation. Write Operation is used to update the resource(s) as per the request. Write Attributes operation is used to update the attributes of the object, object instance or resource. """ self.handle_lwm2m_put(msg, uri_query, remote, rx_record) elif constants.GET == msg.code: """ Handles Requests like Discovery, Observation """ try: observe_value = msg.findOption(options.Observe).value except: observe_value = "" if observe_value == OBSERVE_OPTION_VALUE_OBSERVATION: """ Sets the Observation. Two types of observations. General Observation and Specific Observation. General Observation is used for anything that is not observed and updates are sent as general notifications using a general token. Specific observation is implicitly defined by the observer(as request) and handled as specific notification with a specific token """ path = msg.findOption(URI_PATH_VALUE) if len(path) == 1: self.set_m2m_server_adapter_params(rx_record, remote) else: self.logger.info( "Specific Observation Request Received") content_type_number = msg.findOption( options.ContentType) if content_type_number is None: content_type = "text/plain" else: content_type = constants.media_types[ content_type_number.value] token_id = msg.token app_ip = loads(msg.payload)["app_ip"] app_port = loads(msg.payload)["app_port"] client_port = self.generate_client_port() response = self.observation.forward_request(path, remote, observe_value, \ self.lwm2m_dm_server_ip, self.lwm2m_dm_server_port, \ app_ip, app_port, token_id, client_port) msg = connection.Message(connection.Message.ACK, code=constants.CONTENT, \ payload="test") #todo: payload to be replaced self.dm_server.sendto( msg._pack(rx_record.transaction_id, token_id), remote) elif observe_value == OBSERVE_OPTION_VALUE_CANCEL_OBSERVATION: """ Removes the observation from the List """ self.logger.info("Cancel Observation Request Received") path = msg.findOption(URI_PATH_VALUE) token_id = msg.token app_ip = loads(msg.payload)["app_ip"] app_port = loads(msg.payload)["app_port"] client_port = self.generate_client_port() response = self.observation.forward_request(path, remote, observe_value, \ self.lwm2m_dm_server_ip, self.lwm2m_dm_server_port, \ app_ip, app_port, token_id, client_port) def _handle_response(response): msg = connection.Message(connection.Message.ACK, code=constants.CONTENT, payload=response) self.dm_server.sendto( msg._pack(rx_record.transaction_id), remote) response.then(_handle_response) else: method = None try: method = uri_query[0].value.split("=")[1] except: pass if method == "read": path = msg.findOption(URI_PATH_VALUE) self.read.read_resource(path, remote) msg = connection.Message(connection.Message.ACK, code=constants.CONTENT, \ payload="info read", content_type="text/plain") self.dm_server.sendto( msg._pack(rx_record.transaction_id), remote) elif method == "discover": if msg.payload == "/.well-known/core": payload = dumps(self.discover.get_all_resources()) else: path = msg.findOption(URI_PATH_VALUE) client_port = self.generate_client_port() payload = self.discover.forward_request( path, remote, client_port) def _handle_response(payload): msg = connection.Message(connection.Message.ACK, code=constants.CONTENT, \ payload=payload, content_type="application/json") self.dm_server.sendto( msg._pack(rx_record.transaction_id), remote) if payload is Promise: payload.then(_handle_response) else: _handle_response(payload) elif msg.transaction_type == connection.Message.NON: print "reached msg non" payload = msg.payload print payload
def handle_lwm2m_put(self, msg, uri_query, remote, rx_record): """ It consists of Normal Update, Write Operation, Write Attribute Operation. Write Operation is used to update the resource(s) as per the request. Write Attributes operation is used to update the attributes of the object, object instance or resource. """ method = None try: method = uri_query[0].value.split("=")[1] except: pass if method == "write": path = msg.findOption(URI_PATH_VALUE) content_type_number = msg.findOption(options.ContentType) if content_type_number is None: content_type = "text/plain" else: content_type = constants.media_types[content_type_number.value] self.write.write_resource(msg.payload, path, content_type) payload_forward = msg.payload msg = connection.Message(connection.Message.ACK, code=constants.CHANGED, payload="Resource Updated") self.dm_server.sendto(msg._pack(rx_record.transaction_id), remote) client_port = self.generate_client_port() self.write.forward_write_request(path, payload_forward, \ content_type, remote, client_port) elif method == "write_attributes": path = msg.findOption(URI_PATH_VALUE) content_type_number = msg.findOption(options.ContentType) if content_type_number is None: content_type = "text/plain" else: content_type = constants.media_types[content_type_number.value] payload = loads(msg.payload) self.write_attributes.set_attributes(path, remote, payload) msg = connection.Message(connection.Message.ACK, code=constants.CHANGED, payload="Resource Attributes Updated") self.dm_server.sendto(msg._pack(rx_record.transaction_id), remote) client_port = self.generate_client_port() self.write_attributes.forward_request(path, remote, payload, content_type, client_port) else: endpoint_location = msg.findOption(URI_PATH_VALUE)[0].value if msg.payload == "": self.logger.info("Updating the Registration Params") endpoint_object = self.lwm2m_resources.return_endpoint_object( endpoint_location=endpoint_location) endpoint_object.listener_ip = uri_query[6].value.split("=")[1] endpoint_object.local_ip = uri_query[6].value.split("=")[1] msg = connection.Message(connection.Message.ACK, code=constants.CHANGED, payload="Resource Updated") self.dm_server.sendto(msg._pack(rx_record.transaction_id), remote) else: self.logger.info("Adding/Updating the Resources") payload = self.update_resource( loads(msg.payload), endpoint_location=endpoint_location) msg = connection.Message(connection.Message.ACK, code=constants.CHANGED, payload="Resource Updated") self.dm_server.sendto(msg._pack(rx_record.transaction_id), remote) self.logger.info("Forwarding the Notification") request = lwm2m_api() client_port = self.generate_client_port() response = request.send_notification(self.general_observation.listener_ip, self.general_observation.listener_port, \ self.general_observation.token_id, payload, content_type="application/json", client_port=client_port)