openstack
/
neutron
Code Issues Proposed changes

Merge "Rename dvr portbinding functions"

This commit is contained in:
Jenkins 2016-07-11 07:12:51 +00:00 committed by Gerrit Code Review
parent f7292d4914 89cd4d07d1
commit 253bef21e0
11 changed files with 111 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
neutron/api/rpc/handlers/l3_rpc.py
View File

@ -193,8 +193,8 @@ class L3RpcCallback(object):
# Ports that are DVR interfaces have multiple bindings (based on
# of hosts on which DVR router interfaces are spawned). Such
# bindings are created/updated here by invoking
# update_dvr_port_binding
self.plugin.update_dvr_port_binding(context, port['id'],
# update_distributed_port_binding
self.plugin.update_distributed_port_binding(context, port['id'],
{'port':
{portbindings.HOST_ID: host,
'device_id': router_id}

5
neutron/db/l3_dvrscheduler_db.py
View File

@ -184,9 +184,8 @@ class L3_DVRsch_db_mixin(l3agent_sch_db.L3AgentSchedulerDbMixin):
admin_context, filters=filter_rtr)
for port in int_ports:
dvr_binding = (ml2_db.
get_dvr_port_binding_by_host(context.session,
port['id'],
port_host))
get_distributed_port_binding_by_host(
context.session, port['id'], port_host))
if dvr_binding:
# unbind this port from router
dvr_binding['router_id'] = None

20
neutron/plugins/ml2/db.py
View File

@ -131,7 +131,7 @@ def clear_binding_levels(session, port_id, host):
'host': host})
def ensure_dvr_port_binding(session, port_id, host, router_id=None):
def ensure_distributed_port_binding(session, port_id, host, router_id=None):
record = (session.query(models.DistributedPortBinding).
filter_by(port_id=port_id, host=host).first())
if record:
@ -149,15 +149,15 @@ def ensure_dvr_port_binding(session, port_id, host, router_id=None):
session.add(record)
return record
except db_exc.DBDuplicateEntry:
LOG.debug("DVR Port %s already bound", port_id)
LOG.debug("Distributed Port %s already bound", port_id)
return (session.query(models.DistributedPortBinding).
filter_by(port_id=port_id, host=host).one())
def delete_dvr_port_binding_if_stale(session, binding):
def delete_distributed_port_binding_if_stale(session, binding):
if not binding.router_id and binding.status == n_const.PORT_STATUS_DOWN:
with session.begin(subtransactions=True):
LOG.debug("DVR: Deleting binding %s", binding)
LOG.debug("Distributed port: Deleting binding %s", binding)
session.delete(binding)
@ -264,9 +264,9 @@ def get_port_binding_host(session, port_id):
return query.host
def generate_dvr_port_status(session, port_id):
def generate_distributed_port_status(session, port_id):
# an OR'ed value of status assigned to parent port from the
# dvrportbinding bucket
# distributedportbinding bucket
query = session.query(models.DistributedPortBinding)
final_status = n_const.PORT_STATUS_BUILD
for bind in query.filter(models.DistributedPortBinding.port_id == port_id):
@ -277,24 +277,24 @@ def generate_dvr_port_status(session, port_id):
return final_status
def get_dvr_port_binding_by_host(session, port_id, host):
def get_distributed_port_binding_by_host(session, port_id, host):
with session.begin(subtransactions=True):
binding = (session.query(models.DistributedPortBinding).
filter(models.DistributedPortBinding.port_id.startswith(port_id),
models.DistributedPortBinding.host == host).first())
if not binding:
LOG.debug("No binding for DVR port %(port_id)s with host "
LOG.debug("No binding for distributed port %(port_id)s with host "
"%(host)s", {'port_id': port_id, 'host': host})
return binding
def get_dvr_port_bindings(session, port_id):
def get_distributed_port_bindings(session, port_id):
with session.begin(subtransactions=True):
bindings = (session.query(models.DistributedPortBinding).
filter(models.DistributedPortBinding.port_id.startswith(
port_id)).all())
if not bindings:
LOG.debug("No bindings for DVR port %s", port_id)
LOG.debug("No bindings for distributed port %s", port_id)
return bindings

4
neutron/plugins/ml2/drivers/l2pop/db.py
View File

@ -70,7 +70,7 @@ def _get_active_network_ports(session, network_id):
return query
def get_nondvr_active_network_ports(session, network_id):
def get_nondistributed_active_network_ports(session, network_id):
query = _get_active_network_ports(session, network_id)
query = query.filter(models_v2.Port.device_owner !=
const.DEVICE_OWNER_DVR_INTERFACE)
@ -78,7 +78,7 @@ def get_nondvr_active_network_ports(session, network_id):
if get_agent_ip(agent)]
def get_dvr_active_network_ports(session, network_id):
def get_distributed_active_network_ports(session, network_id):
with session.begin(subtransactions=True):
query = session.query(ml2_models.DistributedPortBinding,
agents_db.Agent)

