openstack/neutron
Code Issues Proposed changes

Merge "Drop RpcProxy usage from l2population code"

Browse Source
This commit is contained in:
Jenkins 2014-11-28 02:00:22 +00:00 committed by Gerrit Code Review
commit 213aa4f0d0
2 changed files with 146 additions and 207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
neutron/plugins/ml2/drivers/l2pop/rpc.py
View File

@ -16,6 +16,8 @@
import collections
import copy
from oslo import messaging
from neutron.common import rpc as n_rpc
from neutron.common import topics
from neutron.openstack.common import log as logging
@ -27,16 +29,15 @@ LOG = logging.getLogger(__name__)
PortInfo = collections.namedtuple("PortInfo", "mac_address ip_address")
class L2populationAgentNotifyAPI(n_rpc.RpcProxy):
BASE_RPC_API_VERSION = '1.0'
class L2populationAgentNotifyAPI(object):
def __init__(self, topic=topics.AGENT):
super(L2populationAgentNotifyAPI, self).__init__(
topic=topic, default_version=self.BASE_RPC_API_VERSION)
self.topic = topic
self.topic_l2pop_update = topics.get_topic_name(topic,
topics.L2POPULATION,
topics.UPDATE)
target = messaging.Target(topic=topic, version='1.0')
self.client = n_rpc.get_client(target)
def _notification_fanout(self, context, method, fdb_entries):
LOG.debug('Fanout notify l2population agents at %(topic)s '
@ -46,10 +47,8 @@ class L2populationAgentNotifyAPI(n_rpc.RpcProxy):
'fdb_entries': fdb_entries})
marshalled_fdb_entries = self._marshall_fdb_entries(fdb_entries)
self.fanout_cast(context,
self.make_msg(method,
fdb_entries=marshalled_fdb_entries),
topic=self.topic_l2pop_update)
cctxt = self.client.prepare(topic=self.topic_l2pop_update, fanout=True)
cctxt.cast(context, method, fdb_entries=marshalled_fdb_entries)
def _notification_host(self, context, method, fdb_entries, host):
LOG.debug('Notify l2population agent %(host)s at %(topic)s the '
@ -58,11 +57,10 @@ class L2populationAgentNotifyAPI(n_rpc.RpcProxy):
'topic': self.topic,
'method': method,
'fdb_entries': fdb_entries})
marshalled_fdb_entries = self._marshall_fdb_entries(fdb_entries)
self.cast(context,
self.make_msg(method,
fdb_entries=marshalled_fdb_entries),
topic='%s.%s' % (self.topic_l2pop_update, host))
cctxt = self.client.prepare(topic=self.topic_l2pop_update, server=host)
cctxt.cast(context, method, fdb_entries=marshalled_fdb_entries)
def add_fdb_entries(self, context, fdb_entries, host=None):
if fdb_entries:

253
neutron/tests/unit/ml2/drivers/test_l2population.py
View File

