def test_create_update_subnet_with_dhcp(self):
ovs = utils.OvsFlowsParser()
flows_before_change = ovs.dump(self.integration_bridge)
network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api))
network_id = network.create()
subnet = {
'network_id': network_id,
'cidr': '10.10.254.0/24',
'gateway_ip': '10.10.254.1',
'ip_version': 4,
'name': 'subnet-test',
'enable_dhcp': True
}
subnet = self.neutron.create_subnet({'subnet': subnet})
subnet_id = subnet['subnet']['id']
dhcp_ip = utils.wait_until_is_and_return(
lambda: self.get_dhcp_ip(network_id, subnet_id),
exception=Exception('DHCP IP was not generated'))
self.assertFalse(utils.check_dhcp_ip_rule(flows_before_change,
dhcp_ip))
utils.wait_until_true(
lambda: utils.check_dhcp_ip_rule(ovs.dump(self.integration_bridge),
dhcp_ip),
exception=Exception('DHCP ip was not found in OpenFlow rules'),
timeout=5)
# change dhcp
updated_subnet = {'enable_dhcp': False}
self.neutron.update_subnet(subnet_id, {'subnet': updated_subnet})
time.sleep(const.DEFAULT_RESOURCE_READY_TIMEOUT)
flows_after_update = ovs.dump(self.integration_bridge)
self.assertFalse(utils.check_dhcp_ip_rule(flows_after_update, dhcp_ip))
network.close()
def test_create_router_interface(self):
ovs = utils.OvsFlowsParser()
flows_before_change = ovs.dump(self.integration_bridge)
router = self.store(objects.RouterTestObj(self.neutron, self.nb_api))
network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api))
network_id = network.create()
subnet = {
'network_id': network_id,
'cidr': '10.30.0.0/24',
'gateway_ip': '10.30.0.1',
'ip_version': 4,
'name': 'subnet-test',
'enable_dhcp': True
}
subnet = self.neutron.create_subnet({'subnet': subnet})
subnet_id = subnet['subnet']['id']
router_id = router.create()
self.assertTrue(router.exists())
subnet_msg = {'subnet_id': subnet_id}
time.sleep(const.DEFAULT_RESOURCE_READY_TIMEOUT)
self.neutron.add_interface_router(router_id, body=subnet_msg)
dhcp_ip = utils.wait_until_is_and_return(
lambda: self.get_dhcp_ip(network_id, subnet_id),
exception=Exception('DHCP IP was not generated'))
flows_after_change = ovs.dump(self.integration_bridge)
self.assertFalse(utils.check_dhcp_ip_rule(flows_before_change,
dhcp_ip))
self.assertTrue(utils.check_dhcp_ip_rule(flows_after_change, dhcp_ip))
self.neutron.remove_interface_router(router_id, body=subnet_msg)
router.close()
network.close()
utils.wait_until_none(
lambda: utils.check_dhcp_ip_rule(ovs.dump(self.integration_bridge),
dhcp_ip),
exception=Exception('DHCP IP was not removed from OpenFlow rules'),
timeout=30)
def test_db_consistent(self):
self.db_sync_time = self.conf.db_sync_time
network = self.store(objects.NetworkTestObj(self.neutron, self.nb_api))
network_id = network.create()
topic = network.get_topic()
subnet = self.store(objects.SubnetTestObj(self.neutron, self.nb_api,
network_id))
subnet_body = {'network_id': network_id,
'cidr': '10.50.0.0/24',
'gateway_ip': '10.50.0.1',
'ip_version': 4,
'name': 'private',
'enable_dhcp': True}
subnet.create(subnet=subnet_body)
time.sleep(constants.DEFAULT_RESOURCE_READY_TIMEOUT)
self.assertTrue(network.exists())
self.assertTrue(subnet.exists())
vm = self.store(objects.VMTestObj(self, self.neutron))
vm.create(network=network)
self.assertIsNotNone(vm.server.addresses['mynetwork'])
mac = vm.server.addresses['mynetwork'][0]['OS-EXT-IPS-MAC:mac_addr']
self.assertIsNotNone(mac)
ovs = utils.OvsFlowsParser()
utils.wait_until_true(
lambda: self._check_l2_lookup_rule(
ovs.dump(self.integration_bridge), mac),
timeout=10, sleep=1,
exception=Exception('no rule for vm in l2 lookup table')
)
net_id = '11111111-1111-1111-1111-111111111111'
df_network = l2.LogicalSwitch(
id=net_id,
topic=topic,
name='df_nw1',
network_type='vxlan',
segmentation_id=4000,
is_external=False,
mtu=1500,
unique_key=1,
version=1)
df_subnet = l2.Subnet(
id='22222222-2222-2222-2222-222222222222',
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)
time.sleep(self.db_sync_time)
utils.wait_until_true(
lambda: utils.check_dhcp_ip_rule(
ovs.dump(self.integration_bridge), '10.60.0.2'),
timeout=self.db_sync_time + constants.DEFAULT_CMD_TIMEOUT, sleep=1,
exception=Exception('no goto dhcp rule for lswitch')
)
df_network.version = 2
df_network.subnets[0].dhcp_ip = '10.60.0.3'
df_network_json = df_network.to_json()
self.nb_api.driver.set_key('lswitch', net_id, df_network_json, topic)
time.sleep(self.db_sync_time)
utils.wait_until_true(
lambda: utils.check_dhcp_ip_rule(
ovs.dump(self.integration_bridge), '10.60.0.3'),
timeout=self.db_sync_time + constants.DEFAULT_CMD_TIMEOUT, sleep=1,
exception=Exception('no goto dhcp rule for lswitch')
)
self.nb_api.driver.delete_key('lswitch', net_id, topic)
time.sleep(self.db_sync_time)
utils.wait_until_true(
lambda: self._check_no_lswitch_dhcp_rule(
ovs.dump(self.integration_bridge), '10.60.0.3'),
timeout=self.db_sync_time + constants.DEFAULT_CMD_TIMEOUT, sleep=1,
exception=Exception('could not delete goto dhcp rule for lswitch')
)
vm.close()
subnet.close()
network.close()
def _check_no_lswitch_dhcp_rule(self, flows, dhcp_ip):
if utils.check_dhcp_ip_rule(flows, dhcp_ip):
return False
return True