def _test_separate(self, message, notification): serializer = Serializer() datagram = serializer.serialize(message) self.proto.datagramReceived(datagram, ("127.0.0.1", 5600)) datagram, source = self.tr.written[0] host, port = source message = serializer.deserialize(datagram, host, port) self.assertEqual(message.type, defines.inv_types["ACK"]) self.assertEqual(message.code, None) self.assertEqual(message.mid, self.current_mid + 4) self.assertEqual(message.source, source) datagram, source = self.tr.written[1] host, port = source message = serializer.deserialize(datagram, host, port) self.assertEqual(message.type, notification.type) self.assertEqual(message.code, notification.code) self.assertEqual(message.source, source) self.assertEqual(message.token, notification.token) self.assertEqual(message.payload, notification.payload) self.assertEqual(message.options, notification.options) self.tr.written = [] message = Message.new_ack(message) datagram = serializer.serialize(message) self.proto.datagramReceived(datagram, ("127.0.0.1", 5600)) self.tr.written = []
def _test_separate(self, message, notification): serializer = Serializer() datagram = serializer.serialize(message) sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.sendto(datagram, self.server_address) datagram, source = sock.recvfrom(4096) host, port = source message = serializer.deserialize(datagram, host, port) self.assertEqual(message.type, defines.inv_types["ACK"]) self.assertEqual(message.code, None) self.assertEqual(message.mid, self.current_mid - 1) self.assertEqual(message.source, source) datagram, source = sock.recvfrom(4096) host, port = source message = serializer.deserialize(datagram, host, port) self.assertEqual(message.type, notification.type) self.assertEqual(message.code, notification.code) self.assertEqual(message.source, source) self.assertEqual(message.token, notification.token) self.assertEqual(message.payload, notification.payload) self.assertEqual(message.options, notification.options) message = Message.new_ack(message) datagram = serializer.serialize(message) sock.sendto(datagram, self.server_address) sock.close()
def _test_modular(self, lst): serializer = Serializer() for t in lst: message, expected = t send_ack = False if message is not None: datagram = serializer.serialize(message) self.proto.datagramReceived(datagram, ("127.0.0.1", 5600)) else: send_ack = True datagram, source = self.tr.written.pop(0) host, port = source message = serializer.deserialize(datagram, host, port) self.assertEqual(message.type, expected.type) if not send_ack: self.assertEqual(message.mid, expected.mid) self.assertEqual(message.code, expected.code) self.assertEqual(message.source, source) self.assertEqual(message.token, expected.token) self.assertEqual(message.payload, expected.payload) self.assertEqual(message.options, expected.options) if send_ack: message = Message.new_ack(message) datagram = serializer.serialize(message) self.proto.datagramReceived(datagram, ("127.0.0.1", 5600)) self.tr.written = []
def _test_modular(self, lst): serializer = Serializer() sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) for t in lst: message, expected = t send_ack = False if message is not None: datagram = serializer.serialize(message) sock.sendto(datagram, self.server_address) else: send_ack = True datagram, source = sock.recvfrom(4096) host, port = source message = serializer.deserialize(datagram, host, port) self.assertEqual(message.type, expected.type) if not send_ack: self.assertEqual(message.mid, expected.mid) self.assertEqual(message.code, expected.code) self.assertEqual(message.source, source) self.assertEqual(message.token, expected.token) self.assertEqual(message.payload, expected.payload) self.assertEqual(message.options, expected.options) if send_ack: message = Message.new_ack(message) datagram = serializer.serialize(message) sock.sendto(datagram, self.server_address) sock.close()
def send_datagram(self, message): host, port = message.destination logger.debug("send_datagram - " + str(message)) serializer = Serializer() message = serializer.serialize(message) self._socket.sendto(message, (host, port))
def send_datagram(self, message): """ Send a message over the UDP socket. :param message: the message to send """ host, port = message.destination logger.debug("send_datagram - " + str(message)) serializer = Serializer() raw_message = serializer.serialize(message) try: self._socket.sendto(raw_message, (host, port)) except Exception as e: if self._cb_ignore_write_exception is not None and isinstance( self._cb_ignore_write_exception, collections.Callable): if not self._cb_ignore_write_exception(e, self): raise # if you're explicitly setting that you don't want a response, don't wait for it # https://tools.ietf.org/html/rfc7967#section-2.1 for opt in message.options: if opt.number == defines.OptionRegistry.NO_RESPONSE.number: if opt.value == 26: return if self._receiver_thread is None or not self._receiver_thread.is_alive( ): self._receiver_thread = threading.Thread( target=self.receive_datagram) self._receiver_thread.daemon = True self._receiver_thread.start()
def send(self, request, endpoint, resend=False): self._endpoint = endpoint self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self._receiver_thread = threading.Thread(target=self.datagram_received) self._receiver_thread.start() if not resend: if request.mid is None: request.mid = self._currentMID self._currentMID += 1 key = hash(str(self._endpoint[0]) + str(self._endpoint[1]) + str(request.mid)) key_token = hash(str(self._endpoint[0]) + str(self._endpoint[1]) + str(request.token)) self.sent[key] = (request, time.time()) self.sent[key_token] = request if request.type is None: request.type = defines.inv_types["CON"] serializer = Serializer() request.destination = self._endpoint host, port = request.destination print "Message sent to " + host + ":" + str(port) print "----------------------------------------" print request print "----------------------------------------" datagram = serializer.serialize(request) log.msg("Send datagram") self._socket.sendto(datagram, self._endpoint)
def _test_plugtest(self, message, expected): serializer = Serializer() datagram = serializer.serialize(message) sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.sendto(datagram, message.destination) datagram, source = sock.recvfrom(4096) host, port = source message = serializer.deserialize(datagram, host, port) if expected.type is not None: self.assertEqual(message.type, expected.type) if expected.mid is not None: self.assertEqual(message.mid, expected.mid) self.assertEqual(message.code, expected.code) if expected.source is not None: self.assertEqual(message.source, source) if expected.token is not None: self.assertEqual(message.token, expected.token) if expected.payload is not None: self.assertEqual(message.payload, expected.payload) if expected.options is not None: self.assertEqual(message.options, expected.options) sock.close()
def _test_plugtest(self, message_list): serializer = Serializer() sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) for message, expected in message_list: if message is not None: datagram = serializer.serialize(message) sock.sendto(datagram, message.destination) if expected is not None: datagram, source = sock.recvfrom(4096) received_message = serializer.deserialize(datagram, source) 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, source) 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) sock.close()
def _test_plugtest(self, message_list): # pragma: no cover serializer = Serializer() sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) for message, expected in message_list: if message is not None: datagram = serializer.serialize(message) sock.sendto(datagram, message.destination) if expected is not None: datagram, source = sock.recvfrom(4096) received_message = serializer.deserialize(datagram, source) 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, source) 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) for o in expected.options: option_value = getattr( expected, o.name.lower().replace("-", "_")) option_value_rec = getattr( received_message, o.name.lower().replace("-", "_")) self.assertEqual(option_value, option_value_rec) sock.close()
def _test_plugtest(self, message_list): # pragma: no cover serializer = Serializer() sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) for message, expected in message_list: if message is not None: datagram = serializer.serialize(message) sock.sendto(datagram, message.destination) if expected is not None: datagram, source = sock.recvfrom(4096) received_message = serializer.deserialize(datagram, source) 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, source) 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) for o in expected.options: option_value = getattr(expected, o.name.lower().replace("-", "_")) option_value_rec = getattr(received_message, o.name.lower().replace("-", "_")) self.assertEqual(option_value, option_value_rec) sock.close()
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 send(self, message): serializer = Serializer() message.destination = self.server host, port = message.destination print "Message sent to " + host + ":" + str(port) print "----------------------------------------" print message print "----------------------------------------" datagram = serializer.serialize(message) log.msg("Send datagram") self.transport.write(datagram, self.server)
def test_etag_deserialize(self): req = Request() req.type = defines.Types["CON"] req._mid = 1 req.etag = bytearray([0xc5]) serializer = Serializer() serialized = serializer.serialize(req) received_message = serializer.deserialize(serialized, ("127.0.0.1", 5683)) self.assertEqual(req.etag, received_message.etag)
def test_etag_deserialize(self): req = Request() req.type = defines.Types["CON"] req._mid = 1 req.etag = bytearray([0xC5]) serializer = Serializer() serialized = serializer.serialize(req) received_message = serializer.deserialize(serialized, ("127.0.0.1", 5683)) self.assertEqual(req.etag, received_message.etag)
def send_datagram(self, message): """ :type message: Message :param message: """ if not self.stopped.isSet(): host, port = message.destination logger.debug("send_datagram - " + str(message)) serializer = Serializer() message = serializer.serialize(message) self._socket.sendto(message, (host, port))
def send_datagram(self, message): """ Send a message through the udp socket. :type message: Message :param message: the message to send """ if not self.stopped.isSet(): host, port = message.destination logger.info("send_datagram - " + str(message)) serializer = Serializer() message = serializer.serialize(message) self._socket.sendto(message, (host, port))
def send(self, message, host, port): """ Send the message :param message: the message to send :param host: destination host :param port: destination port """ print "Message send to " + host + ":" + str(port) print "----------------------------------------" print message print "----------------------------------------" serializer = Serializer() message = serializer.serialize(message) self.transport.write(message, (host, port))
def send_datagram(self, message): """ Send a message over the UDP socket. :param message: the message to send """ host, port = message.destination logger.debug("send_datagram - " + str(message)) serializer = Serializer() message = serializer.serialize(message) self._socket.sendto(message, (host, port)) if not self._receiver_thread.isAlive(): self._receiver_thread.start()
def send_datagram(self, message): """ Send a message through the udp socket. :type message: Message :param message: the message to send """ if not self.stopped.isSet(): host, port = message.destination logger.debug("send_datagram - " + str(message)) serializer = Serializer() message = serializer.serialize(message) if self.multicast: self._unicast_socket.sendto(message, (host, port)) else: self._socket.sendto(message, (host, port))
def _test(self, message, expected): serializer = Serializer() datagram = serializer.serialize(message) self.proto.datagramReceived(datagram, ("127.0.0.1", 5600)) datagram, source = self.tr.written[-1] host, port = source message = serializer.deserialize(datagram, host, port) self.assertEqual(message.type, expected.type) self.assertEqual(message.mid, expected.mid) self.assertEqual(message.code, expected.code) self.assertEqual(message.source, source) self.assertEqual(message.token, expected.token) self.assertEqual(message.payload, expected.payload) self.assertEqual(message.options, expected.options) self.tr.written = []
def send(self, message, host, port): """ Send the message :param message: the message to send :param host: destination host :param port: destination port """ # print "Message send to " + host + ":" + str(port) # print "----------------------------------------" # print message # print "----------------------------------------" serializer = Serializer() message = serializer.serialize(message) self._socket.sendto(message, (host, port))
def send_notification(self, t): """ Sends a notification message. :param t: (the resource, request, the notification message) """ assert isinstance(t, tuple) resource, request, notification_message = t host, port = notification_message.destination serializer = Serializer() self._parent.schedule_retrasmission(request, notification_message, resource) print "Notification Message send to " + host + ":" + str(port) print "----------------------------------------" print notification_message print "----------------------------------------" notification_message = serializer.serialize(notification_message) self._parent.transport.write(notification_message, (host, port))
def send_datagram(self, message): """ Send a message through the udp socket. :type message: Message :param message: the message to send """ if not self.stopped.isSet(): host, port = message.destination logger.debug("send_datagram - " + str(message)) serializer = Serializer() if (message.mid is None): message.mid = self._messageLayer.fetch_mid() message = serializer.serialize(message) if self.multicast: self._unicast_socket.sendto(message, (host, port)) else: self._socket.sendto(message, (host, port))
def _test_check(self, message_list, timeout=0): serializer = Serializer() sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) for message, expected in message_list: if message is not None: datagram = serializer.serialize(message) sleep(timeout) sock.sendto(datagram, message.destination) if expected is not None: datagram, source = sock.recvfrom(4096) received_message = serializer.deserialize(datagram, source) 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, source) if expected.token is not None: self.assertEqual(received_message.token, expected.token) if expected.content_type is not None: self.assertEqual(received_message.content_type, expected.content_type) if expected.payload is not None: expected_list = self.parse_core_link_format( expected.payload) received_list = self.parse_core_link_format( received_message.payload) all_list = [] for expected_elem in expected_list: for received_elem in received_list: if expected_elem['path'] == received_elem['path']: all_list_elem = (expected_elem, received_elem) all_list.append(all_list_elem) for data in all_list: for k in data[1]: self.assertIn(k, data[0]) if (k != "lt") and (k in data[0]): self.assertEqual(data[0][k], data[1][k]) else: self.assertEqual(expected.payload, received_message.payload) sock.close()
def _test_check(self, message_list, timeout=0): serializer = Serializer() sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) for message, expected in message_list: if message is not None: datagram = serializer.serialize(message) sleep(timeout) sock.sendto(datagram, message.destination) if expected is not None: datagram, source = sock.recvfrom(4096) received_message = serializer.deserialize(datagram, source) 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, source) if expected.token is not None: self.assertEqual(received_message.token, expected.token) if expected.content_type is not None: self.assertEqual(received_message.content_type, expected.content_type) if expected.payload is not None: expected_list = self.parse_core_link_format(expected.payload) received_list = self.parse_core_link_format(received_message.payload) self.assertEqual(len(expected_list), len(received_list)) all_list = [] for expected_elem in expected_list: for received_elem in received_list: if expected_elem['path'] == received_elem['path']: all_list_elem = (expected_elem, received_elem) all_list.append(all_list_elem) self.assertEqual(len(expected_list), len(all_list)) for data in all_list: for k in data[1]: self.assertIn(k, data[0]) if (k != "lt") and (k in data[0]): self.assertEqual(data[0][k], data[1][k]) else: self.assertEqual(expected.payload, received_message.payload) sock.close()
def _test(self, message, expected): serializer = Serializer() datagram = serializer.serialize(message) sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.sendto(datagram, message.destination) host, port = message.destination # print "Message sent to " + host + ":" + str(port) # print "----------------------------------------" # print message # print "----------------------------------------" datagram, source = sock.recvfrom(4096) host, port = source message = serializer.deserialize(datagram, host, port) self.assertEqual(message.type, expected.type) self.assertEqual(message.mid, expected.mid) self.assertEqual(message.code, expected.code) self.assertEqual(message.source, source) self.assertEqual(message.token, expected.token) self.assertEqual(message.payload, expected.payload) self.assertEqual(message.options, expected.options)
def send_datagram(self, message): """ Send a message over the UDP socket. :param message: the message to send """ host, port = message.destination logger.debug("send_datagram - " + str(message)) serializer = Serializer() raw_message = serializer.serialize(message) try: self._socket.sendto(raw_message, (host, port)) except Exception as e: if self._cb_ignore_write_exception is not None and callable(self._cb_ignore_write_exception): if not self._cb_ignore_write_exception(e, self): raise if self._receiver_thread is None or not self._receiver_thread.isAlive(): self._receiver_thread = threading.Thread(target=self.receive_datagram) self._receiver_thread.start()
def send_datagram(self, message): """ Send a message through the udp socket. :type message: Message :param message: the message to send """ if not self.stopped.isSet(): host, port = message.destination logger.debug("send_datagram - " + str(message)) serializer = Serializer() try: message = serializer.serialize(message) except Exception as e: logger.error("Exception received in send_datagram") logger.exception(traceback.format_exc()) if self.multicast: self._unicast_socket.sendto(message, (host, port)) else: self._socket.sendto(message, (host, port))