openstack
/
dragonflow
Code Issues Proposed changes

Make Subnet a first-order model 

Change-Id: I369f7d99626f07b8e22a13bf374dae06697468bc
Closes-Bug: #1549125
Related-Bug: #1708178
This commit is contained in:
Omer Anson 2017-08-17 16:49:30 +03:00
parent e4a933af50
commit 395eeabf24
16 changed files with 185 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
dragonflow/controller/apps/dnat.py
View File

@ -337,7 +337,10 @@ class DNATApp(df_base_app.DFlowApp):
)
def _get_external_subnet(self, fip):
subnets = fip.floating_lport.lswitch.subnets
floating_lport = fip.floating_lport
subnets = self.db_store.get_all(
l2.Subnet(lswitch=floating_lport.lswitch.id),
index=l2.Subnet.get_index('lswitch'))
for subnet in subnets:
if fip.floating_ip_address in subnet.cidr:
return subnet

38
dragonflow/db/models/l2.py
View File

@ -29,16 +29,6 @@ from dragonflow.db.models import secgroups
LOG = log.getLogger(__name__)
@mf.construct_nb_db_model
class Subnet(mf.ModelBase, mixins.Name, mixins.Topic):
enable_dhcp = fields.BoolField()
dhcp_ip = df_fields.IpAddressField()
cidr = df_fields.IpNetworkField()
gateway_ip = df_fields.IpAddressField()
dns_nameservers = df_fields.ListOfField(df_fields.IpAddressField())
host_routes = fields.ListField(host_route.HostRoute)
@mf.register_model
@mf.construct_nb_db_model(
indexes={
@ -53,7 +43,6 @@ class LogicalSwitch(mf.ModelBase, mixins.Name, mixins.Version, mixins.Topic,
is_external = fields.BoolField()
mtu = fields.IntField()
subnets = fields.ListField(Subnet)
segmentation_id = fields.IntField()
# TODO(oanson) Validate network_type
network_type = fields.StringField()
@ -61,18 +50,25 @@ class LogicalSwitch(mf.ModelBase, mixins.Name, mixins.Version, mixins.Topic,
physical_network = fields.StringField()
qos_policy = df_fields.ReferenceField(qos.QosPolicy)
def find_subnet(self, subnet_id):
for subnet in self.subnets:
if subnet.id == subnet_id:
return subnet
def add_subnet(self, subnet):
self.subnets.append(subnet)
@mf.register_model
@mf.construct_nb_db_model(
indexes={
'lswitch': 'lswitch.id',
},
)
class Subnet(mf.ModelBase, mixins.Name, mixins.Topic, mixins.Version,
mixins.BasicEvents):
def remove_subnet(self, subnet_id):
for idx, subnet in enumerate(self.subnets):
if subnet.id == subnet_id:
return self.subnets.pop(idx)
table_name = "lsubnet"
enable_dhcp = fields.BoolField()
dhcp_ip = df_fields.IpAddressField()
cidr = df_fields.IpNetworkField()
gateway_ip = df_fields.IpAddressField()
dns_nameservers = df_fields.ListOfField(df_fields.IpAddressField())
host_routes = fields.ListField(host_route.HostRoute)
lswitch = df_fields.ReferenceField(LogicalSwitch, required=True)
class AddressPair(models.Base):

4
dragonflow/neutron/db/models/l2.py
View File

@ -47,7 +47,9 @@ def subnet_from_neutron_subnet(subnet):
cidr=subnet['cidr'],
gateway_ip=subnet['gateway_ip'],
dns_nameservers=subnet.get('dns_nameservers', []),
host_routes=subnet.get('host_routes', []))
host_routes=subnet.get('host_routes', []),
version=subnet['revision_number'],
lswitch=subnet['network_id'])
def _validate_ip_prefix_allowed_address_pairs(allowed_address_pairs):

31
dragonflow/neutron/ml2/mech_driver.py
View File

@ -292,13 +292,12 @@ class DFMechDriver(api.MechanismDriver):
subnet = context.current
network = context.network.current
net_id = subnet['network_id']
topic = df_utils.get_obj_topic(network)
lswitch = self.nb_api.get(l2.LogicalSwitch(id=net_id,
topic=topic))
lswitch.version = network['revision_number']
df_subnet = neutron_l2.subnet_from_neutron_subnet(subnet)
lswitch.add_subnet(df_subnet)
self.nb_api.update(lswitch)
self.nb_api.create(df_subnet)
topic = df_utils.get_obj_topic(network)
self.nb_api.update(l2.LogicalSwitch(
id=net_id, topic=topic,
version=network['revision_number']))
LOG.info("DFMechDriver: create subnet %s", subnet['id'])
return subnet
@ -306,14 +305,13 @@ class DFMechDriver(api.MechanismDriver):
@lock_db.wrap_db_lock(lock_db.RESOURCE_ML2_SUBNET)
def update_subnet_postcommit(self, context):
new_subnet = context.current
subnet = neutron_l2.subnet_from_neutron_subnet(new_subnet)
self.nb_api.update(subnet)
network = context.network.current
topic = df_utils.get_obj_topic(network)
lswitch = self.nb_api.get(l2.LogicalSwitch(id=new_subnet['network_id'],
topic=topic))
lswitch.version = network['revision_number']
subnet = lswitch.find_subnet(new_subnet['id'])
subnet.update(neutron_l2.subnet_from_neutron_subnet(new_subnet))
self.nb_api.update(lswitch)
self.nb_api.update(l2.LogicalSwitch(
id=network['id'], topic=topic,
version=network['revision_number']))
LOG.info("DFMechDriver: update subnet %s", new_subnet['id'])
return new_subnet
@ -330,11 +328,10 @@ class DFMechDriver(api.MechanismDriver):
try:
topic = df_utils.get_obj_topic(network)
lswitch = self.nb_api.get(l2.LogicalSwitch(
id=net_id, topic=topic))
lswitch.remove_subnet(subnet_id)
lswitch.version = network['revision_number']
self.nb_api.update(lswitch)
self.nb_api.delete(l2.Subnet(id=subnet_id))
self.nb_api.update(l2.LogicalSwitch(
id=net_id, topic=topic,
version=network['revision_number']))
except df_exceptions.DBKeyNotFound:
LOG.debug("network %s is not found in DB, might have "
"been deleted concurrently", net_id)

24
dragonflow/tests/fullstack/test_db_consistent.py
View File

@ -83,23 +83,27 @@ class TestDbConsistent(test_base.DFTestBase):
mtu=1500,
unique_key=1,
version=1)
df_network_json = df_network.to_json()
self.nb_api.driver.create_key(l2.LogicalSwitch.table_name,
net_id, df_network_json, topic)
self.addCleanup(self.nb_api.driver.delete_key, 'lswitch',
net_id, topic)
subnet_id = '22222222-2222-2222-2222-222222222222'
df_subnet = l2.Subnet(
id='22222222-2222-2222-2222-222222222222',
id=subnet_id,
topic=topic,
name='df_sn1',
enable_dhcp=True,
cidr='10.60.0.0/24',
dhcp_ip='10.60.0.2',
gateway_ip='10.60.0.1')
df_network.add_subnet(df_subnet)
df_network_json = df_network.to_json()
self.nb_api.driver.create_key(
'lswitch', net_id, df_network_json, topic)
self.addCleanup(self.nb_api.driver.delete_key, 'lswitch',
net_id, topic)
gateway_ip='10.60.0.1',
version=1,
lswitch=net_id)
self.nb_api.driver.create_key(l2.Subnet.table_name,
subnet_id, df_subnet.to_json(), topic)
self.addCleanup(self.nb_api.driver.delete_key, l2.Subnet.table_name,
subnet_id, topic)
port_id = '33333333-2222-2222-2222-222222222222,'
dhcp_port = l2.LogicalPort(

5
dragonflow/tests/fullstack/test_neutron_api.py
View File

@ -120,11 +120,10 @@ class TestNeutronAPIandDB(test_base.DFTestBase):
]
}
subnet.create(subnet_data)
lswitch = self.nb_api.get(l2.LogicalSwitch(id=network_id))
subnet = lswitch.subnets
db_subnet = subnet.get_subnet()
self.assertEqual(subnet_data['host_routes'],
[host_route.to_struct()
for host_route in subnet[0].host_routes])
for host_route in db_subnet.host_routes])
def test_create_delete_router(self):
router = self.store(objects.RouterTestObj(self.neutron, self.nb_api))

