def test___init__(self, mocked_register):
mock_conn = mock.MagicMock()
with mock.patch.object(rpc.Connection, 'create_consumer',
new_callable=mock_conn):
test_obj = agent.TrunkSkeleton()
self.assertEqual(2, mocked_register.call_count)
calls = [mock.call(test_obj.handle_trunks, resources.TRUNK),
mock.call(test_obj.handle_subports, resources.SUBPORT)]
mocked_register.assert_has_calls(calls, any_order=True)
# Test to see if the call to rpc.get_server has the correct
# target and the correct endpoints
topic = resources_rpc.resource_type_versioned_topic(
resources.SUBPORT)
subport_target = oslo_messaging.Target(
topic=topic, server=cfg.CONF.host, fanout=True)
topic = resources_rpc.resource_type_versioned_topic(
resources.TRUNK)
trunk_target = oslo_messaging.Target(
topic=topic, server=cfg.CONF.host, fanout=True)
calls = [mock.call(subport_target.topic, mock.ANY, fanout=True),
mock.call(trunk_target.topic, mock.ANY, fanout=True)]
self.assertIn(calls[0], mock_conn().mock_calls)
self.assertIn(calls[1], mock_conn().mock_calls)
self.assertIn("ResourcesPushRpcCallback",
str(mock_conn().call_args_list))
def test___init__(self, mocked_register):
mock_conn = mock.MagicMock()
with mock.patch.object(rpc.Connection, 'create_consumer',
new_callable=mock_conn):
test_obj = agent.TrunkSkeleton()
self.assertEqual(2, mocked_register.call_count)
calls = [mock.call(test_obj.handle_trunks, resources.TRUNK),
mock.call(test_obj.handle_subports, resources.SUBPORT)]
mocked_register.assert_has_calls(calls, any_order=True)
# Test to see if the call to rpc.get_server has the correct
# target and the correct endpoints
topic = resources_rpc.resource_type_versioned_topic(
resources.SUBPORT)
subport_target = oslo_messaging.Target(
topic=topic, server=cfg.CONF.host, fanout=True)
topic = resources_rpc.resource_type_versioned_topic(
resources.TRUNK)
trunk_target = oslo_messaging.Target(
topic=topic, server=cfg.CONF.host, fanout=True)
calls = [mock.call(subport_target.topic, mock.ANY, fanout=True),
mock.call(trunk_target.topic, mock.ANY, fanout=True)]
self.assertIn(calls[0], mock_conn().mock_calls)
self.assertIn(calls[1], mock_conn().mock_calls)
self.assertIn("ResourcesPushRpcCallback",
str(mock_conn().call_args_list))
def test___init__(self, mocked_get_server, mocked_register):
test_obj = agent.TrunkSkeleton()
self.assertEqual(2, mocked_register.call_count)
calls = [
mock.call(test_obj.handle_trunks, resources.TRUNK),
mock.call(test_obj.handle_subports, resources.SUBPORT)
]
mocked_register.assert_has_calls(calls, any_order=True)
# Test to see if the call to rpc.get_server has the correct
# target and the correct endpoints
topic = resources_rpc.resource_type_versioned_topic(resources.SUBPORT)
subport_target = oslo_messaging.Target(topic=topic,
server=cfg.CONF.host,
fanout=True)
topic = resources_rpc.resource_type_versioned_topic(resources.TRUNK)
trunk_target = oslo_messaging.Target(topic=topic,
server=cfg.CONF.host,
fanout=True)
calls = [
mock.call(subport_target, mock.ANY),
mock.call(trunk_target, mock.ANY)
]
mocked_get_server.assert_has_calls(calls, any_order=True)
self.assertIn("ResourcesPushRpcCallback",
str(mocked_get_server.call_args_list))
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 __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()]
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 _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 _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 _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 test_resource_type_versioned_topic(self, validate_mock):
obj_name = FakeResource.obj_name()
expected = topics.RESOURCE_TOPIC_PATTERN % {
'resource_type': 'FakeResource', 'version': '1.0'}
with mock.patch.object(resources_rpc.resources, 'get_resource_cls',
return_value=FakeResource):
observed = resources_rpc.resource_type_versioned_topic(obj_name)
self.assertEqual(expected, observed)
def test_resource_type_versioned_topic(self, validate_mock):
obj_name = FakeResource.obj_name()
expected = topics.RESOURCE_TOPIC_PATTERN % {
'resource_type': 'FakeResource', 'version': '1.0'}
with mock.patch.object(resources_rpc.resources, 'get_resource_cls',
return_value=FakeResource):
observed = resources_rpc.resource_type_versioned_topic(obj_name)
self.assertEqual(expected, observed)
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 _init_rpc_listeners(self):
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 test_initialize_subscribed_to_rpc(self, rpc_mock, subscribe_mock):
self.qos_ext.initialize(self.connection, constants.EXTENSION_DRIVER_TYPE)
self.connection.create_consumer.assert_has_calls(
[
mock.call(resources_rpc.resource_type_versioned_topic(resource_type), [rpc_mock()], fanout=True)
for resource_type in self.qos_ext.SUPPORTED_RESOURCES
]
)
subscribe_mock.assert_called_with(mock.ANY, resources.QOS_POLICY)
def _register_rpc_consumers(self):
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 _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):
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 _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, 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 test___init__(self, mocked_get_server, mocked_register):
test_obj = agent.TrunkSkeleton()
self.assertEqual(2, mocked_register.call_count)
calls = [mock.call(test_obj.handle_trunks, resources.TRUNK),
mock.call(test_obj.handle_subports, resources.SUBPORT)]
mocked_register.assert_has_calls(calls, any_order=True)
# Test to see if the call to rpc.get_server has the correct
# target and the correct endpoints
topic = resources_rpc.resource_type_versioned_topic(resources.SUBPORT)
subport_target = oslo_messaging.Target(
topic=topic, server=cfg.CONF.host, fanout=True)
topic = resources_rpc.resource_type_versioned_topic(resources.TRUNK)
trunk_target = oslo_messaging.Target(
topic=topic, server=cfg.CONF.host, fanout=True)
calls = [mock.call(subport_target, mock.ANY),
mock.call(trunk_target, mock.ANY)]
mocked_get_server.assert_has_calls(calls, any_order=True)
self.assertIn("ResourcesPushRpcCallback",
str(mocked_get_server.call_args_list))
def test_initialize_subscribed_to_rpc(self, rpc_mock, subscribe_mock):
self.agent_ext.initialize(self.connection,
constants.EXTENSION_DRIVER_TYPE)
self.connection.create_consumer.assert_has_calls([
mock.call(
resources_rpc.resource_type_versioned_topic(resource_type),
[rpc_mock()],
fanout=True)
for resource_type in self.agent_ext.SUPPORTED_RESOURCE_TYPES
])
subscribe_mock.assert_called_with(mock.ANY, resources.LOGGING_RESOURCE)
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 test_initialize_subscribed_to_rpc(self, rpc_mock, subscribe_mock):
call_to_patch = 'neutron_lib.rpc.Connection'
with mock.patch(call_to_patch,
return_value=self.connection) as create_connection:
self.np_ext.initialize(self.connection, lib_const.L3_AGENT_MODE)
create_connection.assert_has_calls([mock.call()])
self.connection.create_consumer.assert_has_calls([
mock.call(resources_rpc.resource_type_versioned_topic(
resources.NDPPROXY), [rpc_mock()],
fanout=True)
])
subscribe_mock.assert_called_with(mock.ANY, resources.NDPPROXY)
def _register_port_notification(self, connection):
"""Allows an extension to receive notifications of updates made to
items of interest.
"""
#endpoints = [resources_rpc.ResourcesPushRpcCallback()]
endpoints = [taas_plugin_callbacks.TaasCallbacks()]
# We assume that the neutron server always broadcasts the latest
# version known to the agent
registry.register(self._handle_port_notification, resources.PORT)
topic = resources_rpc.resource_type_versioned_topic(resources.PORT)
connection.create_consumer(topic, endpoints, fanout=True)
def test_initialize_subscribed_to_rpc(self, rpc_mock, subscribe_mock):
with mock.patch.object(
n_rpc, 'Connection',
return_value=self.connection) as create_connection:
self.fip_qos_ext.initialize(self.connection,
lib_const.L3_AGENT_MODE)
create_connection.assert_has_calls([mock.call()])
self.connection.create_consumer.assert_has_calls([
mock.call(resources_rpc.resource_type_versioned_topic(
resources.QOS_POLICY), [rpc_mock()],
fanout=True)
])
subscribe_mock.assert_called_with(mock.ANY, resources.QOS_POLICY)
def test_initialize_subscribed_to_rpc(self, rpc_mock, subscribe_mock):
with mock.patch.object(n_rpc, 'Connection',
return_value=self.connection) as create_connection:
self.fip_qos_ext.initialize(
self.connection, lib_const.L3_AGENT_MODE)
create_connection.assert_has_calls([mock.call()])
self.connection.create_consumer.assert_has_calls(
[mock.call(
resources_rpc.resource_type_versioned_topic(
resources.QOS_POLICY),
[rpc_mock()],
fanout=True)]
)
subscribe_mock.assert_called_with(mock.ANY, resources.QOS_POLICY)
def test_initialize_subscribed_to_rpc(self, rpc_mock, subscribe_mock):
call_to_patch = 'neutron.common.rpc.Connection'
with mock.patch(call_to_patch,
return_value=self.connection) as create_connection:
self.fip_pf_ext.initialize(
self.connection, lib_const.L3_AGENT_MODE)
create_connection.assert_has_calls([mock.call()])
self.connection.create_consumer.assert_has_calls(
[mock.call(
resources_rpc.resource_type_versioned_topic(
resources.PORTFORWARDING),
[rpc_mock()],
fanout=True)]
)
subscribe_mock.assert_called_with(
mock.ANY, resources.PORTFORWARDING)
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 _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)