@ -93,8 +93,6 @@ L2_AGENT_5 = {
NOTIFIER = 'neutron.plugins.ml2.rpc.AgentNotifierApi'
DEVICE_OWNER_COMPUTE = 'compute:None'
FLOODING_ENTRY_AS_LIST = list(constants.FLOODING_ENTRY)
class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
_mechanism_drivers = ['openvswitch', 'linuxbridge',
@ -131,11 +129,13 @@ class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
self.fanout_topic = topics.get_topic_name(topics.AGENT,
topics.L2POPULATION,
topics.UPDATE)
fanout = ('neutron.common.rpc.RpcProxy.fanout_cast')
fanout = ('neutron.plugins.ml2.drivers.l2pop.rpc.'
'L2populationAgentNotifyAPI._notification_fanout')
fanout_patch = mock.patch(fanout)
self.mock_fanout = fanout_patch.start()
cast = ('neutron.common.rpc.RpcProxy.cast')
cast = ('neutron.plugins.ml2.drivers.l2pop.rpc.'
'L2populationAgentNotifyAPI._notification_host')
cast_patch = mock.patch(cast)
self.mock_cast = cast_patch.start()
@ -226,20 +226,17 @@ class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
device=device)
p1_ips = [p['ip_address'] for p in p1['fixed_ips']]
expected = {'args':
{'fdb_entries':
{p1['network_id']:
expected = {p1['network_id']:
{'ports':
{'20.0.0.1': [FLOODING_ENTRY_AS_LIST,
[p1['mac_address'],
p1_ips[0]]]},
{'20.0.0.1': [constants.FLOODING_ENTRY,
l2pop_rpc.PortInfo(
p1['mac_address'],
p1_ips[0])]},
'network_type': 'vxlan',
'segment_id': 1}}},
'namespace': None,
'method': 'add_fdb_entries'}
'segment_id': 1}}
self.mock_fanout.assert_called_with(
mock.ANY, expected, topic=self.fanout_topic)
mock.ANY, 'add_fdb_entries', expected)
def test_fdb_add_not_called_type_local(self):
self._register_ml2_agents()
@ -286,20 +283,17 @@ class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
device=device)
p1_ips = [p['ip_address'] for p in p1['fixed_ips']]
expected = {'args':
{'fdb_entries':
{p1['network_id']:
expected = {p1['network_id']:
{'ports':
{'20.0.0.5': [FLOODING_ENTRY_AS_LIST,
[p1['mac_address'],
p1_ips[0]]]},
{'20.0.0.5': [constants.FLOODING_ENTRY,
l2pop_rpc.PortInfo(
p1['mac_address'],
p1_ips[0])]},
'network_type': 'vlan',
'segment_id': 2}}},
'namespace': None,
'method': 'add_fdb_entries'}
'segment_id': 2}}
self.mock_fanout.assert_called_with(
mock.ANY, expected, topic=self.fanout_topic)
mock.ANY, 'add_fdb_entries', expected)
def test_fdb_add_two_agents(self):
self._register_ml2_agents()
@ -332,41 +326,30 @@ class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
p1_ips = [p['ip_address'] for p in p1['fixed_ips']]
p2_ips = [p['ip_address'] for p in p2['fixed_ips']]
expected1 = {'args':
{'fdb_entries':
{p1['network_id']:
expected1 = {p1['network_id']:
{'ports':
{'20.0.0.2': [FLOODING_ENTRY_AS_LIST,
[p2['mac_address'],
p2_ips[0]]]},
{'20.0.0.2': [constants.FLOODING_ENTRY,
l2pop_rpc.PortInfo(
p2['mac_address'],
p2_ips[0])]},
'network_type': 'vxlan',
'segment_id': 1}}},
'namespace': None,
'method': 'add_fdb_entries'}
topic = topics.get_topic_name(topics.AGENT,
topics.L2POPULATION,
topics.UPDATE,
HOST)
'segment_id': 1}}
self.mock_cast.assert_called_with(mock.ANY,
expected1,
topic=topic)
'add_fdb_entries',
expected1, HOST)
expected2 = {'args':
{'fdb_entries':
{p1['network_id']:
expected2 = {p1['network_id']:
{'ports':
{'20.0.0.1': [FLOODING_ENTRY_AS_LIST,
[p1['mac_address'],
p1_ips[0]]]},
{'20.0.0.1': [constants.FLOODING_ENTRY,
l2pop_rpc.PortInfo(
p1['mac_address'],
p1_ips[0])]},
'network_type': 'vxlan',
'segment_id': 1}}},
'namespace': None,
'method': 'add_fdb_entries'}
'segment_id': 1}}
self.mock_fanout.assert_called_with(
mock.ANY, expected2, topic=self.fanout_topic)
mock.ANY, 'add_fdb_entries', expected2)
def test_fdb_add_called_two_networks(self):
self._register_ml2_agents()
@ -400,46 +383,34 @@ class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
p1_ips = [p['ip_address']
for p in p1['fixed_ips']]
expected1 = {'args':
{'fdb_entries':
{p1['network_id']:
expected1 = {p1['network_id']:
{'ports':
{'20.0.0.2':
[FLOODING_ENTRY_AS_LIST,
[p1['mac_address'],
p1_ips[0]]]},
[constants.FLOODING_ENTRY,
l2pop_rpc.PortInfo(
p1['mac_address'],
p1_ips[0])]},
'network_type': 'vxlan',
'segment_id': 1}}},
'namespace': None,
'method': 'add_fdb_entries'}
'segment_id': 1}}
topic = topics.get_topic_name(topics.AGENT,
topics.L2POPULATION,
topics.UPDATE,
self.mock_cast.assert_called_with(
mock.ANY, 'add_fdb_entries', expected1,
HOST)
self.mock_cast.assert_called_with(mock.ANY,
expected1,
topic=topic)
p3_ips = [p['ip_address']
for p in p3['fixed_ips']]
expected2 = {'args':
{'fdb_entries':
{p1['network_id']:
expected2 = {p1['network_id']:
{'ports':
{'20.0.0.1':
[FLOODING_ENTRY_AS_LIST,
[p3['mac_address'],
p3_ips[0]]]},
[constants.FLOODING_ENTRY,
l2pop_rpc.PortInfo(
p3['mac_address'],
p3_ips[0])]},
'network_type': 'vxlan',
'segment_id': 1}}},
'namespace': None,
'method': 'add_fdb_entries'}
'segment_id': 1}}
self.mock_fanout.assert_called_with(
mock.ANY, expected2,
topic=self.fanout_topic)
mock.ANY, 'add_fdb_entries', expected2)
def test_update_port_down(self):
self._register_ml2_agents()
@ -474,19 +445,16 @@ class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
device=device2)
p2_ips = [p['ip_address'] for p in p2['fixed_ips']]
expected = {'args':
{'fdb_entries':
{p2['network_id']:
expected = {p2['network_id']:
{'ports':
{'20.0.0.1': [[p2['mac_address'],
p2_ips[0]]]},
{'20.0.0.1': [l2pop_rpc.PortInfo(
p2['mac_address'],
p2_ips[0])]},
'network_type': 'vxlan',
'segment_id': 1}}},
'namespace': None,
'method': 'remove_fdb_entries'}
'segment_id': 1}}
self.mock_fanout.assert_called_with(
mock.ANY, expected, topic=self.fanout_topic)
mock.ANY, 'remove_fdb_entries', expected)
def test_update_port_down_last_port_up(self):
self._register_ml2_agents()
@ -514,20 +482,17 @@ class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
device=device2)
p2_ips = [p['ip_address'] for p in p2['fixed_ips']]
expected = {'args':
{'fdb_entries':
{p2['network_id']:
expected = {p2['network_id']:
{'ports':
{'20.0.0.1': [FLOODING_ENTRY_AS_LIST,
[p2['mac_address'],
p2_ips[0]]]},
{'20.0.0.1': [constants.FLOODING_ENTRY,
l2pop_rpc.PortInfo(
p2['mac_address'],
p2_ips[0])]},
'network_type': 'vxlan',
'segment_id': 1}}},
'namespace': None,
'method': 'remove_fdb_entries'}
'segment_id': 1}}
self.mock_fanout.assert_called_with(
mock.ANY, expected, topic=self.fanout_topic)
mock.ANY, 'remove_fdb_entries', expected)
def test_delete_port(self):
self._register_ml2_agents()
@ -559,19 +524,16 @@ class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
device=device1)
self._delete('ports', port2['port']['id'])
p2_ips = [p['ip_address'] for p in p2['fixed_ips']]
expected = {'args':
{'fdb_entries':
{p2['network_id']:
expected = {p2['network_id']:
{'ports':
{'20.0.0.1': [[p2['mac_address'],
p2_ips[0]]]},
{'20.0.0.1': [l2pop_rpc.PortInfo(
p2['mac_address'],
p2_ips[0])]},
'network_type': 'vxlan',
'segment_id': 1}}},
'namespace': None,
'method': 'remove_fdb_entries'}
'segment_id': 1}}
self.mock_fanout.assert_any_call(
mock.ANY, expected, topic=self.fanout_topic)
mock.ANY, 'remove_fdb_entries', expected)
def test_delete_port_last_port_up(self):
self._register_ml2_agents()
@ -595,20 +557,17 @@ class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
device=device)
self._delete('ports', port['port']['id'])
p1_ips = [p['ip_address'] for p in p1['fixed_ips']]
expected = {'args':
{'fdb_entries':
{p1['network_id']:
expected = {p1['network_id']:
{'ports':
{'20.0.0.1': [FLOODING_ENTRY_AS_LIST,
[p1['mac_address'],
p1_ips[0]]]},
{'20.0.0.1': [constants.FLOODING_ENTRY,
l2pop_rpc.PortInfo(
p1['mac_address'],
p1_ips[0])]},
'network_type': 'vxlan',
'segment_id': 1}}},
'namespace': None,
'method': 'remove_fdb_entries'}
'segment_id': 1}}
self.mock_fanout.assert_any_call(
mock.ANY, expected, topic=self.fanout_topic)
mock.ANY, 'remove_fdb_entries', expected)
def test_fixed_ips_changed(self):
self._register_ml2_agents()
@ -636,18 +595,14 @@ class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
ips = res['port']['fixed_ips']
self.assertEqual(len(ips), 2)
add_expected = {'args':
{'fdb_entries':
{'chg_ip':
add_expected = {'chg_ip':
{p1['network_id']:
{'20.0.0.1':
{'after': [(p1['mac_address'],
'10.0.0.10')]}}}}},
'namespace': None,
'method': 'update_fdb_entries'}
'10.0.0.10')]}}}}
self.mock_fanout.assert_any_call(
mock.ANY, add_expected, topic=self.fanout_topic)
mock.ANY, 'update_fdb_entries', add_expected)
self.mock_fanout.reset_mock()
@ -658,20 +613,16 @@ class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
ips = res['port']['fixed_ips']
self.assertEqual(len(ips), 2)
upd_expected = {'args':
{'fdb_entries':
{'chg_ip':
upd_expected = {'chg_ip':
{p1['network_id']:
{'20.0.0.1':
{'before': [(p1['mac_address'],
'10.0.0.10')],
'after': [(p1['mac_address'],
'10.0.0.16')]}}}}},
'namespace': None,
'method': 'update_fdb_entries'}
'10.0.0.16')]}}}}
self.mock_fanout.assert_any_call(
mock.ANY, upd_expected, topic=self.fanout_topic)
mock.ANY, 'update_fdb_entries', upd_expected)
self.mock_fanout.reset_mock()
@ -681,18 +632,14 @@ class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
ips = res['port']['fixed_ips']
self.assertEqual(len(ips), 1)
del_expected = {'args':
{'fdb_entries':
{'chg_ip':
del_expected = {'chg_ip':
{p1['network_id']:
{'20.0.0.1':
{'before': [(p1['mac_address'],
'10.0.0.2')]}}}}},
'namespace': None,
'method': 'update_fdb_entries'}
'10.0.0.2')]}}}}
self.mock_fanout.assert_any_call(
mock.ANY, del_expected, topic=self.fanout_topic)
mock.ANY, 'update_fdb_entries', del_expected)
def test_no_fdb_updates_without_port_updates(self):
self._register_ml2_agents()
@ -761,20 +708,17 @@ class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
device=device1,
agent_id=L2_AGENT_2['host'])
p1_ips = [p['ip_address'] for p in p1['fixed_ips']]
expected = {'args':
{'fdb_entries':
{p1['network_id']:
expected = {p1['network_id']:
{'ports':
{'20.0.0.1': [FLOODING_ENTRY_AS_LIST,
[p1['mac_address'],
p1_ips[0]]]},
{'20.0.0.1': [constants.FLOODING_ENTRY,
l2pop_rpc.PortInfo(
p1['mac_address'],
p1_ips[0])]},
'network_type': 'vxlan',
'segment_id': 1}}},
'namespace': None,
'method': 'remove_fdb_entries'}
'segment_id': 1}}
self.mock_fanout.assert_called_with(
mock.ANY, expected, topic=self.fanout_topic)
mock.ANY, 'remove_fdb_entries', expected)
def test_host_changed_twice(self):
self._register_ml2_agents()
@ -819,20 +763,17 @@ class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
device=device1,
agent_id=L2_AGENT_4['host'])
p1_ips = [p['ip_address'] for p in p1['fixed_ips']]
expected = {'args':
{'fdb_entries':
{p1['network_id']:
expected = {p1['network_id']:
{'ports':
{'20.0.0.1': [FLOODING_ENTRY_AS_LIST,
[p1['mac_address'],
p1_ips[0]]]},
{'20.0.0.1': [constants.FLOODING_ENTRY,
l2pop_rpc.PortInfo(
p1['mac_address'],
p1_ips[0])]},
'network_type': 'vxlan',
'segment_id': 1}}},
'namespace': None,
'method': 'remove_fdb_entries'}
'segment_id': 1}}
self.mock_fanout.assert_called_with(
mock.ANY, expected, topic=self.fanout_topic)
mock.ANY, 'remove_fdb_entries', expected)
def test_delete_port_invokes_update_device_down(self):
l2pop_mech = l2pop_mech_driver.L2populationMechanismDriver()