openstack
/
neutron
Code Issues Proposed changes

Deprecate the functions map after segment moving out of ml2 

This is a clean up for patch [1], the functions map should be removed
to make code easy to read. Start a deprecation cycle for these functions
in case external projects will use them.

[1] https://review.openstack.org/#/c/242393

Change-Id: I77c83bd7ee0c8ef92d8aaaa8e968479b848532fe
Partially-Implements: blueprint routed-networks
This commit is contained in:
Hong Hui Xiao 2016-04-01 04:09:33 +00:00
parent 16aa695880
commit 66c357400b
9 changed files with 85 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -13,6 +13,7 @@
# License for the specific language governing permissions and limitations
# under the License.
from debtcollector import moves
from neutron_lib import constants as n_const
from oslo_db import exception as db_exc
from oslo_log import log
@ -35,17 +36,29 @@ LOG = log.getLogger(__name__)
MAX_PORTS_PER_QUERY = 500
# The API methods from segments_db
add_network_segment = segments_db.add_network_segment
add_network_segment = moves.moved_function(
segments_db.add_network_segment, 'add_network_segment', __name__,
version='Newton', removal_version='Ocata')
get_network_segments = segments_db.get_network_segments
get_network_segments = moves.moved_function(
segments_db.get_network_segments, 'get_network_segments', __name__,
version='Newton', removal_version='Ocata')
get_networks_segments = segments_db.get_networks_segments
get_networks_segments = moves.moved_function(
segments_db.get_networks_segments, 'get_networks_segments', __name__,
version='Newton', removal_version='Ocata')
get_segment_by_id = segments_db.get_segment_by_id
get_segment_by_id = moves.moved_function(
segments_db.get_segment_by_id, 'get_segment_by_id', __name__,
version='Newton', removal_version='Ocata')
get_dynamic_segment = segments_db.get_dynamic_segment
get_dynamic_segment = moves.moved_function(
segments_db.get_dynamic_segment, 'get_dynamic_segment', __name__,
version='Newton', removal_version='Ocata')
delete_network_segment = segments_db.delete_network_segment
delete_network_segment = moves.moved_function(
segments_db.delete_network_segment, 'delete_network_segment', __name__,
version='Newton', removal_version='Ocata')
def add_port_binding(session, port_id):

10
neutron/plugins/ml2/driver_context.py
View File

@ -18,8 +18,8 @@ from oslo_log import log
from oslo_serialization import jsonutils
from neutron._i18n import _LW
from neutron.db import segments_db
from neutron.extensions import portbindings
from neutron.plugins.ml2 import db
from neutron.plugins.ml2 import driver_api as api
LOG = log.getLogger(__name__)
@ -42,8 +42,8 @@ class NetworkContext(MechanismDriverContext, api.NetworkContext):
super(NetworkContext, self).__init__(plugin, plugin_context)
self._network = network
self._original_network = original_network
self._segments = db.get_network_segments(plugin_context.session,
network['id'])
self._segments = segments_db.get_network_segments(
plugin_context.session, network['id'])
@property
def current(self):
@ -192,8 +192,8 @@ class PortContext(MechanismDriverContext, api.PortContext):
self._original_binding_levels[-1].segment_id)
def _expand_segment(self, segment_id):
segment = db.get_segment_by_id(self._plugin_context.session,
segment_id)
segment = segments_db.get_segment_by_id(self._plugin_context.session,
segment_id)
if not segment:
LOG.warning(_LW("Could not expand segment %s"), segment_id)
return segment

5
neutron/plugins/ml2/extensions/dns_integration.py
View File

@ -23,10 +23,10 @@ from neutron.callbacks import registry
from neutron.callbacks import resources
from neutron.db import dns_db
from neutron.db import models_v2
from neutron.db import segments_db
from neutron.extensions import dns
from neutron import manager
from neutron.plugins.common import utils as plugin_utils
from neutron.plugins.ml2 import db
from neutron.plugins.ml2 import driver_api as api
from neutron.services.externaldns import driver
@ -187,7 +187,8 @@ class DNSExtensionDriverML2(DNSExtensionDriver):
return True
if network['router:external']:
return True
segments = db.get_network_segments(context.session, network['id'])
segments = segments_db.get_network_segments(context.session,
network['id'])
if len(segments) > 1:
return False
provider_net = segments[0]

