def create_network(os_creds, network_settings, cleanup=False):
"""
Creates a network on which the CMTSs can attach
:param os_creds: The OpenStack credentials object
:param network_settings: The network settings object
:param cleanup: Denotes whether or not this is being called for cleanup
:return: A reference to the network creator objects for each network from
which network elements such as the subnet, router, interface
router, and network objects can be accessed.
"""
# Check for OS for network existence
# If exists return network instance data
# Else, create network and return instance data
logger.info('Attempting to create network with name - %s',
network_settings.name)
network_creator = OpenStackNetwork(os_creds, network_settings)
if cleanup:
network_creator.initialize()
else:
network_creator.create()
logger.info('Created network ')
return network_creator
def test_network_same_name_diff_proj(self):
"""
Tests the creation of an OpenStackNetwork with the same name
within a different project/tenant when not configured but implied by
the OSCreds.
"""
# Create Network
self.admin_net_creator = OpenStackNetwork(
self.admin_os_creds, self.net_config.network_settings)
self.admin_net_creator.create()
self.proj_net_creator = OpenStackNetwork(
self.os_creds, self.net_config.network_settings)
self.proj_net_creator.create()
self.assertNotEqual(
self.admin_net_creator.get_network().id,
self.proj_net_creator.get_network().id)
admin_creator2 = OpenStackNetwork(
self.admin_os_creds, self.net_config.network_settings)
admin_creator2.create()
self.assertEqual(
self.admin_net_creator.get_network(), admin_creator2.get_network())
proj_creator2 = OpenStackNetwork(
self.os_creds, self.net_config.network_settings)
proj_creator2.create()
self.assertEqual(self.proj_net_creator.get_network(),
proj_creator2.get_network())
def test_derive_net_settings_no_subnet(self):
"""
Validates the utility function settings_utils#create_network_config
returns an acceptable NetworkConfig object and ensures that the
new settings object will not cause the new OpenStackNetwork instance
to create another network
"""
net_settings = NetworkConfig(name=self.network_name)
self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
network = self.net_creator.create()
derived_settings = settings_utils.create_network_config(
self.neutron, network)
self.assertIsNotNone(derived_settings)
self.assertEqual(net_settings.name, derived_settings.name)
self.assertEqual(net_settings.admin_state_up,
derived_settings.admin_state_up)
self.assertEqual(net_settings.external, derived_settings.external)
self.assertEqual(len(net_settings.subnet_settings),
len(derived_settings.subnet_settings))
net_creator = OpenStackNetwork(self.os_creds, derived_settings)
derived_network = net_creator.create()
self.assertEqual(network, derived_network)
def prepare_network(self):
"""Create network/subnet/router if they doen't exist yet"""
self.logger.info(
"Creating network/subnet/router if they doen't exist yet...")
subnet_settings = SubnetSettings(name='%s_subnet' % self.case_name,
cidr="192.168.100.0/24")
network_settings = NetworkSettings(name='%s_net' % self.case_name,
subnet_settings=[subnet_settings])
orchestra_network = OpenStackNetwork(self.snaps_creds,
network_settings)
orchestra_network_info = orchestra_network.create()
self.mano['details']['network'] = {}
self.mano['details']['network']['id'] = orchestra_network_info.id
self.mano['details']['network']['name'] = orchestra_network_info.name
self.mano['details']['external_net_name'] = snaps_utils.\
get_ext_net_name(self.snaps_creds)
self.created_resources.append(orchestra_network)
orchestra_router = OpenStackRouter(
self.snaps_creds,
RouterSettings(
name='%s_router' % self.case_name,
external_gateway=self.mano['details']['external_net_name'],
internal_subnets=[subnet_settings.name]))
orchestra_router.create()
self.created_resources.append(orchestra_router)
self.logger.info("Created network and router for Open Baton NFVO...")
def create_network_infrastructure(self, net_name, subnet_name, subnet_cidr,
router_name):
logger.info("Creating networks...")
# Network and subnet
subnet_settings = SubnetConfig(name=subnet_name, cidr=subnet_cidr)
network_settings = NetworkConfig(name=net_name,
subnet_settings=[subnet_settings])
network_creator = OpenStackNetwork(self.os_creds, network_settings)
network = network_creator.create()
self.creators.append(network_creator)
# Router
logger.info("Creating the router...")
ext_network_name = env.get('EXTERNAL_NETWORK')
router_settings = RouterConfig(name=router_name,
external_gateway=ext_network_name,
internal_subnets=[subnet_name])
router_creator = OpenStackRouter(self.os_creds, router_settings)
router = router_creator.create()
self.creators.append(router_creator)
return network, router
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)
class CreateRouterSecurityGroupTests(OSIntegrationTestCase):
"""
Class for testing routers with ports containing security groups
"""
def setUp(self):
"""
Initializes objects used for router testing
"""
super(self.__class__, self).__start__()
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.router_creator = None
self.network_creator = None
self.sec_grp_creator = OpenStackSecurityGroup(
self.os_creds, SecurityGroupConfig(name=self.guid + '-sec_grp'))
self.sec_grp_creator.create()
self.neutron = neutron_utils.neutron_client(self.os_creds,
self.os_session)
def tearDown(self):
"""
Cleans the remote OpenStack objects used for router testing
"""
if self.router_creator:
self.router_creator.clean()
if self.network_creator:
self.network_creator.clean()
if self.sec_grp_creator:
self.sec_grp_creator.clean()
super(self.__class__, self).__clean__()
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()
class CreateMultipleRouterTests(OSIntegrationTestCase):
"""
Test for the OpenStackRouter class and how it interacts with routers
groups within other projects with the same name
"""
def setUp(self):
"""
Initializes objects used for router testing
"""
super(self.__class__, self).__start__()
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.admin_router_creator = None
self.proj_router_creator = None
self.neutron = neutron_utils.neutron_client(self.os_creds,
self.os_session)
network_settings = NetworkConfig(
name=self.guid + '-pub-net',
shared=True,
subnet_settings=[
create_network.SubnetConfig(cidr=cidr1,
name=self.guid + '-pub-subnet',
gateway_ip=static_gateway_ip1)
])
self.network_creator = OpenStackNetwork(self.admin_os_creds,
network_settings)
self.network_creator.create()
def tearDown(self):
"""
Cleans the remote OpenStack objects used for router testing
"""
if self.admin_router_creator:
self.admin_router_creator.clean()
if self.proj_router_creator:
self.proj_router_creator.clean()
if self.network_creator:
self.network_creator.clean()
super(self.__class__, self).__clean__()
def test_router_same_name_diff_proj(self):
"""
Tests the creation of an OpenStackNetwork with the same name
within a different project/tenant when not configured but implied by
the OSCreds.
"""
# Create Router
router_config = RouterConfig(name=self.guid + '-router')
self.admin_router_creator = OpenStackRouter(self.admin_os_creds,
router_config)
self.admin_router_creator.create()
self.proj_router_creator = OpenStackRouter(self.os_creds,
router_config)
self.proj_router_creator.create()
self.assertNotEqual(self.admin_router_creator.get_router().id,
self.proj_router_creator.get_router().id)
admin_creator2 = OpenStackRouter(self.admin_os_creds, router_config)
admin_creator2.create()
self.assertEqual(self.admin_router_creator.get_router(),
admin_creator2.get_router())
proj_creator2 = OpenStackRouter(self.os_creds, router_config)
proj_creator2.create()
self.assertEqual(self.proj_router_creator.get_router(),
proj_creator2.get_router())
def test_router_create_by_admin_to_different_project(self):
"""
Tests the creation of an OpenStackRouter by the admin user and
initialize again with tenant credentials.
"""
# Create Network
admin_router_config = RouterConfig(
name=self.guid + '-router',
project_name=self.os_creds.project_name)
self.admin_router_creator = OpenStackRouter(self.admin_os_creds,
admin_router_config)
self.admin_router_creator.create()
proj_router_config = RouterConfig(
name=self.guid + '-router',
project_name=self.os_creds.project_name)
self.proj_router_creator = OpenStackRouter(self.os_creds,
proj_router_config)
self.proj_router_creator.create()
self.assertEqual(self.admin_router_creator.get_router().id,
self.proj_router_creator.get_router().id)
class CreateRouterNegativeTests(OSIntegrationTestCase):
"""
Class for testing routers with various negative scenarios expected to fail.
"""
def setUp(self):
"""
Initializes objects used for router testing
"""
super(self.__class__, self).__start__()
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.network_creator = None
self.router_creator = None
def tearDown(self):
"""
Cleans the remote OpenStack objects used for router testing
"""
if self.router_creator:
self.router_creator.clean()
if self.network_creator:
self.network_creator.clean()
super(self.__class__, self).__clean__()
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_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_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()
class CreateRouterSuccessTests(OSIntegrationTestCase):
"""
Class for testing routers with various positive scenarios expected to
succeed
"""
def setUp(self):
"""
Initializes objects used for router testing
"""
super(self.__class__, self).__start__()
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.router_creator = None
self.network_creator1 = None
self.network_creator2 = None
self.neutron = neutron_utils.neutron_client(self.os_creds,
self.os_session)
def tearDown(self):
"""
Cleans the remote OpenStack objects used for router testing
"""
if self.router_creator:
self.router_creator.clean()
if self.network_creator1:
self.network_creator1.clean()
if self.network_creator2:
self.network_creator2.clean()
super(self.__class__, self).__clean__()
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_user_to_new_project(self):
"""
Test creation of a most basic router with the admin user pointing
to the new 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_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_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_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 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_router_admin_state_false(self):
"""
Test creation of a basic router with admin state down.
"""
router_settings = RouterConfig(name=self.guid + '-pub-router',
admin_state_up=False)
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_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)
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_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 check_router_recreation(self, router, orig_settings):
"""
Validates the derived RouterConfig with the original
:param router: the Router domain object to test
:param orig_settings: the original RouterConfig object that was
responsible for creating the router
:return: the derived RouterConfig object
"""
derived_settings = settings_utils.create_router_config(
self.neutron, router)
self.assertIsNotNone(derived_settings)
self.assertEqual(orig_settings.enable_snat,
derived_settings.enable_snat)
self.assertEqual(orig_settings.external_gateway,
derived_settings.external_gateway)
self.assertEqual(orig_settings.name, derived_settings.name)
self.assertEqual(orig_settings.internal_subnets,
derived_settings.internal_subnets)
if orig_settings.external_gateway:
self.assertEqual(len(orig_settings.port_settings),
len(derived_settings.port_settings))
else:
self.assertEqual(len(orig_settings.port_settings),
len(derived_settings.port_settings))
if len(orig_settings.port_settings) > 0:
self.assertEqual(orig_settings.port_settings[0].name,
derived_settings.port_settings[0].name)
if len(orig_settings.port_settings) > 1:
self.assertEqual(orig_settings.port_settings[1].name,
derived_settings.port_settings[1].name)
return derived_settings
def deploy_orchestrator(self): # pylint: disable=too-many-locals
"""
Create network, subnet, router
Bootstrap juju
"""
self.__logger.info("Deployed Orchestrator")
private_net_name = getattr(
config.CONF, 'vnf_{}_private_net_name'.format(self.case_name))
private_subnet_name = '{}-{}'.format(
getattr(config.CONF,
'vnf_{}_private_subnet_name'.format(self.case_name)),
self.uuid)
private_subnet_cidr = getattr(
config.CONF, 'vnf_{}_private_subnet_cidr'.format(self.case_name))
abot_router = '{}-{}'.format(
getattr(config.CONF,
'vnf_{}_external_router'.format(self.case_name)),
self.uuid)
self.__logger.info("Creating full network ...")
subnet_settings = SubnetConfig(name=private_subnet_name,
cidr=private_subnet_cidr,
dns_nameservers=[env.get('NAMESERVER')])
network_settings = NetworkConfig(name=private_net_name,
subnet_settings=[subnet_settings])
network_creator = OpenStackNetwork(self.snaps_creds, network_settings)
net_id = network_creator.create().id
self.created_object.append(network_creator)
ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds)
self.__logger.info("Creating network Router ....")
router_creator = OpenStackRouter(
self.snaps_creds,
RouterConfig(name=abot_router,
external_gateway=ext_net_name,
internal_subnets=[subnet_settings.name]))
router_creator.create()
self.created_object.append(router_creator)
self.__logger.info("Creating Flavor ....")
flavor_settings = FlavorConfig(
name=self.orchestrator['requirements']['flavor']['name'],
ram=self.orchestrator['requirements']['flavor']['ram_min'],
disk=10,
vcpus=1)
flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
flavor_creator.create()
self.created_object.append(flavor_creator)
self.__logger.info("Upload some OS images if it doesn't exist")
images = get_config("tenant_images", self.config_file)
self.__logger.info("Images needed for vEPC: %s", images)
for image_name, image_file in images.iteritems():
self.__logger.info("image: %s, file: %s", image_name, image_file)
if image_file and image_name:
image_creator = OpenStackImage(
self.snaps_creds,
ImageConfig(name=image_name,
image_user='******',
img_format='qcow2',
image_file=image_file))
image_id = image_creator.create().id
cmd = [
'timeout', '-t', JujuEpc.juju_timeout, 'juju', 'metadata',
'generate-image', '-d', '/root', '-i', image_id, '-s',
image_name, '-r', self.snaps_creds.region_name, '-u',
self.public_auth_url
]
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
self.__logger.info("%s\n%s", " ".join(cmd), output)
self.created_object.append(image_creator)
self.__logger.info("Network ID : %s", net_id)
cmd = [
'timeout', '-t', JujuEpc.juju_timeout, 'juju', 'bootstrap',
'abot-epc', 'abot-controller', '--metadata-source', '/root',
'--constraints', 'mem=2G', '--bootstrap-series', 'xenial',
'--config', 'network={}'.format(net_id), '--config',
'ssl-hostname-verification=false', '--config',
'use-floating-ip=true', '--config', 'use-default-secgroup=true',
'--debug'
]
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
self.__logger.info("%s\n%s", " ".join(cmd), output)
return True
class NovaUtilsInstanceTests(OSComponentTestCase):
"""
Tests the creation of VM instances via nova_utils.py
"""
def setUp(self):
"""
Setup objects required by VM instances
:return:
"""
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.nova = nova_utils.nova_client(
self.os_creds, self.os_session)
self.keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
self.neutron = neutron_utils.neutron_client(
self.os_creds, self.os_session)
self.glance = glance_utils.glance_client(
self.os_creds, self.os_session)
self.image_creator = None
self.network_creator = None
self.flavor_creator = None
self.port = None
self.vm_inst = None
try:
image_settings = openstack_tests.cirros_image_settings(
name=guid + '-image', image_metadata=self.image_metadata)
self.image_creator = OpenStackImage(
self.os_creds, image_settings=image_settings)
self.image_creator.create()
network_settings = openstack_tests.get_priv_net_config(
project_name=self.os_creds.project_name,
net_name="{}-{}".format(guid, 'net'),
subnet_name="{}-{}".format(guid, 'subnet')).network_settings
self.network_creator = OpenStackNetwork(
self.os_creds, network_settings)
self.network_creator.create()
flavor_config = openstack_tests.get_flavor_config(
name="{}-{}".format(guid, 'flavor-name'), ram=256, disk=10,
vcpus=1, metadata=self.flavor_metadata)
self.flavor_creator = OpenStackFlavor(self.os_creds, flavor_config)
self.flavor_creator.create()
port_settings = PortConfig(
name=guid + '-port', network_name=network_settings.name)
self.port = neutron_utils.create_port(
self.neutron, self.os_creds, port_settings)
self.instance_settings = VmInstanceConfig(
name=guid + '-vm_inst',
flavor=self.flavor_creator.flavor_settings.name,
port_settings=[port_settings])
except:
self.tearDown()
raise
def tearDown(self):
"""
Cleanup deployed resources
:return:
"""
if self.vm_inst:
try:
nova_utils.delete_vm_instance(self.nova, self.vm_inst)
except:
pass
if self.port:
try:
neutron_utils.delete_port(self.neutron, self.port)
except:
pass
if self.flavor_creator:
try:
self.flavor_creator.clean()
except:
pass
if self.network_creator:
try:
self.network_creator.clean()
except:
pass
if self.image_creator:
try:
self.image_creator.clean()
except:
pass
super(self.__class__, self).__clean__()
def test_create_instance(self):
"""
Tests the nova_utils.create_server() method
:return:
"""
self.vm_inst = nova_utils.create_server(
self.nova, self.keystone, self.neutron, self.glance,
self.instance_settings, self.image_creator.image_settings,
self.os_creds.project_name)
self.assertIsNotNone(self.vm_inst)
# Wait until instance is ACTIVE
iters = 0
active = False
status = None
while iters < 60:
status = nova_utils.get_server_status(self.nova, self.vm_inst)
if create_instance.STATUS_ACTIVE == status:
active = True
break
time.sleep(3)
iters += 1
self.assertTrue(active, msg='VM {} status {} is not {}'.format(
self.vm_inst.name, status, create_instance.STATUS_ACTIVE))
vm_inst = nova_utils.get_latest_server_object(
self.nova, self.neutron, self.keystone, self.vm_inst,
self.os_creds.project_name)
self.assertEqual(self.vm_inst.name, vm_inst.name)
self.assertEqual(self.vm_inst.id, vm_inst.id)
def deploy_orchestrator(self):
"""
Deploy Cloudify Manager.
network, security group, fip, VM creation
"""
# network creation
start_time = time.time()
self.__logger.info("Creating keypair ...")
kp_file = os.path.join(self.data_dir, "cloudify_vrouter.pem")
keypair_settings = KeypairSettings(name='cloudify_vrouter_kp',
private_filepath=kp_file)
keypair_creator = OpenStackKeypair(self.snaps_creds, keypair_settings)
keypair_creator.create()
self.created_object.append(keypair_creator)
self.__logger.info("Creating full network ...")
subnet_settings = SubnetSettings(name='cloudify_vrouter_subnet',
cidr='10.67.79.0/24')
network_settings = NetworkSettings(name='cloudify_vrouter_network',
subnet_settings=[subnet_settings])
network_creator = OpenStackNetwork(self.snaps_creds, network_settings)
network_creator.create()
self.created_object.append(network_creator)
ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds)
router_creator = OpenStackRouter(
self.snaps_creds,
RouterSettings(name='cloudify_vrouter_router',
external_gateway=ext_net_name,
internal_subnets=[subnet_settings.name]))
router_creator.create()
self.created_object.append(router_creator)
# security group creation
self.__logger.info("Creating security group for cloudify manager vm")
sg_rules = list()
sg_rules.append(
SecurityGroupRuleSettings(sec_grp_name="sg-cloudify-manager",
direction=Direction.ingress,
protocol=Protocol.tcp,
port_range_min=1,
port_range_max=65535))
sg_rules.append(
SecurityGroupRuleSettings(sec_grp_name="sg-cloudify-manager",
direction=Direction.ingress,
protocol=Protocol.udp,
port_range_min=1,
port_range_max=65535))
security_group_creator = OpenStackSecurityGroup(
self.snaps_creds,
SecurityGroupSettings(name="sg-cloudify-manager",
rule_settings=sg_rules))
security_group_creator.create()
self.created_object.append(security_group_creator)
# orchestrator VM flavor
self.__logger.info("Get or create flavor for cloudify manager vm ...")
flavor_settings = FlavorSettings(
name=self.orchestrator['requirements']['flavor']['name'],
ram=self.orchestrator['requirements']['flavor']['ram_min'],
disk=50,
vcpus=2)
flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
flavor_creator.create()
self.created_object.append(flavor_creator)
image_settings = ImageSettings(
name=self.orchestrator['requirements']['os_image'],
image_user='******',
exists=True)
port_settings = PortSettings(name='cloudify_manager_port',
network_name=network_settings.name)
manager_settings = VmInstanceSettings(
name='cloudify_manager',
flavor=flavor_settings.name,
port_settings=[port_settings],
security_group_names=[
security_group_creator.sec_grp_settings.name
],
floating_ip_settings=[
FloatingIpSettings(
name='cloudify_manager_fip',
port_name=port_settings.name,
router_name=router_creator.router_settings.name)
])
manager_creator = OpenStackVmInstance(self.snaps_creds,
manager_settings, image_settings,
keypair_settings)
self.__logger.info("Creating cloudify manager VM")
manager_creator.create()
self.created_object.append(manager_creator)
public_auth_url = os_utils.get_endpoint('identity')
self.__logger.info("Set creds for cloudify manager")
cfy_creds = dict(keystone_username=self.tenant_name,
keystone_password=self.tenant_name,
keystone_tenant_name=self.tenant_name,
keystone_url=public_auth_url)
cfy_client = CloudifyClient(host=manager_creator.get_floating_ip().ip,
username='******',
password='******',
tenant='default_tenant')
self.orchestrator['object'] = cfy_client
self.cfy_manager_ip = manager_creator.get_floating_ip().ip
self.__logger.info("Attemps running status of the Manager")
cfy_status = None
retry = 10
while str(cfy_status) != 'running' and retry:
try:
cfy_status = cfy_client.manager.get_status()['status']
self.__logger.debug("The current manager status is %s",
cfy_status)
except Exception: # pylint: disable=broad-except
self.__logger.warning("Cloudify Manager isn't " +
"up and running. Retrying ...")
retry = retry - 1
time.sleep(30)
if str(cfy_status) == 'running':
self.__logger.info("Cloudify Manager is up and running")
else:
raise Exception("Cloudify Manager isn't up and running")
self.__logger.info("Put OpenStack creds in manager")
secrets_list = cfy_client.secrets.list()
for k, val in cfy_creds.iteritems():
if not any(d.get('key', None) == k for d in secrets_list):
cfy_client.secrets.create(k, val)
else:
cfy_client.secrets.update(k, val)
duration = time.time() - start_time
self.__logger.info("Put private keypair in manager")
if manager_creator.vm_ssh_active(block=True):
ssh = manager_creator.ssh_client()
scp = SCPClient(ssh.get_transport(), socket_timeout=15.0)
scp.put(kp_file, '~/')
cmd = "sudo cp ~/cloudify_vrouter.pem /etc/cloudify/"
run_blocking_ssh_command(ssh, cmd)
cmd = "sudo chmod 444 /etc/cloudify/cloudify_vrouter.pem"
run_blocking_ssh_command(ssh, cmd)
cmd = "sudo yum install -y gcc python-devel"
run_blocking_ssh_command(ssh, cmd,
"Unable to install packages on manager")
self.details['orchestrator'].update(status='PASS', duration=duration)
self.vnf['inputs'].update(dict(external_network_name=ext_net_name))
return True
def test_vnf(self):
"""Run IXIA Stress test on clearwater ims instance."""
start_time = time.time()
cfy_client = self.orchestrator['object']
outputs = cfy_client.deployments.outputs.get(
self.vnf['descriptor'].get('name'))['outputs']
dns_ip = outputs['dns_ip']
ellis_ip = outputs['ellis_ip']
self.__logger.info("Creating full IXIA network ...")
subnet_settings = SubnetConfig(name='ixia_management_subnet',
cidr='10.10.10.0/24',
dns_nameservers=[env.get('NAMESERVER')])
network_settings = NetworkConfig(name='ixia_management_network',
subnet_settings=[subnet_settings])
network_creator = OpenStackNetwork(self.snaps_creds, network_settings)
network_creator.create()
self.created_object.append(network_creator)
ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds)
router_creator = OpenStackRouter(
self.snaps_creds,
RouterConfig(name='ixia_management_router',
external_gateway=ext_net_name,
internal_subnets=[subnet_settings.name]))
router_creator.create()
self.created_object.append(router_creator)
# security group creation
self.__logger.info("Creating security groups for IXIA VMs")
sg_rules = list()
sg_rules.append(
SecurityGroupRuleConfig(sec_grp_name="ixia_management",
direction=Direction.ingress,
protocol=Protocol.tcp,
port_range_min=1,
port_range_max=65535))
sg_rules.append(
SecurityGroupRuleConfig(sec_grp_name="ixia_management",
direction=Direction.ingress,
protocol=Protocol.udp,
port_range_min=1,
port_range_max=65535))
sg_rules.append(
SecurityGroupRuleConfig(sec_grp_name="ixia_management",
direction=Direction.ingress,
protocol=Protocol.icmp))
ixia_managment_sg_settings = SecurityGroupConfig(
name="ixia_management", rule_settings=sg_rules)
securit_group_creator = OpenStackSecurityGroup(
self.snaps_creds, ixia_managment_sg_settings)
securit_group_creator.create()
self.created_object.append(securit_group_creator)
sg_rules = list()
sg_rules.append(
SecurityGroupRuleConfig(sec_grp_name="ixia_ssh_http",
direction=Direction.ingress,
protocol=Protocol.tcp,
port_range_min=1,
port_range_max=65535))
ixia_ssh_http_sg_settings = SecurityGroupConfig(name="ixia_ssh_http",
rule_settings=sg_rules)
securit_group_creator = OpenStackSecurityGroup(
self.snaps_creds, ixia_ssh_http_sg_settings)
securit_group_creator.create()
self.created_object.append(securit_group_creator)
chassis_flavor_settings = FlavorConfig(name="ixia_vChassis",
ram=4096,
disk=40,
vcpus=2)
flavor_creator = OpenStackFlavor(self.snaps_creds,
chassis_flavor_settings)
flavor_creator.create()
self.created_object.append(flavor_creator)
card_flavor_settings = FlavorConfig(name="ixia_vCard",
ram=4096,
disk=4,
vcpus=2)
flavor_creator = OpenStackFlavor(self.snaps_creds,
card_flavor_settings)
flavor_creator.create()
self.created_object.append(flavor_creator)
load_flavor_settings = FlavorConfig(name="ixia_vLoad",
ram=8192,
disk=100,
vcpus=4)
flavor_creator = OpenStackFlavor(self.snaps_creds,
load_flavor_settings)
flavor_creator.create()
self.created_object.append(flavor_creator)
chassis_image_settings = ImageConfig(
name=self.test['requirements']['chassis']['image'],
image_user='******',
exists=True)
card_image_settings = ImageConfig(
name=self.test['requirements']['card']['image'],
image_user='******',
exists=True)
load_image_settings = ImageConfig(
name=self.test['requirements']['load']['image'],
image_user='******',
exists=True)
chassis_port_settings = PortConfig(name='ixia_chassis_port',
network_name=network_settings.name)
card1_port1_settings = PortConfig(name='ixia_card1_port1',
network_name=network_settings.name)
card2_port1_settings = PortConfig(name='ixia_card2_port1',
network_name=network_settings.name)
card1_port2_settings = PortConfig(name='ixia_card1_port2',
network_name="cloudify_ims_network")
card2_port2_settings = PortConfig(name='ixia_card2_port2',
network_name="cloudify_ims_network")
load_port_settings = PortConfig(name='ixia_load_port',
network_name=network_settings.name)
chassis_settings = VmInstanceConfig(
name='ixia_vChassis',
flavor=chassis_flavor_settings.name,
port_settings=[chassis_port_settings],
security_group_names=[
ixia_ssh_http_sg_settings.name, ixia_managment_sg_settings.name
],
floating_ip_settings=[
FloatingIpConfig(
name='ixia_vChassis_fip',
port_name=chassis_port_settings.name,
router_name=router_creator.router_settings.name)
])
vm_creator = OpenStackVmInstance(self.snaps_creds, chassis_settings,
chassis_image_settings)
self.__logger.info("Creating Ixia vChassis VM")
vm_creator.create()
fip_chassis = vm_creator.get_floating_ip().ip
self.created_object.append(vm_creator)
card1_settings = VmInstanceConfig(
name='ixia_vCard1',
flavor=card_flavor_settings.name,
port_settings=[card1_port1_settings, card1_port2_settings],
security_group_names=[ixia_managment_sg_settings.name])
vm_creator = OpenStackVmInstance(self.snaps_creds, card1_settings,
card_image_settings)
self.__logger.info("Creating Ixia vCard1 VM")
vm_creator.create()
vcard_ips = list()
vcard_ips_p2 = list()
vcard_ips.append(vm_creator.get_port_ip('ixia_card1_port1'))
vcard_ips_p2.append(vm_creator.get_port_ip('ixia_card1_port2'))
self.created_object.append(vm_creator)
card2_settings = VmInstanceConfig(
name='ixia_vCard2',
flavor=card_flavor_settings.name,
port_settings=[card2_port1_settings, card2_port2_settings],
security_group_names=[ixia_managment_sg_settings.name])
vm_creator = OpenStackVmInstance(self.snaps_creds, card2_settings,
card_image_settings)
self.__logger.info("Creating Ixia vCard2 VM")
vm_creator.create()
vcard_ips.append(vm_creator.get_port_ip('ixia_card2_port1'))
vcard_ips_p2.append(vm_creator.get_port_ip('ixia_card2_port2'))
self.created_object.append(vm_creator)
load_settings = VmInstanceConfig(
name='ixia_vLoad',
flavor=load_flavor_settings.name,
port_settings=[load_port_settings],
security_group_names=[
ixia_ssh_http_sg_settings.name, ixia_managment_sg_settings.name
],
floating_ip_settings=[
FloatingIpConfig(
name='ixia_vLoad_fip',
port_name=load_port_settings.name,
router_name=router_creator.router_settings.name)
])
vm_creator = OpenStackVmInstance(self.snaps_creds, load_settings,
load_image_settings)
self.__logger.info("Creating Ixia vLoad VM")
vm_creator.create()
fip_load = vm_creator.get_floating_ip().ip
self.created_object.append(vm_creator)
self.__logger.info("Chassis IP is: %s", fip_chassis)
login_url = "https://" + str(fip_chassis) + "/api/v1/auth/session"
cards_url = "https://" + str(fip_chassis) + "/api/v2/ixos/cards/"
payload = json.dumps({
"username": "******",
"password": "******",
"rememberMe": "false"
})
api_key = json.loads(
(IxChassisUtils.ChassisRestAPI.postWithPayload(login_url,
payload)))["apiKey"]
self.__logger.info("Adding 2 card back inside the ixia chassis...")
for ip in vcard_ips:
payload = {"ipAddress": str(ip)}
response = json.loads(
IxChassisUtils.ChassisRestAPI.postOperation(
cards_url, api_key, payload))
count = 0
while (int(
IxChassisUtils.ChassisRestAPI.getWithHeaders(
response['url'], api_key)['progress']) != 100):
self.__logger.debug("Operation did not finish yet. \
Waiting for 1 more second..")
time.sleep(1)
if count > 60:
raise Exception("Adding card take more than 60 seconds")
count += 1
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy())
ssh.connect(fip_chassis, username="******", password="******")
cmd = "set license-check disable"
run_blocking_ssh_command(ssh, cmd)
cmd = "restart-service ixServer"
run_blocking_ssh_command(ssh, cmd)
self.config_ellis(ellis_ip)
# Get IPs of P-CSCF
resolver = dns.resolver.Resolver()
resolver.nameservers = [dns_ip]
result = resolver.query("bono.clearwater.local")
iplistims = ''
i = 0
for rdata in result:
i = i + 1
print rdata.address
iplistims += str(rdata.address)
if i != len(result):
iplistims += ';'
kResourcesUrl = 'http://%s:%s/api/v0/resources' % (fip_load, 8080)
kRxfPath = r"REG_CALL_OPNFV_v13.rxf"
test_filname = self.test['inputs']['test_filname']
kGatewaySharedFolder = '/mnt/ixload-share/'
kRxfRelativeUploadPath = 'uploads/%s' % os.path.split(kRxfPath)[1]
kRxfAbsoluteUploadPath = os.path.join(kGatewaySharedFolder,
kRxfRelativeUploadPath)
kChassisList = [str(fip_chassis)]
dataFileNameList = [
test_filname, 'Registration_only_LPS.tst', 'SIPCall.tst'
]
kPortListPerCommunityCommunity = {
"VoIP1@VM1": [(1, 1, 1)],
"VoIP2@VM2": [(1, 2, 1)]
}
kStatsToDisplayDict = self.test['inputs']['stats']
connection = IxRestUtils.getConnection(fip_load, 8080)
self.__logger.info("Creating a new session...")
sessionUrl = IxLoadUtils.createSession(connection,
self.test['version'])
license_server = self.test['inputs']['licenseServer']
IxLoadUtils.configureLicenseServer(connection, sessionUrl,
license_server)
files_dir = os.path.join(self.case_dir, 'ixia/files')
target_file = open(os.path.join(files_dir, test_filname), 'w')
j2_env = Environment(loader=FileSystemLoader(files_dir),
trim_blocks=True)
self.test['inputs'].update(
dict(ipchassis=fip_chassis,
ipcard1=vcard_ips_p2[0],
ipcard2=vcard_ips_p2[1],
iplistims=iplistims))
target_file.write(
j2_env.get_template(test_filname + '.template').render(
self.test['inputs']))
target_file.close()
self.__logger.info('Uploading files %s...' % kRxfPath)
for dataFile in dataFileNameList:
localFilePath = os.path.join(files_dir, dataFile)
remoteFilePath = os.path.join(kGatewaySharedFolder,
'uploads/%s' % dataFile)
IxLoadUtils.uploadFile(connection, kResourcesUrl, localFilePath,
remoteFilePath)
self.__logger.info('Upload file finished.')
self.__logger.info("Loading repository %s..." % kRxfAbsoluteUploadPath)
IxLoadUtils.loadRepository(connection, sessionUrl,
kRxfAbsoluteUploadPath)
self.__logger.info("Clearing chassis list...")
IxLoadUtils.clearChassisList(connection, sessionUrl)
self.__logger.info("Adding chassis %s..." % (kChassisList))
IxLoadUtils.addChassisList(connection, sessionUrl, kChassisList)
self.__logger.info("Assigning new ports...")
IxLoadUtils.assignPorts(connection, sessionUrl,
kPortListPerCommunityCommunity)
self.__logger.info("Starting the test...")
IxLoadUtils.runTest(connection, sessionUrl)
self.__logger.info("Polling values for stats %s..." %
(kStatsToDisplayDict))
result = IxLoadUtils.pollStats(connection, sessionUrl,
kStatsToDisplayDict)
self.__logger.info("Test finished.")
self.__logger.info("Checking test status...")
testRunError = IxLoadUtils.getTestRunError(connection, sessionUrl)
self.__logger.info(result)
duration = time.time() - start_time
self.details['test_vnf'].update(status='PASS',
result=result,
duration=duration)
if testRunError:
self.__logger.info("The test exited with following error: %s" %
(testRunError))
self.details['test_vnf'].update(status='FAIL', duration=duration)
return False
else:
self.__logger.info("The test completed successfully.")
self.details['test_vnf'].update(status='PASS', duration=duration)
self.result += 1 / 3 * 100
return True
class CreateMultipleNetworkTests(OSIntegrationTestCase):
"""
Test for the CreateNetwork class and how it interacts with networks
groups within other projects with the same name
"""
def setUp(self):
"""
Sets up object for test
"""
super(self.__class__, self).__start__()
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.net_config = openstack_tests.get_pub_net_config(
project_name=self.os_creds.project_name,
net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet')
self.neutron = neutron_utils.neutron_client(
self.os_creds, self.os_session)
# Initialize for cleanup
self.admin_net_creator = None
self.proj_net_creator = None
def tearDown(self):
"""
Cleans the network
"""
if self.admin_net_creator:
self.admin_net_creator.clean()
if self.proj_net_creator:
self.proj_net_creator.clean()
super(self.__class__, self).__clean__()
def test_network_same_name_diff_proj(self):
"""
Tests the creation of an OpenStackNetwork with the same name
within a different project/tenant when not configured but implied by
the OSCreds.
"""
# Create Network
self.admin_net_creator = OpenStackNetwork(
self.admin_os_creds, self.net_config.network_settings)
self.admin_net_creator.create()
self.proj_net_creator = OpenStackNetwork(
self.os_creds, self.net_config.network_settings)
self.proj_net_creator.create()
self.assertNotEqual(
self.admin_net_creator.get_network().id,
self.proj_net_creator.get_network().id)
admin_creator2 = OpenStackNetwork(
self.admin_os_creds, self.net_config.network_settings)
admin_creator2.create()
self.assertEqual(
self.admin_net_creator.get_network(), admin_creator2.get_network())
proj_creator2 = OpenStackNetwork(
self.os_creds, self.net_config.network_settings)
proj_creator2.create()
self.assertEqual(self.proj_net_creator.get_network(),
proj_creator2.get_network())
def test_network_create_by_admin_to_different_project(self):
"""
Tests the creation of an OpenStackNetwork by the admin user and
initialize again with tenant credentials.
"""
# Create Network
net_settings = self.net_config.network_settings
net_settings.project_name = self.os_creds.project_name
self.admin_net_creator = OpenStackNetwork(
self.admin_os_creds, net_settings)
self.admin_net_creator.create()
self.proj_net_creator = OpenStackNetwork(
self.os_creds, self.net_config.network_settings)
self.proj_net_creator.create()
self.assertEqual(
self.admin_net_creator.get_network().id,
self.proj_net_creator.get_network().id)
class CreateNetworkTypeTests(OSComponentTestCase):
"""
Test for the CreateNetwork class defined in create_nework.py for testing
creating networks of different types
"""
def setUp(self):
"""
Sets up object for test
"""
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.net_config = openstack_tests.get_pub_net_config(
project_name=self.os_creds.project_name,
net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet')
self.neutron = neutron_utils.neutron_client(
self.os_creds, self.os_session)
self.keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
# Initialize for cleanup
self.net_creator = None
def tearDown(self):
"""
Cleans the network
"""
if self.net_creator:
self.net_creator.clean()
super(self.__class__, self).__clean__()
def test_create_network_type_vlan(self):
"""
Tests the creation of an OpenStack network of type vlan.
"""
# Create Network
network_type = 'vlan'
net_settings = NetworkConfig(
name=self.net_config.network_settings.name,
subnet_settings=self.net_config.network_settings.subnet_settings,
network_type=network_type)
# When setting the network_type, creds must be admin
self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
network = self.net_creator.create()
# Validate network was created
self.assertTrue(neutron_utils_tests.validate_network(
self.neutron, self.keystone, net_settings.name, True,
self.os_creds.project_name))
self.assertEquals(network_type, network.type)
def test_create_network_type_vlan_with_physical_net_and_seg_id(self):
"""
Tests the creation of an OpenStack network of type vlan with
specified physical network and segmentation id.
"""
# Create Network
network_type = 'vlan'
# The two values must be variable to work on all OpenStack pods
physical_network = 'datacentre'
segmentation_id = 2366
net_settings = NetworkConfig(
name=self.net_config.network_settings.name,
subnet_settings=self.net_config.network_settings.subnet_settings,
network_type=network_type,
physical_network=physical_network,
segmentation_id=segmentation_id)
# When setting the network_type, creds must be admin
self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
network = self.net_creator.create()
# Validate network was created
self.assertTrue(neutron_utils_tests.validate_network(
self.neutron, self.keystone, net_settings.name, True,
self.os_creds.project_name))
self.assertEquals(network_type, network.type)
def test_create_network_type_vxlan(self):
"""
Tests the creation of an OpenStack network of type vxlan.
"""
# Create Network
network_type = 'vxlan'
net_settings = NetworkConfig(
name=self.net_config.network_settings.name,
subnet_settings=self.net_config.network_settings.subnet_settings,
network_type=network_type)
# When setting the network_type, creds must be admin
self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
network = self.net_creator.create()
# Validate network was created
self.assertTrue(neutron_utils_tests.validate_network(
self.neutron, self.keystone, net_settings.name, True,
self.os_creds.project_name))
self.assertEqual(network_type, network.type)
def test_create_network_type_flat(self):
"""
Tests the creation of an OpenStack network of type flat.
"""
# Create Network
network_type = 'flat'
# This value must be variable to work on all OpenStack pods
physical_network = 'datacentre'
net_settings = NetworkConfig(
name=self.net_config.network_settings.name,
subnet_settings=self.net_config.network_settings.subnet_settings,
network_type=network_type, physical_network=physical_network)
self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
network = self.net_creator.create()
# Validate network was created
self.assertTrue(neutron_utils_tests.validate_network(
self.neutron, self.keystone, net_settings.name, True,
self.os_creds.project_name))
self.assertEquals(network_type, network.type)
def test_create_network_type_foo(self):
"""
Tests the creation of an OpenStack network of type foo which should
raise an exception.
"""
# Create Network
network_type = 'foo'
net_settings = NetworkConfig(
name=self.net_config.network_settings.name,
subnet_settings=self.net_config.network_settings.subnet_settings,
network_type=network_type)
self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
with self.assertRaises(Exception):
self.net_creator.create()
class CreateNetworkIPv6Tests(OSIntegrationTestCase):
"""
Test for the CreateNetwork class defined in create_nework.py when
"""
def setUp(self):
"""
Sets up object for test
"""
super(self.__class__, self).__start__()
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.neutron = neutron_utils.neutron_client(
self.os_creds, self.os_session)
# Initialize for cleanup
self.net_creator = None
def tearDown(self):
"""
Cleans the network
"""
if self.net_creator:
self.net_creator.clean()
super(self.__class__, self).__clean__()
def test_create_network_one_ipv6_subnet(self):
"""
Tests the creation of an OpenStack network without a router.
"""
# Create Network
subnet_settings = SubnetConfig(
name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
ip_version=6)
network_settings = NetworkConfig(
name=self.guid + '-net', subnet_settings=[subnet_settings])
self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
self.net_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))
network = self.net_creator.get_network()
self.assertEqual(1, len(network.subnets))
subnet = network.subnets[0]
self.assertEqual(network.id, subnet.network_id)
self.assertEqual(subnet_settings.name, subnet.name)
self.assertEqual('1:1::/64', subnet.cidr)
self.assertEqual(6, subnet.ip_version)
self.assertEqual(0, len(subnet.dns_nameservers))
def test_create_network_ipv4_ipv6_subnet(self):
"""
Tests the creation of an OpenStack network without a router.
"""
# Create Network
subnet4_settings = SubnetConfig(
name=self.guid + '-subnet4', cidr='10.0.1.0/24', ip_version=4)
subnet6_settings = SubnetConfig(
name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64',
ip_version=6)
network_settings = NetworkConfig(
name=self.guid + '-net',
subnet_settings=[subnet4_settings, subnet6_settings])
self.net_creator = OpenStackNetwork(self.os_creds, network_settings)
self.net_creator.create()
# Validate network was created
network = self.net_creator.get_network()
self.assertEqual(2, len(network.subnets))
subnet4 = None
subnet6 = None
for subnet in network.subnets:
if subnet.name == subnet4_settings.name:
subnet4 = subnet
if subnet.name == subnet6_settings.name:
subnet6 = subnet
# Validate IPv4 subnet
self.assertEqual(network.id, subnet4.network_id)
self.assertEqual(subnet4_settings.name, subnet4.name)
self.assertEqual(subnet4_settings.cidr, subnet4.cidr)
self.assertEqual(4, subnet4.ip_version)
self.assertEqual(0, len(subnet4.dns_nameservers))
# Validate IPv6 subnet
self.assertEqual(network.id, subnet6.network_id)
self.assertEqual(subnet6_settings.name, subnet6.name)
self.assertEqual('1:1::/64', subnet6.cidr)
self.assertEqual(6, subnet6.ip_version)
self.assertEqual(0, len(subnet6.dns_nameservers))
class CreateNetworkGatewayTests(OSIntegrationTestCase):
"""
Test for the CreateNetwork class defined in create_nework.py
"""
def setUp(self):
"""
Sets up object for test
"""
super(self.__class__, self).__start__()
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.neutron = neutron_utils.neutron_client(
self.os_creds, self.os_session)
self.ip_prfx = '10.1.0.'
# Initialize for cleanup
self.net_creator = None
def tearDown(self):
"""
Cleans the network
"""
if self.net_creator:
self.net_creator.clean()
super(self.__class__, self).__clean__()
def test_create_subnet_default_gateway_ip(self):
"""
Tests the creation of an OpenStack network with a subnet that has a
default value assigned to the gateway IP.
"""
# Create Network
subnet_config = SubnetConfig(
name=self.guid + '-subnet', cidr=self.ip_prfx + '0/24')
net_config = NetworkConfig(
name=self.guid + '-net', subnets=[subnet_config])
self.net_creator = OpenStackNetwork(
self.os_creds, net_config)
out_net = self.net_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))
# Validate subnets
self.assertTrue(neutron_utils_tests.validate_subnet(
self.neutron, out_net,
self.net_creator.network_settings.subnet_settings[0].name,
self.net_creator.network_settings.subnet_settings[0].cidr, True))
self.assertEqual(self.ip_prfx + '1', out_net.subnets[0].gateway_ip)
def test_create_subnet_valid_gateway_ip(self):
"""
Tests the creation of an OpenStack network with a subnet that has a
valid value assigned to the gateway IP.
"""
# Create Network
subnet_config = SubnetConfig(
name=self.guid + '-subnet', cidr=self.ip_prfx + '0/24',
gateway_ip=self.ip_prfx + '2')
net_config = NetworkConfig(
name=self.guid + '-net', subnets=[subnet_config])
self.net_creator = OpenStackNetwork(
self.os_creds, net_config)
out_net = self.net_creator.create()
self.assertIsNotNone(out_net)
get_net = neutron_utils.get_network_by_id(self.neutron, out_net.id)
self.assertIsNotNone(get_net)
# Validate subnets
self.assertTrue(neutron_utils_tests.validate_subnet(
self.neutron, out_net,
self.net_creator.network_settings.subnet_settings[0].name,
self.net_creator.network_settings.subnet_settings[0].cidr, True))
self.assertEqual(self.ip_prfx + '2', out_net.subnets[0].gateway_ip)
def test_create_subnet_no_gateway(self):
"""
Tests the creation of an OpenStack network with a subnet that has a
valid value assigned to the gateway IP.
"""
# Create Network
subnet_config = SubnetConfig(
name=self.guid + '-subnet', cidr=self.ip_prfx + '0/24',
gateway_ip='none')
net_config = NetworkConfig(
name=self.guid + '-net', subnets=[subnet_config])
self.net_creator = OpenStackNetwork(
self.os_creds, net_config)
out_net = self.net_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))
# Validate subnets
self.assertTrue(neutron_utils_tests.validate_subnet(
self.neutron, out_net,
self.net_creator.network_settings.subnet_settings[0].name,
self.net_creator.network_settings.subnet_settings[0].cidr, True))
self.assertIsNone(out_net.subnets[0].gateway_ip)
def test_create_subnet_invalid_gateway_ip(self):
"""
Tests the creation of an OpenStack network with a subnet that has an
invalid value assigned to the gateway IP.
"""
# Create Network
subnet_config = SubnetConfig(
name=self.guid + '-subnet', cidr=self.ip_prfx + '0/24',
gateway_ip='foo')
net_config = NetworkConfig(
name=self.guid + '-net', subnets=[subnet_config])
self.net_creator = OpenStackNetwork(
self.os_creds, net_config)
with self.assertRaises(BadRequest):
self.net_creator.create()
class CreateNetworkSuccessTests(OSIntegrationTestCase):
"""
Test for the CreateNetwork class defined in create_nework.py
"""
def setUp(self):
"""
Sets up object for test
"""
super(self.__class__, self).__start__()
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.net_config = openstack_tests.get_pub_net_config(
project_name=self.os_creds.project_name,
net_name="{}-{}".format(guid, 'pub-net'), mtu=999,
subnet_name="{}-{}".format(guid, 'pub-subnet'),
router_name="{}-{}".format(guid, 'pub-router'),
external_net=self.ext_net_name,
netconf_override=self.netconf_override)
self.neutron = neutron_utils.neutron_client(
self.os_creds, self.os_session)
# Initialize for cleanup
self.net_creator = None
self.router_creator = None
def tearDown(self):
"""
Cleans the network
"""
if self.router_creator:
self.router_creator.clean()
if self.net_creator:
self.net_creator.clean()
super(self.__class__, self).__clean__()
def test_create_network_without_router(self):
"""
Tests the creation of an OpenStack network without a router.
"""
# Create Network
self.net_creator = OpenStackNetwork(
self.os_creds, self.net_config.network_settings)
network = self.net_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))
def test_create_delete_network(self):
"""
Tests the creation of an OpenStack network, it's deletion, then cleanup
"""
# Create Network
self.net_creator = OpenStackNetwork(
self.os_creds, self.net_config.network_settings)
self.net_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))
neutron_utils.delete_network(
self.neutron, self.net_creator.get_network())
self.assertIsNone(neutron_utils.get_network(
self.neutron, self.keystone,
network_settings=self.net_creator.network_settings,
project_name=self.os_creds.project_name))
# This shall not throw an exception here
self.net_creator.clean()
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_networks_same_name(self):
"""
Tests the creation of an OpenStack network and ensures that the
OpenStackNetwork object will not create a second.
"""
# Create Network
self.net_creator = OpenStackNetwork(
self.os_creds, self.net_config.network_settings)
self.net_creator.create()
self.net_creator2 = OpenStackNetwork(
self.os_creds, self.net_config.network_settings)
self.net_creator2.create()
self.assertEqual(self.net_creator.get_network().id,
self.net_creator2.get_network().id)
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_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)
class CreateRouterSharedNetworksTests(OSIntegrationTestCase):
"""
Class for testing routers external and/or shared networks
"""
def setUp(self):
"""
Initializes objects used for router testing
"""
super(self.__class__, self).__start__()
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.router_creator = None
ext_network_settings = NetworkConfig(
name=self.guid + '-ext-net',
external=True,
subnet_settings=[
create_network.SubnetConfig(cidr=cidr1,
name=self.guid + '-ext-subnet1')
])
self.ext_network_creator = OpenStackNetwork(self.admin_os_creds,
ext_network_settings)
self.ext_network_creator.create()
shared_network_settings = NetworkConfig(
name=self.guid + '-shared-net',
shared=True,
subnet_settings=[
create_network.SubnetConfig(cidr=cidr2,
name=self.guid + '-shared-subnet1')
])
self.shared_network_creator = OpenStackNetwork(
self.admin_os_creds, shared_network_settings)
self.shared_network_creator.create()
overlay_network_settings = NetworkConfig(
name=self.guid + '-overlay-net',
subnet_settings=[
create_network.SubnetConfig(cidr=cidr3,
name=self.guid +
'-overlay-subnet1')
])
self.overlay_network_creator = OpenStackNetwork(
self.os_creds, overlay_network_settings)
self.overlay_network_creator.create()
self.neutron = neutron_utils.neutron_client(self.os_creds,
self.os_session)
def tearDown(self):
"""
Cleans the remote OpenStack objects used for router testing
"""
if self.router_creator:
self.router_creator.clean()
if self.overlay_network_creator:
self.overlay_network_creator.clean()
if self.shared_network_creator:
self.shared_network_creator.clean()
if self.ext_network_creator:
self.ext_network_creator.clean()
super(self.__class__, self).__clean__()
def test_create_router_external(self):
"""
Test creation of a router with a custom external network created by
admin.
"""
router_settings = RouterConfig(
name=self.guid + '-pub-router',
external_gateway=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_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 deploy_orchestrator(self): # pylint: disable=too-many-locals
"""
Create network, subnet, router
Bootstrap juju
"""
self.__logger.info("Deployed Orchestrator")
private_net_name = getattr(
CONST, 'vnf_{}_private_net_name'.format(self.case_name))
private_subnet_name = getattr(
CONST, 'vnf_{}_private_subnet_name'.format(self.case_name))
private_subnet_cidr = getattr(
CONST, 'vnf_{}_private_subnet_cidr'.format(self.case_name))
abot_router = getattr(
CONST, 'vnf_{}_external_router'.format(self.case_name))
self.__logger.info("Creating full network ...")
subnet_settings = SubnetConfig(
name=private_subnet_name, cidr=private_subnet_cidr)
network_settings = NetworkConfig(
name=private_net_name, subnet_settings=[subnet_settings])
network_creator = OpenStackNetwork(self.snaps_creds, network_settings)
net_id = network_creator.create().id
self.created_object.append(network_creator)
ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds)
self.__logger.info("Creating network Router ....")
router_creator = OpenStackRouter(
self.snaps_creds, RouterConfig(
name=abot_router,
external_gateway=ext_net_name,
internal_subnets=[subnet_settings.name]))
router_creator.create()
self.created_object.append(router_creator)
self.__logger.info("Creating Flavor ....")
flavor_settings = FlavorConfig(
name=self.orchestrator['requirements']['flavor']['name'],
ram=self.orchestrator['requirements']['flavor']['ram_min'],
disk=10, vcpus=1)
flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
flavor_creator.create()
self.created_object.append(flavor_creator)
self.__logger.info("Upload some OS images if it doesn't exist")
images = get_config("tenant_images", self.config_file)
self.__logger.info("Images needed for vEPC: %s", images)
for image_name, image_file in images.iteritems():
self.__logger.info("image: %s, file: %s", image_name, image_file)
if image_file and image_name:
image_creator = OpenStackImage(self.snaps_creds, ImageConfig(
name=image_name, image_user='******', img_format='qcow2',
image_file=image_file))
image_id = image_creator.create().id
os.system(
'juju metadata generate-image -d ~ -i {} -s {} -r '
'{} -u {}'.format(
image_id, image_name,
os.environ.get(
"OS_REGION_NAME", self.default_region_name),
self.public_auth_url))
self.created_object.append(image_creator)
self.__logger.info("Credential information : %s", net_id)
juju_bootstrap_command = (
'juju bootstrap abot-epc abot-controller --config network={} '
'--metadata-source ~ --config ssl-hostname-verification=false '
'--constraints mem=2G --bootstrap-series xenial '
'--config use-floating-ip=true --debug '
'--config use-default-secgroup=true'.format(net_id))
os.system(juju_bootstrap_command)
return True
class SettingsUtilsNetworkingTests(OSComponentTestCase):
"""
Tests the ability to reverse engineer NetworkConfig objects from existing
networks deployed to OpenStack
"""
def setUp(self):
"""
Instantiates OpenStack instances that cannot be spawned by Heat
"""
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.network_name = guid + '-net'
self.subnet_name = guid + '-subnet'
self.net_creator = None
self.neutron = neutron_utils.neutron_client(self.os_creds,
self.os_session)
def tearDown(self):
"""
Cleans the image and downloaded image file
"""
if self.net_creator:
try:
self.net_creator.clean()
except:
pass
super(self.__class__, self).__clean__()
def test_derive_net_settings_no_subnet(self):
"""
Validates the utility function settings_utils#create_network_config
returns an acceptable NetworkConfig object and ensures that the
new settings object will not cause the new OpenStackNetwork instance
to create another network
"""
net_settings = NetworkConfig(name=self.network_name)
self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
network = self.net_creator.create()
derived_settings = settings_utils.create_network_config(
self.neutron, network)
self.assertIsNotNone(derived_settings)
self.assertEqual(net_settings.name, derived_settings.name)
self.assertEqual(net_settings.admin_state_up,
derived_settings.admin_state_up)
self.assertEqual(net_settings.external, derived_settings.external)
self.assertEqual(len(net_settings.subnet_settings),
len(derived_settings.subnet_settings))
net_creator = OpenStackNetwork(self.os_creds, derived_settings)
derived_network = net_creator.create()
self.assertEqual(network, derived_network)
def test_derive_net_settings_two_subnets(self):
"""
Validates the utility function settings_utils#create_network_config
returns an acceptable NetworkConfig object
"""
subnet_settings = list()
subnet_settings.append(SubnetConfig(name='sub1', cidr='10.0.0.0/24'))
subnet_settings.append(SubnetConfig(name='sub2', cidr='10.0.1.0/24'))
net_settings = NetworkConfig(name=self.network_name,
subnet_settings=subnet_settings)
self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
network = self.net_creator.create()
derived_settings = settings_utils.create_network_config(
self.neutron, network)
self.assertIsNotNone(derived_settings)
self.assertEqual(net_settings.name, derived_settings.name)
self.assertEqual(net_settings.admin_state_up,
derived_settings.admin_state_up)
self.assertEqual(net_settings.external, derived_settings.external)
self.assertEqual(len(net_settings.subnet_settings),
len(derived_settings.subnet_settings))
# Validate the first subnet
orig_sub1 = net_settings.subnet_settings[0]
found = False
for derived_sub in derived_settings.subnet_settings:
if orig_sub1.name == derived_sub.name:
self.assertEqual(orig_sub1.cidr, derived_sub.cidr)
found = True
self.assertTrue(found)
# Validate the second subnet
orig_sub2 = net_settings.subnet_settings[1]
found = False
for derived_sub in derived_settings.subnet_settings:
if orig_sub2.name == derived_sub.name:
self.assertEqual(orig_sub2.cidr, derived_sub.cidr)
self.assertEqual(orig_sub2.ip_version, derived_sub.ip_version)
found = True
self.assertTrue(found)
img_format='qcow2',
url='http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-disk.img')
image = OpenStackImage(os_creds, image_settings)
image.create()
# See in Horizon
# Network
from snaps.config.network import NetworkConfig, SubnetConfig
from snaps.openstack.create_network import OpenStackNetwork
subnet_settings = SubnetConfig(name='test-subnet', cidr='10.0.0.1/24')
network_settings = NetworkConfig(name='test-net',
subnet_settings=[subnet_settings])
network = OpenStackNetwork(os_creds, network_settings)
network.create()
# Flavors
from snaps.config.flavor import FlavorConfig
from snaps.openstack.create_flavor import OpenStackFlavor
flavor_settings = FlavorConfig(name='test-flavor', ram=256, disk=10, vcpus=2)
flavor = OpenStackFlavor(os_creds, flavor_settings)
flavor.create()
# Instances
from snaps.config.network import PortConfig
from snaps.openstack.create_instance import OpenStackVmInstance
port_settings = PortConfig(name='test-port',
network_name=network_settings.name)
class NovaUtilsInstanceVolumeTests(OSComponentTestCase):
"""
Tests the creation of VM instances via nova_utils.py
"""
def setUp(self):
"""
Setup objects required by VM instances
:return:
"""
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
self.cinder = cinder_utils.cinder_client(
self.os_creds, self.os_session)
self.image_creator = None
self.network_creator = None
self.flavor_creator = None
self.volume_creator = None
self.instance_creator = None
try:
image_settings = openstack_tests.cirros_image_settings(
name=guid + '-image', image_metadata=self.image_metadata)
self.image_creator = OpenStackImage(
self.os_creds, image_settings=image_settings)
self.image_creator.create()
network_settings = openstack_tests.get_priv_net_config(
project_name=self.os_creds.project_name,
net_name="{}-{}".format(guid, 'net'),
subnet_name="{}-{}".format(guid, 'subnet')).network_settings
self.network_creator = OpenStackNetwork(
self.os_creds, network_settings)
self.network_creator.create()
flavor_settings = openstack_tests.get_flavor_config(
name=guid + '-flavor', ram=256, disk=10, vcpus=1,
metadata=self.flavor_metadata)
self.flavor_creator = OpenStackFlavor(
self.os_creds, flavor_settings)
self.flavor_creator.create()
# Create Volume
volume_settings = VolumeConfig(
name=self.__class__.__name__ + '-' + str(guid))
self.volume_creator = OpenStackVolume(
self.os_creds, volume_settings)
self.volume_creator.create(block=True)
port_settings = PortConfig(
name=guid + '-port', network_name=network_settings.name)
instance_settings = VmInstanceConfig(
name=guid + '-vm_inst',
flavor=self.flavor_creator.flavor_settings.name,
port_settings=[port_settings])
self.instance_creator = OpenStackVmInstance(
self.os_creds, instance_settings, image_settings)
self.instance_creator.create(block=True)
except:
self.tearDown()
raise
def tearDown(self):
"""
Cleanup deployed resources
:return:
"""
if self.instance_creator:
try:
self.instance_creator.clean()
except:
pass
if self.volume_creator:
try:
self.volume_creator.clean()
except:
pass
if self.flavor_creator:
try:
self.flavor_creator.clean()
except:
pass
if self.network_creator:
try:
self.network_creator.clean()
except:
pass
if self.image_creator:
try:
self.image_creator.clean()
except:
pass
super(self.__class__, self).__clean__()
def test_add_remove_volume(self):
"""
Tests the nova_utils.attach_volume() and detach_volume functions with
a timeout value
:return:
"""
self.assertIsNotNone(self.volume_creator.get_volume())
self.assertEqual(0, len(self.volume_creator.get_volume().attachments))
# Attach volume to VM
neutron = neutron_utils.neutron_client(
self.os_creds, self.os_session)
keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
self.assertIsNotNone(nova_utils.attach_volume(
self.nova, neutron, keystone, self.instance_creator.get_vm_inst(),
self.volume_creator.get_volume(), self.os_creds.project_name))
vol_attach = None
vol_detach = None
attached = False
start_time = time.time()
while time.time() < start_time + 120:
vol_attach = cinder_utils.get_volume_by_id(
self.cinder, self.volume_creator.get_volume().id)
if len(vol_attach.attachments) > 0:
attached = True
break
time.sleep(3)
self.assertTrue(attached)
self.assertIsNotNone(vol_attach)
keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
vm_attach = nova_utils.get_server_object_by_id(
self.nova, neutron, keystone,
self.instance_creator.get_vm_inst().id, self.os_creds.project_name)
# Validate Attachment
self.assertIsNotNone(vol_attach)
self.assertEqual(self.volume_creator.get_volume().id, vol_attach.id)
self.assertEqual(1, len(vol_attach.attachments))
self.assertEqual(vm_attach.volume_ids[0]['id'],
vol_attach.attachments[0]['volume_id'])
# Detach volume to VM
self.assertIsNotNone(nova_utils.detach_volume(
self.nova, neutron, keystone, self.instance_creator.get_vm_inst(),
self.volume_creator.get_volume(), self.os_creds.project_name))
start_time = time.time()
while time.time() < start_time + 120:
vol_detach = cinder_utils.get_volume_by_id(
self.cinder, self.volume_creator.get_volume().id)
if len(vol_detach.attachments) == 0:
attached = False
break
time.sleep(3)
self.assertFalse(attached)
self.assertIsNotNone(vol_detach)
vm_detach = nova_utils.get_server_object_by_id(
self.nova, neutron, keystone,
self.instance_creator.get_vm_inst().id, self.os_creds.project_name)
# Validate Detachment
self.assertIsNotNone(vol_detach)
self.assertEqual(self.volume_creator.get_volume().id, vol_detach.id)
self.assertEqual(0, len(vol_detach.attachments))
self.assertEqual(0, len(vm_detach.volume_ids))
def test_attach_volume_nowait(self):
"""
Tests the nova_utils.attach_volume() with a timeout value that is too
small to have the volume attachment data to be included on the VmInst
object that was supposed to be returned
"""
self.assertIsNotNone(self.volume_creator.get_volume())
self.assertEqual(0, len(self.volume_creator.get_volume().attachments))
# Attach volume to VM
neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
with self.assertRaises(NovaException):
nova_utils.attach_volume(
self.nova, neutron, keystone,
self.instance_creator.get_vm_inst(),
self.volume_creator.get_volume(), self.os_creds.project_name,
0)
def test_detach_volume_nowait(self):
"""
Tests the nova_utils.detach_volume() with a timeout value that is too
small to have the volume attachment data to be included on the VmInst
object that was supposed to be returned
"""
self.assertIsNotNone(self.volume_creator.get_volume())
self.assertEqual(0, len(self.volume_creator.get_volume().attachments))
# Attach volume to VM
neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
nova_utils.attach_volume(
self.nova, neutron, keystone, self.instance_creator.get_vm_inst(),
self.volume_creator.get_volume(), self.os_creds.project_name)
# Check VmInst for attachment
keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
latest_vm = nova_utils.get_server_object_by_id(
self.nova, neutron, keystone,
self.instance_creator.get_vm_inst().id, self.os_creds.project_name)
self.assertEqual(1, len(latest_vm.volume_ids))
# Check Volume for attachment
vol_attach = None
attached = False
start_time = time.time()
while time.time() < start_time + 120:
vol_attach = cinder_utils.get_volume_by_id(
self.cinder, self.volume_creator.get_volume().id)
if len(vol_attach.attachments) > 0:
attached = True
break
time.sleep(3)
self.assertTrue(attached)
self.assertIsNotNone(vol_attach)
# Detach volume
with self.assertRaises(NovaException):
nova_utils.detach_volume(
self.nova, neutron, keystone,
self.instance_creator.get_vm_inst(),
self.volume_creator.get_volume(), self.os_creds.project_name,
0)
def deploy_orchestrator(self): # pylint: disable=too-many-locals
"""
Create network, subnet, router
Bootstrap juju
"""
self.__logger.info("Deployed Orchestrator")
private_net_name = CONST.__getattribute__(
'vnf_{}_private_net_name'.format(self.case_name))
private_subnet_name = CONST.__getattribute__(
'vnf_{}_private_subnet_name'.format(self.case_name))
private_subnet_cidr = CONST.__getattribute__(
'vnf_{}_private_subnet_cidr'.format(self.case_name))
abot_router = CONST.__getattribute__(
'vnf_{}_external_router'.format(self.case_name))
dns_nameserver = CONST.__getattribute__(
'vnf_{}_dns_nameserver'.format(self.case_name))
ext_net_name = CONST.__getattribute__(
'vnf_{}_external_network_name'.format(self.case_name))
self.__logger.info("Creating full network ...")
subnet_settings = SubnetSettings(name=private_subnet_name,
cidr=private_subnet_cidr,
dns_nameservers=dns_nameserver)
network_settings = NetworkSettings(name=private_net_name,
subnet_settings=[subnet_settings])
network_creator = OpenStackNetwork(self.snaps_creds, network_settings)
network_creator.create()
self.created_object.append(network_creator)
ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds)
self.__logger.info("Creating network Router ....")
router_creator = OpenStackRouter(
self.snaps_creds,
RouterSettings(
name=abot_router,
external_gateway=ext_net_name,
internal_subnets=[subnet_settings.name]))
router_creator.create()
self.created_object.append(router_creator)
self.__logger.info("Creating Flavor ....")
flavor_settings = FlavorSettings(
name=self.orchestrator['requirements']['flavor']['name'],
ram=self.orchestrator['requirements']['flavor']['ram_min'],
disk=10,
vcpus=1)
flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
self.__logger.info("Juju Bootstrap: Skip creation of flavors")
flavor_creator.create()
self.created_object.append(flavor_creator)
self.__logger.info("Installing Dependency Packages .......")
source_dir = "/src/epc-requirements/juju_bin_build"
if os.path.exists(source_dir):
shutil.rmtree(source_dir)
os.makedirs(source_dir)
os.environ['GOPATH'] = str(source_dir)
os.environ['GOBIN'] = str(source_dir) + "/bin"
os.environ['PATH'] = ((os.path.expandvars('$GOPATH')) + ":" +
(os.path.expandvars('$GOBIN')) + ":" +
(os.path.expandvars('$PATH')))
os.system('go get -d -v github.com/juju/juju/...')
os.chdir(source_dir + "/src" + "/github.com" + "/juju" + "/juju")
os.system('git checkout tags/juju-2.2.5')
os.system('go get github.com/rogpeppe/godeps')
os.system('godeps -u dependencies.tsv')
os.system('go install -v github.com/juju/juju/...')
self.__logger.info("Creating Cloud for Abot-epc .....")
os.system('juju add-cloud abot-epc -f {}'.format(self.filename))
os.system('juju add-credential abot-epc -f {}'.format(self.filename))
for image_name in self.images.keys():
self.__logger.info("Generating Metadata for %s", image_name)
image_id = os_utils.get_image_id(self.glance_client, image_name)
os.system(
'juju metadata generate-image -d ~ -i {} -s {} -r '
'{} -u {}'.format(
image_id, image_name,
os.environ.get("OS_REGION_NAME", self.default_region_name),
self.public_auth_url))
net_id = os_utils.get_network_id(self.neutron_client, private_net_name)
self.__logger.info("Credential information : %s", net_id)
juju_bootstrap_command = ('juju bootstrap abot-epc abot-controller '
'--config network={} --metadata-source ~ '
'--config ssl-hostname-verification=false '
'--constraints mem=2G --bootstrap-series '
'xenial '
'--config use-floating-ip=true --debug'.
format(net_id))
os.system(juju_bootstrap_command)
return True
def deploy_orchestrator(self):
# pylint: disable=too-many-locals,too-many-statements
"""
Deploy Cloudify Manager.
network, security group, fip, VM creation
"""
start_time = time.time()
# orchestrator VM flavor
self.__logger.info("Get or create flavor for cloudify manager vm ...")
flavor_settings = FlavorConfig(
name="{}-{}".format(
self.orchestrator['requirements']['flavor']['name'],
self.uuid),
ram=self.orchestrator['requirements']['flavor']['ram_min'],
disk=50,
vcpus=2)
flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
flavor_creator.create()
self.created_object.append(flavor_creator)
self.__logger.info("Creating a second user to bypass issues ...")
user_creator = OpenStackUser(
self.snaps_creds,
UserConfig(
name='cloudify_network_bug-{}'.format(self.uuid),
password=str(uuid.uuid4()),
project_name=self.tenant_name,
domain_name=self.snaps_creds.user_domain_name,
roles={'_member_': self.tenant_name}))
user_creator.create()
self.created_object.append(user_creator)
snaps_creds = user_creator.get_os_creds(self.snaps_creds.project_name)
self.__logger.debug("snaps creds: %s", snaps_creds)
self.__logger.info("Creating keypair ...")
kp_file = os.path.join(self.data_dir, "cloudify_ims.pem")
keypair_settings = KeypairConfig(
name='cloudify_ims_kp-{}'.format(self.uuid),
private_filepath=kp_file)
keypair_creator = OpenStackKeypair(snaps_creds, keypair_settings)
keypair_creator.create()
self.created_object.append(keypair_creator)
# needs some images
self.__logger.info("Upload some OS images if it doesn't exist")
for image_name, image_file in self.images.iteritems():
self.__logger.info("image: %s, file: %s", image_name, image_file)
if image_file and image_name:
image_creator = OpenStackImage(
snaps_creds,
ImageConfig(
name=image_name, image_user='******',
img_format='qcow2', image_file=image_file))
image_creator.create()
self.created_object.append(image_creator)
# network creation
self.__logger.info("Creating full network ...")
subnet_settings = SubnetConfig(
name='cloudify_ims_subnet-{}'.format(self.uuid),
cidr='10.67.79.0/24',
dns_nameservers=[env.get('NAMESERVER')])
network_settings = NetworkConfig(
name='cloudify_ims_network-{}'.format(self.uuid),
subnet_settings=[subnet_settings])
network_creator = OpenStackNetwork(snaps_creds, network_settings)
network_creator.create()
self.created_object.append(network_creator)
ext_net_name = snaps_utils.get_ext_net_name(snaps_creds)
router_creator = OpenStackRouter(
snaps_creds,
RouterConfig(
name='cloudify_ims_router-{}'.format(self.uuid),
external_gateway=ext_net_name,
internal_subnets=[subnet_settings.name]))
router_creator.create()
self.created_object.append(router_creator)
# security group creation
self.__logger.info("Creating security group for cloudify manager vm")
sg_rules = list()
sg_rules.append(
SecurityGroupRuleConfig(
sec_grp_name="sg-cloudify-manager-{}".format(self.uuid),
direction=Direction.ingress, protocol=Protocol.tcp,
port_range_min=1, port_range_max=65535))
sg_rules.append(
SecurityGroupRuleConfig(
sec_grp_name="sg-cloudify-manager-{}".format(self.uuid),
direction=Direction.ingress, protocol=Protocol.udp,
port_range_min=1, port_range_max=65535))
security_group_creator = OpenStackSecurityGroup(
snaps_creds,
SecurityGroupConfig(
name="sg-cloudify-manager-{}".format(self.uuid),
rule_settings=sg_rules))
security_group_creator.create()
self.created_object.append(security_group_creator)
image_settings = ImageConfig(
name=self.orchestrator['requirements']['os_image'],
image_user='******',
exists=True)
port_settings = PortConfig(
name='cloudify_manager_port-{}'.format(self.uuid),
network_name=network_settings.name)
manager_settings = VmInstanceConfig(
name='cloudify_manager-{}'.format(self.uuid),
flavor=flavor_settings.name,
port_settings=[port_settings],
security_group_names=[
security_group_creator.sec_grp_settings.name],
floating_ip_settings=[FloatingIpConfig(
name='cloudify_manager_fip-{}'.format(self.uuid),
port_name=port_settings.name,
router_name=router_creator.router_settings.name)])
manager_creator = OpenStackVmInstance(
snaps_creds, manager_settings, image_settings,
keypair_settings)
self.__logger.info("Creating cloudify manager VM")
manager_creator.create()
self.created_object.append(manager_creator)
public_auth_url = keystone_utils.get_endpoint(snaps_creds, 'identity')
cfy_creds = dict(
keystone_username=snaps_creds.username,
keystone_password=snaps_creds.password,
keystone_tenant_name=snaps_creds.project_name,
keystone_url=public_auth_url,
region=snaps_creds.region_name,
user_domain_name=snaps_creds.user_domain_name,
project_domain_name=snaps_creds.project_domain_name)
self.__logger.info("Set creds for cloudify manager %s", cfy_creds)
cfy_client = CloudifyClient(
host=manager_creator.get_floating_ip().ip,
username='******', password='******', tenant='default_tenant')
self.orchestrator['object'] = cfy_client
self.__logger.info("Attemps running status of the Manager")
for loop in range(10):
try:
self.__logger.debug(
"status %s", cfy_client.manager.get_status())
cfy_status = cfy_client.manager.get_status()['status']
self.__logger.info(
"The current manager status is %s", cfy_status)
if str(cfy_status) != 'running':
raise Exception("Cloudify Manager isn't up and running")
self.__logger.info("Put OpenStack creds in manager")
secrets_list = cfy_client.secrets.list()
for k, val in cfy_creds.iteritems():
if not any(d.get('key', None) == k for d in secrets_list):
cfy_client.secrets.create(k, val)
else:
cfy_client.secrets.update(k, val)
break
except Exception: # pylint: disable=broad-except
self.logger.info(
"try %s: Cloudify Manager isn't up and running", loop + 1)
time.sleep(30)
else:
self.logger.error("Cloudify Manager isn't up and running")
return False
duration = time.time() - start_time
if manager_creator.vm_ssh_active(block=True):
self.__logger.info("Put private keypair in manager")
ssh = manager_creator.ssh_client()
scp = SCPClient(ssh.get_transport(), socket_timeout=15.0)
scp.put(kp_file, '~/')
cmd = "sudo cp ~/cloudify_ims.pem /etc/cloudify/"
self.run_blocking_ssh_command(ssh, cmd)
cmd = "sudo chmod 444 /etc/cloudify/cloudify_ims.pem"
self.run_blocking_ssh_command(ssh, cmd)
# cmd2 is badly unpinned by Cloudify
cmd = "sudo yum install -y gcc python-devel python-cmd2"
self.run_blocking_ssh_command(
ssh, cmd, "Unable to install packages on manager")
self.run_blocking_ssh_command(ssh, 'cfy status')
else:
self.__logger.error("Cannot connect to manager")
return False
self.details['orchestrator'].update(status='PASS', duration=duration)
self.vnf['inputs'].update(dict(
external_network_name=ext_net_name,
network_name=network_settings.name,
key_pair_name=keypair_settings.name
))
self.result = 1/3 * 100
return True