5
dragonflow/tests/fullstack/test_objects.py
View File

@ -409,10 +409,7 @@ class SubnetTestObj(object):
return subnet['subnet']
def get_subnet(self):
network = self.nb_api.get(l2.LogicalSwitch(id=self.network_id))
if not network:
return None
return network.find_subnet(self.subnet_id)
return self.nb_api.get(l2.Subnet(id=self.subnet_id))
def exists(self):
subnet = self.get_subnet()

38
dragonflow/tests/unit/test_app_base.py
View File

@ -27,7 +27,6 @@ from dragonflow.controller import topology
from dragonflow.db import api_nb
from dragonflow.db import db_store
from dragonflow.db import model_framework
from dragonflow.db import model_proxy
from dragonflow.db.models import core
from dragonflow.db.models import l2
from dragonflow.db.models import l3
@ -81,6 +80,7 @@ class DFAppTestBase(tests_base.BaseTestCase):
# Add basic network topology
self.controller.update(fake_logic_switch1)
self.controller.update(fake_lswitch_default_subnets[0])
self.controller.update(fake_external_switch1)
self.controller.update(fake_logic_router1)
self.controller.db_store.update(fake_chassis1)
@ -114,16 +114,7 @@ fake_logic_router1 = l3.LogicalRouter(
ports=fake_logical_router_ports)
fake_lswitch_default_subnets = [l2.Subnet(name="private-subnet",
enable_dhcp=True,
topic="fake_tenant1",
gateway_ip="10.0.0.1",
cidr="10.0.0.0/24",
id="fake_subnet1")]
fake_logic_switch1 = l2.LogicalSwitch(
subnets=fake_lswitch_default_subnets,
unique_key=1,
name='private',
is_external=False,
@ -134,16 +125,17 @@ fake_logic_switch1 = l2.LogicalSwitch(
version=5)
external_switch1_subnets = [l2.Subnet(name="public-subnet",
enable_dhcp=False,
topic="fake_tenant1",
gateway_ip="172.24.4.1",
cidr="172.24.4.0/24",
id="fake_external_subnet1")]
fake_lswitch_default_subnets = [l2.Subnet(name="private-subnet",
enable_dhcp=True,
topic="fake_tenant1",
gateway_ip="10.0.0.1",
cidr="10.0.0.0/24",
id="fake_subnet1",
version=1,
lswitch='fake_switch1')]
fake_external_switch1 = l2.LogicalSwitch(
subnets=external_switch1_subnets,
unique_key=2,
name='public',
is_external=True,
@ -153,6 +145,16 @@ fake_external_switch1 = l2.LogicalSwitch(
id='fake_external_switch1')
external_switch1_subnets = [l2.Subnet(name="public-subnet",
enable_dhcp=False,
topic="fake_tenant1",
gateway_ip="172.24.4.1",
cidr="172.24.4.0/24",
id="fake_external_subnet1",
version=1,
lswitch='fake_external_switch1')]
fake_chassis1 = core.Chassis(
id='fakehost',
ip='172.24.4.50',
@ -243,7 +245,7 @@ fake_dhcp_params = {
fake_local_port1 = make_fake_local_port(
macs=['fa:16:3e:8c:2e:b3'],
ips=['10.0.0.6', '2222:2222::3'],
subnets=[model_proxy.create_reference(l2.Subnet, 'fake_subnet1')],
subnets=['fake_subnet1'],
id='fake_port1',
dhcp_params=fake_dhcp_params)

6
dragonflow/tests/unit/test_classifier_app.py
View File

@ -12,6 +12,7 @@
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import copy
import mock
import testscenarios
@ -40,13 +41,16 @@ class TestClassifierAppForVlan(testscenarios.WithScenarios,
def setUp(self):
super(TestClassifierAppForVlan, self).setUp()
fake_vlan_switch1 = l2.LogicalSwitch(
subnets=test_app_base.fake_lswitch_default_subnets,
network_type='vlan',
id='fake_vlan_switch1', mtu=1500,
is_external=False, segmentation_id=41,
topic='fake_tenant1', unique_key=2,
name='private')
self.controller.update(fake_vlan_switch1)
subnet = copy.deepcopy(test_app_base.fake_lswitch_default_subnets[0])
subnet.id = 'fake_vlan_subnet1'
subnet.lswitch = 'fake_vlan_switch1'
self.controller.update(subnet)
self.app = self.open_flow_app.dispatcher.apps['classifier']
def test_classifier_for_vlan_port(self):

6
dragonflow/tests/unit/test_dhcp_app.py
View File

@ -45,7 +45,7 @@ class TestDHCPApp(test_app_base.DFAppTestBase):
def test_host_route_include_metadata_route(self):
cfg.CONF.set_override('df_add_link_local_route', True,
group='df_dhcp_app')
subnet = test_app_base.fake_logic_switch1.subnets[0]
subnet = test_app_base.fake_lswitch_default_subnets[0]
host_route_bin = self.app._get_host_routes_list_bin(
subnet, test_app_base.fake_local_port1)
self.assertIn(addrconv.ipv4.text_to_bin(const.METADATA_SERVICE_IP),
@ -66,13 +66,13 @@ class TestDHCPApp(test_app_base.DFAppTestBase):
self.assertIsNone(opt_value2)
def test_host_route_include_port_dhcp_opt_121(self):
subnet = test_app_base.fake_logic_switch1.subnets[0]
subnet = test_app_base.fake_lswitch_default_subnets[0]
host_route_bin = self.app._get_host_routes_list_bin(
subnet, test_app_base.fake_local_port1)
self.assertIn(addrconv.ipv4.text_to_bin('10.0.0.1'), host_route_bin)
def test_gateway_include_port_dhcp_opt_3(self):
subnet = copy.copy(test_app_base.fake_logic_switch1.subnets[0])
subnet = copy.copy(test_app_base.fake_lswitch_default_subnets[0])
subnet.gateway_ip = None
gateway_ip = self.app._get_port_gateway_address(
subnet, test_app_base.fake_local_port1)

6
dragonflow/tests/unit/test_l2_app.py
View File

@ -13,6 +13,7 @@
# License for the specific language governing permissions and limitations
# under the License.
import copy
import mock
from dragonflow.controller.common import constants as const
@ -26,7 +27,6 @@ class TestL2App(test_app_base.DFAppTestBase):
def setUp(self):
super(TestL2App, self).setUp()
fake_local_switch1 = l2.LogicalSwitch(
subnets=test_app_base.fake_lswitch_default_subnets,
network_type='local',
id='fake_local_switch1',
segmentation_id=41,
@ -36,6 +36,10 @@ class TestL2App(test_app_base.DFAppTestBase):
is_external=False,
name='private')
self.controller.update(fake_local_switch1)
subnet = copy.deepcopy(test_app_base.fake_lswitch_default_subnets[0])
subnet.id = 'fake_local_subnet1'
subnet.lswitch = 'fake_local_switch1'
self.controller.update(subnet)
self.app = self.open_flow_app.dispatcher.apps['l2']
def test_multicast_local_port(self):

38
dragonflow/tests/unit/test_legacy_snat.py
View File

@ -32,21 +32,21 @@ class TestLegacySNatApp(test_app_base.DFAppTestBase):
self.app.mod_flow.reset_mock()
def test_create_router(self):
self.subnets = [l2.Subnet(dhcp_ip="10.1.0.2",
name="private-subnet",
enable_dhcp=True,
topic="fake_tenant1",
gateway_ip="10.1.0.1",
cidr="10.1.0.0/24",
id="test_subnet10_1")]
self.lswitch = l2.LogicalSwitch(subnets=self.subnets,
unique_key=3,
self.lswitch = l2.LogicalSwitch(unique_key=3,
name='test_lswitch_1',
is_external=False,
segmentation_id=41,
topic='fake_tenant1',
id='test_lswitch_1',
version=5)
self.subnet = l2.Subnet(dhcp_ip="10.1.0.2",
name="private-subnet",
enable_dhcp=True,
topic="fake_tenant1",
gateway_ip="10.1.0.1",
cidr="10.1.0.0/24",
id="test_subnet10_1",
lswitch='test_lswitch_1')
self.router_ports = [l3.LogicalRouterPort(network="10.1.0.1/24",
lswitch=self.lswitch,
topic="fake_tenant1",
@ -60,6 +60,7 @@ class TestLegacySNatApp(test_app_base.DFAppTestBase):
unique_key=5,
ports=self.router_ports)
self.controller.update(self.lswitch)
self.controller.update(self.subnet)
self.app.mod_flow.reset_mock()
self.controller.update(self.router)
self.app._add_router_port.assert_called_once_with(self.router_ports[0])
@ -96,21 +97,21 @@ class TestLegacySNatApp(test_app_base.DFAppTestBase):
def test_update_router(self):
self.test_create_router()
subnets2 = [l2.Subnet(dhcp_ip="10.2.0.2",
name="private-subnet",
enable_dhcp=True,
topic="fake_tenant1",
gateway_ip="10.2.0.1",
cidr="10.2.0.0/24",
id="test_subnet10_2")]
lswitch2 = l2.LogicalSwitch(subnets=subnets2,
unique_key=6,
lswitch2 = l2.LogicalSwitch(unique_key=6,
name='test_lswitch_2',
is_external=False,
segmentation_id=42,
topic='fake_tenant1',
id='test_lswitch_2',
version=5)
subnet2 = l2.Subnet(dhcp_ip="10.2.0.2",
name="private-subnet",
enable_dhcp=True,
topic="fake_tenant1",
gateway_ip="10.2.0.1",
cidr="10.2.0.0/24",
id="test_subnet10_2",
lswitch='test_lswitch_2')
router_ports2 = [l3.LogicalRouterPort(network="10.2.0.1/24",
lswitch=lswitch2,
topic="fake_tenant1",
@ -118,6 +119,7 @@ class TestLegacySNatApp(test_app_base.DFAppTestBase):
unique_key=7,
id="fake_router_1_port2")]
self.controller.update(lswitch2)
self.controller.update(subnet2)
router = copy.copy(self.router)
router.ports = router_ports2
router.version += 1

103
dragonflow/tests/unit/test_mech_driver.py
View File

@ -146,7 +146,8 @@ class TestDFMechDriver(DFMechanismDriverTestCase):
self.assertGreater(new_network['revision_number'],
network['revision_number'])
lswitch.version = new_network['revision_number']
self.nb_api.update.assert_called_once_with(lswitch)
self.nb_api.update.assert_called_once_with(l2.LogicalSwitch(
id=lswitch.id, topic=lswitch.topic, version=lswitch.version))
self.nb_api.update.reset_mock()
data = {'subnet': {'name': 'updated'}}
@ -156,17 +157,13 @@ class TestDFMechDriver(DFMechanismDriverTestCase):
new_network = self.driver.get_network(self.context, network['id'])
new_lswitch = neutron_l2.logical_switch_from_neutron_network(
new_network)
updated_subnet = self.driver.get_subnet(self.context,
subnet_id)
new_lswitch.subnets = [neutron_l2.subnet_from_neutron_subnet(
updated_subnet)]
self.assertGreater(new_network['revision_number'],
network['revision_number'])
self.nb_api.update.called_once_with(new_lswitch)
self.nb_api.update.reset_mock()
self.nb_api.get.side_effect = nb_api_get_func(lswitch)
self.assertEqual(new_network['revision_number'],
lswitch.version)
self.assertGreater(new_network['revision_number'],
lswitch.version)
network = new_network
req = self.new_delete_request('subnets', subnet_id)
@ -182,82 +179,99 @@ class TestDFMechDriver(DFMechanismDriverTestCase):
def test_create_update_subnet_gateway_ip(self):
network, lswitch = self._test_create_network_revision()
self.nb_api.create.reset_mock()
self.nb_api.update.reset_mock()
self.nb_api.get.side_effect = nb_api_get_func(lswitch)
with self.subnet(network={'network': network},
set_context=True) as subnet:
set_context=True) as n_subnet:
# Create Subnet, create DHCP port
self.assertEqual(2, self.nb_api.create.call_count)
self.nb_api.update.assert_called_once()
lswitch = self.nb_api.update.call_args_list[0][0][0]
self.assertIsInstance(lswitch, l2.LogicalSwitch)
self.nb_api.get.side_effect = nb_api_get_func(lswitch)
dhcp_lport = self.nb_api.create.call_args_list[0][0][0]
self.assertIsInstance(dhcp_lport, l2.LogicalPort)
subnet = self.nb_api.create.call_args_list[1][0][0]
self.assertIsInstance(subnet, l2.Subnet)
self.nb_api.get.side_effect = nb_api_get_func(subnet)
self.nb_api.update.reset_mock()
df_subnet = lswitch.find_subnet(subnet['subnet']['id'])
self.assertIsNotNone(df_subnet.gateway_ip)
self.assertIsNotNone(subnet.gateway_ip)
data = {'subnet': {'gateway_ip': None}}
req = self.new_update_request('subnets',
data, subnet['subnet']['id'])
data, n_subnet['subnet']['id'])
req.get_response(self.api)
self.nb_api.update.assert_called_once()
lswitch = self.nb_api.update.call_args_list[0][0][0]
self.nb_api.get.side_effect = nb_api_get_func(lswitch)
self.nb_api.update.reset_mock()
df_subnet = lswitch.find_subnet(subnet['subnet']['id'])
self.assertIsNone(df_subnet.gateway_ip)
# Update subnet, update lswitch's version
self.assertEqual(2, self.nb_api.update.call_count)
subnet = self.nb_api.update.call_args_list[0][0][0]
self.assertIsInstance(subnet, l2.Subnet)
self.assertIsNone(subnet.gateway_ip)
def test_create_update_subnet_dnsnameserver(self):
network, lswitch = self._test_create_network_revision()
self.nb_api.create.reset_mock()
self.nb_api.update.reset_mock()
self.nb_api.get.side_effect = nb_api_get_func(lswitch)
with self.subnet(network={'network': network}, set_context=True,
dns_nameservers=['1.1.1.1']) as subnet:
dns_nameservers=['1.1.1.1']) as n_subnet:
# Create Subnet, create DHCP port
self.assertEqual(2, self.nb_api.create.call_count)
self.nb_api.update.assert_called_once()
lswitch = self.nb_api.update.call_args_list[0][0][0]
self.assertIsInstance(lswitch, l2.LogicalSwitch)
self.nb_api.get.side_effect = nb_api_get_func(lswitch)
dhcp_lport = self.nb_api.create.call_args_list[0][0][0]
self.assertIsInstance(dhcp_lport, l2.LogicalPort)
subnet = self.nb_api.create.call_args_list[1][0][0]
self.assertIsInstance(subnet, l2.Subnet)
self.nb_api.get.side_effect = nb_api_get_func(subnet)
self.nb_api.update.reset_mock()
df_subnet = lswitch.find_subnet(subnet['subnet']['id'])
self.assertEqual([netaddr.IPAddress('1.1.1.1')],
df_subnet.dns_nameservers)
subnet.dns_nameservers)
data = {'subnet': {'dns_nameservers': None}}
req = self.new_update_request('subnets',
data, subnet['subnet']['id'])
data, n_subnet['subnet']['id'])
req.get_response(self.api)
self.nb_api.update.assert_called_once()
lswitch = self.nb_api.update.call_args_list[0][0][0]
self.nb_api.get.side_effect = nb_api_get_func(lswitch)
self.nb_api.update.reset_mock()
df_subnet = lswitch.find_subnet(subnet['subnet']['id'])
self.assertEqual([], df_subnet.dns_nameservers)
# Update subnet, update lswitch's version
self.assertEqual(2, self.nb_api.update.call_count)
subnet = self.nb_api.update.call_args_list[0][0][0]
self.assertIsInstance(subnet, l2.Subnet)
self.assertEqual([], subnet.dns_nameservers)
def test_create_update_subnet_hostroute(self):
host_routes = [{'destination': '135.207.0.0/16', 'nexthop': '1.2.3.4'}]
network, lswitch = self._test_create_network_revision()
self.nb_api.create.reset_mock()
self.nb_api.update.reset_mock()
self.nb_api.get.side_effect = nb_api_get_func(lswitch)
with self.subnet(network={'network': network}, host_routes=host_routes,
set_context=True) as subnet:
set_context=True) as n_subnet:
# Create Subnet, create DHCP port
self.assertEqual(2, self.nb_api.create.call_count)
self.nb_api.update.assert_called_once()
lswitch = self.nb_api.update.call_args_list[0][0][0]
self.assertIsInstance(lswitch, l2.LogicalSwitch)
self.nb_api.get.side_effect = nb_api_get_func(lswitch)
dhcp_lport = self.nb_api.create.call_args_list[0][0][0]
self.assertIsInstance(dhcp_lport, l2.LogicalPort)
subnet = self.nb_api.create.call_args_list[1][0][0]
self.assertIsInstance(subnet, l2.Subnet)
self.nb_api.get.side_effect = nb_api_get_func(subnet)
self.nb_api.update.reset_mock()
df_subnet = lswitch.find_subnet(subnet['subnet']['id'])
self.assertEqual([host_route.HostRoute(**hr)
for hr in host_routes],
df_subnet.host_routes)
subnet.host_routes)
data = {'subnet': {'host_routes': None}}
req = self.new_update_request('subnets',
data, subnet['subnet']['id'])
data, n_subnet['subnet']['id'])
req.get_response(self.api)
self.nb_api.update.assert_called_once()
lswitch = self.nb_api.update.call_args_list[0][0][0]
df_subnet = lswitch.find_subnet(subnet['subnet']['id'])
self.assertEqual([], df_subnet.host_routes)
# Update subnet, update lswitch's version
self.assertEqual(2, self.nb_api.update.call_count)
subnet = self.nb_api.update.call_args_list[0][0][0]
self.assertIsInstance(subnet, l2.Subnet)
self.assertEqual([], subnet.host_routes)
def test_create_update_port_allowed_address_pairs(self):
kwargs = {'allowed_address_pairs':
@ -412,9 +426,11 @@ class TestDFMechDriver(DFMechanismDriverTestCase):
def test_update_subnet_with_disabled_dhcp(self):
network, lswitch = self._test_create_network_revision()
self.nb_api.create.reset_mock()
self.nb_api.update.reset_mock()
self.nb_api.get.side_effect = nb_api_get_func(lswitch)
with self.subnet(network={'network': network}) as s:
with self.subnet(network={'network': network}, enable_dhcp=False) as s:
self.nb_api.create.assert_called_once()
self.nb_api.update.assert_called_once()
lswitch = self.nb_api.update.call_args_list[0][0][0]
self.nb_api.get.side_effect = nb_api_get_func(lswitch)
@ -425,10 +441,11 @@ class TestDFMechDriver(DFMechanismDriverTestCase):
req = self.new_update_request('subnets', data, subnet['id'])
req.get_response(self.api)
self.nb_api.update.assert_called_once()
lswitch = self.nb_api.update.call_args_list[0][0][0]
df_subnet = lswitch.find_subnet(subnet['id'])
self.assertIsNone(df_subnet.dhcp_ip)
# Update subnet, update lswitch's version
self.assertEqual(2, self.nb_api.update.call_count)
subnet = self.nb_api.update.call_args_list[0][0][0]
self.assertIsInstance(subnet, l2.Subnet)
self.assertIsNone(subnet.dhcp_ip)
def _test_create(self, port):

8
dragonflow/tests/unit/test_provider_net_app.py
View File

@ -13,6 +13,8 @@
# License for the specific language governing permissions and limitations
# under the License.
import copy
from dragonflow.controller.common import constants as const
from dragonflow.db.models import l2
from dragonflow.tests.unit import test_app_base
@ -28,7 +30,6 @@ class TestProviderNetsApp(test_app_base.DFAppTestBase):
def setUp(self):
super(TestProviderNetsApp, self).setUp()
fake_vlan_switch1 = l2.LogicalSwitch(
subnets=test_app_base.fake_lswitch_default_subnets,
network_type='vlan',
id='fake_vlan_switch1',
mtu=1454,
@ -38,7 +39,12 @@ class TestProviderNetsApp(test_app_base.DFAppTestBase):
topic='fake_tenant1',
segmentation_id=10,
name='private')
fake_vlan_subnet = copy.deepcopy(
test_app_base.fake_lswitch_default_subnets[0])
fake_vlan_subnet.id = 'fake_vlan_subnet1'
fake_vlan_subnet.lswitch = 'fake_vlan_switch1'
self.controller.update(fake_vlan_switch1)
self.controller.update(fake_vlan_subnet)
self.app = self.open_flow_app.dispatcher.apps['provider']
self.app.ofproto.OFPVID_PRESENT = 0x1000

7
dragonflow/tests/unit/test_trunk_app.py
View File

@ -57,15 +57,14 @@ class TestTrunkApp(test_app_base.DFAppTestBase):
unique_key=17,
segmentation_id=17,
topic='fake_tenant1')
subnet = self._create_2nd_subnet()
lswitch.add_subnet(subnet)
return lswitch
def _create_2nd_subnet(self):
return l2.Subnet(id='subnet2',
enable_dhcp=False,
cidr='192.168.18.0/24',
topic='fake_tenant1')
topic='fake_tenant1',
lswitch='lswitch2')
def _create_child_port(self):
return l2.LogicalPort(id='lport2',
@ -89,6 +88,8 @@ class TestTrunkApp(test_app_base.DFAppTestBase):
def test_create_child_segmentation(self):
lswitch2 = self._create_2nd_lswitch()
self.controller.update(lswitch2)
subnet2 = self._create_2nd_subnet()
self.controller.update(subnet2)
lport = self._create_child_port()
self.controller.update(lport)

7
dragonflow/tests/unit/test_tunneling_app.py
View File

@ -13,6 +13,8 @@
# License for the specific language governing permissions and limitations
# under the License.
import copy
from dragonflow.controller.common import constants as const
from dragonflow.db.models import l2
from dragonflow.tests.unit import test_app_base
@ -28,7 +30,6 @@ class TestTunnelingApp(test_app_base.DFAppTestBase):
def setUp(self):
super(TestTunnelingApp, self).setUp()
fake_gre_switch1 = l2.LogicalSwitch(
subnets=test_app_base.fake_lswitch_default_subnets,
mtu=1464,
unique_key=6,
topic='fake_tenant1',
@ -38,6 +39,10 @@ class TestTunnelingApp(test_app_base.DFAppTestBase):
network_type='gre',
id='fake_gre_switch1')
self.controller.update(fake_gre_switch1)
subnet = copy.deepcopy(test_app_base.fake_lswitch_default_subnets[0])
subnet.id = 'fake_gre_subnet1'
subnet.lswitch = 'fake_gre_switch1'
self.controller.update(subnet)
self.app = self.open_flow_app.dispatcher.apps['tunneling']
def test_tunneling_for_local_port(self):