147 lines
4.9 KiB
Python
147 lines
4.9 KiB
Python
# Copyright 2016 Mirantis, Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
import abc
|
|
import logging
|
|
import threading
|
|
|
|
import futurist
|
|
import six
|
|
|
|
from oslo_messaging._drivers.zmq_driver.client import zmq_response
|
|
from oslo_messaging._drivers.zmq_driver import zmq_async
|
|
from oslo_messaging._drivers.zmq_driver import zmq_names
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
zmq = zmq_async.import_zmq()
|
|
|
|
|
|
@six.add_metaclass(abc.ABCMeta)
|
|
class ReceiverBase(object):
|
|
"""Base response receiving interface."""
|
|
|
|
def __init__(self, conf):
|
|
self.conf = conf
|
|
self._lock = threading.Lock()
|
|
self._requests = {}
|
|
self._poller = zmq_async.get_poller()
|
|
self._executor = zmq_async.get_executor(method=self._run_loop)
|
|
self._executor.execute()
|
|
|
|
@abc.abstractproperty
|
|
def message_types(self):
|
|
"""A list of supported incoming response types."""
|
|
|
|
def register_socket(self, socket):
|
|
"""Register a socket for receiving data."""
|
|
self._poller.register(socket, recv_method=self.recv_response)
|
|
|
|
@abc.abstractmethod
|
|
def recv_response(self, socket):
|
|
"""Receive a response and return a tuple of the form
|
|
(reply_id, message_type, message_id, response).
|
|
"""
|
|
|
|
def track_request(self, request):
|
|
"""Track a request via already registered sockets and return
|
|
a list of futures for monitoring all types of responses.
|
|
"""
|
|
futures = []
|
|
for message_type in self.message_types:
|
|
future = futurist.Future()
|
|
self._set_future(request.message_id, message_type, future)
|
|
futures.append(future)
|
|
return futures
|
|
|
|
def untrack_request(self, request):
|
|
"""Untrack a request and stop monitoring any responses."""
|
|
for message_type in self.message_types:
|
|
self._pop_future(request.message_id, message_type)
|
|
|
|
def stop(self):
|
|
self._poller.close()
|
|
self._executor.stop()
|
|
|
|
def _get_future(self, message_id, message_type):
|
|
with self._lock:
|
|
return self._requests.get((message_id, message_type))
|
|
|
|
def _set_future(self, message_id, message_type, future):
|
|
with self._lock:
|
|
self._requests[(message_id, message_type)] = future
|
|
|
|
def _pop_future(self, message_id, message_type):
|
|
with self._lock:
|
|
return self._requests.pop((message_id, message_type), None)
|
|
|
|
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))
|
|
|
|
|
|
class AckReceiver(ReceiverBase):
|
|
|
|
message_types = (zmq_names.ACK_TYPE,)
|
|
|
|
|
|
class ReplyReceiver(ReceiverBase):
|
|
|
|
message_types = (zmq_names.REPLY_TYPE,)
|
|
|
|
|
|
class ReplyReceiverProxy(ReplyReceiver):
|
|
|
|
def recv_response(self, socket):
|
|
empty = socket.recv()
|
|
assert empty == b'', "Empty expected!"
|
|
reply_id = socket.recv()
|
|
assert reply_id is not None, "Reply ID expected!"
|
|
message_type = int(socket.recv())
|
|
assert message_type == zmq_names.REPLY_TYPE, "Reply expected!"
|
|
message_id = socket.recv()
|
|
raw_reply = socket.recv_loaded()
|
|
assert isinstance(raw_reply, dict), "Dict expected!"
|
|
reply = zmq_response.Response(**raw_reply)
|
|
LOG.debug("Received reply for %s", message_id)
|
|
return reply_id, message_type, message_id, reply
|
|
|
|
|
|
class ReplyReceiverDirect(ReplyReceiver):
|
|
|
|
def recv_response(self, socket):
|
|
empty = socket.recv()
|
|
assert empty == b'', "Empty expected!"
|
|
raw_reply = socket.recv_loaded()
|
|
assert isinstance(raw_reply, dict), "Dict expected!"
|
|
reply = zmq_response.Response(**raw_reply)
|
|
LOG.debug("Received reply for %s", reply.message_id)
|
|
return reply.reply_id, reply.msg_type, reply.message_id, reply
|
|
|
|
|
|
class AckAndReplyReceiver(ReceiverBase):
|
|
|
|
message_types = (zmq_names.ACK_TYPE, zmq_names.REPLY_TYPE)
|