def _register_rpc_consumers(self, connection):
endpoints = [resources_rpc.ResourcesPushRpcCallback()]
for resource_type in self.SUPPORTED_RESOURCES:
# we assume that neutron-server always broadcasts the latest
# version known to the agent
topic = resources_rpc.resource_type_versioned_topic(resource_type)
connection.create_consumer(topic, endpoints, fanout=True)
def _init_rpc_listeners(self):
endpoints = [resources_rpc.ResourcesPushRpcCallback()]
self._connection = n_rpc.create_connection()
for rtype in self.rcache.resource_types:
registry_rpc.register(self.resource_change_handler, rtype)
topic = resources_rpc.resource_type_versioned_topic(rtype)
self._connection.create_consumer(topic, endpoints, fanout=True)
self._connection.consume_in_threads()
def _register_rpc_consumers(self):
registry.register(self._handle_notification, resources.NDPPROXY)
self._connection = n_rpc.Connection()
endpoints = [resources_rpc.ResourcesPushRpcCallback()]
topic = resources_rpc.resource_type_versioned_topic(
resources.NDPPROXY)
self._connection.create_consumer(topic, endpoints, fanout=True)
self._connection.consume_in_threads()
def setUp(self):
super(ResourcesPushRpcCallbackTestCase, self).setUp()
mock.patch.object(resources_rpc, '_validate_resource_type').start()
mock.patch.object(
resources_rpc.resources,
'get_resource_cls', return_value=FakeResource).start()
self.resource_obj = _create_test_resource(self.context)
self.resource_prim = self.resource_obj.obj_to_primitive()
self.callbacks = resources_rpc.ResourcesPushRpcCallback()
def _init_rpc_listeners(self):
LOG.info('%s(): caller(): %s', log_utils.get_fname(1),
log_utils.get_fname(2))
endpoints = [resources_rpc.ResourcesPushRpcCallback()]
self._connection = n_rpc.Connection()
for rtype in self.rcache.resource_types:
registry_rpc.register(self.resource_change_handler, rtype)
topic = resources_rpc.resource_type_versioned_topic(rtype)
self._connection.create_consumer(topic, endpoints, fanout=True)
self._connection.consume_in_threads()
def _register_rpc_consumers(self):
LOG.info('%s(): caller(): %s', log_utils.get_fname(1), log_utils.get_fname(2))
registry.register(self._handle_notification, resources.QOS_POLICY)
self._connection = n_rpc.Connection()
endpoints = [resources_rpc.ResourcesPushRpcCallback()]
topic = resources_rpc.resource_type_versioned_topic(
resources.QOS_POLICY)
self._connection.create_consumer(topic, endpoints, fanout=True)
self._connection.consume_in_threads()
def _register_rpc_consumers(self, connection):
"""Allows an extension to receive notifications of updates made to
items of interest.
"""
endpoints = [resources_rpc.ResourcesPushRpcCallback()]
for resource_type in self.SUPPORTED_RESOURCE_TYPES:
# We assume that the neutron server always broadcasts the latest
# version known to the agent
registry.register(self._handle_notification, resource_type)
topic = resources_rpc.resource_type_versioned_topic(resource_type)
connection.create_consumer(topic, endpoints, fanout=True)
def __init__(self):
registry.register(self.handle_trunks, resources.TRUNK)
registry.register(self.handle_subports, resources.SUBPORT)
self._connection = n_rpc.Connection()
endpoints = [resources_rpc.ResourcesPushRpcCallback()]
topic = resources_rpc.resource_type_versioned_topic(resources.SUBPORT)
self._connection.create_consumer(topic, endpoints, fanout=True)
topic = resources_rpc.resource_type_versioned_topic(resources.TRUNK)
self._connection.create_consumer(topic, endpoints, fanout=True)
self._connection.consume_in_threads()
def _register_rpc_consumers(self, connection):
endpoints = [resources_rpc.ResourcesPushRpcCallback()]
# Consume BaGPipeChainHop OVO RPC
cons_registry.register(self.handle_sfc_chain_hops,
sfc_obj.BaGPipeChainHop.obj_name())
topic_chain_hop = resources_rpc.resource_type_versioned_topic(
sfc_obj.BaGPipeChainHop.obj_name())
connection.create_consumer(topic_chain_hop, endpoints, fanout=True)
# Consume BaGPipePortHops OVO RPC
cons_registry.register(self.handle_sfc_port_hops,
sfc_obj.BaGPipePortHops.obj_name())
topic_port_hops = resources_rpc.resource_type_versioned_topic(
sfc_obj.BaGPipePortHops.obj_name())
connection.create_consumer(topic_port_hops, endpoints, fanout=True)
def _setup_rpc(self, connection):
self.rpc_pull_api = resources_rpc.ResourcesPullRpcApi()
rpc_registry.register(self.handle_notification_net_assocs,
objects.BGPVPNNetAssociation.obj_name())
rpc_registry.register(self.handle_notification_router_assocs,
objects.BGPVPNRouterAssociation.obj_name())
rpc_registry.register(self.handle_notification_port_assocs,
objects.BGPVPNPortAssociation.obj_name())
endpoints = [resources_rpc.ResourcesPushRpcCallback()]
topic_net_assoc = resources_rpc.resource_type_versioned_topic(
objects.BGPVPNNetAssociation.obj_name())
topic_router_assoc = resources_rpc.resource_type_versioned_topic(
objects.BGPVPNRouterAssociation.obj_name())
topic_port_assoc = resources_rpc.resource_type_versioned_topic(
objects.BGPVPNPortAssociation.obj_name())
connection.create_consumer(topic_net_assoc, endpoints, fanout=True)
connection.create_consumer(topic_router_assoc, endpoints, fanout=True)
connection.create_consumer(topic_port_assoc, endpoints, fanout=True)
def _register_rpc_consumers(self, connection):
endpoints = [resources_rpc.ResourcesPushRpcCallback()]
for resource_type in self.SUPPORTED_RESOURCE_TYPES:
registry.register(self._handle_notification, resource_type)
topic = resources_rpc.resource_type_versioned_topic(resource_type)
connection.create_consumer(topic, endpoints, fanout=True)
def setUp(self):
super(ResourcesPushRpcCallbackTestCase, self).setUp()
self.callbacks = resources_rpc.ResourcesPushRpcCallback()
