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}