def unregister(self, target, hostname, listener_type):
if target.topic and target.server:
key = zmq_address.target_to_key(target, listener_type)
self._redis.srem(key, hostname)
if target.topic:
key = zmq_address.prefix_str(target.topic, listener_type)
self._redis.srem(key, hostname)
def register(self, target, hostname, listener_type, expire=-1):
if target.topic and target.server:
key = zmq_address.target_to_key(target, listener_type)
self._add_key_with_expire(key, hostname, expire)
if target.topic:
key = zmq_address.prefix_str(target.topic, listener_type)
self._add_key_with_expire(key, hostname, expire)
def get_hosts_fanout(self, target, listener_type):
hosts = []
key = zmq_address.target_to_key(target, listener_type)
hosts.extend([host for host in self._cache[key]
if self._address[host] > 0])
LOG.debug("[Dummy] get_hosts_fanout for target %(target)s: %(hosts)s",
{"target": target, "hosts": hosts})
return hosts
def get_fanout_hosts(self, target):
target_key = zmq_address.target_to_key(
target, zmq_names.socket_type_str(self.listener_type))
LOG.debug("Processing target %s for fanout." % target_key)
if not self.routing_table.contains(target_key):
self._fetch_fanout_hosts_from_matchmaker(target, target_key)
return self.routing_table.get_hosts_fanout(target_key)
def register(self, target, hostname, listener_type, expire=-1):
if target.server:
key = zmq_address.target_to_key(target, listener_type)
if hostname not in self._cache[key]:
self._cache[key].append(hostname)
key = zmq_address.prefix_str(target.topic, listener_type)
if hostname not in self._cache[key]:
self._cache[key].append(hostname)
self._address[hostname] = expire
def acquire_connection(self, request):
target_key = zmq_address.target_to_key(
request.target, zmq_names.socket_type_str(zmq.ROUTER))
if request.msg_type in zmq_names.MULTISEND_TYPES:
hosts = self.routing_table.get_fanout_hosts(request.target)
return self.fanout_sockets.get_cached_socket(target_key, hosts,
immediate=False)
else:
hosts = self.routing_table.get_all_round_robin_hosts(
request.target)
return self.sockets_manager.get_cached_socket(target_key, hosts)
def get_hosts(self, target, listener_type):
LOG.debug("[Redis] get_hosts for target %s", target)
hosts = []
key = zmq_address.target_to_key(target, listener_type)
hosts.extend(self._get_hosts_by_key(key))
if (not hosts or target.fanout) and target.topic and target.server:
key = zmq_address.prefix_str(target.topic, listener_type)
hosts.extend(self._get_hosts_by_key(key))
return hosts
def unregister(self, target, hostname, listener_type):
if target.server:
key = zmq_address.target_to_key(target, listener_type)
if hostname in self._cache[key]:
self._cache[key].remove(hostname)
key = zmq_address.prefix_str(target.topic, listener_type)
if hostname in self._cache[key]:
self._cache[key].remove(hostname)
if hostname in self._address:
self._address.pop(hostname)
def register(self, target, hostname, listener_type, expire=-1):
def register_key(key):
self._redis.sadd(key, hostname)
if expire > 0:
self._redis.expire(key, expire)
if target.topic and target.server:
key = zmq_address.target_to_key(target, listener_type)
register_key(key)
if target.topic:
key = zmq_address.prefix_str(target.topic, listener_type)
register_key(key)
def register(self, target, hostname):
if target.topic and target.server:
key = zmq_address.target_to_key(target)
if hostname not in self._get_hosts_by_key(key):
self._redis.lpush(key, hostname)
if target.topic:
if hostname not in self._get_hosts_by_key(target.topic):
self._redis.lpush(target.topic, hostname)
if target.server:
if hostname not in self._get_hosts_by_key(target.server):
self._redis.lpush(target.server, hostname)
def register(self, target, hostname, listener_type):
if target.topic and target.server:
key = zmq_address.target_to_key(target, listener_type)
if hostname not in self._get_hosts_by_key(key):
self._redis.lpush(key, hostname)
if target.topic:
key = zmq_address.prefix_str(target.topic, listener_type)
if hostname not in self._get_hosts_by_key(key):
self._redis.lpush(key, hostname)
if target.server:
key = zmq_address.prefix_str(target.server, listener_type)
if hostname not in self._get_hosts_by_key(key):
self._redis.lpush(key, hostname)
def _send_request(self, socket, request):
"""Send request to consumer.
Helper private method which defines basic sending behavior.
:param socket: Socket to publish message on
:type socket: zmq.Socket
:param request: Message data and destination container object
:type request: zmq_request.Request
"""
LOG.info(_LI("Sending %(type)s message_id %(message)s to a target"
"%(target)s key: %(key)s, host:%(host)s")
% {"type": request.msg_type,
"message": request.message_id,
"target": request.target,
"key": zmq_address.target_to_key(request.target),
"host": request.host})
socket.send_pyobj(request)
def get_hosts(self, target, listener_type):
hosts = []
if target.server:
key = zmq_address.target_to_key(target, listener_type)
hosts.extend([host for host in self._cache[key]
if self._address[host] > 0])
if not hosts:
key = zmq_address.prefix_str(target.topic, listener_type)
hosts.extend([host for host in self._cache[key]
if self._address[host] > 0])
LOG.debug("[Dummy] get_hosts for target %(target)s: %(hosts)s",
{"target": target, "hosts": hosts})
return hosts
def _fetch_round_robin_hosts_from_matchmaker(self, target):
target_key = zmq_address.target_to_key(
target, zmq_names.socket_type_str(self.listener_type))
LOG.debug("Processing target %s for round-robin." % target_key)
if target_key not in self.round_robin_targets:
with self._lock:
if target_key not in self.round_robin_targets:
LOG.debug("Target %s is not in cache. Check matchmaker "
"server." % target_key)
hosts = self.matchmaker.get_hosts_retry(
target, zmq_names.socket_type_str(self.listener_type))
LOG.debug("Received hosts %s" % hosts)
self.routing_table.update_hosts(target_key, hosts)
self.round_robin_targets[target_key] = \
self.routing_table.get_hosts_round_robin(target_key)
return target_key
def _fetch_round_robin_hosts_from_matchmaker(self, target):
target_key = zmq_address.target_to_key(
target, zmq_names.socket_type_str(self.listener_type))
LOG.debug("Processing target %s for round-robin." % target_key)
if target_key not in self.round_robin_targets:
with self._lock:
if target_key not in self.round_robin_targets:
LOG.debug("Target %s is not in cache. Check matchmaker "
"server." % target_key)
hosts = self.matchmaker.get_hosts_retry(
target, zmq_names.socket_type_str(self.listener_type))
LOG.debug("Received hosts %s" % hosts)
self.routing_table.update_hosts(target_key, hosts)
self.round_robin_targets[target_key] = \
self.routing_table.get_hosts_round_robin(target_key)
return target_key
def register(self, target, hostname, listener_type, expire=-1):
def register_key(key):
if hostname not in self._get_hosts_by_key(key):
self._redis.lpush(key, hostname)
if expire > 0:
self._redis.expire(key, expire)
if target.topic and target.server:
key = zmq_address.target_to_key(target, listener_type)
register_key(key)
if target.topic:
key = zmq_address.prefix_str(target.topic, listener_type)
register_key(key)
if target.server:
key = zmq_address.prefix_str(target.server, listener_type)
register_key(key)
def unregister(self, target, hostname, listener_type):
key = zmq_address.target_to_key(target, listener_type)
if hostname in self._cache[key]:
self._cache[key].remove(hostname)
def register(self, target, hostname, listener_type):
key = zmq_address.target_to_key(target, listener_type)
if hostname not in self._cache[key]:
self._cache[key].append(hostname)
def test_target_to_key_topic_server_round_robin(self):
target = oslo_messaging.Target(topic='topic', server='server')
key = zmq_address.target_to_key(target, self.listener_type)
self.assertEqual(self.listener_type + '/topic/server', key)
def test_target_to_key_topic_server_fanout(self):
target = oslo_messaging.Target(topic='topic',
server='server',
fanout=True)
key = zmq_address.target_to_key(target, self.listener_type)
self.assertEqual(self.listener_type + '/topic', key)
def _generate_identity(self):
return six.b(self.conf.oslo_messaging_zmq.rpc_zmq_host + "/" +
zmq_address.target_to_key(self.target) + "/" +
str(uuid.uuid4()))
def unregister(self, target, hostname, listener_type):
key = zmq_address.target_to_key(target, listener_type)
self._redis.srem(key, hostname)
def get_hosts(self, target):
hosts = []
key = zmq_address.target_to_key(target)
hosts.extend(self._get_hosts_by_key(key))
return hosts
def test_target_to_key_topic_only(self):
target = oslo_messaging.Target(topic='topic')
key = zmq_address.target_to_key(target, self.listener_type)
self.assertEqual(self.listener_type + '/topic', key)
def test_target_to_key_topic_server_round_robin(self):
target = oslo_messaging.Target(topic='topic', server='server')
key = zmq_address.target_to_key(target, self.listener_type)
self.assertEqual(self.listener_type + '/topic/server', key)
def get_hosts(self, target, listener_type):
key = zmq_address.target_to_key(target, listener_type)
return self._cache[key]
def _generate_identity(self):
return six.b(self.conf.oslo_messaging_zmq.rpc_zmq_host + "/" +
zmq_address.target_to_key(self.target) + "/" +
str(uuid.uuid4()))
def test_target_to_key_topic_only(self):
target = oslo_messaging.Target(topic='topic')
key = zmq_address.target_to_key(target, self.listener_type)
self.assertEqual(self.listener_type + '/topic', key)
def test_target_to_key_topic_server_fanout_no_prefix(self):
target = oslo_messaging.Target(topic='topic', server='server',
fanout=True)
key = zmq_address.target_to_key(target)
self.assertEqual('topic', key)
def get_hosts(self, target, listener_type):
LOG.debug("[Redis] get_hosts for target %s", target)
hosts = []
key = zmq_address.target_to_key(target, listener_type)
hosts.extend(self._get_hosts_by_key(key))
return hosts
def test_target_to_key_topic_server_fanout(self):
target = oslo_messaging.Target(topic='topic', server='server',
fanout=True)
key = zmq_address.target_to_key(target, self.listener_type)
self.assertEqual(self.listener_type + '/topic', key)
def unregister(self, target, hostname, listener_type):
key = zmq_address.target_to_key(target, listener_type)
self._redis.srem(key, hostname)
def test_target_to_key_topic_server_fanout_no_prefix(self):
target = oslo_messaging.Target(topic='topic',
server='server',
fanout=True)
key = zmq_address.target_to_key(target)
self.assertEqual('topic', key)
def unregister(self, target, hostname):
key = zmq_address.target_to_key(target)
self._redis.lrem(key, 0, hostname)
def get_hosts(self, target, listener_type):
LOG.debug("[Redis] get_hosts for target %s", target)
hosts = []
key = zmq_address.target_to_key(target, listener_type)
hosts.extend(self._get_hosts_by_key(key))
return hosts
