def test_create_with_invalid_internal_sub(self):
"""
Test adding an internal subnet owned by admin which should fail.
"""
network_settings1 = NetworkConfig(
name=self.guid + '-pub-net1',
subnet_settings=[
create_network.SubnetConfig(cidr=cidr1,
name=self.guid + '-pub-subnet1',
gateway_ip=static_gateway_ip1)
])
self.network_creator1 = OpenStackNetwork(self.admin_os_creds,
network_settings1)
self.network_creator1.create()
self.router_settings = RouterConfig(
name=self.guid + '-pub-router',
external_gateway=self.ext_net_name,
internal_subnets=[network_settings1.subnet_settings[0].name])
self.router_creator = create_router.OpenStackRouter(
self.os_creds, self.router_settings)
with self.assertRaises(RouterCreationError):
self.router_creator.create()
def test_create_delete_router(self):
"""
Test that clean() will not raise an exception if the router is deleted
by another process.
"""
self.router_settings = RouterConfig(name=self.guid + '-pub-router',
external_gateway=self.ext_net_name)
self.router_creator = create_router.OpenStackRouter(
self.os_creds, self.router_settings)
created_router = self.router_creator.create()
self.assertIsNotNone(created_router)
retrieved_router = neutron_utils.get_router(
self.neutron,
self.keystone,
router_settings=self.router_settings,
project_name=self.os_creds.project_name)
self.assertIsNotNone(retrieved_router)
neutron_utils.delete_router(self.neutron, created_router)
retrieved_router = neutron_utils.get_router(
self.neutron,
self.keystone,
router_settings=self.router_settings,
project_name=self.os_creds.project_name)
self.assertIsNone(retrieved_router)
# Should not raise an exception
self.router_creator.clean()
def test_create_router_admin_ports(self):
"""
Test creation of a router with ports to subnets owned by the admin
project
"""
network_settings = NetworkConfig(
name=self.guid + '-pub-net1',
subnet_settings=[
create_network.SubnetConfig(cidr=cidr1,
name=self.guid + '-pub-subnet1',
gateway_ip=static_gateway_ip1)
])
self.network_creator = OpenStackNetwork(self.admin_os_creds,
network_settings)
self.network_creator.create()
port_settings = [
create_network.PortConfig(
name=self.guid + '-port1',
ip_addrs=[{
'subnet_name': network_settings.subnet_settings[0].name,
'ip': static_gateway_ip1
}],
network_name=network_settings.name)
]
router_settings = RouterConfig(name=self.guid + '-pub-router',
external_gateway=self.ext_net_name,
port_settings=port_settings)
self.router_creator = create_router.OpenStackRouter(
self.os_creds, router_settings)
with self.assertRaises(PortConfigError):
self.router_creator.create()
def test_create_router_secure_port(self):
"""
Test creation of a router with a port that has a security group.
"""
network_settings = NetworkConfig(
name=self.guid + '-pub-net1',
subnet_settings=[
create_network.SubnetConfig(cidr=cidr1,
name=self.guid + '-pub-subnet1')
])
self.network_creator = OpenStackNetwork(self.os_creds,
network_settings)
self.network_creator.create()
port_settings = [
create_network.PortConfig(
name=self.guid + '-port1',
ip_addrs=[{
'subnet_name': network_settings.subnet_settings[0].name,
'ip': static_gateway_ip1
}],
network_name=network_settings.name,
security_groups=[self.sec_grp_creator.sec_grp_settings.name])
]
router_settings = RouterConfig(name=self.guid + '-pub-router',
external_gateway=self.ext_net_name,
port_settings=port_settings)
self.router_creator = create_router.OpenStackRouter(
self.os_creds, router_settings)
self.router_creator.create()
def test_create_network_router_new_user_to_admin_project(self):
"""
Tests the creation of an OpenStack network and router with the admin
user to the new project.
"""
# Create Network/Subnet where the project names have been changed
new_project_name = self.os_creds.project_name
self.net_config.network_settings.project_name = new_project_name
self.net_config.network_settings.subnet_settings[0].project_name = \
new_project_name
self.net_creator = OpenStackNetwork(
self.admin_os_creds, self.net_config.network_settings)
self.net_creator.create()
retrieved_net = neutron_utils.get_network(
self.neutron, self.keystone,
network_settings=self.net_config.network_settings,
project_name=self.os_creds.project_name)
self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
# Create Router
self.net_config.router_settings.project_name = new_project_name
self.router_creator = create_router.OpenStackRouter(
self.admin_os_creds, self.net_config.router_settings)
self.router_creator.create()
retrieved_router = neutron_utils.get_router(
self.neutron, self.keystone,
router_settings=self.router_creator.router_settings,
project_name=self.os_creds.project_name)
self.assertEqual(
self.router_creator.get_router().id, retrieved_router.id)
def test_create_router_invalid_gateway_name(self):
"""
Test creating a router without a valid network gateway name.
"""
with self.assertRaises(RouterConfigError):
router_settings = RouterConfig(name=self.guid + '-pub-router',
external_gateway="Invalid_name")
self.router_creator = create_router.OpenStackRouter(
self.os_creds, router_settings)
self.router_creator.create()
def test_create_router_noname(self):
"""
Test creating a router without a name.
"""
with self.assertRaises(RouterConfigError):
router_settings = RouterConfig(name=None,
external_gateway=self.ext_net_name)
self.router_creator = create_router.OpenStackRouter(
self.os_creds, router_settings)
self.router_creator.create()
def test_create_router_port_external(self):
"""
Test creation of a router with a port to an custom external network
created by admin.
"""
router_settings = RouterConfig(
name=self.guid + '-pub-router',
network_name=self.ext_network_creator.get_network().name)
self.router_creator = create_router.OpenStackRouter(
self.os_creds, router_settings)
self.router_creator.create()
def test_create_router_port_shared(self):
"""
Test creation of a router with a port to an custom shared network
created by admin.
"""
port_settings = [
create_network.PortConfig(
name=self.guid + '-port1',
network_name=self.shared_network_creator.get_network().name)
]
router_settings = RouterConfig(name=self.guid + '-pub-router',
port_settings=port_settings)
self.router_creator = create_router.OpenStackRouter(
self.os_creds, router_settings)
self.router_creator.create()
def test_create_router_with_ext_port(self):
"""
Test creation of a router with a port to an external network as an
'admin' user.
"""
port_settings = [
create_network.PortConfig(name=self.guid + '-port1',
network_name=self.ext_net_name)
]
router_settings = RouterConfig(name=self.guid + '-pub-router',
port_settings=port_settings)
self.router_creator = create_router.OpenStackRouter(
self.admin_os_creds, router_settings)
self.router_creator.create()
admin_neutron = neutron_utils.neutron_client(self.admin_os_creds,
self.admin_os_session)
admin_keystone = keystone_utils.keystone_client(
self.admin_os_creds, self.admin_os_session)
router = neutron_utils.get_router(
admin_neutron,
admin_keystone,
router_settings=router_settings,
project_name=self.admin_os_creds.project_name)
self.assertIsNotNone(router)
self.assertEquals(router, self.router_creator.get_router())
ext_net = neutron_utils.get_network(admin_neutron,
admin_keystone,
network_name=self.ext_net_name)
self.assertIsNotNone(ext_net)
self.assertIsNotNone(router.port_subnets)
id_found = False
for port, subnets in router.port_subnets:
self.assertIsNotNone(subnets)
self.assertIsNotNone(port)
if ext_net.id == port.network_id:
id_found = True
for subnet in subnets:
self.assertIsNotNone(subnet)
self.assertEqual(ext_net.id, subnet.network_id)
self.assertTrue(id_found)
def test_create_router_external_network(self):
"""
Test creation of a router connected to an external network and a
private network.
"""
network_settings = NetworkConfig(
name=self.guid + '-pub-net1',
subnet_settings=[
create_network.SubnetConfig(cidr=cidr1,
name=self.guid + '-pub-subnet1',
gateway_ip=static_gateway_ip1)
])
self.network_creator1 = OpenStackNetwork(self.os_creds,
network_settings)
self.network_creator1.create()
port_settings = [
create_network.PortConfig(
name=self.guid + '-port1',
ip_addrs=[{
'subnet_name': network_settings.subnet_settings[0].name,
'ip': static_gateway_ip1
}],
network_name=network_settings.name)
]
router_settings = RouterConfig(name=self.guid + '-pub-router',
external_gateway=self.ext_net_name,
port_settings=port_settings)
self.router_creator = create_router.OpenStackRouter(
self.os_creds, router_settings)
self.router_creator.create()
router = neutron_utils.get_router(
self.neutron,
self.keystone,
router_settings=router_settings,
project_name=self.os_creds.project_name)
self.assertEquals(router, self.router_creator.get_router())
self.check_router_recreation(router, router_settings)
def test_create_router_vanilla(self):
"""
Test creation of a most basic router with minimal options.
"""
router_settings = RouterConfig(name=self.guid + '-pub-router',
external_gateway=self.ext_net_name)
self.router_creator = create_router.OpenStackRouter(
self.os_creds, router_settings)
self.router_creator.create()
router = neutron_utils.get_router(
self.neutron,
self.keystone,
router_settings=router_settings,
project_name=self.os_creds.project_name)
self.assertIsNotNone(router)
self.assertEqual(self.router_creator.get_router(), router)
self.check_router_recreation(router, router_settings)
def test_create_router_admin_state_True(self):
"""
Test creation of a basic router with admin state Up.
"""
router_settings = RouterConfig(name=self.guid + '-pub-router',
admin_state_up=True)
self.router_creator = create_router.OpenStackRouter(
self.os_creds, router_settings)
self.router_creator.create()
router = neutron_utils.get_router(
self.neutron,
self.keystone,
router_settings=router_settings,
project_name=self.os_creds.project_name)
self.assertIsNotNone(router)
self.assertEqual(self.router_creator.get_router(), router)
self.check_router_recreation(router, router_settings)
def test_create_network_router_admin_user_to_new_project(self):
"""
Tests the creation of an OpenStack network to the the current using
the credentials to the admin project.
"""
# Create Network/Subnet where the project names have been changed
project_name = self.os_creds.project_name
config = self.net_config.network_settings
config.project_name = project_name
config.subnet_settings[0].project_name = project_name
self.net_creator = OpenStackNetwork(self.admin_os_creds, config)
self.net_creator.create()
retrieved_net = neutron_utils.get_network(
self.neutron, self.keystone,
network_name=self.net_config.network_settings.name,
project_name=self.os_creds.project_name)
self.assertEqual(self.net_creator.get_network().id, retrieved_net.id)
# Initialize with actual credentials
config.project_name = None
config.subnet_settings[0].project_name = None
proj_net_creator = OpenStackNetwork(self.os_creds, config)
proj_net = proj_net_creator.create()
self.assertEqual(retrieved_net, proj_net)
# Create Router
self.net_config.router_settings.project_name = project_name
self.router_creator = create_router.OpenStackRouter(
self.admin_os_creds, self.net_config.router_settings)
self.router_creator.create()
retrieved_router = neutron_utils.get_router(
self.neutron, self.keystone,
router_settings=self.router_creator.router_settings,
project_name=self.os_creds.project_name)
self.assertEqual(
self.router_creator.get_router().id, retrieved_router.id)
def test_create_router_new_user_as_admin_project(self):
"""
Test creation of a most basic router with the new user pointing
to the admin project.
"""
router_settings = RouterConfig(name=self.guid + '-pub-router',
external_gateway=self.ext_net_name,
project_name=self.os_creds.project_name)
self.router_creator = create_router.OpenStackRouter(
self.admin_os_creds, router_settings)
self.router_creator.create()
router = neutron_utils.get_router(
self.neutron,
self.keystone,
router_settings=router_settings,
project_name=self.os_creds.project_name)
self.assertIsNotNone(router)
self.assertEqual(self.router_creator.get_router().id, router.id)
self.check_router_recreation(router, router_settings)
def test_create_network_with_router(self):
"""
Tests the creation of an OpenStack network with a router.
"""
# Create Network
self.net_creator = OpenStackNetwork(
self.os_creds, self.net_config.network_settings)
network = self.net_creator.create()
# Create Router
self.router_creator = create_router.OpenStackRouter(
self.os_creds, self.net_config.router_settings)
self.router_creator.create()
# Validate network was created
self.assertTrue(neutron_utils_tests.validate_network(
self.neutron, self.keystone,
self.net_creator.network_settings.name, True,
self.os_creds.project_name, mtu=999))
# Validate subnets
self.assertTrue(neutron_utils_tests.validate_subnet(
self.neutron, network,
self.net_creator.network_settings.subnet_settings[0].name,
self.net_creator.network_settings.subnet_settings[0].cidr, True))
# Validate routers
neutron_utils_tests.validate_router(
self.neutron, self.keystone,
self.router_creator.router_settings.name,
self.os_creds.project_name, True)
neutron_utils_tests.validate_interface_router(
self.router_creator.get_internal_router_interface(),
self.router_creator.get_router(),
self.net_creator.get_network().subnets[0])
def test_create_with_internal_sub(self):
"""
Test internal_subnets works.
"""
network_settings1 = NetworkConfig(
name=self.guid + '-pub-net1',
subnet_settings=[
create_network.SubnetConfig(cidr=cidr1,
name=self.guid + '-pub-subnet1',
gateway_ip=static_gateway_ip1)
])
self.network_creator1 = OpenStackNetwork(self.os_creds,
network_settings1)
self.network_creator1.create()
self.router_settings = RouterConfig(
name=self.guid + '-pub-router',
external_gateway=self.ext_net_name,
internal_subnets=[network_settings1.subnet_settings[0].name])
self.router_creator = create_router.OpenStackRouter(
self.os_creds, self.router_settings)
created_router = self.router_creator.create()
self.assertIsNotNone(created_router)
def setUp(self):
"""
Instantiates the CreateImage object that is responsible for downloading
and creating an OS image file within OpenStack
"""
super(self.__class__, self).__start__()
self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.keypair_priv_filepath = 'tmp/' + guid
self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
self.keypair_name = guid + '-kp'
self.vm_inst_name = guid + '-inst'
self.test_file_local_path = 'tmp/' + guid + '-hello.txt'
self.port_1_name = guid + '-port-1'
self.port_2_name = guid + '-port-2'
self.floating_ip_name = guid + 'fip1'
# Setup members to cleanup just in case they don't get created
self.inst_creator = None
self.keypair_creator = None
self.sec_grp_creator = None
self.flavor_creator = None
self.router_creator = None
self.network_creator = None
self.image_creator = None
try:
# Create Image
os_image_settings = openstack_tests.ubuntu_image_settings(
name=guid + '-' + '-image', image_metadata=self.image_metadata)
self.image_creator = create_image.OpenStackImage(
self.os_creds, os_image_settings)
self.image_creator.create()
# First network is public
self.pub_net_config = openstack_tests.get_pub_net_config(
project_name=self.os_creds.project_name,
net_name=guid + '-pub-net',
mtu=1442,
subnet_name=guid + '-pub-subnet',
router_name=guid + '-pub-router',
external_net=self.ext_net_name)
self.network_creator = create_network.OpenStackNetwork(
self.os_creds, self.pub_net_config.network_settings)
self.network_creator.create()
# Create routers
self.router_creator = create_router.OpenStackRouter(
self.os_creds, self.pub_net_config.router_settings)
self.router_creator.create()
# Create Flavor
flavor_config = openstack_tests.get_flavor_config(
name=guid + '-flavor-name',
ram=2048,
disk=10,
vcpus=2,
metadata=self.flavor_metadata)
self.flavor_creator = create_flavor.OpenStackFlavor(
self.admin_os_creds, flavor_config)
self.flavor_creator.create()
# Create Key/Pair
self.keypair_creator = create_keypairs.OpenStackKeypair(
self.os_creds,
KeypairConfig(name=self.keypair_name,
public_filepath=self.keypair_pub_filepath,
private_filepath=self.keypair_priv_filepath))
self.keypair_creator.create()
# Create Security Group
sec_grp_name = guid + '-sec-grp'
rule1 = SecurityGroupRuleConfig(sec_grp_name=sec_grp_name,
direction=Direction.ingress,
protocol=Protocol.icmp)
rule2 = SecurityGroupRuleConfig(sec_grp_name=sec_grp_name,
direction=Direction.ingress,
protocol=Protocol.tcp,
port_range_min=22,
port_range_max=22)
self.sec_grp_creator = OpenStackSecurityGroup(
self.os_creds,
SecurityGroupConfig(name=sec_grp_name,
rule_settings=[rule1, rule2]))
self.sec_grp_creator.create()
# Create instance
ports_settings = list()
ports_settings.append(
PortConfig(
name=self.port_1_name,
network_name=self.pub_net_config.network_settings.name))
instance_settings = VmInstanceConfig(
name=self.vm_inst_name,
flavor=self.flavor_creator.flavor_settings.name,
port_settings=ports_settings,
floating_ip_settings=[
FloatingIpConfig(
name=self.floating_ip_name,
port_name=self.port_1_name,
router_name=self.pub_net_config.router_settings.name)
])
self.inst_creator = create_instance.OpenStackVmInstance(
self.os_creds,
instance_settings,
self.image_creator.image_settings,
keypair_settings=self.keypair_creator.keypair_settings)
except:
self.tearDown()
raise
def test_create_router_private_network(self):
"""
Test creation of a router connected with two private networks and no
external gateway
"""
network_settings1 = NetworkConfig(
name=self.guid + '-pub-net1',
subnet_settings=[
create_network.SubnetConfig(cidr=cidr1,
name=self.guid + '-pub-subnet1',
gateway_ip=static_gateway_ip1)
])
network_settings2 = NetworkConfig(
name=self.guid + '-pub-net2',
subnet_settings=[
create_network.SubnetConfig(cidr=cidr2,
name=self.guid + '-pub-subnet2',
gateway_ip=static_gateway_ip2)
])
self.network_creator1 = OpenStackNetwork(self.os_creds,
network_settings1)
self.network_creator2 = OpenStackNetwork(self.os_creds,
network_settings2)
self.network_creator1.create()
self.network_creator2.create()
port_settings = [
create_network.PortConfig(
name=self.guid + '-port1',
ip_addrs=[{
'subnet_name': network_settings1.subnet_settings[0].name,
'ip': static_gateway_ip1
}],
network_name=network_settings1.name),
create_network.PortConfig(
name=self.guid + '-port2',
ip_addrs=[{
'subnet_name': network_settings2.subnet_settings[0].name,
'ip': static_gateway_ip2
}],
network_name=network_settings2.name)
]
router_settings = RouterConfig(name=self.guid + '-pub-router',
port_settings=port_settings)
self.router_creator = create_router.OpenStackRouter(
self.os_creds, router_settings)
self.router_creator.create()
router = neutron_utils.get_router(
self.neutron,
self.keystone,
router_settings=router_settings,
project_name=self.os_creds.project_name)
self.assertEqual(router, self.router_creator.get_router())
# Instantiate second identical creator to ensure a second router
# has not been created
router_creator2 = create_router.OpenStackRouter(
self.os_creds, router_settings)
router2 = router_creator2.create()
self.assertIsNotNone(self.router_creator.get_router(), router2)
self.check_router_recreation(router2, router_settings)