21
neutron/plugins/ml2/managers.py
View File

@ -23,13 +23,13 @@ import six
import stevedore
from neutron._i18n import _, _LE, _LI, _LW
from neutron.db import segments_db
from neutron.extensions import external_net
from neutron.extensions import multiprovidernet as mpnet
from neutron.extensions import portbindings
from neutron.extensions import providernet as provider
from neutron.extensions import vlantransparent
from neutron.plugins.ml2.common import exceptions as ml2_exc
from neutron.plugins.ml2 import db
from neutron.plugins.ml2 import driver_api as api
from neutron.plugins.ml2 import models
from neutron.services.qos import qos_consts
@ -155,7 +155,7 @@ class TypeManager(stevedore.named.NamedExtensionManager):
def extend_networks_dict_provider(self, context, networks):
ids = [network['id'] for network in networks]
net_segments = db.get_networks_segments(context.session, ids)
net_segments = segments_db.get_networks_segments(context.session, ids)
for network in networks:
segments = net_segments[network['id']]
self._extend_network_dict_provider(network, segments)
@ -184,7 +184,8 @@ class TypeManager(stevedore.named.NamedExtensionManager):
def _add_network_segment(self, session, network_id, segment, mtu,
segment_index=0):
db.add_network_segment(session, network_id, segment, segment_index)
segments_db.add_network_segment(
session, network_id, segment, segment_index)
if segment.get(api.MTU, 0) > 0:
mtu.append(segment[api.MTU])
@ -252,8 +253,8 @@ class TypeManager(stevedore.named.NamedExtensionManager):
raise exc.NoNetworkAvailable()
def release_network_segments(self, session, network_id):
segments = db.get_network_segments(session, network_id,
filter_dynamic=None)
segments = segments_db.get_network_segments(session, network_id,
filter_dynamic=None)
for segment in segments:
network_type = segment.get(api.NETWORK_TYPE)
@ -266,7 +267,7 @@ class TypeManager(stevedore.named.NamedExtensionManager):
def allocate_dynamic_segment(self, session, network_id, segment):
"""Allocate a dynamic segment using a partial or full segment dict."""
dynamic_segment = db.get_dynamic_segment(
dynamic_segment = segments_db.get_dynamic_segment(
session, network_id, segment.get(api.PHYSICAL_NETWORK),
segment.get(api.SEGMENTATION_ID))
@ -275,18 +276,18 @@ class TypeManager(stevedore.named.NamedExtensionManager):
driver = self.drivers.get(segment.get(api.NETWORK_TYPE))
dynamic_segment = driver.obj.reserve_provider_segment(session, segment)
db.add_network_segment(session, network_id, dynamic_segment,
is_dynamic=True)
segments_db.add_network_segment(session, network_id, dynamic_segment,
is_dynamic=True)
return dynamic_segment
def release_dynamic_segment(self, session, segment_id):
"""Delete a dynamic segment."""
segment = db.get_segment_by_id(session, segment_id)
segment = segments_db.get_segment_by_id(session, segment_id)
if segment:
driver = self.drivers.get(segment.get(api.NETWORK_TYPE))
if driver:
driver.obj.release_segment(session, segment)
db.delete_network_segment(session, segment_id)
segments_db.delete_network_segment(session, segment_id)
else:
LOG.error(_LE("Failed to release segment '%s' because "
"network type is not supported."), segment)

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

@ -63,6 +63,7 @@ from neutron.db import provisioning_blocks
from neutron.db.quota import driver # noqa
from neutron.db import securitygroups_db
from neutron.db import securitygroups_rpc_base as sg_db_rpc
from neutron.db import segments_db
from neutron.db import vlantransparent_db
from neutron.extensions import allowedaddresspairs as addr_pair
from neutron.extensions import availability_zone as az_ext
@ -1682,7 +1683,8 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
def filter_hosts_with_network_access(
self, context, network_id, candidate_hosts):
segments = db.get_network_segments(context.session, network_id)
segments = segments_db.get_network_segments(context.session,
network_id)
return self.mechanism_manager.filter_hosts_with_segment_access(
context, segments, candidate_hosts, self.get_agents)

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

@ -982,7 +982,8 @@ class TestL2PopulationMechDriver(base.BaseTestCase):
original_port = port.copy()
original_port['mac_address'] = u'12:34:56:78:4b:0f'
with mock.patch.object(driver_context.db, 'get_network_segments'):
with mock.patch.object(driver_context.segments_db,
'get_network_segments'):
ctx = driver_context.PortContext(mock.Mock(),
mock.Mock(),
port,

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

@ -24,6 +24,7 @@ from neutron import context
from neutron.db import db_base_plugin_v2
from neutron.db import l3_db
from neutron.db import models_v2
from neutron.db import segments_db
from neutron.extensions import portbindings
from neutron.plugins.ml2 import db as ml2_db
from neutron.plugins.ml2 import driver_api as api
@ -64,11 +65,11 @@ class Ml2DBTestCase(testlib_api.SqlTestCase):
network_id='foo-network-id'):
self._setup_neutron_network(network_id)
for segment in segments:
ml2_db.add_network_segment(
segments_db.add_network_segment(
self.ctx.session, network_id, segment,
is_dynamic=is_seg_dynamic)
net_segments = ml2_db.get_network_segments(
net_segments = segments_db.get_network_segments(
self.ctx.session, network_id,
filter_dynamic=is_seg_dynamic)
@ -113,14 +114,16 @@ class Ml2DBTestCase(testlib_api.SqlTestCase):
api.SEGMENTATION_ID: 4}]
net1segs = self._create_segments(segments1, network_id='net1')
net2segs = self._create_segments(segments2, network_id='net2')
segs = ml2_db.get_networks_segments(self.ctx.session, ['net1', 'net2'])
segs = segments_db.get_networks_segments(
self.ctx.session, ['net1', 'net2'])
self.assertEqual(net1segs, segs['net1'])
self.assertEqual(net2segs, segs['net2'])
def test_get_networks_segments_no_segments(self):
self._create_segments([], network_id='net1')
self._create_segments([], network_id='net2')
segs = ml2_db.get_networks_segments(self.ctx.session, ['net1', 'net2'])
segs = segments_db.get_networks_segments(
self.ctx.session, ['net1', 'net2'])
self.assertEqual([], segs['net1'])
self.assertEqual([], segs['net2'])
@ -132,12 +135,14 @@ class Ml2DBTestCase(testlib_api.SqlTestCase):
net_segment = self._create_segments([segment])[0]
segment_uuid = net_segment[api.ID]
net_segment = ml2_db.get_segment_by_id(self.ctx.session, segment_uuid)
net_segment = segments_db.get_segment_by_id(self.ctx.session,
segment_uuid)
self.assertEqual(segment, net_segment)
def test_get_segment_by_id_result_not_found(self):
segment_uuid = uuidutils.generate_uuid()
net_segment = ml2_db.get_segment_by_id(self.ctx.session, segment_uuid)
net_segment = segments_db.get_segment_by_id(self.ctx.session,
segment_uuid)
self.assertIsNone(net_segment)
def test_delete_network_segment(self):
@ -148,9 +153,10 @@ class Ml2DBTestCase(testlib_api.SqlTestCase):
net_segment = self._create_segments([segment])[0]
segment_uuid = net_segment[api.ID]
ml2_db.delete_network_segment(self.ctx.session, segment_uuid)
segments_db.delete_network_segment(self.ctx.session, segment_uuid)
# Get segment and verify its empty
net_segment = ml2_db.get_segment_by_id(self.ctx.session, segment_uuid)
net_segment = segments_db.get_segment_by_id(self.ctx.session,
segment_uuid)
self.assertIsNone(net_segment)
def test_add_port_binding(self):

12
neutron/tests/unit/plugins/ml2/test_driver_context.py
View File

@ -37,7 +37,8 @@ class TestPortContext(base.BaseTestCase):
port = {'device_owner': constants.DEVICE_OWNER_DVR_INTERFACE}
binding.host = 'foohost'
with mock.patch.object(driver_context.db, 'get_network_segments'):
with mock.patch.object(driver_context.segments_db,
'get_network_segments'):
ctx = driver_context.PortContext(plugin,
plugin_context,
port,
@ -56,7 +57,8 @@ class TestPortContext(base.BaseTestCase):
portbindings.HOST_ID: 'host'}
binding.host = 'foohost'
with mock.patch.object(driver_context.db, 'get_network_segments'):
with mock.patch.object(driver_context.segments_db,
'get_network_segments'):
ctx = driver_context.PortContext(plugin,
plugin_context,
port,
@ -74,7 +76,8 @@ class TestPortContext(base.BaseTestCase):
port = {'device_owner': constants.DEVICE_OWNER_DVR_INTERFACE}
binding.status = 'foostatus'
with mock.patch.object(driver_context.db, 'get_network_segments'):
with mock.patch.object(driver_context.segments_db,
'get_network_segments'):
ctx = driver_context.PortContext(plugin,
plugin_context,
port,
@ -93,7 +96,8 @@ class TestPortContext(base.BaseTestCase):
'status': 'status'}
binding.status = 'foostatus'
with mock.patch.object(driver_context.db, 'get_network_segments'):
with mock.patch.object(driver_context.segments_db,
'get_network_segments'):
ctx = driver_context.PortContext(plugin,
plugin_context,
port,

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

@ -40,6 +40,7 @@ from neutron.db import db_base_plugin_v2 as base_plugin
from neutron.db import l3_db
from neutron.db import models_v2
from neutron.db import provisioning_blocks
from neutron.db import segments_db
from neutron.extensions import availability_zone as az_ext
from neutron.extensions import external_net
from neutron.extensions import multiprovidernet as mpnet
@ -1296,7 +1297,7 @@ class TestMl2PortBinding(Ml2PluginV2TestCase,
new_router_id = 'new_router'
attrs = {'device_id': new_router_id, portbindings.HOST_ID: host_id}
with mock.patch.object(plugin, '_update_port_dict_binding'):
with mock.patch.object(ml2_db, 'get_network_segments',
with mock.patch.object(segments_db, 'get_network_segments',
return_value=[]):
mech_context = driver_context.PortContext(
self, context, mock_port, mock_network, binding, None)
@ -1361,9 +1362,8 @@ class TestMultiSegmentNetworks(Ml2PluginV2TestCase):
network_id = network['network']['id']
self.driver.type_manager.allocate_dynamic_segment(
self.context.session, network_id, segment)
dynamic_segment = ml2_db.get_dynamic_segment(self.context.session,
network_id,
'physnet1')
dynamic_segment = segments_db.get_dynamic_segment(
self.context.session, network_id, 'physnet1')
self.assertEqual('vlan', dynamic_segment[driver_api.NETWORK_TYPE])
self.assertEqual('physnet1',
dynamic_segment[driver_api.PHYSICAL_NETWORK])
@ -1373,9 +1373,8 @@ class TestMultiSegmentNetworks(Ml2PluginV2TestCase):
driver_api.PHYSICAL_NETWORK: 'physnet3'}
self.driver.type_manager.allocate_dynamic_segment(
self.context.session, network_id, segment2)
dynamic_segment = ml2_db.get_dynamic_segment(self.context.session,
network_id,
segmentation_id='1234')
dynamic_segment = segments_db.get_dynamic_segment(
self.context.session, network_id, segmentation_id='1234')
self.assertEqual('vlan', dynamic_segment[driver_api.NETWORK_TYPE])
self.assertEqual('physnet3',
dynamic_segment[driver_api.PHYSICAL_NETWORK])
@ -1392,26 +1391,23 @@ class TestMultiSegmentNetworks(Ml2PluginV2TestCase):
network_id = network['network']['id']
self.driver.type_manager.allocate_dynamic_segment(
self.context.session, network_id, segment)
dynamic_segment = ml2_db.get_dynamic_segment(self.context.session,
network_id,
'physnet1')
dynamic_segment = segments_db.get_dynamic_segment(
self.context.session, network_id, 'physnet1')
self.assertEqual('vlan', dynamic_segment[driver_api.NETWORK_TYPE])
self.assertEqual('physnet1',
dynamic_segment[driver_api.PHYSICAL_NETWORK])
dynamic_segmentation_id = dynamic_segment[driver_api.SEGMENTATION_ID]
self.assertTrue(dynamic_segmentation_id > 0)
dynamic_segment1 = ml2_db.get_dynamic_segment(self.context.session,
network_id,
'physnet1')
dynamic_segment1 = segments_db.get_dynamic_segment(
self.context.session, network_id, 'physnet1')
dynamic_segment1_id = dynamic_segment1[driver_api.SEGMENTATION_ID]
self.assertEqual(dynamic_segmentation_id, dynamic_segment1_id)
segment2 = {driver_api.NETWORK_TYPE: 'vlan',
driver_api.PHYSICAL_NETWORK: 'physnet2'}
self.driver.type_manager.allocate_dynamic_segment(
self.context.session, network_id, segment2)
dynamic_segment2 = ml2_db.get_dynamic_segment(self.context.session,
network_id,
'physnet2')
dynamic_segment2 = segments_db.get_dynamic_segment(
self.context.session, network_id, 'physnet2')
dynamic_segmentation2_id = dynamic_segment2[driver_api.SEGMENTATION_ID]
self.assertNotEqual(dynamic_segmentation_id, dynamic_segmentation2_id)
@ -1426,9 +1422,8 @@ class TestMultiSegmentNetworks(Ml2PluginV2TestCase):
network_id = network['network']['id']
self.driver.type_manager.allocate_dynamic_segment(
self.context.session, network_id, segment)
dynamic_segment = ml2_db.get_dynamic_segment(self.context.session,
network_id,
'physnet1')
dynamic_segment = segments_db.get_dynamic_segment(
self.context.session, network_id, 'physnet1')
self.assertEqual('vlan', dynamic_segment[driver_api.NETWORK_TYPE])
self.assertEqual('physnet1',
dynamic_segment[driver_api.PHYSICAL_NETWORK])
@ -1436,7 +1431,7 @@ class TestMultiSegmentNetworks(Ml2PluginV2TestCase):
self.assertTrue(dynamic_segmentation_id > 0)
self.driver.type_manager.release_dynamic_segment(
self.context.session, dynamic_segment[driver_api.ID])
self.assertIsNone(ml2_db.get_dynamic_segment(
self.assertIsNone(segments_db.get_dynamic_segment(
self.context.session, network_id, 'physnet1'))
def test_create_network_provider(self):
@ -1564,9 +1559,8 @@ class TestMultiSegmentNetworks(Ml2PluginV2TestCase):
driver_api.PHYSICAL_NETWORK: 'physnet2'}
self.driver.type_manager.allocate_dynamic_segment(
self.context.session, network_id, segment)
dynamic_segment = ml2_db.get_dynamic_segment(self.context.session,
network_id,
'physnet2')
dynamic_segment = segments_db.get_dynamic_segment(
self.context.session, network_id, 'physnet2')
self.assertEqual('vlan', dynamic_segment[driver_api.NETWORK_TYPE])
self.assertEqual('physnet2',
dynamic_segment[driver_api.PHYSICAL_NETWORK])
@ -1577,9 +1571,9 @@ class TestMultiSegmentNetworks(Ml2PluginV2TestCase):
req = self.new_delete_request('networks', network_id)
res = req.get_response(self.api)
self.assertEqual(2, rs.call_count)
self.assertEqual([], ml2_db.get_network_segments(
self.assertEqual([], segments_db.get_network_segments(
self.context.session, network_id))
self.assertIsNone(ml2_db.get_dynamic_segment(
self.assertIsNone(segments_db.get_dynamic_segment(
self.context.session, network_id, 'physnet2'))
def test_release_segment_no_type_driver(self):
@ -1599,7 +1593,7 @@ class TestMultiSegmentNetworks(Ml2PluginV2TestCase):
driver_api.PHYSICAL_NETWORK: 'physnet1',
driver_api.ID: 1}
with mock.patch('neutron.plugins.ml2.managers.LOG') as log:
with mock.patch('neutron.plugins.ml2.managers.db') as db:
with mock.patch('neutron.plugins.ml2.managers.segments_db') as db:
db.get_network_segments.return_value = (segment,)
self.driver.type_manager.release_network_segments(
self.context.session, network_id)