5
neutron/plugins/ml2/drivers/l2pop/mech_driver.py
View File

@ -169,9 +169,10 @@ class L2populationMechanismDriver(api.MechanismDriver):
'network_type': segment['network_type'],
'ports': {}}}
tunnel_network_ports = (
l2pop_db.get_dvr_active_network_ports(session, network_id))
l2pop_db.get_distributed_active_network_ports(session, network_id))
fdb_network_ports = (
l2pop_db.get_nondvr_active_network_ports(session, network_id))
l2pop_db.get_nondistributed_active_network_ports(session,
network_id))
ports = agent_fdb_entries[network_id]['ports']
ports.update(self._get_tunnels(
fdb_network_ports + tunnel_network_ports,

44
neutron/plugins/ml2/plugin.py
View File

@ -466,7 +466,7 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
# in the distributed case. Since the PortBinding
# instance will then be needed, it does not make sense
# to optimize this code to avoid fetching it.
cur_binding = db.get_dvr_port_binding_by_host(
cur_binding = db.get_distributed_port_binding_by_host(
session, port_id, orig_binding.host)
cur_context = driver_context.PortContext(
self, plugin_context, port, network, cur_binding, None,
@ -1318,16 +1318,17 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
# DVR and non-DVR cases here.
# TODO(Swami): This code need to be revisited.
if port_db['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE:
dvr_binding_list = db.get_dvr_port_bindings(session, id)
for dvr_binding in dvr_binding_list:
dist_binding_list = db.get_distributed_port_bindings(session,
id)
for dist_binding in dist_binding_list:
levels = db.get_binding_levels(session, id,
dvr_binding.host)
dvr_mech_context = driver_context.PortContext(
dist_binding.host)
dist_mech_context = driver_context.PortContext(
self, context, updated_port, network,
dvr_binding, levels, original_port=original_port)
dist_binding, levels, original_port=original_port)
self.mechanism_manager.update_port_precommit(
dvr_mech_context)
bound_mech_contexts.append(dvr_mech_context)
dist_mech_context)
bound_mech_contexts.append(dist_mech_context)
else:
self.mechanism_manager.update_port_precommit(mech_context)
self._setup_dhcp_agent_provisioning_component(
@ -1376,7 +1377,7 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
need_notify=need_port_update_notify)
return bound_context.current
def _process_dvr_port_binding(self, mech_context, context, attrs):
def _process_distributed_port_binding(self, mech_context, context, attrs):
session = mech_context._plugin_context.session
binding = mech_context._binding
port = mech_context.current
@ -1393,7 +1394,7 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
binding.host = attrs and attrs.get(portbindings.HOST_ID)
binding.router_id = attrs and attrs.get('device_id')
def update_dvr_port_binding(self, context, id, port):
def update_distributed_port_binding(self, context, id, port):
attrs = port[attributes.PORT]
host = attrs and attrs.get(portbindings.HOST_ID)
@ -1404,7 +1405,7 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
return
session = context.session
binding = db.get_dvr_port_binding_by_host(session, id, host)
binding = db.get_distributed_port_binding_by_host(session, id, host)
device_id = attrs and attrs.get('device_id')
router_id = binding and binding.get('router_id')
update_required = (not binding or
@ -1415,7 +1416,7 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
with session.begin(subtransactions=True):
orig_port = self.get_port(context, id)
if not binding:
binding = db.ensure_dvr_port_binding(
binding = db.ensure_distributed_port_binding(
session, id, host, router_id=device_id)
network = self.get_network(context,
orig_port['network_id'])
@ -1423,8 +1424,8 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
mech_context = driver_context.PortContext(self,
context, orig_port, network,
binding, levels, original_port=orig_port)
self._process_dvr_port_binding(mech_context, context,
attrs)
self._process_distributed_port_binding(
mech_context, context, attrs)
except (os_db_exception.DBReferenceError, exc.PortNotFound):
LOG.debug("DVR Port %s has been deleted concurrently", id)
return
@ -1468,7 +1469,8 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
bound_mech_contexts = []
device_owner = port['device_owner']
if device_owner == const.DEVICE_OWNER_DVR_INTERFACE:
bindings = db.get_dvr_port_bindings(context.session, id)
bindings = db.get_distributed_port_bindings(context.session,
id)
for bind in bindings:
levels = db.get_binding_levels(context.session, id,
bind.host)
@ -1541,7 +1543,7 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
network = self.get_network(plugin_context, port['network_id'])
if port['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE:
binding = db.get_dvr_port_binding_by_host(
binding = db.get_distributed_port_binding_by_host(
session, port['id'], host)
if not binding:
LOG.error(_LE("Binding info for DVR port %s not found"),
@ -1604,7 +1606,7 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
self.mechanism_manager.update_port_precommit(mech_context)
updated = True
elif port['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE:
binding = db.get_dvr_port_binding_by_host(
binding = db.get_distributed_port_binding_by_host(
session, port['id'], host)
if not binding:
return
@ -1623,7 +1625,8 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
original_port = self._make_port_dict(port)
network = network or self.get_network(
context, original_port['network_id'])
port.status = db.generate_dvr_port_status(session, port['id'])
port.status = db.generate_distributed_port_status(session,
port['id'])
updated_port = self._make_port_dict(port)
levels = db.get_binding_levels(session, port_id, host)
mech_context = (driver_context.PortContext(
@ -1645,7 +1648,7 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
**kwargs)
if port['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE:
db.delete_dvr_port_binding_if_stale(session, binding)
db.delete_distributed_port_binding_if_stale(session, binding)
return port['id']
@ -1657,7 +1660,8 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
LOG.debug("No Port match for: %s", port_id)
return
if port['device_owner'] == const.DEVICE_OWNER_DVR_INTERFACE:
bindings = db.get_dvr_port_bindings(context.session, port_id)
bindings = db.get_distributed_port_bindings(context.session,
port_id)
for b in bindings:
if b.host == host:
return port

16
neutron/tests/unit/plugins/ml2/drivers/l2pop/test_db.py
View File

@ -71,44 +71,44 @@ class TestL2PopulationDBTestCase(testlib_api.SqlTestCase):
self.ctx.session.add(port_binding_cls(**binding_kwarg))
def test_get_dvr_active_network_ports(self):
def test_get_distributed_active_network_ports(self):
self._setup_port_binding()
# Register a L2 agent + A bunch of other agents on the same host
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
tunnel_network_ports = l2pop_db.get_dvr_active_network_ports(
tunnel_network_ports = l2pop_db.get_distributed_active_network_ports(
self.ctx.session, 'network_id')
self.assertEqual(1, len(tunnel_network_ports))
_, agent = tunnel_network_ports[0]
self.assertEqual(constants.AGENT_TYPE_OVS, agent.agent_type)
def test_get_dvr_active_network_ports_no_candidate(self):
def test_get_distributed_active_network_ports_no_candidate(self):
self._setup_port_binding()
# Register a bunch of non-L2 agents on the same host
helpers.register_l3_agent()
helpers.register_dhcp_agent()
tunnel_network_ports = l2pop_db.get_dvr_active_network_ports(
tunnel_network_ports = l2pop_db.get_distributed_active_network_ports(
self.ctx.session, 'network_id')
self.assertEqual(0, len(tunnel_network_ports))
def test_get_nondvr_active_network_ports(self):
def test_get_nondistributed_active_network_ports(self):
self._setup_port_binding(dvr=False)
# Register a L2 agent + A bunch of other agents on the same host
helpers.register_l3_agent()
helpers.register_dhcp_agent()
helpers.register_ovs_agent()
fdb_network_ports = l2pop_db.get_nondvr_active_network_ports(
fdb_network_ports = l2pop_db.get_nondistributed_active_network_ports(
self.ctx.session, 'network_id')
self.assertEqual(1, len(fdb_network_ports))
_, agent = fdb_network_ports[0]
self.assertEqual(constants.AGENT_TYPE_OVS, agent.agent_type)
def test_get_nondvr_active_network_ports_no_candidate(self):
def test_get_nondistributed_active_network_ports_no_candidate(self):
self._setup_port_binding(dvr=False)
# Register a bunch of non-L2 agents on the same host
helpers.register_l3_agent()
helpers.register_dhcp_agent()
fdb_network_ports = l2pop_db.get_nondvr_active_network_ports(
fdb_network_ports = l2pop_db.get_nondistributed_active_network_ports(
self.ctx.session, 'network_id')
self.assertEqual(0, len(fdb_network_ports))

6
neutron/tests/unit/plugins/ml2/drivers/l2pop/test_mech_driver.py
View File

@ -920,9 +920,11 @@ class TestL2PopulationMechDriver(base.BaseTestCase):
with mock.patch.object(l2pop_db, 'get_agent_ip',
side_effect=agent_ip_side_effect),\
mock.patch.object(l2pop_db, 'get_nondvr_active_network_ports',
mock.patch.object(l2pop_db,
'get_nondistributed_active_network_ports',
return_value=fdb_network_ports),\
mock.patch.object(l2pop_db, 'get_dvr_active_network_ports',
mock.patch.object(l2pop_db,
'get_distributed_active_network_ports',
return_value=tunnel_network_ports):
session = mock.Mock()
agent = mock.Mock()

50
neutron/tests/unit/plugins/ml2/test_db.py
View File

@ -292,7 +292,8 @@ class Ml2DvrDBTestCase(testlib_api.SqlTestCase):
self.ctx.session.add(router)
return router
def _setup_dvr_binding(self, network_id, port_id, router_id, host_id):
def _setup_distributed_binding(self, network_id,
port_id, router_id, host_id):
with self.ctx.session.begin(subtransactions=True):
record = models.DistributedPortBinding(
port_id=port_id,
@ -304,81 +305,85 @@ class Ml2DvrDBTestCase(testlib_api.SqlTestCase):
self.ctx.session.add(record)
return record
def test_ensure_dvr_port_binding_deals_with_db_duplicate(self):
def test_ensure_distributed_port_binding_deals_with_db_duplicate(self):
network_id = 'foo_network_id'
port_id = 'foo_port_id'
router_id = 'foo_router_id'
host_id = 'foo_host_id'
self._setup_neutron_network(network_id, [port_id])
self._setup_dvr_binding(network_id, port_id, router_id, host_id)
self._setup_distributed_binding(network_id, port_id,
router_id, host_id)
with mock.patch.object(query.Query, 'first') as query_first:
query_first.return_value = []
with mock.patch.object(ml2_db.LOG, 'debug') as log_trace:
binding = ml2_db.ensure_dvr_port_binding(
binding = ml2_db.ensure_distributed_port_binding(
self.ctx.session, port_id, host_id, router_id)
self.assertTrue(query_first.called)
self.assertTrue(log_trace.called)
self.assertEqual(port_id, binding.port_id)
def test_ensure_dvr_port_binding(self):
def test_ensure_distributed_port_binding(self):
network_id = 'foo_network_id'
port_id = 'foo_port_id'
self._setup_neutron_network(network_id, [port_id])
router = self._setup_neutron_router()
ml2_db.ensure_dvr_port_binding(
ml2_db.ensure_distributed_port_binding(
self.ctx.session, port_id, 'foo_host', router.id)
expected = (self.ctx.session.query(models.DistributedPortBinding).
filter_by(port_id=port_id).one())
self.assertEqual(port_id, expected.port_id)
def test_ensure_dvr_port_binding_multiple_bindings(self):
def test_ensure_distributed_port_binding_multiple_bindings(self):
network_id = 'foo_network_id'
port_id = 'foo_port_id'
self._setup_neutron_network(network_id, [port_id])
router = self._setup_neutron_router()
ml2_db.ensure_dvr_port_binding(
ml2_db.ensure_distributed_port_binding(
self.ctx.session, port_id, 'foo_host_1', router.id)
ml2_db.ensure_dvr_port_binding(
ml2_db.ensure_distributed_port_binding(
self.ctx.session, port_id, 'foo_host_2', router.id)
bindings = (self.ctx.session.query(models.DistributedPortBinding).
filter_by(port_id=port_id).all())
self.assertEqual(2, len(bindings))
def test_delete_dvr_port_binding_if_stale(self):
def test_delete_distributed_port_binding_if_stale(self):
network_id = 'foo_network_id'
port_id = 'foo_port_id'
self._setup_neutron_network(network_id, [port_id])
binding = self._setup_dvr_binding(
binding = self._setup_distributed_binding(
network_id, port_id, None, 'foo_host_id')
ml2_db.delete_dvr_port_binding_if_stale(self.ctx.session, binding)
ml2_db.delete_distributed_port_binding_if_stale(self.ctx.session,
binding)
count = (self.ctx.session.query(models.DistributedPortBinding).
filter_by(port_id=binding.port_id).count())
self.assertFalse(count)
def test_get_dvr_port_binding_by_host_not_found(self):
port = ml2_db.get_dvr_port_binding_by_host(
def test_get_distributed_port_binding_by_host_not_found(self):
port = ml2_db.get_distributed_port_binding_by_host(
self.ctx.session, 'foo_port_id', 'foo_host_id')
self.assertIsNone(port)
def test_get_dvr_port_bindings_not_found(self):
port = ml2_db.get_dvr_port_bindings(self.ctx.session, 'foo_port_id')
def test_get_distributed_port_bindings_not_found(self):
port = ml2_db.get_distributed_port_bindings(self.ctx.session,
'foo_port_id')
self.assertFalse(len(port))
def test_get_dvr_port_bindings(self):
def test_get_distributed_port_bindings(self):
network_id = 'foo_network_id'
port_id_1 = 'foo_port_id_1'
port_id_2 = 'foo_port_id_2'
self._setup_neutron_network(network_id, [port_id_1, port_id_2])
router = self._setup_neutron_router()
self._setup_dvr_binding(
self._setup_distributed_binding(
network_id, port_id_1, router.id, 'foo_host_id_1')
self._setup_dvr_binding(
self._setup_distributed_binding(
network_id, port_id_1, router.id, 'foo_host_id_2')
ports = ml2_db.get_dvr_port_bindings(self.ctx.session, 'foo_port_id')
ports = ml2_db.get_distributed_port_bindings(self.ctx.session,
'foo_port_id')
self.assertEqual(2, len(ports))
def test_dvr_port_binding_deleted_by_port_deletion(self):
def test_distributed_port_binding_deleted_by_port_deletion(self):
with self.ctx.session.begin(subtransactions=True):
self.ctx.session.add(models_v2.Network(id='network_id'))
device_owner = constants.DEVICE_OWNER_DVR_INTERFACE
@ -408,5 +413,6 @@ class Ml2DvrDBTestCase(testlib_api.SqlTestCase):
with self.ctx.session.begin(subtransactions=True):
self.ctx.session.delete(port)
self.assertEqual([], warning_list)
ports = ml2_db.get_dvr_port_bindings(self.ctx.session, 'port_id')
ports = ml2_db.get_distributed_port_bindings(self.ctx.session,
'port_id')
self.assertEqual(0, len(ports))

30
neutron/tests/unit/plugins/ml2/test_plugin.py
View File

@ -1303,7 +1303,7 @@ class TestMl2PortBinding(Ml2PluginV2TestCase,
self.assertTrue(update_mock.mock_calls)
self.assertEqual('test', binding.host)
def test_process_dvr_port_binding_update_router_id(self):
def test_process_distributed_port_binding_update_router_id(self):
host_id = 'host'
binding = models.DistributedPortBinding(
port_id='port_id',
@ -1323,12 +1323,13 @@ class TestMl2PortBinding(Ml2PluginV2TestCase,
return_value=[]):
mech_context = driver_context.PortContext(
self, context, mock_port, mock_network, binding, None)
plugin._process_dvr_port_binding(mech_context, context, attrs)
plugin._process_distributed_port_binding(mech_context,
context, attrs)
self.assertEqual(new_router_id,
mech_context._binding.router_id)
self.assertEqual(host_id, mech_context._binding.host)
def test_update_dvr_port_binding_on_concurrent_port_delete(self):
def test_update_distributed_port_binding_on_concurrent_port_delete(self):
plugin = manager.NeutronManager.get_plugin()
with self.port() as port:
port = {
@ -1336,20 +1337,21 @@ class TestMl2PortBinding(Ml2PluginV2TestCase,
portbindings.HOST_ID: 'foo_host',
}
with mock.patch.object(plugin, 'get_port', new=plugin.delete_port):
res = plugin.update_dvr_port_binding(
res = plugin.update_distributed_port_binding(
self.context, 'foo_port_id', {'port': port})
self.assertIsNone(res)
def test_update_dvr_port_binding_on_non_existent_port(self):
def test_update_distributed_port_binding_on_non_existent_port(self):
plugin = manager.NeutronManager.get_plugin()
port = {
'id': 'foo_port_id',
portbindings.HOST_ID: 'foo_host',
}
with mock.patch.object(ml2_db, 'ensure_dvr_port_binding') as mock_dvr:
plugin.update_dvr_port_binding(
with mock.patch.object(
ml2_db, 'ensure_distributed_port_binding') as mock_dist:
plugin.update_distributed_port_binding(
self.context, 'foo_port_id', {'port': port})
self.assertFalse(mock_dvr.called)
self.assertFalse(mock_dist.called)
class TestMl2PortBindingNoSG(TestMl2PortBinding):
@ -1973,8 +1975,8 @@ class TestFaultyMechansimDriver(Ml2PluginV2FaultyDriverTestCase):
self._delete('ports', port['port']['id'])
def test_update_dvr_router_interface_port(self):
"""Test validate dvr router interface update succeeds."""
def test_update_distributed_router_interface_port(self):
"""Test validate distributed router interface update succeeds."""
host_id = 'host'
binding = models.DistributedPortBinding(
port_id='port_id',
@ -1990,9 +1992,9 @@ class TestFaultyMechansimDriver(Ml2PluginV2FaultyDriverTestCase):
mock.patch.object(
mech_test.TestMechanismDriver,
'update_port_precommit') as port_pre,\
mock.patch.object(ml2_db,
'get_dvr_port_bindings') as dvr_bindings:
dvr_bindings.return_value = [binding]
mock.patch.object(
ml2_db, 'get_distributed_port_bindings') as dist_bindings:
dist_bindings.return_value = [binding]
port_pre.return_value = True
with self.network() as network:
with self.subnet(network=network) as subnet:
@ -2017,7 +2019,7 @@ class TestFaultyMechansimDriver(Ml2PluginV2FaultyDriverTestCase):
req = self.new_update_request('ports', data, port_id)
res = req.get_response(self.api)
self.assertEqual(200, res.status_int)
self.assertTrue(dvr_bindings.called)
self.assertTrue(dist_bindings.called)
self.assertTrue(port_pre.called)
self.assertTrue(port_post.called)
port = self._show('ports', port_id)

24
neutron/tests/unit/plugins/ml2/test_port_binding.py
View File

@ -212,7 +212,7 @@ class PortBindingTestCase(test_plugin.NeutronDbPluginV2TestCase):
port_dict = plugin.get_port(ctx, port['port']['id'])
self.assertEqual(const.PORT_STATUS_DOWN, port_dict['status'])
def test_dvr_binding(self):
def test_distributed_binding(self):
ctx = context.get_admin_context()
with self.port(device_owner=const.DEVICE_OWNER_DVR_INTERFACE) as port:
port_id = port['port']['id']
@ -223,9 +223,9 @@ class PortBindingTestCase(test_plugin.NeutronDbPluginV2TestCase):
self.assertEqual('DOWN', port['port']['status'])
# Update port to bind for a host.
self.plugin.update_dvr_port_binding(ctx, port_id, {'port': {
portbindings.HOST_ID: 'host-ovs-no_filter',
'device_id': 'router1'}})
self.plugin.update_distributed_port_binding(ctx, port_id, {'port':
{portbindings.HOST_ID: 'host-ovs-no_filter',
'device_id': 'router1'}})
# Get port and verify VIF type and status unchanged.
port = self._show('ports', port_id)
@ -267,15 +267,15 @@ class PortBindingTestCase(test_plugin.NeutronDbPluginV2TestCase):
port['port'][portbindings.VIF_TYPE])
self.assertEqual('DOWN', port['port']['status'])
def test_dvr_binding_multi_host_status(self):
def test_distributed_binding_multi_host_status(self):
ctx = context.get_admin_context()
with self.port(device_owner=const.DEVICE_OWNER_DVR_INTERFACE) as port:
port_id = port['port']['id']
# Update port to bind for 1st host.
self.plugin.update_dvr_port_binding(ctx, port_id, {'port': {
portbindings.HOST_ID: 'host-ovs-no_filter',
'device_id': 'router1'}})
self.plugin.update_distributed_port_binding(ctx, port_id, {'port':
{portbindings.HOST_ID: 'host-ovs-no_filter',
'device_id': 'router1'}})
# Mark 1st device up.
self.plugin.endpoints[0].update_device_up(
@ -287,9 +287,9 @@ class PortBindingTestCase(test_plugin.NeutronDbPluginV2TestCase):
self.assertEqual('ACTIVE', port['port']['status'])
# Update port to bind for a 2nd host.
self.plugin.update_dvr_port_binding(ctx, port_id, {'port': {
portbindings.HOST_ID: 'host-bridge-filter',
'device_id': 'router1'}})
self.plugin.update_distributed_port_binding(ctx, port_id, {'port':
{portbindings.HOST_ID: 'host-bridge-filter',
'device_id': 'router1'}})
# Mark 2nd device up.
self.plugin.endpoints[0].update_device_up(
@ -318,7 +318,7 @@ class PortBindingTestCase(test_plugin.NeutronDbPluginV2TestCase):
port = self._show('ports', port_id)
self.assertEqual('DOWN', port['port']['status'])
def test_dvr_binding_update_unbound_host(self):
def test_distributed_binding_update_unbound_host(self):
ctx = context.get_admin_context()
with self.port(device_owner=const.DEVICE_OWNER_DVR_INTERFACE) as port:
port_id = port['port']['id']