def _test_with_client_observe(self, message_list, callback): # pragma: no cover client = HelperClient(self.server_address) token = None last_mid = 0 for message, expected in message_list: if message is not None: token = message.token client.send_request(message, callback) received_message = self.queue.get() if expected is not None: last_mid = expected.mid if expected.type is not None: self.assertEqual(received_message.type, expected.type) if expected.mid is not None: self.assertEqual(received_message.mid, expected.mid) self.assertEqual(received_message.code, expected.code) if expected.source is not None: self.assertEqual(received_message.source, self.server_address) if expected.token is not None: self.assertEqual(received_message.token, expected.token) if expected.payload is not None: self.assertEqual(received_message.payload, expected.payload) if expected.options is not None: self.assertEqual(received_message.options, expected.options) message = Message() message.type = defines.Types["RST"] message.token = token message._mid = last_mid message.destination = self.server_address client.send_empty(message) client.stop()
def _test_with_client_observe(self, message_list, callback): client = HelperClient(self.server_address) token = None last_mid = 0 for message, expected in message_list: if message is not None: token = message.token client.send_request(message, callback) received_message = self.queue.get() if expected is not None: last_mid = expected.mid if expected.type is not None: self.assertEqual(received_message.type, expected.type) if expected.mid is not None: self.assertEqual(received_message.mid, expected.mid) self.assertEqual(received_message.code, expected.code) if expected.source is not None: self.assertEqual(received_message.source, self.server_address) if expected.token is not None: self.assertEqual(received_message.token, expected.token) if expected.payload is not None: self.assertEqual(received_message.payload, expected.payload) if expected.options is not None: self.assertEqual(received_message.options, expected.options) message = Message() message.type = defines.Types["RST"] message.token = token message._mid = last_mid message.destination = self.server_address client.send_empty(message) client.stop()
def receive_datagram(self, args): """ Handle messages coming from the udp socket. :param args: (data, client_address) """ data, client_address = args logging.debug("receiving datagram") try: host, port = client_address except ValueError: host, port, tmp1, tmp2 = client_address client_address = (host, port) serializer = Serializer() message = serializer.deserialize(data, client_address) if isinstance(message, int): logger.error("receive_datagram - BAD REQUEST") rst = Message() rst.destination = client_address rst.type = Types["RST"] rst.code = message self.send_datagram(rst) return logger.debug("receive_datagram - " + str(message)) if isinstance(message, Request): if not message.proxy_uri or message.uri_path != "coap2http": logger.error("receive_datagram - BAD REQUEST") rst = Message() rst.destination = client_address rst.type = Types["RST"] rst.code = Codes.BAD_REQUEST.number rst.mid = message.mid rst.token = message.token self.send_datagram(rst) return # Execute HTTP/HTTPS request http_response = CoAP_HTTP.execute_http_request( message.code, message.proxy_uri, message.payload) # HTTP response to CoAP response conversion coap_response = CoAP_HTTP.to_coap_response(http_response, message.code, client_address, message.mid, message.token) # Send datagram and return self.send_datagram(coap_response) return elif isinstance(message, Message): logger.error("Received message from %s", message.source) else: # is Response logger.error("Received response from %s", message.source)
def coap_encode(payload): message = Message() message.type = defines.Types['CON'] message.token = 4321 message.mid = 2 message.options = None message.payload = str(payload) serializer = Serializer() messagestring = serializer.serialize(message) return messagestring
def end_observation(self, token): """ Remove an observation token from our records. :param token: the token for the observation """ dummy = Message() dummy.token = token dummy.destination = self._server self._observeLayer.remove_subscriber(dummy)
def cancel_observing(self, response, send_rst): # pragma: no cover if send_rst: message = Message() message.destination = self.server message.code = defines.Codes.EMPTY.number message.type = defines.Types["RST"] message.token = response.token message.mid = response.mid self.protocol.send_message(message) self.stop()
def to_coap_response(http_response, request_method, client_address, mid, token): coap_msg = Message() coap_msg.destination = client_address coap_msg.type = Types["ACK"] coap_msg.code = CoAP_HTTP.to_coap_code(http_response.status_code, request_method) coap_msg.mid = mid coap_msg.token = token if 'Content-Type' in http_response.headers: coap_msg.content_type = CoAP_HTTP.to_coap_content_type( http_response.headers['Content-Type'].split(";")[0]) else: coap_msg.content_type = 0 coap_msg.payload = http_response.content return coap_msg
def cancel_observing(self, response, send_rst): # pragma: no cover """ Delete observing on the remote server. :param response: the last received response :param send_rst: if explicitly send RST message :type send_rst: bool """ if send_rst: message = Message() message.destination = self.server message.code = defines.Codes.EMPTY.number message.type = defines.Types["RST"] message.token = response.token message.mid = response.mid self.protocol.send_message(message) self.stop()