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)
