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 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 __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_update_quotas(self): """ Tests the creation of an OpenStack project where the quotas get updated. """ self.project_creator = OpenStackProject(self.os_creds, self.project_settings) created_project = self.project_creator.create() self.assertIsNotNone(created_project) retrieved_project = keystone_utils.get_project( keystone=self.keystone, project_settings=self.project_settings) self.assertIsNotNone(retrieved_project) self.assertEqual(created_project, retrieved_project) self.assertTrue( validate_project(self.keystone, self.project_settings, created_project)) update_compute_quotas = ComputeQuotas( **{ 'metadata_items': 64, 'cores': 5, 'instances': 5, 'injected_files': 3, 'injected_file_content_bytes': 5120, 'ram': 25600, 'fixed_ips': 100, 'key_pairs': 50 }) self.project_creator.update_compute_quotas(update_compute_quotas) update_network_quotas = NetworkQuotas( **{ 'security_group': 5, 'security_group_rule': 50, 'floatingip': 25, 'network': 5, 'port': 25, 'router': 6, 'subnet': 7 }) self.project_creator.update_network_quotas(update_network_quotas) self.assertEqual(update_compute_quotas, self.project_creator.get_compute_quotas()) self.assertEqual(update_network_quotas, self.project_creator.get_network_quotas()) nova = nova_utils.nova_client(self.os_creds, self.os_session) new_compute_quotas = nova_utils.get_compute_quotas( nova, self.project_creator.get_project().id) self.assertEqual(update_compute_quotas, new_compute_quotas) neutron = neutron_utils.neutron_client(self.os_creds, self.os_session) new_network_quotas = neutron_utils.get_network_quotas( neutron, self.project_creator.get_project().id) self.assertEqual(update_network_quotas, new_network_quotas)
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 test_nova_connect_success(self): """ Tests to ensure that the proper credentials can connect. """ nova = nova_utils.nova_client(self.os_creds, self.os_session) # This should not throw an exception nova.flavors.list()
def get_active_compute_cnt(os_creds): """ Returns the number of active compute servers :param: os_creds: an instance of snaps OSCreds object :return: the number of active compute servers """ nova = nova_utils.nova_client(os_creds) computes = nova_utils.get_availability_zone_hosts(nova, zone_name='nova') return len(computes)
def test_nova_get_hypervisor_hosts(self): """ Tests to ensure that get_hypervisors() function works. """ nova = nova_utils.nova_client(self.os_creds, self.os_session) hosts = nova_utils.get_hypervisor_hosts(nova) # This should not throw an exception self.assertGreaterEqual(len(hosts), 1)
def check_nova(self): """ checks that a simple nova operation works """ try: client = nova_utils.nova_client(self.os_creds) client.servers.list() LOGGER.info("Nova service ...OK") except Exception as error: LOGGER.error("Nova service ...FAILED") raise error
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 setUp(self): super(self.__class__, self).__start__() guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.priv_file_path = 'tmp/' + guid self.pub_file_path = self.priv_file_path + '.pub' self.nova = nova_utils.nova_client(self.os_creds, self.os_session) self.keypair_name = guid self.keypair_creator = None
def update_compute_quotas(self, compute_quotas): """ Updates the compute quotas for this project :param compute_quotas: a ComputeQuotas object. """ nova = nova_utils.nova_client(self._os_creds, self._os_session) try: nova_utils.update_quotas(nova, self.__project.id, compute_quotas) finally: nova.client.session.session.close()
def setUp(self): """ Instantiates the CreateImage object that is responsible for downloading and creating an OS image file within OpenStack """ guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.flavor_settings = FlavorConfig( name=guid + '-name', flavor_id=guid + '-id', ram=1, disk=1, vcpus=1, ephemeral=1, swap=2, rxtx_factor=3.0, is_public=False) self.nova = nova_utils.nova_client(self.os_creds, self.os_session) self.flavor = None
def deploy_vnf(self): """Deploy ABOT-OAI-EPC.""" self.__logger.info("Upload VNFD") descriptor = self.vnf['descriptor'] self.__logger.info("Get or create flavor for all Abot-EPC") flavor_settings = FlavorConfig( name=self.vnf['requirements']['flavor']['name'], ram=self.vnf['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("Deploying Abot-epc bundle file ...") os.system('juju deploy {}'.format('/' + descriptor.get('file_name'))) self.__logger.info("Waiting for instances .....") status = os.system('juju-wait') self.__logger.info("juju wait completed: %s", status) self.__logger.info("Deployed Abot-epc on Openstack") nova_client = nova_utils.nova_client(self.snaps_creds) neutron_client = neutron_utils.neutron_client(self.snaps_creds) if status == 0: instances = os_utils.get_instances(nova_client) for items in instances: metadata = get_instance_metadata(nova_client, items) if 'juju-units-deployed' in metadata: sec_group = ('juju-' + metadata['juju-controller-uuid'] + '-' + metadata['juju-model-uuid']) self.sec_group_id = os_utils.get_security_group_id( neutron_client, sec_group) break self.__logger.info("Adding Security group rule....") os_utils.create_secgroup_rule( neutron_client, self.sec_group_id, 'ingress', 132) self.__logger.info("Copying the feature files to Abot_node ") os.system('juju scp -- -r {}/featureFiles abot-' 'epc-basic/0:~/'.format(self.case_dir)) self.__logger.info("Copying the feature files in Abot_node ") os.system("juju ssh abot-epc-basic/0 'sudo rsync -azvv " "~/featureFiles /etc/rebaca-test-suite" "/featureFiles'") count = 0 while count < 10: epcstatus = os.system('juju status oai-epc | ' 'grep {} | grep {} | grep {}' .format('EPC', 'is', 'running')) if epcstatus == 0: break else: time.sleep(60) count = count + 1 os.system('juju-wait') return True return False
def get_compute_quotas(self): """ Returns the compute quotas as an instance of the ComputeQuotas class :return: """ nova = nova_utils.nova_client(self._os_creds, self._os_session) try: return nova_utils.get_compute_quotas(nova, self.__project.id) finally: nova.client.session.session.close()
def setUp(self): """ Instantiates the CreateSecurityGroup object that is responsible for downloading and creating an OS image file within OpenStack """ guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.flavor_name = guid + 'name' self.nova = nova_utils.nova_client(self.os_creds, self.os_session) # Initialize for cleanup self.flavor_creator = None
def setUp(self): """ Instantiates the CreateImage object that is responsible for downloading and creating an OS image file within OpenStack """ guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.priv_key_file_path = 'tmp/' + guid self.pub_key_file_path = self.priv_key_file_path + '.pub' self.nova = nova_utils.nova_client(self.os_creds, self.os_session) self.keys = nova_utils.create_keys() self.public_key = nova_utils.public_key_openssh(self.keys) self.keypair_name = guid self.keypair = None
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 test_nova_connect_fail(self): """ Tests to ensure that the improper credentials cannot connect. """ from snaps.openstack.os_credentials import OSCreds nova = nova_utils.nova_client( OSCreds(username='******', password='******', auth_url=self.os_creds.auth_url, project_name=self.os_creds.project_name, proxy_settings=self.os_creds.proxy_settings)) # This should throw an exception with self.assertRaises(Exception): nova.flavors.list()
def setUp(self): """ Instantiates OpenStack instances that cannot be spawned by Heat """ guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.name_prefix = guid stack_name = guid + '-stack' heat_tmplt_path = pkg_resources.resource_filename( 'snaps.openstack.tests.heat', 'flavor_heat_template.yaml') self.stack_settings = StackConfig(name=stack_name, template_path=heat_tmplt_path) self.stack = None self.heat_client = heat_utils.heat_client(self.os_creds, self.os_session) self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
def create(self): """ Creates a Project/Tenant in OpenStack if it does not already exist :return: The Project domain object """ self.initialize() if not self.__project: self.__project = keystone_utils.create_project( self._keystone, self.project_settings) for username in self.project_settings.users: user = keystone_utils.get_user(self._keystone, username) if user: try: self.assoc_user(user) except Conflict as e: logger.warn('Unable to associate user %s due to %s', user.name, e) if self.project_settings.quotas: quota_dict = self.project_settings.quotas nova = nova_utils.nova_client(self._os_creds, self._os_session) quotas = nova_utils.get_compute_quotas(nova, self.__project.id) if quotas: if 'cores' in quota_dict: quotas.cores = quota_dict['cores'] if 'instances' in quota_dict: quotas.instances = quota_dict['instances'] if 'injected_files' in quota_dict: quotas.injected_files = quota_dict['injected_files'] if 'injected_file_content_bytes' in quota_dict: quotas.injected_file_content_bytes = \ quota_dict['injected_file_content_bytes'] if 'ram' in quota_dict: quotas.ram = quota_dict['ram'] if 'fixed_ips' in quota_dict: quotas.fixed_ips = quota_dict['fixed_ips'] if 'key_pairs' in quota_dict: quotas.key_pairs = quota_dict['key_pairs'] nova_utils.update_quotas(nova, self.__project.id, quotas) return self.__project
def initialize(self): """ Loads the existing heat stack :return: The Stack domain object or None """ super(self.__class__, self).initialize() self.__neutron = neutron_utils.neutron_client(self._os_creds, self._os_session) self.__nova = nova_utils.nova_client(self._os_creds, self._os_session) self.__glance = glance_utils.glance_client(self._os_creds, self._os_session) self.__cinder = cinder_utils.cinder_client(self._os_creds, self._os_session) self.__heat_cli = heat_utils.heat_client(self._os_creds, self._os_session) self.__stack = heat_utils.get_stack(self.__heat_cli, stack_settings=self.stack_settings) if self.__stack: logger.info('Found stack with name - ' + self.stack_settings.name) return self.__stack
def test_create_project_quota_override(self): """ Tests the creation of an OpenStack project with new quotas. """ quotas = { 'cores': 4, 'instances': 5, 'injected_files': 6, 'injected_file_content_bytes': 60000, 'ram': 70000, 'fixed_ips': 7, 'key_pairs': 8 } self.project_settings.quotas = quotas self.project_creator = OpenStackProject(self.os_creds, self.project_settings) created_project = self.project_creator.create() self.assertIsNotNone(created_project) retrieved_project = keystone_utils.get_project( keystone=self.keystone, project_settings=self.project_settings) self.assertIsNotNone(retrieved_project) self.assertEqual(created_project, retrieved_project) self.assertTrue( validate_project(self.keystone, self.project_settings, created_project)) nova = nova_utils.nova_client(self.os_creds, self.os_session) new_quotas = nova_utils.get_compute_quotas(nova, created_project.id) self.assertEqual(4, new_quotas.cores) self.assertEqual(5, new_quotas.instances) self.assertEqual(6, new_quotas.injected_files) self.assertEqual(60000, new_quotas.injected_file_content_bytes) self.assertEqual(70000, new_quotas.ram) self.assertEqual(7, new_quotas.fixed_ips) self.assertEqual(8, new_quotas.key_pairs)
def deploy_vnf(self): """Deploy ABOT-OAI-EPC.""" self.__logger.info("Upload VNFD") descriptor = self.vnf['descriptor'] self.__logger.info("Get or create flavor for all Abot-EPC") flavor_settings = FlavorConfig( name=self.vnf['requirements']['flavor']['name'], ram=self.vnf['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("Deploying Abot-epc bundle file ...") cmd = [ 'timeout', '-t', JujuEpc.juju_timeout, 'juju', 'deploy', '{}'.format(descriptor.get('file_name')) ] output = subprocess.check_output(cmd, stderr=subprocess.STDOUT) self.__logger.info("%s\n%s", " ".join(cmd), output) self.__logger.info("Waiting for instances .....") cmd = ['timeout', '-t', JujuEpc.juju_timeout, 'juju-wait'] output = subprocess.check_output(cmd, stderr=subprocess.STDOUT) self.__logger.info("%s\n%s", " ".join(cmd), output) self.__logger.info("Deployed Abot-epc on Openstack") nova_client = nova_utils.nova_client(self.snaps_creds) instances = get_instances(nova_client) self.__logger.info("List of Instance: %s", instances) for items in instances: metadata = get_instance_metadata(nova_client, items) if 'juju-units-deployed' in metadata: sec_group = 'juju-{}-{}'.format( metadata['juju-controller-uuid'], metadata['juju-model-uuid']) self.__logger.info("Instance: %s", sec_group) break self.__logger.info("Adding Security group rule....") # This will add sctp rule to a common Security Group Created # by juju and shared to all deployed units. self._add_custom_rule(sec_group) cmd = ['juju', 'status'] output = subprocess.check_output(cmd, stderr=subprocess.STDOUT) self.__logger.debug("%s\n%s", " ".join(cmd), output) for app in ['abot-epc-basic', 'oai-epc', 'oai-hss']: if not self.check_app(app): return False self.__logger.info("Copying the feature files to Abot_node ") cmd = [ 'timeout', '-t', JujuEpc.juju_timeout, 'juju', 'scp', '--', '-r', '-v', '{}/featureFiles'.format(self.case_dir), 'abot-epc-basic/0:~/' ] output = subprocess.check_output(cmd, stderr=subprocess.STDOUT) self.__logger.info("%s\n%s", " ".join(cmd), output) self.__logger.info("Copying the feature files in Abot_node ") cmd = [ 'timeout', '-t', JujuEpc.juju_timeout, 'juju', 'ssh', 'abot-epc-basic/0', 'sudo', 'rsync', '-azvv', '~/featureFiles', '/etc/rebaca-test-suite/featureFiles' ] output = subprocess.check_output(cmd, stderr=subprocess.STDOUT) self.__logger.info("%s\n%s", " ".join(cmd), output) return True
def setUp(self): """ Instantiates the CreateImage object that is responsible for downloading and creating an OS image file within OpenStack """ super(self.__class__, self).__start__() self.nova = nova_utils.nova_client(self.os_creds, self.os_session) guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.keypair_priv_filepath = 'tmp/' + guid self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub' self.keypair_name = guid + '-kp' self.vm_inst_name = guid + '-inst' self.test_file_local_path = 'tmp/' + guid + '-hello.txt' self.port_1_name = guid + '-port-1' self.port_2_name = guid + '-port-2' self.floating_ip_name = guid + 'fip1' # Setup members to cleanup just in case they don't get created self.inst_creator = None self.keypair_creator = None self.sec_grp_creator = None self.flavor_creator = None self.router_creator = None self.network_creator = None self.image_creator = None try: # Create Image os_image_settings = openstack_tests.ubuntu_image_settings( name=guid + '-' + '-image', image_metadata=self.image_metadata) self.image_creator = create_image.OpenStackImage( self.os_creds, os_image_settings) self.image_creator.create() # First network is public self.pub_net_config = openstack_tests.get_pub_net_config( project_name=self.os_creds.project_name, net_name=guid + '-pub-net', mtu=1442, subnet_name=guid + '-pub-subnet', router_name=guid + '-pub-router', external_net=self.ext_net_name) self.network_creator = create_network.OpenStackNetwork( self.os_creds, self.pub_net_config.network_settings) self.network_creator.create() # Create routers self.router_creator = create_router.OpenStackRouter( self.os_creds, self.pub_net_config.router_settings) self.router_creator.create() # Create Flavor flavor_config = openstack_tests.get_flavor_config( name=guid + '-flavor-name', ram=2048, disk=10, vcpus=2, metadata=self.flavor_metadata) self.flavor_creator = create_flavor.OpenStackFlavor( self.admin_os_creds, flavor_config) self.flavor_creator.create() # Create Key/Pair self.keypair_creator = create_keypairs.OpenStackKeypair( self.os_creds, KeypairConfig(name=self.keypair_name, public_filepath=self.keypair_pub_filepath, private_filepath=self.keypair_priv_filepath)) self.keypair_creator.create() # Create Security Group sec_grp_name = guid + '-sec-grp' rule1 = SecurityGroupRuleConfig(sec_grp_name=sec_grp_name, direction=Direction.ingress, protocol=Protocol.icmp) rule2 = SecurityGroupRuleConfig(sec_grp_name=sec_grp_name, direction=Direction.ingress, protocol=Protocol.tcp, port_range_min=22, port_range_max=22) self.sec_grp_creator = OpenStackSecurityGroup( self.os_creds, SecurityGroupConfig(name=sec_grp_name, rule_settings=[rule1, rule2])) self.sec_grp_creator.create() # Create instance ports_settings = list() ports_settings.append( PortConfig( name=self.port_1_name, network_name=self.pub_net_config.network_settings.name)) instance_settings = VmInstanceConfig( name=self.vm_inst_name, flavor=self.flavor_creator.flavor_settings.name, port_settings=ports_settings, floating_ip_settings=[ FloatingIpConfig( name=self.floating_ip_name, port_name=self.port_1_name, router_name=self.pub_net_config.router_settings.name) ]) self.inst_creator = create_instance.OpenStackVmInstance( self.os_creds, instance_settings, self.image_creator.image_settings, keypair_settings=self.keypair_creator.keypair_settings) except: self.tearDown() raise
def 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 initialize(self): super(OpenStackComputeObject, self).initialize() self._nova = nova_utils.nova_client(self._os_creds, self._os_session)
def get_nova_client(self): nova_client = nova_utils.nova_client(self.snaps_creds) return nova_client
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)