c2634fa580
H302 violation is reported by flake8 when importing separated objects from
modules instead of importing the whole module.
e.g. from package.module import function
function()
is changed to
from package import module
module.function()
Change-Id: Ic6975f39c755ded54149a9c01fcdcfaf78c596fc
Partial-Bug: #1291032
864 lines
41 KiB
Python
864 lines
41 KiB
Python
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
|
|
|
# Copyright 2013 Cisco Systems, Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
#
|
|
# @author: Juergen Brendel, Cisco Systems Inc.
|
|
# @author: Abhishek Raut, Cisco Systems Inc.
|
|
# @author: Rudrajit Tapadar, Cisco Systems Inc.
|
|
|
|
from six import moves
|
|
from sqlalchemy.orm import exc as s_exc
|
|
from testtools import matchers
|
|
|
|
from neutron.common import exceptions as n_exc
|
|
from neutron import context
|
|
from neutron.db import api as db
|
|
from neutron.db import db_base_plugin_v2
|
|
from neutron.plugins.cisco.common import cisco_constants
|
|
from neutron.plugins.cisco.common import cisco_exceptions as c_exc
|
|
from neutron.plugins.cisco.db import n1kv_db_v2
|
|
from neutron.plugins.cisco.db import n1kv_models_v2
|
|
from neutron.tests import base
|
|
from neutron.tests.unit import test_db_plugin as test_plugin
|
|
|
|
|
|
PHYS_NET = 'physnet1'
|
|
PHYS_NET_2 = 'physnet2'
|
|
VLAN_MIN = 10
|
|
VLAN_MAX = 19
|
|
VXLAN_MIN = 5000
|
|
VXLAN_MAX = 5009
|
|
SEGMENT_RANGE = '200-220'
|
|
SEGMENT_RANGE_MIN_OVERLAP = '210-230'
|
|
SEGMENT_RANGE_MAX_OVERLAP = '190-209'
|
|
SEGMENT_RANGE_OVERLAP = '190-230'
|
|
TEST_NETWORK_ID = 'abcdefghijklmnopqrstuvwxyz'
|
|
TEST_NETWORK_ID2 = 'abcdefghijklmnopqrstuvwxy2'
|
|
TEST_NETWORK_ID3 = 'abcdefghijklmnopqrstuvwxy3'
|
|
TEST_NETWORK_PROFILE = {'name': 'test_profile',
|
|
'segment_type': 'vlan',
|
|
'physical_network': 'physnet1',
|
|
'segment_range': '10-19'}
|
|
TEST_NETWORK_PROFILE_2 = {'name': 'test_profile_2',
|
|
'segment_type': 'vlan',
|
|
'physical_network': 'physnet1',
|
|
'segment_range': SEGMENT_RANGE}
|
|
TEST_NETWORK_PROFILE_VXLAN = {'name': 'test_profile',
|
|
'segment_type': 'overlay',
|
|
'sub_type': 'native_vxlan',
|
|
'segment_range': '5000-5009',
|
|
'multicast_ip_range': '239.0.0.70-239.0.0.80'}
|
|
TEST_POLICY_PROFILE = {'id': '4a417990-76fb-11e2-bcfd-0800200c9a66',
|
|
'name': 'test_policy_profile'}
|
|
TEST_NETWORK_PROFILE_MULTI_SEGMENT = {'name': 'test_profile',
|
|
'segment_type': 'multi-segment'}
|
|
TEST_NETWORK_PROFILE_VLAN_TRUNK = {'name': 'test_profile',
|
|
'segment_type': 'trunk',
|
|
'sub_type': 'vlan'}
|
|
TEST_NETWORK_PROFILE_VXLAN_TRUNK = {'name': 'test_profile',
|
|
'segment_type': 'trunk',
|
|
'sub_type': 'overlay'}
|
|
|
|
|
|
def _create_test_network_profile_if_not_there(session,
|
|
profile=TEST_NETWORK_PROFILE):
|
|
try:
|
|
_profile = session.query(n1kv_models_v2.NetworkProfile).filter_by(
|
|
name=profile['name']).one()
|
|
except s_exc.NoResultFound:
|
|
_profile = n1kv_db_v2.create_network_profile(session, profile)
|
|
return _profile
|
|
|
|
|
|
def _create_test_policy_profile_if_not_there(session,
|
|
profile=TEST_POLICY_PROFILE):
|
|
try:
|
|
_profile = session.query(n1kv_models_v2.PolicyProfile).filter_by(
|
|
name=profile['name']).one()
|
|
except s_exc.NoResultFound:
|
|
_profile = n1kv_db_v2.create_policy_profile(profile)
|
|
return _profile
|
|
|
|
|
|
class VlanAllocationsTest(base.BaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(VlanAllocationsTest, self).setUp()
|
|
db.configure_db()
|
|
self.session = db.get_session()
|
|
self.net_p = _create_test_network_profile_if_not_there(self.session)
|
|
n1kv_db_v2.sync_vlan_allocations(self.session, self.net_p)
|
|
self.addCleanup(db.clear_db)
|
|
|
|
def test_sync_vlan_allocations_outside_segment_range(self):
|
|
self.assertRaises(c_exc.VlanIDNotFound,
|
|
n1kv_db_v2.get_vlan_allocation,
|
|
self.session,
|
|
PHYS_NET,
|
|
VLAN_MIN - 1)
|
|
self.assertRaises(c_exc.VlanIDNotFound,
|
|
n1kv_db_v2.get_vlan_allocation,
|
|
self.session,
|
|
PHYS_NET,
|
|
VLAN_MAX + 1)
|
|
self.assertRaises(c_exc.VlanIDNotFound,
|
|
n1kv_db_v2.get_vlan_allocation,
|
|
self.session,
|
|
PHYS_NET_2,
|
|
VLAN_MIN + 20)
|
|
self.assertRaises(c_exc.VlanIDNotFound,
|
|
n1kv_db_v2.get_vlan_allocation,
|
|
self.session,
|
|
PHYS_NET_2,
|
|
VLAN_MIN + 20)
|
|
self.assertRaises(c_exc.VlanIDNotFound,
|
|
n1kv_db_v2.get_vlan_allocation,
|
|
self.session,
|
|
PHYS_NET_2,
|
|
VLAN_MAX + 20)
|
|
|
|
def test_sync_vlan_allocations_unallocated_vlans(self):
|
|
self.assertFalse(n1kv_db_v2.get_vlan_allocation(self.session,
|
|
PHYS_NET,
|
|
VLAN_MIN).allocated)
|
|
self.assertFalse(n1kv_db_v2.get_vlan_allocation(self.session,
|
|
PHYS_NET,
|
|
VLAN_MIN + 1).
|
|
allocated)
|
|
self.assertFalse(n1kv_db_v2.get_vlan_allocation(self.session,
|
|
PHYS_NET,
|
|
VLAN_MAX - 1).
|
|
allocated)
|
|
self.assertFalse(n1kv_db_v2.get_vlan_allocation(self.session,
|
|
PHYS_NET,
|
|
VLAN_MAX).allocated)
|
|
|
|
def test_vlan_pool(self):
|
|
vlan_ids = set()
|
|
for x in moves.xrange(VLAN_MIN, VLAN_MAX + 1):
|
|
(physical_network, seg_type,
|
|
vlan_id, m_ip) = n1kv_db_v2.reserve_vlan(self.session, self.net_p)
|
|
self.assertEqual(physical_network, PHYS_NET)
|
|
self.assertThat(vlan_id, matchers.GreaterThan(VLAN_MIN - 1))
|
|
self.assertThat(vlan_id, matchers.LessThan(VLAN_MAX + 1))
|
|
vlan_ids.add(vlan_id)
|
|
|
|
self.assertRaises(n_exc.NoNetworkAvailable,
|
|
n1kv_db_v2.reserve_vlan,
|
|
self.session,
|
|
self.net_p)
|
|
|
|
n1kv_db_v2.release_vlan(self.session, PHYS_NET, vlan_ids.pop())
|
|
physical_network, seg_type, vlan_id, m_ip = (n1kv_db_v2.reserve_vlan(
|
|
self.session, self.net_p))
|
|
self.assertEqual(physical_network, PHYS_NET)
|
|
self.assertThat(vlan_id, matchers.GreaterThan(VLAN_MIN - 1))
|
|
self.assertThat(vlan_id, matchers.LessThan(VLAN_MAX + 1))
|
|
vlan_ids.add(vlan_id)
|
|
|
|
for vlan_id in vlan_ids:
|
|
n1kv_db_v2.release_vlan(self.session, PHYS_NET, vlan_id)
|
|
|
|
def test_specific_vlan_inside_pool(self):
|
|
vlan_id = VLAN_MIN + 5
|
|
self.assertFalse(n1kv_db_v2.get_vlan_allocation(self.session,
|
|
PHYS_NET,
|
|
vlan_id).allocated)
|
|
n1kv_db_v2.reserve_specific_vlan(self.session, PHYS_NET, vlan_id)
|
|
self.assertTrue(n1kv_db_v2.get_vlan_allocation(self.session,
|
|
PHYS_NET,
|
|
vlan_id).allocated)
|
|
|
|
self.assertRaises(n_exc.VlanIdInUse,
|
|
n1kv_db_v2.reserve_specific_vlan,
|
|
self.session,
|
|
PHYS_NET,
|
|
vlan_id)
|
|
|
|
n1kv_db_v2.release_vlan(self.session, PHYS_NET, vlan_id)
|
|
self.assertFalse(n1kv_db_v2.get_vlan_allocation(self.session,
|
|
PHYS_NET,
|
|
vlan_id).allocated)
|
|
|
|
def test_specific_vlan_outside_pool(self):
|
|
vlan_id = VLAN_MAX + 5
|
|
self.assertRaises(c_exc.VlanIDNotFound,
|
|
n1kv_db_v2.get_vlan_allocation,
|
|
self.session,
|
|
PHYS_NET,
|
|
vlan_id)
|
|
self.assertRaises(c_exc.VlanIDOutsidePool,
|
|
n1kv_db_v2.reserve_specific_vlan,
|
|
self.session,
|
|
PHYS_NET,
|
|
vlan_id)
|
|
|
|
|
|
class VxlanAllocationsTest(base.BaseTestCase,
|
|
n1kv_db_v2.NetworkProfile_db_mixin):
|
|
|
|
def setUp(self):
|
|
super(VxlanAllocationsTest, self).setUp()
|
|
db.configure_db()
|
|
self.session = db.get_session()
|
|
self.net_p = _create_test_network_profile_if_not_there(
|
|
self.session, TEST_NETWORK_PROFILE_VXLAN)
|
|
n1kv_db_v2.sync_vxlan_allocations(self.session, self.net_p)
|
|
self.addCleanup(db.clear_db)
|
|
|
|
def test_sync_vxlan_allocations_outside_segment_range(self):
|
|
self.assertRaises(c_exc.VxlanIDNotFound,
|
|
n1kv_db_v2.get_vxlan_allocation,
|
|
self.session,
|
|
VXLAN_MIN - 1)
|
|
self.assertRaises(c_exc.VxlanIDNotFound,
|
|
n1kv_db_v2.get_vxlan_allocation,
|
|
self.session,
|
|
VXLAN_MAX + 1)
|
|
|
|
def test_sync_vxlan_allocations_unallocated_vxlans(self):
|
|
self.assertFalse(n1kv_db_v2.get_vxlan_allocation(self.session,
|
|
VXLAN_MIN).allocated)
|
|
self.assertFalse(n1kv_db_v2.get_vxlan_allocation(self.session,
|
|
VXLAN_MIN + 1).
|
|
allocated)
|
|
self.assertFalse(n1kv_db_v2.get_vxlan_allocation(self.session,
|
|
VXLAN_MAX - 1).
|
|
allocated)
|
|
self.assertFalse(n1kv_db_v2.get_vxlan_allocation(self.session,
|
|
VXLAN_MAX).allocated)
|
|
|
|
def test_vxlan_pool(self):
|
|
vxlan_ids = set()
|
|
for x in moves.xrange(VXLAN_MIN, VXLAN_MAX + 1):
|
|
vxlan = n1kv_db_v2.reserve_vxlan(self.session, self.net_p)
|
|
vxlan_id = vxlan[2]
|
|
self.assertThat(vxlan_id, matchers.GreaterThan(VXLAN_MIN - 1))
|
|
self.assertThat(vxlan_id, matchers.LessThan(VXLAN_MAX + 1))
|
|
vxlan_ids.add(vxlan_id)
|
|
|
|
self.assertRaises(n_exc.NoNetworkAvailable,
|
|
n1kv_db_v2.reserve_vxlan,
|
|
self.session,
|
|
self.net_p)
|
|
n1kv_db_v2.release_vxlan(self.session, vxlan_ids.pop())
|
|
vxlan = n1kv_db_v2.reserve_vxlan(self.session, self.net_p)
|
|
vxlan_id = vxlan[2]
|
|
self.assertThat(vxlan_id, matchers.GreaterThan(VXLAN_MIN - 1))
|
|
self.assertThat(vxlan_id, matchers.LessThan(VXLAN_MAX + 1))
|
|
vxlan_ids.add(vxlan_id)
|
|
|
|
for vxlan_id in vxlan_ids:
|
|
n1kv_db_v2.release_vxlan(self.session, vxlan_id)
|
|
n1kv_db_v2.delete_network_profile(self.session, self.net_p.id)
|
|
|
|
def test_specific_vxlan_inside_pool(self):
|
|
vxlan_id = VXLAN_MIN + 5
|
|
self.assertFalse(n1kv_db_v2.get_vxlan_allocation(self.session,
|
|
vxlan_id).allocated)
|
|
n1kv_db_v2.reserve_specific_vxlan(self.session, vxlan_id)
|
|
self.assertTrue(n1kv_db_v2.get_vxlan_allocation(self.session,
|
|
vxlan_id).allocated)
|
|
|
|
self.assertRaises(c_exc.VxlanIDInUse,
|
|
n1kv_db_v2.reserve_specific_vxlan,
|
|
self.session,
|
|
vxlan_id)
|
|
|
|
n1kv_db_v2.release_vxlan(self.session, vxlan_id)
|
|
self.assertFalse(n1kv_db_v2.get_vxlan_allocation(self.session,
|
|
vxlan_id).allocated)
|
|
|
|
def test_specific_vxlan_outside_pool(self):
|
|
vxlan_id = VXLAN_MAX + 5
|
|
self.assertRaises(c_exc.VxlanIDNotFound,
|
|
n1kv_db_v2.get_vxlan_allocation,
|
|
self.session,
|
|
vxlan_id)
|
|
self.assertRaises(c_exc.VxlanIDOutsidePool,
|
|
n1kv_db_v2.reserve_specific_vxlan,
|
|
self.session,
|
|
vxlan_id)
|
|
|
|
|
|
class NetworkBindingsTest(test_plugin.NeutronDbPluginV2TestCase):
|
|
|
|
def setUp(self):
|
|
super(NetworkBindingsTest, self).setUp()
|
|
db.configure_db()
|
|
self.session = db.get_session()
|
|
self.addCleanup(db.clear_db)
|
|
|
|
def test_add_network_binding(self):
|
|
with self.network() as network:
|
|
TEST_NETWORK_ID = network['network']['id']
|
|
|
|
self.assertRaises(c_exc.NetworkBindingNotFound,
|
|
n1kv_db_v2.get_network_binding,
|
|
self.session,
|
|
TEST_NETWORK_ID)
|
|
|
|
p = _create_test_network_profile_if_not_there(self.session)
|
|
n1kv_db_v2.add_network_binding(
|
|
self.session, TEST_NETWORK_ID, 'vlan',
|
|
PHYS_NET, 1234, '0.0.0.0', p.id, None)
|
|
binding = n1kv_db_v2.get_network_binding(
|
|
self.session, TEST_NETWORK_ID)
|
|
self.assertIsNotNone(binding)
|
|
self.assertEqual(binding.network_id, TEST_NETWORK_ID)
|
|
self.assertEqual(binding.network_type, 'vlan')
|
|
self.assertEqual(binding.physical_network, PHYS_NET)
|
|
self.assertEqual(binding.segmentation_id, 1234)
|
|
|
|
def test_create_multi_segment_network(self):
|
|
with self.network() as network:
|
|
TEST_NETWORK_ID = network['network']['id']
|
|
|
|
self.assertRaises(c_exc.NetworkBindingNotFound,
|
|
n1kv_db_v2.get_network_binding,
|
|
self.session,
|
|
TEST_NETWORK_ID)
|
|
|
|
p = _create_test_network_profile_if_not_there(
|
|
self.session,
|
|
TEST_NETWORK_PROFILE_MULTI_SEGMENT)
|
|
n1kv_db_v2.add_network_binding(
|
|
self.session, TEST_NETWORK_ID, 'multi-segment',
|
|
None, 0, '0.0.0.0', p.id, None)
|
|
binding = n1kv_db_v2.get_network_binding(
|
|
self.session, TEST_NETWORK_ID)
|
|
self.assertIsNotNone(binding)
|
|
self.assertEqual(binding.network_id, TEST_NETWORK_ID)
|
|
self.assertEqual(binding.network_type, 'multi-segment')
|
|
self.assertIsNone(binding.physical_network)
|
|
self.assertEqual(binding.segmentation_id, 0)
|
|
|
|
def test_add_multi_segment_binding(self):
|
|
with self.network() as network:
|
|
TEST_NETWORK_ID = network['network']['id']
|
|
|
|
self.assertRaises(c_exc.NetworkBindingNotFound,
|
|
n1kv_db_v2.get_network_binding,
|
|
self.session,
|
|
TEST_NETWORK_ID)
|
|
|
|
p = _create_test_network_profile_if_not_there(
|
|
self.session,
|
|
TEST_NETWORK_PROFILE_MULTI_SEGMENT)
|
|
n1kv_db_v2.add_network_binding(
|
|
self.session, TEST_NETWORK_ID, 'multi-segment',
|
|
None, 0, '0.0.0.0', p.id,
|
|
[(TEST_NETWORK_ID2, TEST_NETWORK_ID3)])
|
|
binding = n1kv_db_v2.get_network_binding(
|
|
self.session, TEST_NETWORK_ID)
|
|
self.assertIsNotNone(binding)
|
|
self.assertEqual(binding.network_id, TEST_NETWORK_ID)
|
|
self.assertEqual(binding.network_type, 'multi-segment')
|
|
self.assertIsNone(binding.physical_network)
|
|
self.assertEqual(binding.segmentation_id, 0)
|
|
ms_binding = (n1kv_db_v2.get_multi_segment_network_binding(
|
|
self.session, TEST_NETWORK_ID,
|
|
(TEST_NETWORK_ID2, TEST_NETWORK_ID3)))
|
|
self.assertIsNotNone(ms_binding)
|
|
self.assertEqual(ms_binding.multi_segment_id, TEST_NETWORK_ID)
|
|
self.assertEqual(ms_binding.segment1_id, TEST_NETWORK_ID2)
|
|
self.assertEqual(ms_binding.segment2_id, TEST_NETWORK_ID3)
|
|
ms_members = (n1kv_db_v2.get_multi_segment_members(
|
|
self.session, TEST_NETWORK_ID))
|
|
self.assertEqual(ms_members,
|
|
[(TEST_NETWORK_ID2, TEST_NETWORK_ID3)])
|
|
self.assertTrue(n1kv_db_v2.is_multi_segment_member(
|
|
self.session, TEST_NETWORK_ID2))
|
|
self.assertTrue(n1kv_db_v2.is_multi_segment_member(
|
|
self.session, TEST_NETWORK_ID3))
|
|
n1kv_db_v2.del_multi_segment_binding(
|
|
self.session, TEST_NETWORK_ID,
|
|
[(TEST_NETWORK_ID2, TEST_NETWORK_ID3)])
|
|
ms_members = (n1kv_db_v2.get_multi_segment_members(
|
|
self.session, TEST_NETWORK_ID))
|
|
self.assertEqual(ms_members, [])
|
|
|
|
def test_create_vlan_trunk_network(self):
|
|
with self.network() as network:
|
|
TEST_NETWORK_ID = network['network']['id']
|
|
|
|
self.assertRaises(c_exc.NetworkBindingNotFound,
|
|
n1kv_db_v2.get_network_binding,
|
|
self.session,
|
|
TEST_NETWORK_ID)
|
|
|
|
p = _create_test_network_profile_if_not_there(
|
|
self.session,
|
|
TEST_NETWORK_PROFILE_VLAN_TRUNK)
|
|
n1kv_db_v2.add_network_binding(
|
|
self.session, TEST_NETWORK_ID, 'trunk',
|
|
None, 0, '0.0.0.0', p.id, None)
|
|
binding = n1kv_db_v2.get_network_binding(
|
|
self.session, TEST_NETWORK_ID)
|
|
self.assertIsNotNone(binding)
|
|
self.assertEqual(binding.network_id, TEST_NETWORK_ID)
|
|
self.assertEqual(binding.network_type, 'trunk')
|
|
self.assertIsNone(binding.physical_network)
|
|
self.assertEqual(binding.segmentation_id, 0)
|
|
|
|
def test_create_vxlan_trunk_network(self):
|
|
with self.network() as network:
|
|
TEST_NETWORK_ID = network['network']['id']
|
|
|
|
self.assertRaises(c_exc.NetworkBindingNotFound,
|
|
n1kv_db_v2.get_network_binding,
|
|
self.session,
|
|
TEST_NETWORK_ID)
|
|
|
|
p = _create_test_network_profile_if_not_there(
|
|
self.session,
|
|
TEST_NETWORK_PROFILE_VXLAN_TRUNK)
|
|
n1kv_db_v2.add_network_binding(
|
|
self.session, TEST_NETWORK_ID, 'trunk',
|
|
None, 0, '0.0.0.0', p.id, None)
|
|
binding = n1kv_db_v2.get_network_binding(
|
|
self.session, TEST_NETWORK_ID)
|
|
self.assertIsNotNone(binding)
|
|
self.assertEqual(binding.network_id, TEST_NETWORK_ID)
|
|
self.assertEqual(binding.network_type, 'trunk')
|
|
self.assertIsNone(binding.physical_network)
|
|
self.assertEqual(binding.segmentation_id, 0)
|
|
|
|
def test_add_vlan_trunk_binding(self):
|
|
with self.network() as network1:
|
|
with self.network() as network2:
|
|
TEST_NETWORK_ID = network1['network']['id']
|
|
|
|
self.assertRaises(c_exc.NetworkBindingNotFound,
|
|
n1kv_db_v2.get_network_binding,
|
|
self.session,
|
|
TEST_NETWORK_ID)
|
|
TEST_NETWORK_ID2 = network2['network']['id']
|
|
self.assertRaises(c_exc.NetworkBindingNotFound,
|
|
n1kv_db_v2.get_network_binding,
|
|
self.session,
|
|
TEST_NETWORK_ID2)
|
|
p_v = _create_test_network_profile_if_not_there(self.session)
|
|
n1kv_db_v2.add_network_binding(
|
|
self.session, TEST_NETWORK_ID2, 'vlan',
|
|
PHYS_NET, 1234, '0.0.0.0', p_v.id, None)
|
|
p = _create_test_network_profile_if_not_there(
|
|
self.session,
|
|
TEST_NETWORK_PROFILE_VLAN_TRUNK)
|
|
n1kv_db_v2.add_network_binding(
|
|
self.session, TEST_NETWORK_ID, 'trunk',
|
|
None, 0, '0.0.0.0', p.id, [(TEST_NETWORK_ID2, 0)])
|
|
binding = n1kv_db_v2.get_network_binding(
|
|
self.session, TEST_NETWORK_ID)
|
|
self.assertIsNotNone(binding)
|
|
self.assertEqual(binding.network_id, TEST_NETWORK_ID)
|
|
self.assertEqual(binding.network_type, 'trunk')
|
|
self.assertEqual(binding.physical_network, PHYS_NET)
|
|
self.assertEqual(binding.segmentation_id, 0)
|
|
t_binding = (n1kv_db_v2.get_trunk_network_binding(
|
|
self.session, TEST_NETWORK_ID,
|
|
(TEST_NETWORK_ID2, 0)))
|
|
self.assertIsNotNone(t_binding)
|
|
self.assertEqual(t_binding.trunk_segment_id, TEST_NETWORK_ID)
|
|
self.assertEqual(t_binding.segment_id, TEST_NETWORK_ID2)
|
|
self.assertEqual(t_binding.dot1qtag, '0')
|
|
t_members = (n1kv_db_v2.get_trunk_members(
|
|
self.session, TEST_NETWORK_ID))
|
|
self.assertEqual(t_members,
|
|
[(TEST_NETWORK_ID2, '0')])
|
|
self.assertTrue(n1kv_db_v2.is_trunk_member(
|
|
self.session, TEST_NETWORK_ID2))
|
|
n1kv_db_v2.del_trunk_segment_binding(
|
|
self.session, TEST_NETWORK_ID,
|
|
[(TEST_NETWORK_ID2, '0')])
|
|
t_members = (n1kv_db_v2.get_multi_segment_members(
|
|
self.session, TEST_NETWORK_ID))
|
|
self.assertEqual(t_members, [])
|
|
|
|
def test_add_vxlan_trunk_binding(self):
|
|
with self.network() as network1:
|
|
with self.network() as network2:
|
|
TEST_NETWORK_ID = network1['network']['id']
|
|
|
|
self.assertRaises(c_exc.NetworkBindingNotFound,
|
|
n1kv_db_v2.get_network_binding,
|
|
self.session,
|
|
TEST_NETWORK_ID)
|
|
TEST_NETWORK_ID2 = network2['network']['id']
|
|
self.assertRaises(c_exc.NetworkBindingNotFound,
|
|
n1kv_db_v2.get_network_binding,
|
|
self.session,
|
|
TEST_NETWORK_ID2)
|
|
p_v = _create_test_network_profile_if_not_there(
|
|
self.session, TEST_NETWORK_PROFILE_VXLAN_TRUNK)
|
|
n1kv_db_v2.add_network_binding(
|
|
self.session, TEST_NETWORK_ID2, 'overlay',
|
|
None, 5100, '224.10.10.10', p_v.id, None)
|
|
p = _create_test_network_profile_if_not_there(
|
|
self.session,
|
|
TEST_NETWORK_PROFILE_VXLAN_TRUNK)
|
|
n1kv_db_v2.add_network_binding(
|
|
self.session, TEST_NETWORK_ID, 'trunk',
|
|
None, 0, '0.0.0.0', p.id,
|
|
[(TEST_NETWORK_ID2, 5)])
|
|
binding = n1kv_db_v2.get_network_binding(
|
|
self.session, TEST_NETWORK_ID)
|
|
self.assertIsNotNone(binding)
|
|
self.assertEqual(binding.network_id, TEST_NETWORK_ID)
|
|
self.assertEqual(binding.network_type, 'trunk')
|
|
self.assertIsNone(binding.physical_network)
|
|
self.assertEqual(binding.segmentation_id, 0)
|
|
t_binding = (n1kv_db_v2.get_trunk_network_binding(
|
|
self.session, TEST_NETWORK_ID,
|
|
(TEST_NETWORK_ID2, '5')))
|
|
self.assertIsNotNone(t_binding)
|
|
self.assertEqual(t_binding.trunk_segment_id, TEST_NETWORK_ID)
|
|
self.assertEqual(t_binding.segment_id, TEST_NETWORK_ID2)
|
|
self.assertEqual(t_binding.dot1qtag, '5')
|
|
t_members = (n1kv_db_v2.get_trunk_members(
|
|
self.session, TEST_NETWORK_ID))
|
|
self.assertEqual(t_members,
|
|
[(TEST_NETWORK_ID2, '5')])
|
|
self.assertTrue(n1kv_db_v2.is_trunk_member(
|
|
self.session, TEST_NETWORK_ID2))
|
|
n1kv_db_v2.del_trunk_segment_binding(
|
|
self.session, TEST_NETWORK_ID,
|
|
[(TEST_NETWORK_ID2, '5')])
|
|
t_members = (n1kv_db_v2.get_multi_segment_members(
|
|
self.session, TEST_NETWORK_ID))
|
|
self.assertEqual(t_members, [])
|
|
|
|
|
|
class NetworkProfileTests(base.BaseTestCase,
|
|
n1kv_db_v2.NetworkProfile_db_mixin):
|
|
|
|
def setUp(self):
|
|
super(NetworkProfileTests, self).setUp()
|
|
db.configure_db()
|
|
self.session = db.get_session()
|
|
self.addCleanup(db.clear_db)
|
|
|
|
def test_create_network_profile(self):
|
|
_db_profile = n1kv_db_v2.create_network_profile(self.session,
|
|
TEST_NETWORK_PROFILE)
|
|
self.assertIsNotNone(_db_profile)
|
|
db_profile = (self.session.query(n1kv_models_v2.NetworkProfile).
|
|
filter_by(name=TEST_NETWORK_PROFILE['name']).one())
|
|
self.assertIsNotNone(db_profile)
|
|
self.assertEqual(_db_profile.id, db_profile.id)
|
|
self.assertEqual(_db_profile.name, db_profile.name)
|
|
self.assertEqual(_db_profile.segment_type, db_profile.segment_type)
|
|
self.assertEqual(_db_profile.segment_range, db_profile.segment_range)
|
|
self.assertEqual(_db_profile.multicast_ip_index,
|
|
db_profile.multicast_ip_index)
|
|
self.assertEqual(_db_profile.multicast_ip_range,
|
|
db_profile.multicast_ip_range)
|
|
n1kv_db_v2.delete_network_profile(self.session, _db_profile.id)
|
|
|
|
def test_create_multi_segment_network_profile(self):
|
|
_db_profile = (n1kv_db_v2.create_network_profile(
|
|
self.session, TEST_NETWORK_PROFILE_MULTI_SEGMENT))
|
|
self.assertIsNotNone(_db_profile)
|
|
db_profile = (
|
|
self.session.query(
|
|
n1kv_models_v2.NetworkProfile).filter_by(
|
|
name=TEST_NETWORK_PROFILE_MULTI_SEGMENT['name'])
|
|
.one())
|
|
self.assertIsNotNone(db_profile)
|
|
self.assertEqual(_db_profile.id, db_profile.id)
|
|
self.assertEqual(_db_profile.name, db_profile.name)
|
|
self.assertEqual(_db_profile.segment_type, db_profile.segment_type)
|
|
self.assertEqual(_db_profile.segment_range, db_profile.segment_range)
|
|
self.assertEqual(_db_profile.multicast_ip_index,
|
|
db_profile.multicast_ip_index)
|
|
self.assertEqual(_db_profile.multicast_ip_range,
|
|
db_profile.multicast_ip_range)
|
|
n1kv_db_v2.delete_network_profile(self.session, _db_profile.id)
|
|
|
|
def test_create_vlan_trunk_network_profile(self):
|
|
_db_profile = (n1kv_db_v2.create_network_profile(
|
|
self.session, TEST_NETWORK_PROFILE_VLAN_TRUNK))
|
|
self.assertIsNotNone(_db_profile)
|
|
db_profile = (self.session.query(n1kv_models_v2.NetworkProfile).
|
|
filter_by(name=TEST_NETWORK_PROFILE_VLAN_TRUNK['name']).
|
|
one())
|
|
self.assertIsNotNone(db_profile)
|
|
self.assertEqual(_db_profile.id, db_profile.id)
|
|
self.assertEqual(_db_profile.name, db_profile.name)
|
|
self.assertEqual(_db_profile.segment_type, db_profile.segment_type)
|
|
self.assertEqual(_db_profile.segment_range, db_profile.segment_range)
|
|
self.assertEqual(_db_profile.multicast_ip_index,
|
|
db_profile.multicast_ip_index)
|
|
self.assertEqual(_db_profile.multicast_ip_range,
|
|
db_profile.multicast_ip_range)
|
|
self.assertEqual(_db_profile.sub_type, db_profile.sub_type)
|
|
n1kv_db_v2.delete_network_profile(self.session, _db_profile.id)
|
|
|
|
def test_create_vxlan_trunk_network_profile(self):
|
|
_db_profile = (n1kv_db_v2.create_network_profile(
|
|
self.session, TEST_NETWORK_PROFILE_VXLAN_TRUNK))
|
|
self.assertIsNotNone(_db_profile)
|
|
db_profile = (self.session.query(n1kv_models_v2.NetworkProfile).
|
|
filter_by(name=TEST_NETWORK_PROFILE_VXLAN_TRUNK['name']).
|
|
one())
|
|
self.assertIsNotNone(db_profile)
|
|
self.assertEqual(_db_profile.id, db_profile.id)
|
|
self.assertEqual(_db_profile.name, db_profile.name)
|
|
self.assertEqual(_db_profile.segment_type, db_profile.segment_type)
|
|
self.assertEqual(_db_profile.segment_range, db_profile.segment_range)
|
|
self.assertEqual(_db_profile.multicast_ip_index,
|
|
db_profile.multicast_ip_index)
|
|
self.assertEqual(_db_profile.multicast_ip_range,
|
|
db_profile.multicast_ip_range)
|
|
self.assertEqual(_db_profile.sub_type, db_profile.sub_type)
|
|
n1kv_db_v2.delete_network_profile(self.session, _db_profile.id)
|
|
|
|
def test_create_network_profile_overlap(self):
|
|
_db_profile = n1kv_db_v2.create_network_profile(self.session,
|
|
TEST_NETWORK_PROFILE_2)
|
|
ctx = context.get_admin_context()
|
|
TEST_NETWORK_PROFILE_2['name'] = 'net-profile-min-overlap'
|
|
TEST_NETWORK_PROFILE_2['segment_range'] = SEGMENT_RANGE_MIN_OVERLAP
|
|
test_net_profile = {'network_profile': TEST_NETWORK_PROFILE_2}
|
|
self.assertRaises(n_exc.InvalidInput,
|
|
self.create_network_profile,
|
|
ctx,
|
|
test_net_profile)
|
|
|
|
TEST_NETWORK_PROFILE_2['name'] = 'net-profile-max-overlap'
|
|
TEST_NETWORK_PROFILE_2['segment_range'] = SEGMENT_RANGE_MAX_OVERLAP
|
|
test_net_profile = {'network_profile': TEST_NETWORK_PROFILE_2}
|
|
self.assertRaises(n_exc.InvalidInput,
|
|
self.create_network_profile,
|
|
ctx,
|
|
test_net_profile)
|
|
|
|
TEST_NETWORK_PROFILE_2['name'] = 'net-profile-overlap'
|
|
TEST_NETWORK_PROFILE_2['segment_range'] = SEGMENT_RANGE_OVERLAP
|
|
test_net_profile = {'network_profile': TEST_NETWORK_PROFILE_2}
|
|
self.assertRaises(n_exc.InvalidInput,
|
|
self.create_network_profile,
|
|
ctx,
|
|
test_net_profile)
|
|
n1kv_db_v2.delete_network_profile(self.session, _db_profile.id)
|
|
|
|
def test_delete_network_profile(self):
|
|
try:
|
|
profile = (self.session.query(n1kv_models_v2.NetworkProfile).
|
|
filter_by(name=TEST_NETWORK_PROFILE['name']).one())
|
|
except s_exc.NoResultFound:
|
|
profile = n1kv_db_v2.create_network_profile(self.session,
|
|
TEST_NETWORK_PROFILE)
|
|
|
|
n1kv_db_v2.delete_network_profile(self.session, profile.id)
|
|
try:
|
|
self.session.query(n1kv_models_v2.NetworkProfile).filter_by(
|
|
name=TEST_NETWORK_PROFILE['name']).one()
|
|
except s_exc.NoResultFound:
|
|
pass
|
|
else:
|
|
self.fail("Network Profile (%s) was not deleted" %
|
|
TEST_NETWORK_PROFILE['name'])
|
|
|
|
def test_update_network_profile(self):
|
|
TEST_PROFILE_1 = {'name': 'test_profile_1'}
|
|
profile = _create_test_network_profile_if_not_there(self.session)
|
|
updated_profile = n1kv_db_v2.update_network_profile(self.session,
|
|
profile.id,
|
|
TEST_PROFILE_1)
|
|
self.assertEqual(updated_profile.name, TEST_PROFILE_1['name'])
|
|
n1kv_db_v2.delete_network_profile(self.session, profile.id)
|
|
|
|
def test_get_network_profile(self):
|
|
profile = n1kv_db_v2.create_network_profile(self.session,
|
|
TEST_NETWORK_PROFILE)
|
|
got_profile = n1kv_db_v2.get_network_profile(self.session, profile.id)
|
|
self.assertEqual(profile.id, got_profile.id)
|
|
self.assertEqual(profile.name, got_profile.name)
|
|
n1kv_db_v2.delete_network_profile(self.session, profile.id)
|
|
|
|
def test_get_network_profiles(self):
|
|
test_profiles = [{'name': 'test_profile1',
|
|
'segment_type': 'vlan',
|
|
'physical_network': 'phys1',
|
|
'segment_range': '200-210'},
|
|
{'name': 'test_profile2',
|
|
'segment_type': 'vlan',
|
|
'physical_network': 'phys1',
|
|
'segment_range': '211-220'},
|
|
{'name': 'test_profile3',
|
|
'segment_type': 'vlan',
|
|
'physical_network': 'phys1',
|
|
'segment_range': '221-230'},
|
|
{'name': 'test_profile4',
|
|
'segment_type': 'vlan',
|
|
'physical_network': 'phys1',
|
|
'segment_range': '231-240'},
|
|
{'name': 'test_profile5',
|
|
'segment_type': 'vlan',
|
|
'physical_network': 'phys1',
|
|
'segment_range': '241-250'},
|
|
{'name': 'test_profile6',
|
|
'segment_type': 'vlan',
|
|
'physical_network': 'phys1',
|
|
'segment_range': '251-260'},
|
|
{'name': 'test_profile7',
|
|
'segment_type': 'vlan',
|
|
'physical_network': 'phys1',
|
|
'segment_range': '261-270'}]
|
|
[n1kv_db_v2.create_network_profile(self.session, p)
|
|
for p in test_profiles]
|
|
# TODO(abhraut): Fix this test to work with real tenant_td
|
|
profiles = n1kv_db_v2._get_network_profiles(db_session=self.session)
|
|
self.assertEqual(len(test_profiles), len(list(profiles)))
|
|
|
|
|
|
class PolicyProfileTests(base.BaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(PolicyProfileTests, self).setUp()
|
|
db.configure_db()
|
|
self.session = db.get_session()
|
|
self.addCleanup(db.clear_db)
|
|
|
|
def test_create_policy_profile(self):
|
|
_db_profile = n1kv_db_v2.create_policy_profile(TEST_POLICY_PROFILE)
|
|
self.assertIsNotNone(_db_profile)
|
|
db_profile = (self.session.query(n1kv_models_v2.PolicyProfile).
|
|
filter_by(name=TEST_POLICY_PROFILE['name']).one)()
|
|
self.assertIsNotNone(db_profile)
|
|
self.assertTrue(_db_profile.id == db_profile.id)
|
|
self.assertTrue(_db_profile.name == db_profile.name)
|
|
|
|
def test_delete_policy_profile(self):
|
|
profile = _create_test_policy_profile_if_not_there(self.session)
|
|
n1kv_db_v2.delete_policy_profile(profile.id)
|
|
try:
|
|
self.session.query(n1kv_models_v2.PolicyProfile).filter_by(
|
|
name=TEST_POLICY_PROFILE['name']).one()
|
|
except s_exc.NoResultFound:
|
|
pass
|
|
else:
|
|
self.fail("Policy Profile (%s) was not deleted" %
|
|
TEST_POLICY_PROFILE['name'])
|
|
|
|
def test_update_policy_profile(self):
|
|
TEST_PROFILE_1 = {'name': 'test_profile_1'}
|
|
profile = _create_test_policy_profile_if_not_there(self.session)
|
|
updated_profile = n1kv_db_v2.update_policy_profile(self.session,
|
|
profile.id,
|
|
TEST_PROFILE_1)
|
|
self.assertEqual(updated_profile.name, TEST_PROFILE_1['name'])
|
|
|
|
def test_get_policy_profile(self):
|
|
profile = _create_test_policy_profile_if_not_there(self.session)
|
|
got_profile = n1kv_db_v2.get_policy_profile(self.session, profile.id)
|
|
self.assertEqual(profile.id, got_profile.id)
|
|
self.assertEqual(profile.name, got_profile.name)
|
|
|
|
|
|
class ProfileBindingTests(base.BaseTestCase,
|
|
n1kv_db_v2.NetworkProfile_db_mixin,
|
|
db_base_plugin_v2.CommonDbMixin):
|
|
|
|
def setUp(self):
|
|
super(ProfileBindingTests, self).setUp()
|
|
db.configure_db()
|
|
self.session = db.get_session()
|
|
self.addCleanup(db.clear_db)
|
|
|
|
def _create_test_binding_if_not_there(self, tenant_id, profile_id,
|
|
profile_type):
|
|
try:
|
|
_binding = (self.session.query(n1kv_models_v2.ProfileBinding).
|
|
filter_by(profile_type=profile_type,
|
|
tenant_id=tenant_id,
|
|
profile_id=profile_id).one())
|
|
except s_exc.NoResultFound:
|
|
_binding = n1kv_db_v2.create_profile_binding(self.session,
|
|
tenant_id,
|
|
profile_id,
|
|
profile_type)
|
|
return _binding
|
|
|
|
def test_create_profile_binding(self):
|
|
test_tenant_id = "d434dd90-76ec-11e2-bcfd-0800200c9a66"
|
|
test_profile_id = "dd7b9741-76ec-11e2-bcfd-0800200c9a66"
|
|
test_profile_type = "network"
|
|
n1kv_db_v2.create_profile_binding(self.session,
|
|
test_tenant_id,
|
|
test_profile_id,
|
|
test_profile_type)
|
|
try:
|
|
self.session.query(n1kv_models_v2.ProfileBinding).filter_by(
|
|
profile_type=test_profile_type,
|
|
tenant_id=test_tenant_id,
|
|
profile_id=test_profile_id).one()
|
|
except s_exc.MultipleResultsFound:
|
|
self.fail("Bindings must be unique")
|
|
except s_exc.NoResultFound:
|
|
self.fail("Could not create Profile Binding")
|
|
|
|
def test_get_profile_binding(self):
|
|
test_tenant_id = "d434dd90-76ec-11e2-bcfd-0800200c9a66"
|
|
test_profile_id = "dd7b9741-76ec-11e2-bcfd-0800200c9a66"
|
|
test_profile_type = "network"
|
|
self._create_test_binding_if_not_there(test_tenant_id,
|
|
test_profile_id,
|
|
test_profile_type)
|
|
binding = n1kv_db_v2.get_profile_binding(self.session,
|
|
test_tenant_id,
|
|
test_profile_id)
|
|
self.assertEqual(binding.tenant_id, test_tenant_id)
|
|
self.assertEqual(binding.profile_id, test_profile_id)
|
|
self.assertEqual(binding.profile_type, test_profile_type)
|
|
|
|
def test_delete_profile_binding(self):
|
|
test_tenant_id = "d434dd90-76ec-11e2-bcfd-0800200c9a66"
|
|
test_profile_id = "dd7b9741-76ec-11e2-bcfd-0800200c9a66"
|
|
test_profile_type = "network"
|
|
self._create_test_binding_if_not_there(test_tenant_id,
|
|
test_profile_id,
|
|
test_profile_type)
|
|
n1kv_db_v2.delete_profile_binding(self.session,
|
|
test_tenant_id,
|
|
test_profile_id)
|
|
q = (self.session.query(n1kv_models_v2.ProfileBinding).filter_by(
|
|
profile_type=test_profile_type,
|
|
tenant_id=test_tenant_id,
|
|
profile_id=test_profile_id))
|
|
self.assertFalse(q.count())
|
|
|
|
def test_default_tenant_replace(self):
|
|
ctx = context.get_admin_context()
|
|
ctx.tenant_id = "d434dd90-76ec-11e2-bcfd-0800200c9a66"
|
|
test_profile_id = "AAAAAAAA-76ec-11e2-bcfd-0800200c9a66"
|
|
test_profile_type = "policy"
|
|
n1kv_db_v2.create_profile_binding(self.session,
|
|
cisco_constants.TENANT_ID_NOT_SET,
|
|
test_profile_id,
|
|
test_profile_type)
|
|
network_profile = {"network_profile": TEST_NETWORK_PROFILE}
|
|
self.create_network_profile(ctx, network_profile)
|
|
binding = n1kv_db_v2.get_profile_binding(self.session,
|
|
ctx.tenant_id,
|
|
test_profile_id)
|
|
self.assertIsNone(n1kv_db_v2.get_profile_binding(
|
|
self.session,
|
|
cisco_constants.TENANT_ID_NOT_SET,
|
|
test_profile_id))
|
|
self.assertNotEqual(binding.tenant_id,
|
|
cisco_constants.TENANT_ID_NOT_SET)
|