Beispiel #1
0
    def _receive_message(self):
        """
        Internal coroutine for receiving messages from the
        zmq processor DEALER interface
        """
        with self._condition:
            self._condition.wait_for(lambda: self._proc_sock is not None)
        while True:
            msg_bytes = yield from self._proc_sock.recv()
            LOGGER.debug("Client received message: %s", msg_bytes)
            message = validator_pb2.Message()
            message.ParseFromString(msg_bytes)
            try:
                self._futures.set_result(
                    message.correlation_id,
                    future.FutureResult(message_type=message.message_type,
                                        content=message.content))
            except future.FutureCollectionKeyError:
                # if we are getting an initial message, not a response
                if message.message_type in self._handlers:
                    handler = self._handlers[message.message_type]
                else:
                    handler = self._handlers[validator_pb2.Message.DEFAULT]

                handler.handle(message, _Responder(self.send_message))
                self._recv_queue.put_nowait(message)
            else:
                my_future = self._futures.get(message.correlation_id)
                LOGGER.debug("Message round "
                             "trip: %s", my_future.get_duration())
Beispiel #2
0
    def _receive_message(self):
        """
        Internal coroutine for receiving messages from the
        zmq processor ROUTER interface
        """
        with self._condition:
            self._condition.wait_for(lambda: self._proc_sock is not None)
        while True:
            ident, result = yield from self._proc_sock.recv_multipart()
            LOGGER.debug("Server received message "
                         "from %s: %s", ident, result)
            message = validator_pb2.Message()
            message.ParseFromString(result)
            message.sender = ident
            try:
                # if there is a future, then we are getting a response
                self._futures.set_result(
                    message.correlation_id,
                    future.FutureResult(content=message.content,
                                        message_type=message.message_type))
            except future.FutureCollectionKeyError:
                # if there isn't a future, we are getting an initial message
                if message.message_type in self._handlers:
                    handler = self._handlers[message.message_type]
                else:
                    handler = self._handlers[validator_pb2.Message.DEFAULT]

                handler.handle(message, _Responder(self.send_message))
Beispiel #3
0
 def handle(self, message, responder):
     self._service.set_future(message.correlation_id,
                              future.FutureResult(
                                  content=message.content,
                                  message_type=message.message_type))