def prepare(self): """Prepare testscase (Additional pre-configuration steps).""" super(CloudifyIms, self).prepare() self.__logger.info("Additional pre-configuration steps") self.snaps_creds = OSCreds( username=self.creds['username'], password=self.creds['password'], auth_url=self.creds['auth_url'], project_name=self.creds['tenant'], identity_api_version=int(os_utils.get_keystone_client_version())) # needs some images self.__logger.info("Upload some OS images if it doesn't exist") for image_name, image_url in self.images.iteritems(): self.__logger.info("image: %s, url: %s", image_name, image_url) if image_url and image_name: image_creator = OpenStackImage( self.snaps_creds, ImageSettings(name=image_name, image_user='******', img_format='qcow2', url=image_url)) image_creator.create()
def prepare(self): super(CloudifyVrouter, self).prepare() self.__logger.info("Additional pre-configuration steps") self.snaps_creds = OSCreds(username=self.creds['username'], password=self.creds['password'], auth_url=self.creds['auth_url'], project_name=self.creds['tenant'], identity_api_version=int( os_utils.get_keystone_client_version())) self.util.set_credentials(self.creds["username"], self.creds["password"], self.creds["auth_url"], self.creds["tenant"]) # needs some images self.__logger.info("Upload some OS images if it doesn't exist") for image_name, image_file in self.images.iteritems(): self.__logger.info("image: %s, file: %s", image_name, image_file) if image_file and image_name: image_creator = OpenStackImage( self.snaps_creds, ImageSettings(name=image_name, image_user='******', img_format='qcow2', image_file=image_file)) image_creator.create() self.created_object.append(image_creator)
def prepare(self): """Prepare testscase (Additional pre-configuration steps).""" super(CloudifyIms, self).prepare() self.__logger.info("Additional pre-configuration steps") compute_quotas = self.os_project.get_compute_quotas() network_quotas = self.os_project.get_network_quotas() for key, value in (self.vnf['requirements']['compute_quotas'].items()): setattr(compute_quotas, key, value) for key, value in (self.vnf['requirements']['network_quotas'].items()): setattr(network_quotas, key, value) compute_quotas = self.os_project.update_compute_quotas(compute_quotas) network_quotas = self.os_project.update_network_quotas(network_quotas) # needs some images self.__logger.info("Upload some OS images if it doesn't exist") for image_name, image_file in self.images.iteritems(): self.__logger.info("image: %s, file: %s", image_name, image_file) if image_file and image_name: image_creator = OpenStackImage( self.snaps_creds, ImageConfig(name=image_name, image_user='******', img_format='qcow2', image_file=image_file)) image_creator.create()
def prepare(self): """Prepare testcase (Additional pre-configuration steps).""" self.__logger.debug("OS Credentials: %s", os_utils.get_credentials()) super(JujuEpc, self).prepare() self.__logger.info("Additional pre-configuration steps") self.public_auth_url = keystone_utils.get_endpoint( self.snaps_creds, 'identity') # it enforces a versioned public identity endpoint as juju simply # adds /auth/tokens wich fails vs an unversioned endpoint. if not self.public_auth_url.endswith(('v3', 'v3/', 'v2.0', 'v2.0/')): self.public_auth_url = urljoin(self.public_auth_url, 'v3') self.creds = { "tenant": self.tenant_name, "username": self.tenant_name, "password": self.tenant_name, "auth_url": os_utils.get_credentials()['auth_url'] } self.snaps_creds = OSCreds( username=self.creds['username'], password=self.creds['password'], auth_url=self.creds['auth_url'], project_name=self.creds['tenant'], identity_api_version=int(os_utils.get_keystone_client_version())) cloud_data = { 'url': self.public_auth_url, 'pass': self.tenant_name, 'tenant_n': self.tenant_name, 'user_n': self.tenant_name, 'region': os.environ.get( "OS_REGION_NAME", self.default_region_name) } self.__logger.info("Cloud DATA: %s", cloud_data) self.filename = os.path.join(self.case_dir, 'abot-epc.yaml') self.__logger.info("Create %s to add cloud info", self.filename) write_config(self.filename, CLOUD_TEMPLATE, **cloud_data) if self.snaps_creds.identity_api_version == 3: append_config(self.filename, '{}'.format( os_utils.get_credentials()['project_domain_name']), '{}'.format(os_utils.get_credentials()['user_domain_name'])) self.__logger.info("Upload some OS images if it doesn't exist") for image_name, image_file in self.images.iteritems(): self.__logger.info("image: %s, file: %s", image_name, image_file) if image_file and image_name: image_creator = OpenStackImage( self.snaps_creds, ImageSettings(name=image_name, image_user='******', img_format='qcow2', image_file=image_file)) image_creator.create() self.created_object.append(image_creator)
def prepare_images(self): """Upload images if they doen't exist yet""" self.logger.info("Upload images if they doen't exist yet") for image_name, image_file in self.images.iteritems(): self.logger.info("image: %s, file: %s", image_name, image_file) if image_file and image_name: image = OpenStackImage( self.snaps_creds, ImageSettings(name=image_name, image_user='******', img_format='qcow2', image_file=image_file, public=True)) image.create()
def prepare(self): """Prepare testcase (Additional pre-configuration steps).""" self.__logger.debug("OS Credentials: %s", os_utils.get_credentials()) super(JujuEpc, self).prepare() self.__logger.info("Additional pre-configuration steps") self.creds = { "tenant": self.tenant_name, "username": self.tenant_name, "password": self.tenant_name, "auth_url": os_utils.get_credentials()['auth_url'] } self.snaps_creds = OSCreds( username=self.creds['username'], password=self.creds['password'], auth_url=self.creds['auth_url'], project_name=self.creds['tenant'], identity_api_version=int(os_utils.get_keystone_client_version())) cmd = "sed -i 's#endpoint:.*#endpoint: {}#g' {}/abot_epc_\ cloud.yaml".format(self.creds['auth_url'], self.case_dir) os.system(cmd) if self.snaps_creds.identity_api_version == 3: cmd = "sed -i '/username/a\ user-domain-name: {}' {}/abot_" \ "epc_credential.yaml".format(os_utils.get_credentials() ['user_domain_name'], self.case_dir) os.system(cmd) cmd = "sed -i '/username/a\ project-domain-name: {}' {}" \ "/abot_epc_credential.yaml".format(os_utils.get_credentials() ['project_domain_name'], self.case_dir) os.system(cmd) self.__logger.info("Upload some OS images if it doesn't exist") for image_name, image_file in self.images.iteritems(): self.__logger.info("image: %s, file: %s", image_name, image_file) if image_file and image_name: image_creator = OpenStackImage( self.snaps_creds, ImageSettings(name=image_name, image_user='******', img_format='qcow2', image_file=image_file)) image_creator.create() self.created_object.append(image_creator)
def create_image(os_creds, image_settings, cleanup=False): """ Creates an image in OpenStack if necessary :param os_creds: The OpenStack credentials object :param image_settings: The image settings object :param cleanup: Denotes whether or not this is being called for cleanup :return: A reference to the image creator object from which the image object can be accessed """ image_creator = OpenStackImage(os_creds, image_settings) if cleanup: image_creator.initialize() else: image_creator.create() return image_creator
def prepare(self): super(CloudifyVrouter, self).prepare() self.__logger.info("Additional pre-configuration steps") self.util.set_credentials(self.snaps_creds) self.__logger.info("Upload some OS images if it doesn't exist") for image_name, image_file in self.images.iteritems(): self.__logger.info("image: %s, file: %s", image_name, image_file) if image_file and image_name: image_creator = OpenStackImage( self.snaps_creds, ImageConfig(name=image_name, image_user='******', img_format='qcow2', image_file=image_file)) image_creator.create() self.created_object.append(image_creator)
def register_glance_image(self, name, url, img_format, public): logger.info("Registering the image...") # Check whether the image is local or not if 'http' in url: image_settings = ImageConfig(name=name, img_format=img_format, url=url, public=public, image_user='******') else: image_settings = ImageConfig(name=name, img_format=img_format, image_file=url, public=public, image_user='******') # TODO Remove this when tacker is part of SNAPS self.image_settings = image_settings image_creator = OpenStackImage(self.os_creds, image_settings) image_creator.create() self.creators.append(image_creator) return image_creator
class NovaUtilsInstanceVolumeTests(OSComponentTestCase): """ Tests the creation of VM instances via nova_utils.py """ def setUp(self): """ Setup objects required by VM instances :return: """ guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.nova = nova_utils.nova_client(self.os_creds, self.os_session) self.cinder = cinder_utils.cinder_client( self.os_creds, self.os_session) self.image_creator = None self.network_creator = None self.flavor_creator = None self.volume_creator = None self.instance_creator = None try: image_settings = openstack_tests.cirros_image_settings( name=guid + '-image', image_metadata=self.image_metadata) self.image_creator = OpenStackImage( self.os_creds, image_settings=image_settings) self.image_creator.create() network_settings = openstack_tests.get_priv_net_config( project_name=self.os_creds.project_name, net_name="{}-{}".format(guid, 'net'), subnet_name="{}-{}".format(guid, 'subnet')).network_settings self.network_creator = OpenStackNetwork( self.os_creds, network_settings) self.network_creator.create() flavor_settings = openstack_tests.get_flavor_config( name=guid + '-flavor', ram=256, disk=10, vcpus=1, metadata=self.flavor_metadata) self.flavor_creator = OpenStackFlavor( self.os_creds, flavor_settings) self.flavor_creator.create() # Create Volume volume_settings = VolumeConfig( name=self.__class__.__name__ + '-' + str(guid)) self.volume_creator = OpenStackVolume( self.os_creds, volume_settings) self.volume_creator.create(block=True) port_settings = PortConfig( name=guid + '-port', network_name=network_settings.name) instance_settings = VmInstanceConfig( name=guid + '-vm_inst', flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings]) self.instance_creator = OpenStackVmInstance( self.os_creds, instance_settings, image_settings) self.instance_creator.create(block=True) except: self.tearDown() raise def tearDown(self): """ Cleanup deployed resources :return: """ if self.instance_creator: try: self.instance_creator.clean() except: pass if self.volume_creator: try: self.volume_creator.clean() except: pass if self.flavor_creator: try: self.flavor_creator.clean() except: pass if self.network_creator: try: self.network_creator.clean() except: pass if self.image_creator: try: self.image_creator.clean() except: pass super(self.__class__, self).__clean__() def test_add_remove_volume(self): """ Tests the nova_utils.attach_volume() and detach_volume functions with a timeout value :return: """ self.assertIsNotNone(self.volume_creator.get_volume()) self.assertEqual(0, len(self.volume_creator.get_volume().attachments)) # Attach volume to VM neutron = neutron_utils.neutron_client( self.os_creds, self.os_session) keystone = keystone_utils.keystone_client( self.os_creds, self.os_session) self.assertIsNotNone(nova_utils.attach_volume( self.nova, neutron, keystone, self.instance_creator.get_vm_inst(), self.volume_creator.get_volume(), self.os_creds.project_name)) vol_attach = None vol_detach = None attached = False start_time = time.time() while time.time() < start_time + 120: vol_attach = cinder_utils.get_volume_by_id( self.cinder, self.volume_creator.get_volume().id) if len(vol_attach.attachments) > 0: attached = True break time.sleep(3) self.assertTrue(attached) self.assertIsNotNone(vol_attach) keystone = keystone_utils.keystone_client( self.os_creds, self.os_session) vm_attach = nova_utils.get_server_object_by_id( self.nova, neutron, keystone, self.instance_creator.get_vm_inst().id, self.os_creds.project_name) # Validate Attachment self.assertIsNotNone(vol_attach) self.assertEqual(self.volume_creator.get_volume().id, vol_attach.id) self.assertEqual(1, len(vol_attach.attachments)) self.assertEqual(vm_attach.volume_ids[0]['id'], vol_attach.attachments[0]['volume_id']) # Detach volume to VM self.assertIsNotNone(nova_utils.detach_volume( self.nova, neutron, keystone, self.instance_creator.get_vm_inst(), self.volume_creator.get_volume(), self.os_creds.project_name)) start_time = time.time() while time.time() < start_time + 120: vol_detach = cinder_utils.get_volume_by_id( self.cinder, self.volume_creator.get_volume().id) if len(vol_detach.attachments) == 0: attached = False break time.sleep(3) self.assertFalse(attached) self.assertIsNotNone(vol_detach) vm_detach = nova_utils.get_server_object_by_id( self.nova, neutron, keystone, self.instance_creator.get_vm_inst().id, self.os_creds.project_name) # Validate Detachment self.assertIsNotNone(vol_detach) self.assertEqual(self.volume_creator.get_volume().id, vol_detach.id) self.assertEqual(0, len(vol_detach.attachments)) self.assertEqual(0, len(vm_detach.volume_ids)) def test_attach_volume_nowait(self): """ Tests the nova_utils.attach_volume() with a timeout value that is too small to have the volume attachment data to be included on the VmInst object that was supposed to be returned """ self.assertIsNotNone(self.volume_creator.get_volume()) self.assertEqual(0, len(self.volume_creator.get_volume().attachments)) # Attach volume to VM neutron = neutron_utils.neutron_client(self.os_creds, self.os_session) keystone = keystone_utils.keystone_client( self.os_creds, self.os_session) with self.assertRaises(NovaException): nova_utils.attach_volume( self.nova, neutron, keystone, self.instance_creator.get_vm_inst(), self.volume_creator.get_volume(), self.os_creds.project_name, 0) def test_detach_volume_nowait(self): """ Tests the nova_utils.detach_volume() with a timeout value that is too small to have the volume attachment data to be included on the VmInst object that was supposed to be returned """ self.assertIsNotNone(self.volume_creator.get_volume()) self.assertEqual(0, len(self.volume_creator.get_volume().attachments)) # Attach volume to VM neutron = neutron_utils.neutron_client(self.os_creds, self.os_session) keystone = keystone_utils.keystone_client( self.os_creds, self.os_session) nova_utils.attach_volume( self.nova, neutron, keystone, self.instance_creator.get_vm_inst(), self.volume_creator.get_volume(), self.os_creds.project_name) # Check VmInst for attachment keystone = keystone_utils.keystone_client( self.os_creds, self.os_session) latest_vm = nova_utils.get_server_object_by_id( self.nova, neutron, keystone, self.instance_creator.get_vm_inst().id, self.os_creds.project_name) self.assertEqual(1, len(latest_vm.volume_ids)) # Check Volume for attachment vol_attach = None attached = False start_time = time.time() while time.time() < start_time + 120: vol_attach = cinder_utils.get_volume_by_id( self.cinder, self.volume_creator.get_volume().id) if len(vol_attach.attachments) > 0: attached = True break time.sleep(3) self.assertTrue(attached) self.assertIsNotNone(vol_attach) # Detach volume with self.assertRaises(NovaException): nova_utils.detach_volume( self.nova, neutron, keystone, self.instance_creator.get_vm_inst(), self.volume_creator.get_volume(), self.os_creds.project_name, 0)
class HeatUtilsCreateComplexStackTests(OSComponentTestCase): """ Test basic Heat functionality """ def setUp(self): """ Instantiates OpenStack instances that cannot be spawned by Heat """ guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) stack_name = guid + '-stack' self.network_name = guid + '-net' self.subnet_name = guid + '-subnet' self.vm_inst1_name = guid + '-inst1' self.vm_inst2_name = guid + '-inst2' self.flavor1_name = guid + '-flavor1' self.flavor2_name = guid + '-flavor2' self.keypair_name = guid + '-keypair' self.image_creator1 = OpenStackImage( self.os_creds, openstack_tests.cirros_image_settings( name=guid + '-image1', image_metadata=self.image_metadata)) self.image_creator1.create() self.image_creator2 = OpenStackImage( self.os_creds, openstack_tests.cirros_image_settings( name=guid + '-image2', image_metadata=self.image_metadata)) self.image_creator2.create() env_values = { 'image1_name': self.image_creator1.image_settings.name, 'image2_name': self.image_creator2.image_settings.name, 'flavor1_name': self.flavor1_name, 'flavor2_name': self.flavor2_name, 'net_name': self.network_name, 'subnet_name': self.subnet_name, 'keypair_name': self.keypair_name, 'inst1_name': self.vm_inst1_name, 'inst2_name': self.vm_inst2_name, 'external_net_name': self.ext_net_name } heat_tmplt_path = pkg_resources.resource_filename( 'snaps.openstack.tests.heat', 'floating_ip_heat_template.yaml') stack_settings = StackConfig(name=stack_name, template_path=heat_tmplt_path, env_values=env_values) self.heat_client = heat_utils.heat_client(self.os_creds, self.os_session) self.stack = heat_utils.create_stack(self.heat_client, stack_settings) self.assertTrue(stack_active(self.heat_client, self.stack)) self.keypair1_settings = None self.keypair2_settings = None 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_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)
class MagnumUtilsClusterTypeTests(OSComponentTestCase): """ Tests individual functions within magnum_utils.py """ def setUp(self): self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.cluster_type_name = self.guid + '-cluster-type' self.magnum = magnum_utils.magnum_client( self.os_creds, self.os_session) metadata = self.image_metadata if not metadata: metadata = dict() if 'extra_properties' not in metadata: metadata['extra_properties'] = dict() metadata['extra_properties']['os_distro'] = 'cirros' os_image_settings = openstack_tests.cirros_image_settings( name=self.guid + '-image', image_metadata=metadata) self.image_creator = OpenStackImage(self.os_creds, os_image_settings) self.flavor_creator = OpenStackFlavor( self.os_creds, FlavorConfig( name=self.guid + '-flavor', ram=512, disk=10, vcpus=1)) keypair_priv_filepath = 'tmp/' + self.guid keypair_pub_filepath = keypair_priv_filepath + '.pub' self.keypair_creator = OpenStackKeypair( self.os_creds, KeypairConfig( name=self.guid + '-keypair', public_filepath=keypair_pub_filepath, private_filepath=keypair_priv_filepath)) self.cluster_template = None try: self.image_creator.create() self.flavor_creator.create() self.keypair_creator.create() except: self.tearDown() raise def tearDown(self): if self.cluster_template: try: magnum_utils.delete_cluster_template( self.magnum, self.cluster_template.id) except: pass if self.keypair_creator: try: self.keypair_creator.clean() except: pass if self.flavor_creator: try: self.flavor_creator.clean() except: pass if self.image_creator: try: self.image_creator.clean() except: pass super(self.__class__, self).__clean__() def test_create_cluster_template_simple(self): config = ClusterTemplateConfig( name=self.cluster_type_name, image=self.image_creator.image_settings.name, keypair=self.keypair_creator.keypair_settings.name, external_net=self.ext_net_name, flavor=self.flavor_creator.flavor_settings.name) self.cluster_template = magnum_utils.create_cluster_template( self.magnum, config) self.assertIsNotNone(self.cluster_template) self.assertTrue( validate_cluster_template(config, self.cluster_template)) template_by_name = magnum_utils.get_cluster_template( self.magnum, template_name=config.name) self.assertEqual(self.cluster_template, template_by_name) template_by_id = magnum_utils.get_cluster_template_by_id( self.magnum, self.cluster_template.id) self.assertEqual(self.cluster_template, template_by_id) def test_create_cluster_template_all(self): config = ClusterTemplateConfig( name=self.cluster_type_name, image=self.image_creator.image_settings.name, keypair=self.keypair_creator.keypair_settings.name, network_driver='flannel', external_net=self.ext_net_name, floating_ip_enabled=True, docker_volume_size=100, server_type=ServerType.vm, flavor=self.flavor_creator.flavor_settings.name, master_flavor=self.flavor_creator.flavor_settings.name, coe=ContainerOrchestrationEngine.kubernetes, fixed_net='foo', fixed_subnet='bar', registry_enabled=True, insecure_registry='localhost', docker_storage_driver=DockerStorageDriver.overlay, dns_nameserver='8.8.4.4', public=True, tls_disabled=True, http_proxy=None, https_proxy=None, volume_driver='cinder', master_lb_enabled=False, labels={'foo': 'bar'}) self.cluster_template = magnum_utils.create_cluster_template( self.magnum, config) self.assertIsNotNone(self.cluster_template) self.assertTrue( validate_cluster_template(config, self.cluster_template)) template_by_name = magnum_utils.get_cluster_template( self.magnum, template_name=config.name) self.assertEqual(self.cluster_template, template_by_name) template_by_id = magnum_utils.get_cluster_template_by_id( self.magnum, self.cluster_template.id) self.assertEqual(self.cluster_template, template_by_id) def test_create_cluster_template_bad_image(self): config = ClusterTemplateConfig( name=self.cluster_type_name, image='foo', keypair=self.keypair_creator.keypair_settings.name, external_net=self.ext_net_name, flavor=self.flavor_creator.flavor_settings.name) with self.assertRaises(BadRequest): self.cluster_template = magnum_utils.create_cluster_template( self.magnum, config) def test_create_cluster_template_bad_ext_net(self): config = ClusterTemplateConfig( name=self.cluster_type_name, image=self.image_creator.image_settings.name, keypair=self.keypair_creator.keypair_settings.name, external_net='foo', flavor=self.flavor_creator.flavor_settings.name) with self.assertRaises(BadRequest): self.cluster_template = magnum_utils.create_cluster_template( self.magnum, config) def test_create_cluster_template_bad_flavor(self): config = ClusterTemplateConfig( name=self.cluster_type_name, image=self.image_creator.image_settings.name, keypair=self.keypair_creator.keypair_settings.name, external_net=self.ext_net_name, flavor='foo') with self.assertRaises(BadRequest): self.cluster_template = magnum_utils.create_cluster_template( self.magnum, config) def test_create_cluster_template_bad_master_flavor(self): config = ClusterTemplateConfig( name=self.cluster_type_name, image=self.image_creator.image_settings.name, keypair=self.keypair_creator.keypair_settings.name, external_net=self.ext_net_name, flavor=self.flavor_creator.flavor_settings.name, master_flavor='foo') with self.assertRaises(BadRequest): self.cluster_template = magnum_utils.create_cluster_template( self.magnum, config) def test_create_cluster_template_bad_network_driver(self): config = ClusterTemplateConfig( name=self.cluster_type_name, image=self.image_creator.image_settings.name, keypair=self.keypair_creator.keypair_settings.name, external_net=self.ext_net_name, network_driver='foo') with self.assertRaises(BadRequest): self.cluster_template = magnum_utils.create_cluster_template( self.magnum, config) def test_create_cluster_template_bad_volume_driver(self): config = ClusterTemplateConfig( name=self.cluster_type_name, image=self.image_creator.image_settings.name, keypair=self.keypair_creator.keypair_settings.name, external_net=self.ext_net_name, volume_driver='foo') with self.assertRaises(BadRequest): self.cluster_template = magnum_utils.create_cluster_template( self.magnum, config)
class CreateClusterTemplateTests(OSIntegrationTestCase): """ Test for the OpenStackClusterTemplate class defined in py without any QoS Specs or Encryption """ def setUp(self): """ Instantiates the CreateClusterTemplate object that is responsible for downloading and creating an OS template config file within OpenStack """ super(self.__class__, self).__start__() self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.cluster_type_name = self.guid + '-cluster-type' self.magnum = magnum_utils.magnum_client(self.os_creds, self.os_session) metadata = self.image_metadata if not metadata: metadata = dict() if 'extra_properties' not in metadata: metadata['extra_properties'] = dict() metadata['extra_properties']['os_distro'] = 'cirros' os_image_settings = openstack_tests.cirros_image_settings( name=self.guid + '-image', image_metadata=metadata) self.image_creator = OpenStackImage(self.os_creds, os_image_settings) flavor_config = openstack_tests.get_flavor_config( name=self.guid + '-flavor', ram=512, disk=10, vcpus=1, metadata=self.flavor_metadata) self.flavor_creator = OpenStackFlavor(self.os_creds, flavor_config) keypair_priv_filepath = 'tmp/' + self.guid keypair_pub_filepath = keypair_priv_filepath + '.pub' self.keypair_creator = OpenStackKeypair( self.os_creds, KeypairConfig(name=self.guid + '-keypair', public_filepath=keypair_pub_filepath, private_filepath=keypair_priv_filepath)) self.cluster_template_creator = None self.cluster_template_config = ClusterTemplateConfig( name=self.cluster_type_name, image=self.image_creator.image_settings.name, keypair=self.keypair_creator.keypair_settings.name, external_net=self.ext_net_name, flavor=self.flavor_creator.flavor_settings.name) try: self.image_creator.create() self.flavor_creator.create() self.keypair_creator.create() except: self.tearDown() raise def tearDown(self): """ Cleans the template config """ if self.cluster_template_creator: try: self.cluster_template_creator.clean() except: pass if self.keypair_creator: try: self.keypair_creator.clean() except: pass if self.flavor_creator: try: self.flavor_creator.clean() except: pass if self.image_creator: try: self.image_creator.clean() except: pass super(self.__class__, self).__clean__() def test_create_cluster_template(self): """ Tests the creation of an OpenStack cluster template. """ # Create ClusterTemplate self.cluster_template_creator = OpenStackClusterTemplate( self.os_creds, self.cluster_template_config) created_cluster_template = self.cluster_template_creator.create() self.assertIsNotNone(created_cluster_template) self.assertEqual(self.cluster_template_config.name, created_cluster_template.name) retrieved_cluster_template1 = magnum_utils.get_cluster_template( self.magnum, template_config=self.cluster_template_config) self.assertIsNotNone(retrieved_cluster_template1) self.assertEqual(created_cluster_template, retrieved_cluster_template1) retrieved_cluster_template2 = magnum_utils.get_cluster_template_by_id( self.magnum, created_cluster_template.id) self.assertEqual(created_cluster_template, retrieved_cluster_template2) def test_create_delete_cluster_template(self): """ Tests the creation then deletion of an OpenStack template config to ensure clean() does not raise an Exception. """ # Create ClusterTemplate self.cluster_template_creator = OpenStackClusterTemplate( self.os_creds, self.cluster_template_config) created_cluster_template = self.cluster_template_creator.create() self.assertIsNotNone(created_cluster_template) self.cluster_template_creator.clean() tmplt = magnum_utils.get_cluster_template( self.magnum, template_name=self.cluster_template_config.name) self.assertIsNone(tmplt) def test_create_same_cluster_template(self): """ Tests the creation of an OpenStack cluster_template when one already exists. """ # Create ClusterTemplate self.cluster_template_creator = OpenStackClusterTemplate( self.os_creds, self.cluster_template_config) cluster_template1 = self.cluster_template_creator.create() retrieved_cluster_template = magnum_utils.get_cluster_template( self.magnum, template_config=self.cluster_template_config) self.assertEqual(cluster_template1, retrieved_cluster_template) # Should be retrieving the instance data os_cluster_template_2 = OpenStackClusterTemplate( self.os_creds, self.cluster_template_config) cluster_template2 = os_cluster_template_2.create() self.assertEqual(cluster_template2, cluster_template2) def test_create_cluster_template_bad_flavor(self): """ Tests the creation of an OpenStack cluster template raises an exception with an invalid flavor. """ # Create ClusterTemplate cluster_template_config = ClusterTemplateConfig( name=self.cluster_type_name, image=self.image_creator.image_settings.name, keypair=self.keypair_creator.keypair_settings.name, external_net=self.ext_net_name, flavor='foo') self.cluster_template_creator = OpenStackClusterTemplate( self.os_creds, cluster_template_config) with self.assertRaises(BadRequest): self.cluster_template_creator.create() def test_create_cluster_template_bad_master_flavor(self): """ Tests the creation of an OpenStack cluster template raises an exception with an invalid master flavor. """ # Create ClusterTemplate cluster_template_config = ClusterTemplateConfig( name=self.cluster_type_name, image=self.image_creator.image_settings.name, keypair=self.keypair_creator.keypair_settings.name, external_net=self.ext_net_name, flavor=self.flavor_creator.flavor_settings.name, master_flavor='foo') self.cluster_template_creator = OpenStackClusterTemplate( self.os_creds, cluster_template_config) with self.assertRaises(BadRequest): self.cluster_template_creator.create() def test_create_cluster_template_bad_image(self): """ Tests the creation of an OpenStack cluster template raises an exception with an invalid image. """ # Create ClusterTemplate cluster_template_config = ClusterTemplateConfig( name=self.cluster_type_name, image='foo', keypair=self.keypair_creator.keypair_settings.name, external_net=self.ext_net_name, flavor=self.flavor_creator.flavor_settings.name) self.cluster_template_creator = OpenStackClusterTemplate( self.os_creds, cluster_template_config) with self.assertRaises(BadRequest): self.cluster_template_creator.create() def test_create_cluster_template_bad_network_driver(self): """ Tests the creation of an OpenStack cluster template raises an exception with an invalid keypair. """ # Create ClusterTemplate cluster_template_config = ClusterTemplateConfig( name=self.cluster_type_name, image=self.image_creator.image_settings.name, keypair=self.keypair_creator.keypair_settings.name, external_net=self.ext_net_name, flavor=self.flavor_creator.flavor_settings.name, network_driver='foo') self.cluster_template_creator = OpenStackClusterTemplate( self.os_creds, cluster_template_config) with self.assertRaises(BadRequest): self.cluster_template_creator.create() def test_create_cluster_template_bad_volume_driver(self): """ Tests the creation of an OpenStack cluster template raises an exception with an invalid keypair. """ # Create ClusterTemplate cluster_template_config = ClusterTemplateConfig( name=self.cluster_type_name, image=self.image_creator.image_settings.name, keypair=self.keypair_creator.keypair_settings.name, external_net=self.ext_net_name, flavor=self.flavor_creator.flavor_settings.name, volume_driver='foo') self.cluster_template_creator = OpenStackClusterTemplate( self.os_creds, cluster_template_config) with self.assertRaises(BadRequest): self.cluster_template_creator.create()
class CreateVolumeWithImageTests(OSIntegrationTestCase): """ Test cases for the CreateVolume when attempting to associate it to an Image """ def setUp(self): super(self.__class__, self).__start__() self.cinder = cinder_utils.cinder_client(self.os_creds, self.os_session) guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.volume_name = guid + '-vol' self.image_name = guid + '-image' os_image_settings = openstack_tests.cirros_image_settings( name=self.image_name, image_metadata=self.image_metadata) # Create Image self.image_creator = OpenStackImage(self.os_creds, os_image_settings) self.image_creator.create() self.volume_creator = None def tearDown(self): if self.volume_creator: try: self.volume_creator.clean() except: pass if self.image_creator: try: self.image_creator.clean() except: pass super(self.__class__, self).__clean__() def test_bad_image_name(self): """ Tests OpenStackVolume#create() method to ensure a volume is NOT created when associating it to an invalid image name """ self.volume_creator = OpenStackVolume( self.os_creds, VolumeConfig(name=self.volume_name, image_name='foo')) with self.assertRaises(BadRequest): self.volume_creator.create(block=True) def test_valid_volume_image(self): """ Tests OpenStackVolume#create() method to ensure a volume is NOT created when associating it to an invalid image name """ self.volume_creator = OpenStackVolume( self.os_creds, VolumeConfig(name=self.volume_name, image_name=self.image_name)) created_volume = self.volume_creator.create(block=True) self.assertIsNotNone(created_volume) self.assertEqual(self.volume_creator.volume_settings.name, created_volume.name) self.assertTrue(self.volume_creator.volume_active()) retrieved_volume = cinder_utils.get_volume_by_id( self.cinder, created_volume.id) self.assertEqual(created_volume, retrieved_volume)
def deploy_orchestrator(self): # pylint: disable=too-many-locals,too-many-statements """ Deploy Cloudify Manager. network, security group, fip, VM creation """ start_time = time.time() # orchestrator VM flavor self.__logger.info("Get or create flavor for cloudify manager vm ...") flavor_settings = FlavorConfig( name="{}-{}".format( self.orchestrator['requirements']['flavor']['name'], self.uuid), ram=self.orchestrator['requirements']['flavor']['ram_min'], disk=50, vcpus=2) flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings) flavor_creator.create() self.created_object.append(flavor_creator) self.__logger.info("Creating a second user to bypass issues ...") user_creator = OpenStackUser( self.snaps_creds, UserConfig( name='cloudify_network_bug-{}'.format(self.uuid), password=str(uuid.uuid4()), project_name=self.tenant_name, domain_name=self.snaps_creds.user_domain_name, roles={'_member_': self.tenant_name})) user_creator.create() self.created_object.append(user_creator) snaps_creds = user_creator.get_os_creds(self.snaps_creds.project_name) self.__logger.debug("snaps creds: %s", snaps_creds) self.__logger.info("Creating keypair ...") kp_file = os.path.join(self.data_dir, "cloudify_ims.pem") keypair_settings = KeypairConfig( name='cloudify_ims_kp-{}'.format(self.uuid), private_filepath=kp_file) keypair_creator = OpenStackKeypair(snaps_creds, keypair_settings) keypair_creator.create() self.created_object.append(keypair_creator) # needs some images self.__logger.info("Upload some OS images if it doesn't exist") for image_name, image_file in self.images.iteritems(): self.__logger.info("image: %s, file: %s", image_name, image_file) if image_file and image_name: image_creator = OpenStackImage( snaps_creds, ImageConfig( name=image_name, image_user='******', img_format='qcow2', image_file=image_file)) image_creator.create() self.created_object.append(image_creator) # network creation self.__logger.info("Creating full network ...") subnet_settings = SubnetConfig( name='cloudify_ims_subnet-{}'.format(self.uuid), cidr='10.67.79.0/24', dns_nameservers=[env.get('NAMESERVER')]) network_settings = NetworkConfig( name='cloudify_ims_network-{}'.format(self.uuid), subnet_settings=[subnet_settings]) network_creator = OpenStackNetwork(snaps_creds, network_settings) network_creator.create() self.created_object.append(network_creator) ext_net_name = snaps_utils.get_ext_net_name(snaps_creds) router_creator = OpenStackRouter( snaps_creds, RouterConfig( name='cloudify_ims_router-{}'.format(self.uuid), external_gateway=ext_net_name, internal_subnets=[subnet_settings.name])) router_creator.create() self.created_object.append(router_creator) # security group creation self.__logger.info("Creating security group for cloudify manager vm") sg_rules = list() sg_rules.append( SecurityGroupRuleConfig( sec_grp_name="sg-cloudify-manager-{}".format(self.uuid), direction=Direction.ingress, protocol=Protocol.tcp, port_range_min=1, port_range_max=65535)) sg_rules.append( SecurityGroupRuleConfig( sec_grp_name="sg-cloudify-manager-{}".format(self.uuid), direction=Direction.ingress, protocol=Protocol.udp, port_range_min=1, port_range_max=65535)) security_group_creator = OpenStackSecurityGroup( snaps_creds, SecurityGroupConfig( name="sg-cloudify-manager-{}".format(self.uuid), rule_settings=sg_rules)) security_group_creator.create() self.created_object.append(security_group_creator) image_settings = ImageConfig( name=self.orchestrator['requirements']['os_image'], image_user='******', exists=True) port_settings = PortConfig( name='cloudify_manager_port-{}'.format(self.uuid), network_name=network_settings.name) manager_settings = VmInstanceConfig( name='cloudify_manager-{}'.format(self.uuid), flavor=flavor_settings.name, port_settings=[port_settings], security_group_names=[ security_group_creator.sec_grp_settings.name], floating_ip_settings=[FloatingIpConfig( name='cloudify_manager_fip-{}'.format(self.uuid), port_name=port_settings.name, router_name=router_creator.router_settings.name)]) manager_creator = OpenStackVmInstance( snaps_creds, manager_settings, image_settings, keypair_settings) self.__logger.info("Creating cloudify manager VM") manager_creator.create() self.created_object.append(manager_creator) public_auth_url = keystone_utils.get_endpoint(snaps_creds, 'identity') cfy_creds = dict( keystone_username=snaps_creds.username, keystone_password=snaps_creds.password, keystone_tenant_name=snaps_creds.project_name, keystone_url=public_auth_url, region=snaps_creds.region_name, user_domain_name=snaps_creds.user_domain_name, project_domain_name=snaps_creds.project_domain_name) self.__logger.info("Set creds for cloudify manager %s", cfy_creds) cfy_client = CloudifyClient( host=manager_creator.get_floating_ip().ip, username='******', password='******', tenant='default_tenant') self.orchestrator['object'] = cfy_client self.__logger.info("Attemps running status of the Manager") for loop in range(10): try: self.__logger.debug( "status %s", cfy_client.manager.get_status()) cfy_status = cfy_client.manager.get_status()['status'] self.__logger.info( "The current manager status is %s", cfy_status) if str(cfy_status) != 'running': raise Exception("Cloudify Manager isn't up and running") self.__logger.info("Put OpenStack creds in manager") secrets_list = cfy_client.secrets.list() for k, val in cfy_creds.iteritems(): if not any(d.get('key', None) == k for d in secrets_list): cfy_client.secrets.create(k, val) else: cfy_client.secrets.update(k, val) break except Exception: # pylint: disable=broad-except self.logger.info( "try %s: Cloudify Manager isn't up and running", loop + 1) time.sleep(30) else: self.logger.error("Cloudify Manager isn't up and running") return False duration = time.time() - start_time if manager_creator.vm_ssh_active(block=True): self.__logger.info("Put private keypair in manager") ssh = manager_creator.ssh_client() scp = SCPClient(ssh.get_transport(), socket_timeout=15.0) scp.put(kp_file, '~/') cmd = "sudo cp ~/cloudify_ims.pem /etc/cloudify/" self.run_blocking_ssh_command(ssh, cmd) cmd = "sudo chmod 444 /etc/cloudify/cloudify_ims.pem" self.run_blocking_ssh_command(ssh, cmd) # cmd2 is badly unpinned by Cloudify cmd = "sudo yum install -y gcc python-devel python-cmd2" self.run_blocking_ssh_command( ssh, cmd, "Unable to install packages on manager") self.run_blocking_ssh_command(ssh, 'cfy status') else: self.__logger.error("Cannot connect to manager") return False self.details['orchestrator'].update(status='PASS', duration=duration) self.vnf['inputs'].update(dict( external_network_name=ext_net_name, network_name=network_settings.name, key_pair_name=keypair_settings.name )) self.result = 1/3 * 100 return True
auth_url='http://192.168.67.10:5000/v2.0/', project_name='admin', proxy_settings=proxy_settings) # Images from snaps.openstack.create_image import OpenStackImage from snaps.config.image import ImageConfig image_settings = ImageConfig( name='cirros-test', image_user='******', img_format='qcow2', url='http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-disk.img') image = OpenStackImage(os_creds, image_settings) image.create() # See in Horizon # Network from snaps.config.network import NetworkConfig, SubnetConfig from snaps.openstack.create_network import OpenStackNetwork subnet_settings = SubnetConfig(name='test-subnet', cidr='10.0.0.1/24') network_settings = NetworkConfig(name='test-net', subnet_settings=[subnet_settings]) network = OpenStackNetwork(os_creds, network_settings) network.create() # Flavors from snaps.config.flavor import FlavorConfig from snaps.openstack.create_flavor import OpenStackFlavor
def deploy_orchestrator(self): # pylint: disable=too-many-locals """ Create network, subnet, router Bootstrap juju """ self.__logger.info("Deployed Orchestrator") private_net_name = getattr( CONST, 'vnf_{}_private_net_name'.format(self.case_name)) private_subnet_name = getattr( CONST, 'vnf_{}_private_subnet_name'.format(self.case_name)) private_subnet_cidr = getattr( CONST, 'vnf_{}_private_subnet_cidr'.format(self.case_name)) abot_router = getattr( CONST, 'vnf_{}_external_router'.format(self.case_name)) self.__logger.info("Creating full network ...") subnet_settings = SubnetConfig( name=private_subnet_name, cidr=private_subnet_cidr) network_settings = NetworkConfig( name=private_net_name, subnet_settings=[subnet_settings]) network_creator = OpenStackNetwork(self.snaps_creds, network_settings) net_id = network_creator.create().id self.created_object.append(network_creator) ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds) self.__logger.info("Creating network Router ....") router_creator = OpenStackRouter( self.snaps_creds, RouterConfig( name=abot_router, external_gateway=ext_net_name, internal_subnets=[subnet_settings.name])) router_creator.create() self.created_object.append(router_creator) self.__logger.info("Creating Flavor ....") flavor_settings = FlavorConfig( name=self.orchestrator['requirements']['flavor']['name'], ram=self.orchestrator['requirements']['flavor']['ram_min'], disk=10, vcpus=1) flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings) flavor_creator.create() self.created_object.append(flavor_creator) self.__logger.info("Upload some OS images if it doesn't exist") images = get_config("tenant_images", self.config_file) self.__logger.info("Images needed for vEPC: %s", images) for image_name, image_file in images.iteritems(): self.__logger.info("image: %s, file: %s", image_name, image_file) if image_file and image_name: image_creator = OpenStackImage(self.snaps_creds, ImageConfig( name=image_name, image_user='******', img_format='qcow2', image_file=image_file)) image_id = image_creator.create().id os.system( 'juju metadata generate-image -d ~ -i {} -s {} -r ' '{} -u {}'.format( image_id, image_name, os.environ.get( "OS_REGION_NAME", self.default_region_name), self.public_auth_url)) self.created_object.append(image_creator) self.__logger.info("Credential information : %s", net_id) juju_bootstrap_command = ( 'juju bootstrap abot-epc abot-controller --config network={} ' '--metadata-source ~ --config ssl-hostname-verification=false ' '--constraints mem=2G --bootstrap-series xenial ' '--config use-floating-ip=true --debug ' '--config use-default-secgroup=true'.format(net_id)) os.system(juju_bootstrap_command) return True
class HeatUtilsCreateSimpleStackTests(OSComponentTestCase): """ Test basic Heat functionality """ def setUp(self): """ Instantiates OpenStack instances that cannot be spawned by Heat """ guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) stack_name1 = guid + '-stack1' stack_name2 = guid + '-stack2' self.network_name = guid + '-net' self.subnet_name = guid + '-subnet' self.vm_inst_name = guid + '-inst' self.image_creator = OpenStackImage( self.os_creds, openstack_tests.cirros_image_settings( name=guid + '-image', image_metadata=self.image_metadata)) self.image_creator.create() # Create Flavor self.flavor_creator = OpenStackFlavor( self.os_creds, FlavorConfig(name=guid + '-flavor', ram=256, disk=10, vcpus=1)) self.flavor_creator.create() env_values = { 'image_name': self.image_creator.image_settings.name, 'flavor_name': self.flavor_creator.flavor_settings.name, 'net_name': self.network_name, 'subnet_name': self.subnet_name, 'inst_name': self.vm_inst_name } heat_tmplt_path = pkg_resources.resource_filename( 'snaps.openstack.tests.heat', 'test_heat_template.yaml') self.stack_settings1 = StackConfig(name=stack_name1, template_path=heat_tmplt_path, env_values=env_values) self.stack_settings2 = StackConfig(name=stack_name2, template_path=heat_tmplt_path, env_values=env_values) self.stack1 = None self.stack2 = None self.heat_client = heat_utils.heat_client(self.os_creds, self.os_session) def tearDown(self): """ Cleans the stack and image """ if self.stack1: try: heat_utils.delete_stack(self.heat_client, self.stack1) except: pass if self.stack2: try: heat_utils.delete_stack(self.heat_client, self.stack2) except: pass if self.image_creator: try: self.image_creator.clean() except: pass if self.flavor_creator: try: self.flavor_creator.clean() except: pass super(self.__class__, self).__clean__() 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_create_stack_x2(self): """ Tests the creation of an OpenStack keypair that does not exist. """ self.stack1 = heat_utils.create_stack(self.heat_client, self.stack_settings1) stack1_query_1 = heat_utils.get_stack( self.heat_client, stack_settings=self.stack_settings1) self.assertEqual(self.stack1, stack1_query_1) stack1_query_2 = heat_utils.get_stack( self.heat_client, stack_name=self.stack_settings1.name) self.assertEqual(self.stack1, stack1_query_2) stack1_query_3 = heat_utils.get_stack_by_id(self.heat_client, self.stack1.id) self.assertEqual(self.stack1, stack1_query_3) self.assertTrue(stack_active(self.heat_client, self.stack1)) self.stack2 = heat_utils.create_stack(self.heat_client, self.stack_settings2) stack2_query_1 = heat_utils.get_stack( self.heat_client, stack_settings=self.stack_settings2) self.assertEqual(self.stack2, stack2_query_1) stack2_query_2 = heat_utils.get_stack( self.heat_client, stack_name=self.stack_settings2.name) self.assertEqual(self.stack2, stack2_query_2) stack2_query_3 = heat_utils.get_stack_by_id(self.heat_client, self.stack2.id) self.assertEqual(self.stack2, stack2_query_3) self.assertTrue(stack_active(self.heat_client, self.stack2))
class NovaUtilsInstanceTests(OSComponentTestCase): """ Tests the creation of VM instances via nova_utils.py """ def setUp(self): """ Setup objects required by VM instances :return: """ guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.nova = nova_utils.nova_client( self.os_creds, self.os_session) self.keystone = keystone_utils.keystone_client( self.os_creds, self.os_session) self.neutron = neutron_utils.neutron_client( self.os_creds, self.os_session) self.glance = glance_utils.glance_client( self.os_creds, self.os_session) self.image_creator = None self.network_creator = None self.flavor_creator = None self.port = None self.vm_inst = None try: image_settings = openstack_tests.cirros_image_settings( name=guid + '-image', image_metadata=self.image_metadata) self.image_creator = OpenStackImage( self.os_creds, image_settings=image_settings) self.image_creator.create() network_settings = openstack_tests.get_priv_net_config( project_name=self.os_creds.project_name, net_name="{}-{}".format(guid, 'net'), subnet_name="{}-{}".format(guid, 'subnet')).network_settings self.network_creator = OpenStackNetwork( self.os_creds, network_settings) self.network_creator.create() flavor_config = openstack_tests.get_flavor_config( name="{}-{}".format(guid, 'flavor-name'), ram=256, disk=10, vcpus=1, metadata=self.flavor_metadata) self.flavor_creator = OpenStackFlavor(self.os_creds, flavor_config) self.flavor_creator.create() port_settings = PortConfig( name=guid + '-port', network_name=network_settings.name) self.port = neutron_utils.create_port( self.neutron, self.os_creds, port_settings) self.instance_settings = VmInstanceConfig( name=guid + '-vm_inst', flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings]) except: self.tearDown() raise def tearDown(self): """ Cleanup deployed resources :return: """ if self.vm_inst: try: nova_utils.delete_vm_instance(self.nova, self.vm_inst) except: pass if self.port: try: neutron_utils.delete_port(self.neutron, self.port) except: pass if self.flavor_creator: try: self.flavor_creator.clean() except: pass if self.network_creator: try: self.network_creator.clean() except: pass if self.image_creator: try: self.image_creator.clean() except: pass super(self.__class__, self).__clean__() def test_create_instance(self): """ Tests the nova_utils.create_server() method :return: """ self.vm_inst = nova_utils.create_server( self.nova, self.keystone, self.neutron, self.glance, self.instance_settings, self.image_creator.image_settings, self.os_creds.project_name) self.assertIsNotNone(self.vm_inst) # Wait until instance is ACTIVE iters = 0 active = False status = None while iters < 60: status = nova_utils.get_server_status(self.nova, self.vm_inst) if create_instance.STATUS_ACTIVE == status: active = True break time.sleep(3) iters += 1 self.assertTrue(active, msg='VM {} status {} is not {}'.format( self.vm_inst.name, status, create_instance.STATUS_ACTIVE)) vm_inst = nova_utils.get_latest_server_object( self.nova, self.neutron, self.keystone, self.vm_inst, self.os_creds.project_name) self.assertEqual(self.vm_inst.name, vm_inst.name) self.assertEqual(self.vm_inst.id, vm_inst.id)
def deploy_orchestrator(self): # pylint: disable=too-many-locals """ Create network, subnet, router Bootstrap juju """ self.__logger.info("Deployed Orchestrator") private_net_name = getattr( config.CONF, 'vnf_{}_private_net_name'.format(self.case_name)) private_subnet_name = '{}-{}'.format( getattr(config.CONF, 'vnf_{}_private_subnet_name'.format(self.case_name)), self.uuid) private_subnet_cidr = getattr( config.CONF, 'vnf_{}_private_subnet_cidr'.format(self.case_name)) abot_router = '{}-{}'.format( getattr(config.CONF, 'vnf_{}_external_router'.format(self.case_name)), self.uuid) self.__logger.info("Creating full network ...") subnet_settings = SubnetConfig(name=private_subnet_name, cidr=private_subnet_cidr, dns_nameservers=[env.get('NAMESERVER')]) network_settings = NetworkConfig(name=private_net_name, subnet_settings=[subnet_settings]) network_creator = OpenStackNetwork(self.snaps_creds, network_settings) net_id = network_creator.create().id self.created_object.append(network_creator) ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds) self.__logger.info("Creating network Router ....") router_creator = OpenStackRouter( self.snaps_creds, RouterConfig(name=abot_router, external_gateway=ext_net_name, internal_subnets=[subnet_settings.name])) router_creator.create() self.created_object.append(router_creator) self.__logger.info("Creating Flavor ....") flavor_settings = FlavorConfig( name=self.orchestrator['requirements']['flavor']['name'], ram=self.orchestrator['requirements']['flavor']['ram_min'], disk=10, vcpus=1) flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings) flavor_creator.create() self.created_object.append(flavor_creator) self.__logger.info("Upload some OS images if it doesn't exist") images = get_config("tenant_images", self.config_file) self.__logger.info("Images needed for vEPC: %s", images) for image_name, image_file in images.iteritems(): self.__logger.info("image: %s, file: %s", image_name, image_file) if image_file and image_name: image_creator = OpenStackImage( self.snaps_creds, ImageConfig(name=image_name, image_user='******', img_format='qcow2', image_file=image_file)) image_id = image_creator.create().id cmd = [ 'timeout', '-t', JujuEpc.juju_timeout, 'juju', 'metadata', 'generate-image', '-d', '/root', '-i', image_id, '-s', image_name, '-r', self.snaps_creds.region_name, '-u', self.public_auth_url ] output = subprocess.check_output(cmd, stderr=subprocess.STDOUT) self.__logger.info("%s\n%s", " ".join(cmd), output) self.created_object.append(image_creator) self.__logger.info("Network ID : %s", net_id) cmd = [ 'timeout', '-t', JujuEpc.juju_timeout, 'juju', 'bootstrap', 'abot-epc', 'abot-controller', '--metadata-source', '/root', '--constraints', 'mem=2G', '--bootstrap-series', 'xenial', '--config', 'network={}'.format(net_id), '--config', 'ssl-hostname-verification=false', '--config', 'use-floating-ip=true', '--config', 'use-default-secgroup=true', '--debug' ] output = subprocess.check_output(cmd, stderr=subprocess.STDOUT) self.__logger.info("%s\n%s", " ".join(cmd), output) return True