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 generate_creator(os_creds,
vm_inst,
image_config,
project_name,
keypair_config=None):
"""
Initializes an OpenStackVmInstance object
:param os_creds: the OpenStack credentials
:param vm_inst: the SNAPS-OO VmInst domain object
:param image_config: the associated ImageConfig object
:param project_name: the associated project ID
:param keypair_config: the associated KeypairConfig object (optional)
:return: an initialized OpenStackVmInstance object
"""
session = keystone_utils.keystone_session(os_creds)
nova = nova_utils.nova_client(os_creds, session)
keystone = keystone_utils.keystone_client(os_creds, session)
neutron = neutron_utils.neutron_client(os_creds, session)
try:
derived_inst_config = settings_utils.create_vm_inst_config(
nova, keystone, neutron, vm_inst, project_name)
derived_inst_creator = OpenStackVmInstance(os_creds,
derived_inst_config,
image_config,
keypair_config)
derived_inst_creator.initialize()
return derived_inst_creator
finally:
keystone_utils.close_session(session)
def __reboot_openstack_node(vm_info):
creds_dict = vm_info.get('os_creds')
os_creds = OSCreds(**creds_dict)
logger.debug('Retrieving keystone session %s', creds_dict)
os_sess = keystone_utils.keystone_session(os_creds)
try:
logger.debug('Retrieving OpenStack clients with %s', creds_dict)
nova = nova_utils.nova_client(os_creds, os_sess)
neutron = neutron_utils.neutron_client(os_creds, os_sess)
keystone = keystone_utils.keystone_client(os_creds, os_sess)
logger.info('Retrieved OpenStack clients')
vm_inst = nova_utils.get_server_object_by_id(nova, neutron, keystone,
vm_info['id'])
logger.info('Looking up VM named [%s]', vm_inst.name)
if vm_inst:
logger.debug('Generating VM SNAPS creator with creds [%s]',
creds_dict)
snaps_vm = create_instance.generate_creator(
os_creds, vm_inst, None, os_creds.project_name)
if snaps_vm:
logger.info('Rebooting VM with name %s', vm_inst.name)
snaps_vm.reboot(RebootType.hard)
else:
logger.warn('Unable to obtain a SNAPS-OO VM creator [%s]',
vm_inst.name)
else:
logger.warn('Unable to locate VM with name %s', vm_inst.name)
finally:
logger.info('Closing keystone session')
keystone_utils.close_session(os_sess)
def test_create_two_vol_same_name_diff_proj(self):
"""
Creates a volume as admin to the project of os_creds then instantiates
a creator object with the os_creds project to ensure it initializes
without creation
"""
vol_name = self.guid + '-vol'
self.volume_creators.append(
OpenStackVolume(self.admin_os_creds, VolumeConfig(name=vol_name)))
admin_vol = self.volume_creators[0].create(block=True)
self.assertIsNotNone(admin_vol)
admin_key = keystone_utils.keystone_client(self.admin_os_creds,
self.admin_os_session)
admin_proj = keystone_utils.get_project(
admin_key, project_name=self.admin_os_creds.project_name)
self.assertEqual(admin_vol.project_id, admin_proj.id)
admin_cinder = cinder_utils.cinder_client(self.admin_os_creds,
self.admin_os_session)
admin_vol_get = cinder_utils.get_volume(
admin_cinder,
admin_key,
volume_name=vol_name,
project_name=self.admin_os_creds.project_name)
self.assertIsNotNone(admin_vol_get)
self.assertEqual(admin_vol, admin_vol_get)
self.volume_creators.append(
OpenStackVolume(self.os_creds, VolumeConfig(name=vol_name)))
proj_vol = self.volume_creators[1].create(block=True)
self.assertIsNotNone(proj_vol)
self.assertNotEqual(admin_vol, proj_vol)
proj_key = keystone_utils.keystone_client(self.os_creds,
self.os_session)
proj_cinder = cinder_utils.cinder_client(self.os_creds,
self.os_session)
proj_vol_get = cinder_utils.get_volume(
proj_cinder,
proj_key,
volume_name=vol_name,
project_name=self.os_creds.project_name)
self.assertIsNotNone(proj_vol_get)
self.assertEqual(proj_vol, proj_vol_get)
def __init__(self):
self.os_creds = openstack_tests.get_credentials(
os_env_file=constants.ENV_FILE)
self.creators = []
self.nova = nova_utils.nova_client(self.os_creds)
self.neutron = neutron_utils.neutron_client(self.os_creds)
self.heat = heat_utils.heat_client(self.os_creds)
self.keystone = keystone_utils.keystone_client(self.os_creds)
def dict_for_neutron(self, os_creds, network=None):
"""
Returns a dictionary object representing this object.
This is meant to be converted into JSON designed for use by the Neutron
API
:param os_creds: the OpenStack credentials
:param network: The network object on which the subnet will be created
(optional)
:return: the dictionary object
"""
out = {
'cidr': self.cidr,
'ip_version': self.ip_version,
}
if network:
out['network_id'] = network.id
if self.name:
out['name'] = self.name
if self.project_name:
session = keystone_utils.keystone_session(os_creds)
keystone = keystone_utils.keystone_client(os_creds, session)
try:
project = keystone_utils.get_project(
keystone=keystone, project_name=self.project_name)
finally:
keystone_utils.close_session(session)
project_id = None
if project:
project_id = project.id
if project_id:
out['tenant_id'] = project_id
else:
raise SubnetConfigError(
'Could not find project ID for project named - ' +
self.project_name)
if self.start and self.end:
out['allocation_pools'] = [{'start': self.start, 'end': self.end}]
if self.gateway_ip:
if self.gateway_ip == 'none':
out['gateway_ip'] = None
else:
out['gateway_ip'] = self.gateway_ip
if self.enable_dhcp is not None:
out['enable_dhcp'] = self.enable_dhcp
if self.dns_nameservers and len(self.dns_nameservers) > 0:
out['dns_nameservers'] = self.dns_nameservers
if self.host_routes and len(self.host_routes) > 0:
out['host_routes'] = self.host_routes
if self.destination:
out['destination'] = self.destination
if self.nexthop:
out['nexthop'] = self.nexthop
if self.ipv6_ra_mode:
out['ipv6_ra_mode'] = self.ipv6_ra_mode.value
if self.ipv6_address_mode:
out['ipv6_address_mode'] = self.ipv6_address_mode.value
return out
def test_keystone_connect_success(self):
"""
Tests to ensure that the proper credentials can connect.
"""
keystone = keystone_utils.keystone_client(self.os_creds,
self.os_session)
users = keystone.users.list()
self.assertIsNotNone(users)
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 prepare(self):
"""
Prepare the environment for VNF testing:
* Creation of a user,
* Creation of a tenant,
* Allocation admin role to the user on this tenant
Returns base.TestCase.EX_OK if preparation is successfull
Raise VnfPreparationException in case of problem
"""
try:
self.__logger.info("Prepare VNF: %s, description: %s",
self.case_name, self.tenant_description)
snaps_creds = openstack_tests.get_credentials(
os_env_file=constants.ENV_FILE)
self.os_project = OpenStackProject(
snaps_creds,
ProjectConfig(name=self.tenant_name,
description=self.tenant_description,
domain=snaps_creds.project_domain_name))
self.os_project.create()
self.created_object.append(self.os_project)
snaps_creds.project_domain_id = \
self.os_project.get_project().domain_id
snaps_creds.user_domain_id = \
self.os_project.get_project().domain_id
for role in ['admin', 'Admin']:
if keystone_utils.get_role_by_name(
keystone_utils.keystone_client(snaps_creds), role):
admin_role = role
break
user_creator = OpenStackUser(
snaps_creds,
UserConfig(name=self.user_name,
password=str(uuid.uuid4()),
project_name=self.tenant_name,
domain_name=snaps_creds.user_domain_name,
roles={admin_role: self.tenant_name}))
user_creator.create()
self.created_object.append(user_creator)
self.snaps_creds = user_creator.get_os_creds(self.tenant_name)
self.__logger.debug("snaps creds: %s", self.snaps_creds)
return vnf.VnfOnBoarding.EX_OK
except Exception: # pylint: disable=broad-except
self.__logger.exception("Exception raised during VNF preparation")
raise VnfPreparationException
def setUp(self):
"""
Instantiates the CreateVolume object that is responsible for
downloading and creating an OS volume file within OpenStack
"""
guid = uuid.uuid4()
self.volume_name = self.__class__.__name__ + '-' + str(guid)
self.volume = None
self.cinder = cinder_utils.cinder_client(
self.os_creds, self.os_session)
self.keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
def test_keystone_connect_fail(self):
"""
Tests to ensure that the improper credentials cannot connect.
"""
from snaps.openstack.os_credentials import OSCreds
with self.assertRaises(Exception):
keystone = keystone_utils.keystone_client(
OSCreds(username='******',
password='******',
auth_url='url',
project_name='project'))
keystone.users.list()
def setUp(self):
"""
Instantiates the CreateImage object that is responsible for downloading
and creating an OS image file within OpenStack
"""
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.username = self.guid + '-username'
self.user = None
self.project_name = self.guid + '-projName'
self.project = None
self.role = None
self.keystone = keystone_utils.keystone_client(self.os_creds,
self.os_session)
def test_create_stack(self):
"""
Tests the creation of an OpenStack Heat stack1 that does not exist.
"""
self.stack1 = heat_utils.create_stack(self.heat_client,
self.stack_settings1)
stack_query_1 = heat_utils.get_stack(
self.heat_client, stack_settings=self.stack_settings1)
self.assertEqual(self.stack1, stack_query_1)
stack_query_2 = heat_utils.get_stack(
self.heat_client, stack_name=self.stack_settings1.name)
self.assertEqual(self.stack1, stack_query_2)
stack_query_3 = heat_utils.get_stack_by_id(self.heat_client,
self.stack1.id)
self.assertEqual(self.stack1, stack_query_3)
resources = heat_utils.get_resources(self.heat_client, self.stack1.id)
self.assertIsNotNone(resources)
self.assertEqual(4, len(resources))
outputs = heat_utils.get_outputs(self.heat_client, self.stack1)
self.assertIsNotNone(outputs)
self.assertEqual(0, len(outputs))
self.assertTrue(stack_active(self.heat_client, self.stack1))
neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
networks = heat_utils.get_stack_networks(self.heat_client, neutron,
self.stack1)
self.assertIsNotNone(networks)
self.assertEqual(1, len(networks))
self.assertEqual(self.network_name, networks[0].name)
subnets = neutron_utils.get_subnets_by_network(neutron, networks[0])
self.assertEqual(1, len(subnets))
self.assertEqual(self.subnet_name, subnets[0].name)
nova = nova_utils.nova_client(self.os_creds, self.os_session)
keystone = keystone_utils.keystone_client(self.os_creds,
self.os_session)
servers = heat_utils.get_stack_servers(self.heat_client, nova, neutron,
keystone, self.stack1,
self.os_creds.project_name)
self.assertIsNotNone(servers)
self.assertEqual(1, len(servers))
self.assertEqual(self.vm_inst_name, servers[0].name)
def setUp(self):
"""
Instantiates the CreateImage object that is responsible for downloading
and creating an OS image file within OpenStack
"""
guid = str(uuid.uuid4())[:-19]
guid = self.__class__.__name__ + '-' + guid
self.project_settings = ProjectConfig(
name=guid + '-name', domain=self.os_creds.project_domain_name)
self.keystone = keystone_utils.keystone_client(self.os_creds,
self.os_session)
# Initialize for cleanup
self.project_creator = None
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 __start__(self):
"""
Creates a project and user to be leveraged by subclass test methods. If
implementing class uses this method, it must call __clean__() else you
will be left with unwanted users and tenants
"""
self.project_creator = None
self.user_creator = None
self.admin_os_creds = self.os_creds
self.admin_os_session = self.os_session
self.keystone = keystone_utils.keystone_client(self.admin_os_creds,
self.admin_os_session)
if self.use_keystone:
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())[:-19]
project_name = guid + '-proj'
self.project_creator = deploy_utils.create_project(
self.admin_os_creds,
ProjectConfig(name=project_name,
domain=self.admin_os_creds.project_domain_name))
# Set by implementing class for setting the user's roles
roles = dict()
if self.user_roles and isinstance(self.user_roles, list):
for user_role in self.user_roles:
roles[user_role] = project_name
self.user_creator = deploy_utils.create_user(
self.admin_os_creds,
UserConfig(name=guid + '-user',
password=guid,
project_name=project_name,
roles=roles,
domain_name=self.admin_os_creds.user_domain_name))
self.os_creds = self.user_creator.get_os_creds(
self.project_creator.project_settings.name)
self.os_session = keystone_utils.keystone_session(self.os_creds)
# add user to project
self.project_creator.assoc_user(self.user_creator.get_user())
if self.proj_users and isinstance(self.proj_users, list):
for user_name in self.proj_users:
user = keystone_utils.get_user(self.keystone, user_name)
if user:
self.project_creator.assoc_user(user)
def dict_for_neutron(self, neutron, os_creds):
"""
Returns a dictionary object representing this object.
This is meant to be converted into JSON designed for use by the Neutron
API
TODO - expand automated testing to exercise all parameters
:param neutron: The neutron client to retrieve external network
information if necessary
:param os_creds: The OpenStack credentials for retrieving the keystone
client for looking up the project ID when the
self.project_name is not None
:return: the dictionary object
"""
out = dict()
ext_gw = dict()
session = keystone_utils.keystone_session(os_creds)
keystone = keystone_utils.keystone_client(os_creds, session)
try:
if self.name:
out['name'] = self.name
if self.project_name:
project = keystone_utils.get_project(
keystone=keystone, project_name=self.project_name)
if project:
out['tenant_id'] = project.id
else:
raise RouterConfigError(
'Could not find project ID for project named - ' +
self.project_name)
if self.admin_state_up is not None:
out['admin_state_up'] = self.admin_state_up
if self.external_gateway:
ext_net = neutron_utils.get_network(
neutron, keystone, network_name=self.external_gateway)
if ext_net:
ext_gw['network_id'] = ext_net.id
out['external_gateway_info'] = ext_gw
else:
raise RouterConfigError(
'Could not find the external network named - ' +
self.external_gateway)
finally:
keystone_utils.close_session(session)
return {'router': out}
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 initialize(self):
"""
Loads the existing VMInst, Port, FloatingIps
:return: VMInst domain object
"""
super(self.__class__, self).initialize()
self.__neutron = neutron_utils.neutron_client(self._os_creds,
self._os_session)
self.__keystone = keystone_utils.keystone_client(
self._os_creds, self._os_session)
self.__cinder = cinder_utils.cinder_client(self._os_creds,
self._os_session)
self.__glance = glance_utils.glance_client(self._os_creds,
self._os_session)
self.__ports = self.__query_ports(self.instance_settings.port_settings)
self.__lookup_existing_vm_by_name()
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 get_project_id(self, os_creds):
"""
Returns the project ID for a given project_name or None
:param os_creds: the credentials required for keystone client retrieval
:return: the ID or None
"""
if self.project_id:
return self.project_id
else:
if self.project_name:
session = keystone_utils.keystone_session(os_creds)
keystone = keystone_utils.keystone_client(os_creds, session)
try:
project = keystone_utils.get_project(
keystone=keystone, project_name=self.project_name)
if project:
return project.id
finally:
keystone_utils.close_session(session)
return None
def test_create_router_with_stack(self):
"""
Tests the creation of an OpenStack router with Heat and the retrieval
of the Router Domain objects from heat_utils#get_stack_routers().
"""
self.stack = heat_utils.create_stack(self.heat_client,
self.stack_settings)
# Wait until stack deployment has completed
end_time = time.time() + stack_config.STACK_COMPLETE_TIMEOUT
is_active = False
while time.time() < end_time:
status = heat_utils.get_stack_status(self.heat_client,
self.stack.id)
if status == stack_config.STATUS_CREATE_COMPLETE:
is_active = True
break
elif status == stack_config.STATUS_CREATE_FAILED:
is_active = False
break
time.sleep(3)
self.assertTrue(is_active)
routers = heat_utils.get_stack_routers(self.heat_client, self.neutron,
self.stack)
self.assertEqual(1, len(routers))
router = routers[0]
self.assertEqual(self.router_name, router.name)
keystone = keystone_utils.keystone_client(self.os_creds,
self.os_session)
ext_net = neutron_utils.get_network(self.neutron,
keystone,
network_name=self.ext_net_name)
self.assertEqual(ext_net.id, router.external_network_id)
def initialize(self):
self._os_session = keystone_utils.keystone_session(self._os_creds)
self._keystone = keystone_utils.keystone_client(
self._os_creds, session=self._os_session)
def test_get_settings_from_stack(self):
"""
Tests that a heat template with floating IPs and can have the proper
settings derived from settings_utils.py.
"""
resources = heat_utils.get_resources(self.heat_client, self.stack.id)
self.assertIsNotNone(resources)
self.assertEqual(13, len(resources))
options = heat_utils.get_outputs(self.heat_client, self.stack)
self.assertIsNotNone(options)
self.assertEqual(1, len(options))
neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
networks = heat_utils.get_stack_networks(self.heat_client, neutron,
self.stack)
self.assertIsNotNone(networks)
self.assertEqual(1, len(networks))
self.assertEqual(self.network_name, networks[0].name)
network_settings = settings_utils.create_network_config(
neutron, networks[0])
self.assertIsNotNone(network_settings)
self.assertEqual(self.network_name, network_settings.name)
nova = nova_utils.nova_client(self.os_creds, self.os_session)
glance = glance_utils.glance_client(self.os_creds, self.os_session)
keystone = keystone_utils.keystone_client(self.os_creds,
self.os_session)
servers = heat_utils.get_stack_servers(self.heat_client, nova, neutron,
keystone, self.stack,
self.os_creds.project_name)
self.assertIsNotNone(servers)
self.assertEqual(2, len(servers))
image_settings = settings_utils.determine_image_config(
glance, servers[0], [
self.image_creator1.image_settings,
self.image_creator2.image_settings
])
self.assertIsNotNone(image_settings)
if image_settings.name.endswith('1'):
self.assertEqual(self.image_creator1.image_settings.name,
image_settings.name)
else:
self.assertEqual(self.image_creator2.image_settings.name,
image_settings.name)
image_settings = settings_utils.determine_image_config(
glance, servers[1], [
self.image_creator1.image_settings,
self.image_creator2.image_settings
])
if image_settings.name.endswith('1'):
self.assertEqual(self.image_creator1.image_settings.name,
image_settings.name)
else:
self.assertEqual(self.image_creator2.image_settings.name,
image_settings.name)
self.keypair1_settings = settings_utils.determine_keypair_config(
self.heat_client,
self.stack,
servers[0],
priv_key_key='private_key')
self.assertIsNotNone(self.keypair1_settings)
self.assertEqual(self.keypair_name, self.keypair1_settings.name)
self.keypair2_settings = settings_utils.determine_keypair_config(
self.heat_client,
self.stack,
servers[1],
priv_key_key='private_key')
self.assertIsNotNone(self.keypair2_settings)
self.assertEqual(self.keypair_name, self.keypair2_settings.name)
def tearDown(self):
"""
Cleans the stack and image
"""
if self.stack:
try:
heat_utils.delete_stack(self.heat_client, self.stack)
# Wait until stack deployment has completed
end_time = (time.time() + stack_config.STACK_COMPLETE_TIMEOUT)
is_deleted = False
while time.time() < end_time:
status = heat_utils.get_stack_status(
self.heat_client, self.stack.id)
if status == stack_config.STATUS_DELETE_COMPLETE:
is_deleted = True
break
elif status == stack_config.STATUS_DELETE_FAILED:
is_deleted = False
break
time.sleep(3)
if not is_deleted:
nova = nova_utils.nova_client(self.os_creds,
self.os_session)
keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
neutron = neutron_utils.neutron_client(
self.os_creds, self.os_session)
glance = glance_utils.glance_client(
self.os_creds, self.os_session)
servers = heat_utils.get_stack_servers(
self.heat_client, nova, neutron, keystone, self.stack,
self.os_creds.project_name)
for server in servers:
vm_settings = settings_utils.create_vm_inst_config(
nova, keystone, neutron, server,
self.os_creds.project_name)
img_settings = settings_utils.determine_image_config(
glance, server, [
self.image_creator1.image_settings,
self.image_creator2.image_settings
])
vm_creator = OpenStackVmInstance(
self.os_creds, vm_settings, img_settings)
vm_creator.initialize()
vm_creator.clean()
vm_creator.vm_deleted(block=True)
heat_utils.delete_stack(self.heat_client, self.stack)
time.sleep(20)
except:
raise
if self.image_creator1:
try:
self.image_creator1.clean()
except:
pass
if self.image_creator2:
try:
self.image_creator2.clean()
except:
pass
if self.keypair1_settings:
expanded_path = os.path.expanduser(
self.keypair1_settings.private_filepath)
os.chmod(expanded_path, 0o755)
os.remove(expanded_path)
if self.keypair2_settings:
expanded_path = os.path.expanduser(
self.keypair2_settings.private_filepath)
os.chmod(expanded_path, 0o755)
os.remove(expanded_path)
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 setUp(self):
"""
Instantiates the CreateImage object that is responsible for downloading
and creating an OS image file within OpenStack
"""
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.glance = glance_utils.glance_client(self.os_creds,
self.os_session)
self.neutron = neutron_utils.neutron_client(self.os_creds,
self.os_session)
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.keypair_priv_filepath = 'tmp/' + guid
self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
self.keypair_name = guid + '-kp'
self.vm_inst_name = guid + '-inst'
self.test_file_local_path = 'tmp/' + guid + '-hello.txt'
self.port_1_name = guid + '-port-1'
self.port_2_name = guid + '-port-2'
self.floating_ip_name = guid + 'fip1'
# Setup members to cleanup just in case they don't get created
self.inst_creator = None
self.keypair_creator = None
self.sec_grp_creator = None
self.flavor_creator = None
self.router_creator = None
self.network_creator = None
self.image_creator = None
try:
# Create Image
os_image_settings = openstack_tests.cirros_image_settings(
name=guid + '-' + '-image', image_metadata=self.image_metadata)
self.image_creator = create_image.OpenStackImage(
self.os_creds, os_image_settings)
self.image_creator.create()
# First network is public
self.pub_net_config = openstack_tests.get_pub_net_config(
project_name=self.os_creds.project_name,
net_name=guid + '-pub-net',
subnet_name=guid + '-pub-subnet',
router_name=guid + '-pub-router',
external_net=self.ext_net_name)
self.network_creator = create_network.OpenStackNetwork(
self.os_creds, self.pub_net_config.network_settings)
self.network_creator.create()
# Create routers
self.router_creator = create_router.OpenStackRouter(
self.os_creds, self.pub_net_config.router_settings)
self.router_creator.create()
# Create Flavor
self.flavor_creator = create_flavor.OpenStackFlavor(
self.os_creds,
FlavorConfig(name=guid + '-flavor-name',
ram=256,
disk=1,
vcpus=1))
self.flavor_creator.create()
# Create Key/Pair
self.keypair_creator = create_keypairs.OpenStackKeypair(
self.os_creds,
KeypairConfig(name=self.keypair_name,
public_filepath=self.keypair_pub_filepath,
private_filepath=self.keypair_priv_filepath))
self.keypair_creator.create()
# Create Security Group
sec_grp_name = guid + '-sec-grp'
rule1 = SecurityGroupRuleConfig(sec_grp_name=sec_grp_name,
direction=Direction.ingress,
protocol=Protocol.icmp)
rule2 = SecurityGroupRuleConfig(sec_grp_name=sec_grp_name,
direction=Direction.ingress,
protocol=Protocol.tcp,
port_range_min=22,
port_range_max=22)
self.sec_grp_creator = OpenStackSecurityGroup(
self.os_creds,
SecurityGroupConfig(name=sec_grp_name,
rule_settings=[rule1, rule2]))
self.sec_grp_creator.create()
# Create instance
ports_settings = list()
ports_settings.append(
PortConfig(
name=self.port_1_name,
network_name=self.pub_net_config.network_settings.name))
instance_settings = VmInstanceConfig(
name=self.vm_inst_name,
flavor=self.flavor_creator.flavor_settings.name,
port_settings=ports_settings,
floating_ip_settings=[
FloatingIpConfig(
name=self.floating_ip_name,
port_name=self.port_1_name,
router_name=self.pub_net_config.router_settings.name)
])
self.inst_creator = create_instance.OpenStackVmInstance(
self.os_creds,
instance_settings,
self.image_creator.image_settings,
keypair_settings=self.keypair_creator.keypair_settings)
except:
self.tearDown()
raise
def dict_for_neutron(self, neutron, os_creds):
"""
Returns a dictionary object representing this object.
This is meant to be converted into JSON designed for use by the Neutron
API
TODO - expand automated testing to exercise all parameters
:param neutron: the Neutron client
:param os_creds: the OpenStack credentials
:return: the dictionary object
"""
out = dict()
session = keystone_utils.keystone_session(os_creds)
keystone = keystone_utils.keystone_client(os_creds, session)
project_name = os_creds.project_name
if self.project_name:
project_name = project_name
try:
network = neutron_utils.get_network(neutron,
keystone,
network_name=self.network_name)
if network and not (network.shared or network.external):
network = neutron_utils.get_network(
neutron,
keystone,
network_name=self.network_name,
project_name=project_name)
finally:
if session:
keystone_utils.close_session(session)
if not network:
raise PortConfigError('Cannot locate network with name - ' +
self.network_name + ' in project - ' +
str(project_name))
out['network_id'] = network.id
if self.admin_state_up is not None:
out['admin_state_up'] = self.admin_state_up
if self.name:
out['name'] = self.name
if self.project_name:
project = keystone_utils.get_project(
keystone=keystone, project_name=self.project_name)
project_id = None
if project:
project_id = project.id
if project_id:
out['tenant_id'] = project_id
else:
raise PortConfigError(
'Could not find project ID for project named - ' +
self.project_name)
if self.mac_address:
out['mac_address'] = self.mac_address
fixed_ips = self.__get_fixed_ips(neutron, network)
if fixed_ips and len(fixed_ips) > 0:
out['fixed_ips'] = fixed_ips
if self.security_groups:
sec_grp_ids = list()
for sec_grp_name in self.security_groups:
sec_grp = neutron_utils.get_security_group(
neutron,
keystone,
sec_grp_name=sec_grp_name,
project_name=self.project_name)
if sec_grp:
sec_grp_ids.append(sec_grp.id)
out['security_groups'] = sec_grp_ids
if self.port_security_enabled is not None:
out['port_security_enabled'] = self.port_security_enabled
if self.allowed_address_pairs and len(self.allowed_address_pairs) > 0:
out['allowed_address_pairs'] = self.allowed_address_pairs
if self.opt_value:
out['opt_value'] = self.opt_value
if self.opt_name:
out['opt_name'] = self.opt_name
if self.device_owner:
out['device_owner'] = self.device_owner
if self.device_id:
out['device_id'] = self.device_id
if self.extra_dhcp_opts:
out['extra_dhcp_opts'] = self.extra_dhcp_opts
return {'port': out}
