def receive_message(self, socket): try: empty = socket.recv() assert empty == b'', 'Bad format: empty delimiter expected' reply_id = socket.recv() message_type = int(socket.recv()) message_id = socket.recv() context = socket.recv_loaded() message = socket.recv_loaded() LOG.debug( "[%(host)s] Received %(msg_type)s message %(msg_id)s", { "host": self.host, "msg_type": zmq_names.message_type_str(message_type), "msg_id": message_id }) if message_type == zmq_names.CALL_TYPE: return zmq_incoming_message.ZmqIncomingMessage( context, message, reply_id, message_id, socket, self.sender) elif message_type in zmq_names.NON_BLOCKING_TYPES: return zmq_incoming_message.ZmqIncomingMessage( context, message) else: LOG.error(_LE("Unknown message type: %s"), zmq_names.message_type_str(message_type)) except (zmq.ZMQError, AssertionError, ValueError) as e: LOG.error(_LE("Receiving message failure: %s"), str(e))
def receive_message(self, socket): try: empty = socket.recv() assert empty == b'', 'Bad format: empty delimiter expected' reply_id = socket.recv() message_type = int(socket.recv()) message_id = socket.recv() context = socket.recv_loaded() message = socket.recv_loaded() LOG.debug("[%(host)s] Received %(msg_type)s message %(msg_id)s", {"host": self.host, "msg_type": zmq_names.message_type_str(message_type), "msg_id": message_id}) if message_type == zmq_names.CALL_TYPE: return zmq_incoming_message.ZmqIncomingMessage( context, message, reply_id, message_id, socket, self.sender ) elif message_type in zmq_names.NON_BLOCKING_TYPES: return zmq_incoming_message.ZmqIncomingMessage(context, message) else: LOG.error(_LE("Unknown message type: %s"), zmq_names.message_type_str(message_type)) except (zmq.ZMQError, AssertionError) as e: LOG.error(_LE("Receiving message failure: %s"), str(e))
def receive_message(self, socket): try: reply_id, msg_type, message_id, context, message = \ self._receive_request(socket) LOG.debug( "[%(host)s] Received %(msg_type)s message %(msg_id)s", { "host": self.host, "msg_type": zmq_names.message_type_str(msg_type), "msg_id": message_id }) if msg_type == zmq_names.CALL_TYPE or \ msg_type in zmq_names.NON_BLOCKING_TYPES: ack_sender = self.ack_sender \ if self.conf.oslo_messaging_zmq.rpc_use_acks else None reply_sender = self.reply_sender \ if msg_type == zmq_names.CALL_TYPE else None return zmq_incoming_message.ZmqIncomingMessage( context, message, reply_id, message_id, socket, ack_sender, reply_sender) else: LOG.error(_LE("Unknown message type: %s"), zmq_names.message_type_str(msg_type)) except (zmq.ZMQError, AssertionError, ValueError) as e: LOG.error(_LE("Receiving message failed: %s"), str(e))
def receive_message(self, socket): try: reply_id, msg_type, message_id, context, message = \ self._receive_request(socket) if msg_type == zmq_names.CALL_TYPE or \ msg_type in zmq_names.NON_BLOCKING_TYPES: ack_sender = self.ack_sender \ if self.conf.oslo_messaging_zmq.rpc_use_acks else None reply_sender = self.reply_sender \ if msg_type == zmq_names.CALL_TYPE else None message = zmq_incoming_message.ZmqIncomingMessage( context, message, reply_id, message_id, socket, ack_sender, reply_sender, self.messages_cache) # drop a duplicate message if message_id in self.messages_cache: LOG.warning( _LW("[%(host)s] Dropping duplicate %(msg_type)s " "message %(msg_id)s"), { "host": self.host, "msg_type": zmq_names.message_type_str(msg_type), "msg_id": message_id }) # NOTE(gdavoian): send yet another ack for the non-CALL # message, since the old one might be lost; # for the CALL message also try to resend its reply # (of course, if it was already obtained and cached). message._acknowledge() if msg_type == zmq_names.CALL_TYPE: message._reply_from_cache() return None self.messages_cache.add(message_id) LOG.debug( "[%(host)s] Received %(msg_type)s message %(msg_id)s", { "host": self.host, "msg_type": zmq_names.message_type_str(msg_type), "msg_id": message_id }) # NOTE(gdavoian): send an immediate ack, since it may # be too late to wait until the message will be # dispatched and processed by a RPC server message._acknowledge() return message else: LOG.error(_LE("Unknown message type: %s"), zmq_names.message_type_str(msg_type)) except (zmq.ZMQError, AssertionError, ValueError) as e: LOG.error(_LE("Receiving message failure: %s"), str(e))
def _run_loop(self): data, socket = self._poller.poll(timeout=self.conf.rpc_poll_timeout) if data is None: return reply_id, message_type, message_id, response = data assert message_type in self.message_types, \ "%s is not supported!" % zmq_names.message_type_str(message_type) future = self._get_future(message_id, message_type) if future is not None: LOG.debug("Received %(msg_type)s for %(msg_id)s", {"msg_type": zmq_names.message_type_str(message_type), "msg_id": message_id}) future.set_result((reply_id, response))
def _run_loop(self): data, socket = self._poller.poll( timeout=self.conf.oslo_messaging_zmq.rpc_poll_timeout) if data is None: return reply_id, message_type, message_id, response = data assert message_type in self.message_types, \ "%s is not supported!" % zmq_names.message_type_str(message_type) future = self._get_future(message_id, message_type) if future is not None: LOG.debug("Received %(msg_type)s for %(msg_id)s", {"msg_type": zmq_names.message_type_str(message_type), "msg_id": message_id}) future.set_result((reply_id, response))
def _create_message(self, context, message, message_version, reply_id, message_id, socket, message_type): # drop a duplicate message if message_id in self.messages_cache: LOG.warning( _LW("[%(host)s] Dropping duplicate %(msg_type)s " "message %(msg_id)s"), {"host": self.host, "msg_type": zmq_names.message_type_str(message_type), "msg_id": message_id} ) # NOTE(gdavoian): send yet another ack for the direct # message, since the old one might be lost; # for the CALL message also try to resend its reply # (of course, if it was already obtained and cached). if message_type in zmq_names.DIRECT_TYPES: self._acknowledge(message_version, reply_id, message_id, socket) if message_type == zmq_names.CALL_TYPE: self._reply_from_cache(message_id, socket) return None self.messages_cache.add(message_id) # NOTE(gdavoian): send an immediate ack, since it may # be too late to wait until the message will be # dispatched and processed by a RPC server if message_type in zmq_names.DIRECT_TYPES: self._acknowledge(message_version, reply_id, message_id, socket) return super(DealerConsumerWithAcks, self)._create_message( context, message, message_version, reply_id, message_id, socket, message_type )
def _create_message(self, context, message, reply_id, message_id, socket, message_type): # drop a duplicate message if message_id in self.messages_cache: LOG.warning( _LW("[%(host)s] Dropping duplicate %(msg_type)s " "message %(msg_id)s"), { "host": self.host, "msg_type": zmq_names.message_type_str(message_type), "msg_id": message_id }) # NOTE(gdavoian): send yet another ack for the non-CALL # message, since the old one might be lost; # for the CALL message also try to resend its reply # (of course, if it was already obtained and cached). self._acknowledge(reply_id, message_id, socket) if message_type == zmq_names.CALL_TYPE: self._reply_from_cache(message_id, socket) return None self.messages_cache.add(message_id) # NOTE(gdavoian): send an immediate ack, since it may # be too late to wait until the message will be # dispatched and processed by a RPC server self._acknowledge(reply_id, message_id, socket) return super(DealerConsumerWithAcks, self)._create_message(context, message, reply_id, message_id, socket, message_type)
def send(self, socket, ack): assert ack.msg_type == zmq_names.ACK_TYPE, "Ack expected!" # not implemented yet LOG.debug("Sending %(msg_type)s for %(msg_id)s", {"msg_type": zmq_names.message_type_str(ack.msg_type), "msg_id": ack.message_id})
def send(self, socket, ack): assert ack.msg_type == zmq_names.ACK_TYPE, "Ack expected!" with self._lock: self._send(socket, ack) LOG.debug("Sending %(msg_type)s for %(msg_id)s", {"msg_type": zmq_names.message_type_str(ack.msg_type), "msg_id": ack.message_id})
def send(self, socket, request): with self._lock: self._send(socket, request) LOG.debug("Sending %(msg_type)s message %(msg_id)s to " "target %(target)s", {"msg_type": zmq_names.message_type_str(request.msg_type), "msg_id": request.message_id, "target": request.target})
def send(self, socket, reply): assert reply.msg_type == zmq_names.REPLY_TYPE, "Reply expected!" with self._lock: self._send(socket, reply) LOG.debug("Sending %(msg_type)s for %(msg_id)s", {"msg_type": zmq_names.message_type_str(reply.msg_type), "msg_id": reply.message_id})
def send(self, socket, request): with self._lock: self._send(socket, request) LOG.debug("->[proxy:%(addr)s] Sending %(msg_type)s message " "%(msg_id)s to target %(target)s", {"addr": list(socket.connections), "msg_type": zmq_names.message_type_str(request.msg_type), "msg_id": request.message_id, "target": request.target})
def send(self, socket, reply): assert reply.msg_type == zmq_names.REPLY_TYPE, "Reply expected!" with self._lock: self._send(socket, reply) LOG.debug("->[proxy:%(addr)s] Sending %(msg_type)s for %(msg_id)s", {"addr": list(socket.connections), "msg_type": zmq_names.message_type_str(reply.msg_type), "msg_id": reply.message_id})
def send(self, socket, reply): assert reply.msg_type == zmq_names.REPLY_TYPE, "Reply expected!" socket.send(reply.reply_id, zmq.SNDMORE) socket.send(b'', zmq.SNDMORE) socket.send_dumped(reply.to_dict()) LOG.debug("Sending %(msg_type)s for %(msg_id)s", {"msg_type": zmq_names.message_type_str(reply.msg_type), "msg_id": reply.message_id})
def send(self, socket, ack): assert ack.msg_type == zmq_names.ACK_TYPE, "Ack expected!" with self._lock: self._send(socket, ack) LOG.debug("->[proxy:%(addr)s] Sending %(msg_type)s for %(msg_id)s", {"addr": list(socket.connections), "msg_type": zmq_names.message_type_str(ack.msg_type), "msg_id": ack.message_id})
def send(self, socket, request): socket.send(b'', zmq.SNDMORE) socket.send(six.b(str(request.msg_type)), zmq.SNDMORE) socket.send_string(request.message_id, zmq.SNDMORE) socket.send_dumped([request.context, request.message]) LOG.debug("Sending %(msg_type)s message %(msg_id)s to " "target %(target)s", {"msg_type": zmq_names.message_type_str(request.msg_type), "msg_id": request.message_id, "target": request.target})
def send(self, socket, ack): assert ack.msg_type == zmq_names.ACK_TYPE, "Ack expected!" send_version = self._get_send_version(ack.message_version) with self._lock: send_version(socket, ack) LOG.debug("Sending %(msg_type)s for %(msg_id)s (v%(msg_version)s)", {"msg_type": zmq_names.message_type_str(ack.msg_type), "msg_id": ack.message_id, "msg_version": ack.message_version})
def send(self, socket, request): socket.send(b'', zmq.SNDMORE) socket.send(six.b(str(request.msg_type)), zmq.SNDMORE) socket.send_string(request.message_id, zmq.SNDMORE) socket.send_dumped(request.context, zmq.SNDMORE) socket.send_dumped(request.message) LOG.debug("Sending %(msg_type)s message %(msg_id)s to " "target %(target)s", {"msg_type": zmq_names.message_type_str(request.msg_type), "msg_id": request.message_id, "target": request.target})
def receive_message(self, socket): try: reply_id, msg_type, message_id, context, message = \ self._receive_request(socket) LOG.debug("[%(host)s] Received %(msg_type)s message %(msg_id)s", {"host": self.host, "msg_type": zmq_names.message_type_str(msg_type), "msg_id": message_id}) if msg_type == zmq_names.CALL_TYPE: return zmq_incoming_message.ZmqIncomingMessage( context, message, reply_id, message_id, socket, self.sender ) elif msg_type in zmq_names.NON_BLOCKING_TYPES: return zmq_incoming_message.ZmqIncomingMessage(context, message) else: LOG.error(_LE("Unknown message type: %s"), zmq_names.message_type_str(msg_type)) except (zmq.ZMQError, AssertionError) as e: LOG.error(_LE("Receiving message failed: %s"), str(e))
def send(self, socket, ack): assert ack.msg_type == zmq_names.ACK_TYPE, "Ack expected!" socket.send(b'', zmq.SNDMORE) socket.send(six.b(str(ack.msg_type)), zmq.SNDMORE) socket.send(ack.reply_id, zmq.SNDMORE) socket.send_string(ack.message_id) LOG.debug("->[proxy:%(addr)s] Sending %(msg_type)s for %(msg_id)s", {"addr": list(socket.connections), "msg_type": zmq_names.message_type_str(ack.msg_type), "msg_id": ack.message_id})
def send(self, socket, reply): assert reply.msg_type == zmq_names.REPLY_TYPE, "Reply expected!" send_version = self._get_send_version(reply.message_version) with self._lock: send_version(socket, reply) LOG.debug("Sending %(msg_type)s for %(msg_id)s (v%(msg_version)s)", {"msg_type": zmq_names.message_type_str(reply.msg_type), "msg_id": reply.message_id, "msg_version": reply.message_version})
def send(self, socket, request): socket.send(b'', zmq.SNDMORE) socket.send(six.b(str(request.msg_type)), zmq.SNDMORE) socket.send(request.routing_key, zmq.SNDMORE) socket.send_string(request.message_id, zmq.SNDMORE) socket.send_dumped([request.context, request.message]) LOG.debug("->[proxy:%(addr)s] Sending %(msg_type)s message " "%(msg_id)s to target %(target)s", {"addr": list(socket.connections), "msg_type": zmq_names.message_type_str(request.msg_type), "msg_id": request.message_id, "target": request.target})
def send(self, socket, reply): assert reply.msg_type == zmq_names.REPLY_TYPE, "Reply expected!" socket.send(b'', zmq.SNDMORE) socket.send(six.b(str(reply.msg_type)), zmq.SNDMORE) socket.send(reply.reply_id, zmq.SNDMORE) socket.send_string(reply.message_id, zmq.SNDMORE) socket.send_dumped([reply.reply_body, reply.failure]) LOG.debug("->[proxy:%(addr)s] Sending %(msg_type)s for %(msg_id)s", {"addr": list(socket.connections), "msg_type": zmq_names.message_type_str(reply.msg_type), "msg_id": reply.message_id})
def send(self, socket, ack): assert ack.msg_type == zmq_names.ACK_TYPE, "Ack expected!" send_version = self._get_send_version(ack.message_version) with self._lock: send_version(socket, ack) LOG.debug("->[proxy:%(addr)s] Sending %(msg_type)s for %(msg_id)s " "(v%(msg_version)s)", {"addr": list(socket.connections), "msg_type": zmq_names.message_type_str(ack.msg_type), "msg_id": ack.message_id, "msg_version": ack.message_version})
def send(self, socket, request): socket.send(b'', zmq.SNDMORE) socket.send(six.b(str(request.msg_type)), zmq.SNDMORE) socket.send(six.b(request.routing_key), zmq.SNDMORE) socket.send(six.b(request.message_id), zmq.SNDMORE) socket.send_dumped(request.context, zmq.SNDMORE) socket.send_dumped(request.message) LOG.debug("->[proxy:%(addr)s] Sending %(msg_type)s message " "%(msg_id)s to target %(target)s", {"addr": list(socket.connections), "msg_type": zmq_names.message_type_str(request.msg_type), "msg_id": request.message_id, "target": request.target})
def send(self, socket, reply): assert reply.msg_type == zmq_names.REPLY_TYPE, "Reply expected!" send_version = self._get_send_version(reply.message_version) with self._lock: send_version(socket, reply) LOG.debug("->[proxy:%(addr)s] Sending %(msg_type)s for %(msg_id)s " "(v%(msg_version)s)", {"addr": list(socket.connections), "msg_type": zmq_names.message_type_str(reply.msg_type), "msg_id": reply.message_id, "msg_version": reply.message_version})
def send(self, socket, request): assert request.msg_type in zmq_names.REQUEST_TYPES, "Request expected!" send_version = self._get_send_version(request.message_version) with self._lock: send_version(socket, request) LOG.debug("Sending %(msg_type)s message %(msg_id)s to " "target %(target)s (v%(msg_version)s)", {"msg_type": zmq_names.message_type_str(request.msg_type), "msg_id": request.message_id, "target": request.target, "msg_version": request.message_version})
def _receive_request(self, socket): topic_filter = socket.recv() message_type = int(socket.recv()) message_id = socket.recv() context, message = socket.recv_loaded() LOG.debug( "[%(host)s] Received on topic %(filter)s message %(msg_id)s " "%(msg_type)s", { 'host': self.host, 'filter': topic_filter, 'msg_id': message_id, 'msg_type': zmq_names.message_type_str(message_type) }) return context, message
def send(self, socket, request): assert request.msg_type in zmq_names.REQUEST_TYPES, "Request expected!" send_version = self._get_send_version(request.message_version) with self._lock: send_version(socket, request) LOG.debug("->[proxy:%(addr)s] Sending %(msg_type)s message " "%(msg_id)s to target %(target)s (v%(msg_version)s)", {"addr": list(socket.connections), "msg_type": zmq_names.message_type_str(request.msg_type), "msg_id": request.message_id, "target": request.target, "msg_version": request.message_version})
def _run_loop(self): response, socket = \ self._poller.poll(self.conf.oslo_messaging_zmq.rpc_poll_timeout) if response is None: return message_type, message_id = response.msg_type, response.message_id futures = self._get_futures(message_id) if futures is not None: ack_future, reply_future = futures if message_type == zmq_names.REPLY_TYPE: reply_future.set_result(response) else: ack_future.set_result(response) LOG.debug("Received %(msg_type)s for %(msg_id)s", {"msg_type": zmq_names.message_type_str(message_type), "msg_id": message_id})
def _redirect_message(socket, multipart_message): message_type = multipart_message.pop(0) routing_key = multipart_message.pop(0) reply_id = multipart_message.pop(0) message_id = multipart_message[0] socket.send(routing_key, zmq.SNDMORE) socket.send(b'', zmq.SNDMORE) socket.send(reply_id, zmq.SNDMORE) socket.send(six.b(str(message_type)), zmq.SNDMORE) LOG.debug( "Dispatching %(msg_type)s message %(msg_id)s - to %(rkey)s" % { "msg_type": zmq_names.message_type_str(message_type), "msg_id": message_id, "rkey": routing_key }) socket.send_multipart(multipart_message)
def _run_loop(self): response, socket = \ self._poller.poll(self.conf.oslo_messaging_zmq.rpc_poll_timeout) if response is None: return message_type, message_id = response.msg_type, response.message_id futures = self._get_futures(message_id) if futures is not None: ack_future, reply_future = futures if message_type == zmq_names.REPLY_TYPE: reply_future.set_result(response) else: ack_future.set_result(response) LOG.debug( "Received %(msg_type)s for %(msg_id)s", { "msg_type": zmq_names.message_type_str(message_type), "msg_id": message_id })
def _create_message(self, context, message, message_version, reply_id, message_id, socket, message_type): if message_type == zmq_names.CALL_TYPE: message = zmq_incoming_message.ZmqIncomingMessage( context, message, message_version=message_version, reply_id=reply_id, message_id=message_id, socket=socket, reply_method=self._reply ) else: message = zmq_incoming_message.ZmqIncomingMessage(context, message) LOG.debug("[%(host)s] Received %(msg_type)s message %(msg_id)s " "(v%(msg_version)s)", {"host": self.host, "msg_type": zmq_names.message_type_str(message_type), "msg_id": message_id, "msg_version": message_version}) return message
def _create_message(self, context, message, reply_id, message_id, socket, message_type): if message_type == zmq_names.CALL_TYPE: message = zmq_incoming_message.ZmqIncomingMessage( context, message, reply_id=reply_id, message_id=message_id, socket=socket, reply_method=self._reply) else: message = zmq_incoming_message.ZmqIncomingMessage(context, message) LOG.debug( "[%(host)s] Received %(msg_type)s message %(msg_id)s", { "host": self.host, "msg_type": zmq_names.message_type_str(message_type), "msg_id": message_id }) return message
def send_message(self, socket, multipart_message): message_type = int(multipart_message[zmq_names.MESSAGE_TYPE_IDX]) routing_key = multipart_message[zmq_names.ROUTING_KEY_IDX] reply_id = multipart_message[zmq_names.REPLY_ID_IDX] message_id = multipart_message[zmq_names.MESSAGE_ID_IDX] socket.send(routing_key, zmq.SNDMORE) socket.send(b'', zmq.SNDMORE) socket.send(reply_id, zmq.SNDMORE) socket.send(multipart_message[zmq_names.MESSAGE_TYPE_IDX], zmq.SNDMORE) socket.send_multipart(multipart_message[zmq_names.MESSAGE_ID_IDX:]) LOG.debug( "Dispatching %(msg_type)s message %(msg_id)s - from %(rid)s " "-> to %(rkey)s", { "msg_type": zmq_names.message_type_str(message_type), "msg_id": message_id, "rkey": routing_key, "rid": reply_id })
def send_message(self, socket, multipart_message): message_type = zmq_names.ACK_TYPE message_id = multipart_message[zmq_names.MESSAGE_ID_IDX] routing_key = socket.handle.identity reply_id = multipart_message[zmq_names.REPLY_ID_IDX] socket.send(reply_id, zmq.SNDMORE) socket.send(b'', zmq.SNDMORE) socket.send(routing_key, zmq.SNDMORE) socket.send(six.b(str(message_type)), zmq.SNDMORE) socket.send_string(message_id) LOG.debug( "Sending %(msg_type)s for %(msg_id)s to %(rid)s " "[from %(rkey)s]", { "msg_type": zmq_names.message_type_str(message_type), "msg_id": message_id, "rid": reply_id, "rkey": routing_key })
def _send_message_v_1_0(self, socket, multipart_message): message_type = int(multipart_message[zmq_names.MESSAGE_TYPE_IDX]) routing_key = multipart_message[zmq_names.ROUTING_KEY_IDX] reply_id = multipart_message[zmq_names.REPLY_ID_IDX] message_id = multipart_message[zmq_names.MESSAGE_ID_IDX] message_version = multipart_message[zmq_names.MESSAGE_VERSION_IDX] socket.send(routing_key, zmq.SNDMORE) socket.send(b'', zmq.SNDMORE) socket.send(message_version, zmq.SNDMORE) socket.send(reply_id, zmq.SNDMORE) socket.send(multipart_message[zmq_names.MESSAGE_TYPE_IDX], zmq.SNDMORE) socket.send_multipart(multipart_message[zmq_names.MESSAGE_ID_IDX:]) LOG.debug("Dispatching %(msg_type)s message %(msg_id)s - from %(rid)s " "-> to %(rkey)s (v%(msg_version)s)", {"msg_type": zmq_names.message_type_str(message_type), "msg_id": message_id, "rkey": routing_key, "rid": reply_id, "msg_version": message_version})
def _send_message_v_1_0(self, socket, multipart_message): message_type = zmq_names.ACK_TYPE message_id = multipart_message[zmq_names.MESSAGE_ID_IDX] routing_key = socket.handle.identity reply_id = multipart_message[zmq_names.REPLY_ID_IDX] message_version = multipart_message[zmq_names.MESSAGE_VERSION_IDX] socket.send(reply_id, zmq.SNDMORE) socket.send(b'', zmq.SNDMORE) socket.send(message_version, zmq.SNDMORE) socket.send(routing_key, zmq.SNDMORE) socket.send(six.b(str(message_type)), zmq.SNDMORE) socket.send_string(message_id) LOG.debug("Sending %(msg_type)s for %(msg_id)s to %(rid)s " "[from %(rkey)s] (v%(msg_version)s)", {"msg_type": zmq_names.message_type_str(message_type), "msg_id": message_id, "rid": reply_id, "rkey": routing_key, "msg_version": message_version})
def receive_message(self, socket): try: empty = socket.recv() assert empty == b'', 'Bad format: empty delimiter expected' reply_id = socket.recv() message_type = int(socket.recv()) message_id = socket.recv() context = socket.recv_pyobj() message = socket.recv_pyobj() LOG.debug("[%(host)s] Received message %(id)s", {"host": self.host, "id": message_id}) if message_type == zmq_names.CALL_TYPE: return DealerIncomingRequest( socket, reply_id, message_id, context, message) elif message_type in zmq_names.NON_BLOCKING_TYPES: return DealerIncomingMessage(context, message) else: LOG.error(_LE("Unknown message type: %s"), zmq_names.message_type_str(message_type)) except (zmq.ZMQError, AssertionError) as e: LOG.error(_LE("Receiving message failure: %s"), str(e))
def _check_pattern(request, supported_pattern): if request.msg_type != supported_pattern: raise zmq_publisher_base.UnsupportedSendPattern( zmq_names.message_type_str(request.msg_type))
def _check_message_pattern(expected, actual): if expected != actual: raise UnsupportedSendPattern(zmq_names.message_type_str(actual))