def test_create_delete_image(self): """ Tests the creation then deletion of an OpenStack image to ensure clean() does not raise an Exception. """ # Create Image self.image_creator = create_image.OpenStackImage( self.os_creds, self.image_settings) created_image = self.image_creator.create() self.assertIsNotNone(created_image) retrieved_image = glance_utils.get_image( self.glance, image_settings=self.image_settings) self.assertIsNotNone(retrieved_image) self.assertEqual(self.image_creator.get_image().size, retrieved_image.size) self.assertEqual(get_image_size(self.image_settings), retrieved_image.size) # Delete Image manually glance_utils.delete_image(self.glance, created_image) self.assertIsNone(glance_utils.get_image( self.glance, image_settings=self.image_creator.image_settings)) # Must not throw an exception when attempting to cleanup non-existent # image self.image_creator.clean() self.assertIsNone(self.image_creator.get_image())
def initialize(self): """ Loads the existing Image :return: The Image domain object or None """ super(self.__class__, self).initialize() self.__glance = glance_utils.glance_client(self._os_creds, self._os_session) self.__image = glance_utils.get_image( self.__glance, image_settings=self.image_settings) if self.__image: logger.info('Found image with name - ' + self.image_settings.name) return self.__image elif (self.image_settings.exists and not self.image_settings.url and not self.image_settings.image_file): raise ImageCreationError('Image with does not exist with name - ' + self.image_settings.name) if self.image_settings.kernel_image_settings: self.__kernel_image = glance_utils.get_image( self.__glance, image_settings=self.image_settings.kernel_image_settings) if self.image_settings.ramdisk_image_settings: self.__ramdisk_image = glance_utils.get_image( self.__glance, image_settings=self.image_settings.ramdisk_image_settings) return self.__image
def test_glance_connect_fail(self): """ Tests to ensure that the improper credentials cannot connect. """ from snaps.openstack.os_credentials import OSCreds with self.assertRaises(Exception): glance = glance_utils.glance_client( OSCreds(username='******', password='******', auth_url='url', project_name='project')) glance_utils.get_image(glance, image_name='foo')
def test_create_same_image_new_settings(self): """ Tests the creation of an OpenStack image when the image already exists and the configuration only contains the name. """ # Create Image self.image_creator = create_image.OpenStackImage(self.os_creds, self.image_settings) image1 = self.image_creator.create() retrieved_image = glance_utils.get_image( self.glance, image_settings=self.image_settings) self.assertIsNotNone(retrieved_image) self.assertEqual(self.image_creator.get_image().size, retrieved_image.size) self.assertEqual(get_image_size(self.image_settings), retrieved_image.size) self.assertEqual(image1.name, retrieved_image.name) self.assertEqual(image1.id, retrieved_image.id) self.assertEqual(image1.properties, retrieved_image.properties) # Should be retrieving the instance data image_2_settings = ImageConfig(name=self.image_settings.name, image_user='******', exists=True) os_image_2 = create_image.OpenStackImage(self.os_creds, image_2_settings) image2 = os_image_2.create() self.assertEqual(image1.id, image2.id)
def test_create_same_image(self): """ Tests the creation of an OpenStack image when the image already exists. """ # Create Image self.image_creator = create_image.OpenStackImage(self.os_creds, self.image_settings) image1 = self.image_creator.create() retrieved_image = glance_utils.get_image( self.glance, image_settings=self.image_settings) self.assertIsNotNone(retrieved_image) self.assertEqual(self.image_creator.get_image().size, retrieved_image.size) self.assertEqual(get_image_size(self.image_settings), retrieved_image.size) self.assertEqual(image1.name, retrieved_image.name) self.assertEqual(image1.id, retrieved_image.id) self.assertEqual(image1.properties, retrieved_image.properties) # Should be retrieving the instance data os_image_2 = create_image.OpenStackImage(self.os_creds, self.image_settings) image2 = os_image_2.create() self.assertEqual(image1.id, image2.id)
def test_create_image_clean_file(self): """ Tests the creation of an OpenStack image from a file. """ if not self.image_settings.image_file and self.image_settings.url: # Download the file of the image image_file_name = file_utils.download(self.image_settings.url, self.tmp_dir).name else: image_file_name = self.image_settings.image_file if image_file_name: file_image_settings = openstack_tests.file_image_test_settings( name=self.image_name, file_path=image_file_name) self.image_creator = create_image.OpenStackImage( self.os_creds, file_image_settings) created_image = self.image_creator.create() self.assertIsNotNone(created_image) self.assertEqual(self.image_name, created_image.name) retrieved_image = glance_utils.get_image( self.glance, image_settings=file_image_settings) self.assertIsNotNone(retrieved_image) self.assertEqual(self.image_creator.get_image().size, retrieved_image.size) self.assertEqual(get_image_size(file_image_settings), retrieved_image.size) self.assertEqual(created_image.name, retrieved_image.name) self.assertEqual(created_image.id, retrieved_image.id) else: logger.warn( 'Test not executed as the image metadata requires image files')
def test_glance_connect_success(self): """ Tests to ensure that the proper credentials can connect. """ glance = glance_utils.glance_client(self.os_creds, self.os_session) image = glance_utils.get_image(glance, image_name='foo') self.assertIsNone(image)
def test_create_three_part_image_from_url(self): """ Tests the creation of a 3-part OpenStack image from a URL. """ # Create the kernel image if 'disk_file' not in self.glance_test_meta: image_settings = openstack_tests.cirros_image_settings( name=self.image_name, image_metadata={ 'disk_url': openstack_tests.CIRROS_DEFAULT_IMAGE_URL, 'kernel_url': openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, 'ramdisk_url': openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL}) image_creator = create_image.OpenStackImage(self.os_creds, image_settings) self.image_creators.append(image_creator) image_creator.create() main_image = glance_utils.get_image(self.glance, image_settings=image_settings) self.assertIsNotNone(main_image) self.assertIsNotNone(image_creator.get_image()) self.assertEqual(image_creator.get_image().id, main_image.id) kernel_image = glance_utils.get_image( self.glance, image_settings=image_settings.kernel_image_settings) self.assertIsNotNone(kernel_image) self.assertIsNotNone(image_creator.get_kernel_image()) self.assertEqual(kernel_image.id, image_creator.get_kernel_image().id) ramdisk_image = glance_utils.get_image( self.glance, image_settings=image_settings.ramdisk_image_settings) self.assertIsNotNone(ramdisk_image) self.assertIsNotNone(image_creator.get_ramdisk_image()) self.assertEqual(ramdisk_image.id, image_creator.get_ramdisk_image().id) else: logger.warn( 'Test not executed as the image metadata requires image files')
def test_create_image_clean_url(self): """ Tests the creation of an OpenStack image from a URL. """ # Create Image # Set the default image settings, then set any custom parameters sent # from the app self.image_creator = create_image.OpenStackImage(self.os_creds, self.image_settings) created_image = self.image_creator.create() self.assertIsNotNone(created_image) retrieved_image = glance_utils.get_image( self.glance, image_settings=self.image_settings) self.assertIsNotNone(retrieved_image) self.assertEqual(created_image.size, retrieved_image.size) self.assertEqual(get_image_size(self.image_settings), retrieved_image.size) self.assertEqual(created_image.name, retrieved_image.name) self.assertEqual(created_image.id, retrieved_image.id)
def test_create_image_minimal_url(self): """ Tests the glance_utils.create_image() function with a URL unless the self.glance_test_meta has configured a file to be used. """ if 'disk_file' not in self.glance_test_meta: os_image_settings = openstack_tests.cirros_image_settings( name=self.image_name, image_metadata=self.glance_test_meta) self.image = glance_utils.create_image(self.glance, os_image_settings) self.assertIsNotNone(self.image) self.assertEqual(self.image_name, self.image.name) image = glance_utils.get_image(self.glance, image_settings=os_image_settings) self.assertIsNotNone(image) validation_utils.objects_equivalent(self.image, image) else: logger.warn('Test not executed as the image metadata requires ' 'image files')
def test_create_image_minimal_file(self): """ Tests the glance_utils.create_image() function with a file """ if 'disk_file' not in self.glance_test_meta: url_image_settings = openstack_tests.cirros_image_settings( name='foo', image_metadata=self.glance_test_meta) image_file_name = file_utils.download(url_image_settings.url, self.tmp_dir).name else: image_file_name = self.glance_test_meta['disk_file'] file_image_settings = openstack_tests.file_image_test_settings( name=self.image_name, file_path=image_file_name) self.image = glance_utils.create_image(self.glance, file_image_settings) self.assertIsNotNone(self.image) self.assertEqual(self.image_name, self.image.name) image = glance_utils.get_image(self.glance, image_settings=file_image_settings) self.assertIsNotNone(image) validation_utils.objects_equivalent(self.image, image)
def deploy_vnf(self): start_time = time.time() self.__logger.info("Upload VNFD") cfy_client = self.orchestrator['object'] descriptor = self.vnf['descriptor'] self.deployment_name = descriptor.get('name') vrouter_blueprint_dir = os.path.join(self.data_dir, self.util.blueprint_dir) if not os.path.exists(vrouter_blueprint_dir): Repo.clone_from(descriptor.get('url'), vrouter_blueprint_dir, branch=descriptor.get('version')) cfy_client.blueprints.upload( vrouter_blueprint_dir + self.util.blueprint_file_name, descriptor.get('name')) self.__logger.info("Get or create flavor for vrouter") flavor_settings = FlavorSettings( name=self.vnf['requirements']['flavor']['name'], ram=self.vnf['requirements']['flavor']['ram_min'], disk=25, vcpus=1) flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings) flavor = flavor_creator.create() self.created_object.append(flavor_creator) # set image name glance = glance_utils.glance_client(self.snaps_creds) image = glance_utils.get_image(glance, "vyos1.1.7") self.vnf['inputs'].update(dict(target_vnf_image_id=image.id)) self.vnf['inputs'].update(dict(reference_vnf_image_id=image.id)) # set flavor id self.vnf['inputs'].update(dict(target_vnf_flavor_id=flavor.id)) self.vnf['inputs'].update(dict(reference_vnf_flavor_id=flavor.id)) self.vnf['inputs'].update(dict(keystone_username=self.tenant_name)) self.vnf['inputs'].update(dict(keystone_password=self.tenant_name)) self.vnf['inputs'].update(dict(keystone_tenant_name=self.tenant_name)) self.vnf['inputs'].update( dict(keystone_url=os_utils.get_endpoint('identity'))) self.__logger.info("Create VNF Instance") cfy_client.deployments.create(descriptor.get('name'), descriptor.get('name'), self.vnf.get('inputs')) wait_for_execution(cfy_client, get_execution_id(cfy_client, descriptor.get('name')), self.__logger, timeout=7200) self.__logger.info("Start the VNF Instance deployment") execution = cfy_client.executions.start(descriptor.get('name'), 'install') # Show execution log execution = wait_for_execution(cfy_client, execution, self.__logger) duration = time.time() - start_time self.__logger.info(execution) if execution.status == 'terminated': self.details['vnf'].update(status='PASS', duration=duration) result = True else: self.details['vnf'].update(status='FAIL', duration=duration) result = False return result
def test_create_three_part_image_from_url_3_creators(self): """ Tests the creation of a 3-part OpenStack image from a URL. """ if 'disk_file' not in self.glance_test_meta: # Set properties properties = {} if self.glance_test_meta and \ 'extra_properties' in self.glance_test_meta: properties = self.glance_test_meta['extra_properties'] # Create the kernel image kernel_image_settings = openstack_tests.cirros_image_settings( name=self.image_name + '_kernel', url=openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL) if self.glance_test_meta: if 'kernel_url' in self.glance_test_meta: kernel_image_settings.url = self.glance_test_meta[ 'kernel_url'] self.image_creators.append( create_image.OpenStackImage(self.os_creds, kernel_image_settings)) kernel_image = self.image_creators[-1].create() self.assertIsNotNone(kernel_image) self.assertEqual(get_image_size(kernel_image_settings), kernel_image.size) # Create the ramdisk image ramdisk_image_settings = openstack_tests.cirros_image_settings( name=self.image_name + '_ramdisk', url=openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL) if self.glance_test_meta: if 'ramdisk_url' in self.glance_test_meta: ramdisk_image_settings.url = self.glance_test_meta[ 'ramdisk_url'] self.image_creators.append( create_image.OpenStackImage(self.os_creds, ramdisk_image_settings)) ramdisk_image = self.image_creators[-1].create() self.assertIsNotNone(ramdisk_image) self.assertEqual(get_image_size(ramdisk_image_settings), ramdisk_image.size) # Create the main image os_image_settings = openstack_tests.cirros_image_settings( name=self.image_name, url=openstack_tests.CIRROS_DEFAULT_IMAGE_URL) if self.glance_test_meta: if 'disk_url' in self.glance_test_meta: os_image_settings.url = self.glance_test_meta['disk_url'] properties['kernel_id'] = kernel_image.id properties['ramdisk_id'] = ramdisk_image.id os_image_settings.extra_properties = properties self.image_creators.append( create_image.OpenStackImage(self.os_creds, os_image_settings)) created_image = self.image_creators[-1].create() self.assertIsNotNone(created_image) self.assertEqual(self.image_name, created_image.name) retrieved_image = glance_utils.get_image( self.glance, image_settings=os_image_settings) self.assertIsNotNone(retrieved_image) self.assertEqual(self.image_creators[-1].get_image().size, retrieved_image.size) self.assertEqual(get_image_size(os_image_settings), retrieved_image.size) self.assertEqual(created_image.name, retrieved_image.name) self.assertEqual(created_image.id, retrieved_image.id) self.assertEqual(created_image.properties, retrieved_image.properties) else: logger.warn( 'Test not executed as the image metadata requires image files')
def test_create_three_part_image_from_file_3_creators(self): """ Tests the creation of a 3-part OpenStack image from files. """ file_only = False # Set properties properties = {} if self.glance_test_meta: if 'extra_properties' in self.glance_test_meta: properties = self.glance_test_meta['extra_properties'] if 'disk_file' in self.glance_test_meta: file_only = True # Create the kernel image kernel_file_name = None kernel_url = openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL if 'kernel_file' in self.glance_test_meta: kernel_file_name = self.glance_test_meta['kernel_file'] elif 'kernel_url' in self.glance_test_meta: kernel_url = self.glance_test_meta['kernel_url'] else: kernel_url = openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL if not kernel_file_name and not file_only: kernel_file_name = file_utils.download(kernel_url, self.tmp_dir).name else: logger.warn('Will not download the kernel image.' ' Cannot execute test') return kernel_file_image_settings = openstack_tests.file_image_test_settings( name=self.image_name + '_kernel', file_path=kernel_file_name) self.image_creators.append(create_image.OpenStackImage( self.os_creds, kernel_file_image_settings)) kernel_image = self.image_creators[-1].create() self.assertIsNotNone(kernel_image) self.assertEqual(get_image_size(kernel_file_image_settings), kernel_image.size) # Create the ramdisk image ramdisk_file_name = None ramdisk_url = openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL if 'ramdisk_file' in self.glance_test_meta: ramdisk_file_name = self.glance_test_meta['ramdisk_file'] elif 'ramdisk_url' in self.glance_test_meta: ramdisk_url = self.glance_test_meta['ramdisk_url'] if not ramdisk_file_name and not file_only: ramdisk_file_name = file_utils.download(ramdisk_url, self.tmp_dir).name else: logger.warn('Will not download the ramdisk image.' ' Cannot execute test') return ramdisk_file_image_settings = openstack_tests.file_image_test_settings( name=self.image_name + '_ramdisk', file_path=ramdisk_file_name) self.image_creators.append(create_image.OpenStackImage( self.os_creds, ramdisk_file_image_settings)) ramdisk_image = self.image_creators[-1].create() self.assertIsNotNone(ramdisk_image) self.assertEqual(get_image_size(ramdisk_file_image_settings), ramdisk_image.size) # Create the main disk image disk_file_name = None disk_url = openstack_tests.CIRROS_DEFAULT_IMAGE_URL if 'disk_file' in self.glance_test_meta: disk_file_name = self.glance_test_meta['disk_file'] elif 'disk_url' in self.glance_test_meta: disk_url = self.glance_test_meta['disk_url'] if not disk_file_name and not file_only: disk_file_name = file_utils.download(disk_url, self.tmp_dir).name else: logger.warn('Will not download the disk file image.' ' Cannot execute test') return file_image_settings = openstack_tests.file_image_test_settings( name=self.image_name, file_path=disk_file_name) properties['kernel_id'] = kernel_image.id properties['ramdisk_id'] = ramdisk_image.id file_image_settings.extra_properties = properties self.image_creators.append( create_image.OpenStackImage(self.os_creds, file_image_settings)) created_image = self.image_creators[-1].create() self.assertIsNotNone(created_image) self.assertEqual(self.image_name, created_image.name) retrieved_image = glance_utils.get_image( self.glance, image_settings=file_image_settings) self.assertIsNotNone(retrieved_image) self.assertEqual(self.image_creators[-1].get_image().size, retrieved_image.size) self.assertEqual(get_image_size(file_image_settings), retrieved_image.size) self.assertEqual(created_image.name, retrieved_image.name) self.assertEqual(created_image.id, retrieved_image.id) self.assertEqual(created_image.properties, retrieved_image.properties)
def create_server(nova, keystone, neutron, glance, instance_config, image_config, project_name, keypair_config=None): """ Creates a VM instance :param nova: the nova client (required) :param keystone: the keystone client for retrieving projects (required) :param neutron: the neutron client for retrieving ports (required) :param glance: the glance client (required) :param instance_config: the VMInstConfig object (required) :param image_config: the VM's ImageConfig object (required) :param project_name: the associated project name (required) :param keypair_config: the VM's KeypairConfig object (optional) :return: a snaps.domain.VmInst object """ ports = list() for port_setting in instance_config.port_settings: port = neutron_utils.get_port(neutron, keystone, port_settings=port_setting, project_name=project_name) if port: ports.append(port) else: raise Exception('Cannot find port named - ' + port_setting.name) nics = [] for port in ports: kv = dict() kv['port-id'] = port.id nics.append(kv) logger.info('Creating VM with name - ' + instance_config.name) keypair_name = None if keypair_config: keypair_name = keypair_config.name flavor = get_flavor_by_name(nova, instance_config.flavor) if not flavor: raise NovaException('Flavor not found with name - %s', instance_config.flavor) image = glance_utils.get_image(glance, image_settings=image_config) if image: userdata = None if instance_config.userdata: if isinstance(instance_config.userdata, str): userdata = instance_config.userdata + '\n' elif (isinstance(instance_config.userdata, dict) and 'script_file' in instance_config.userdata): try: userdata = file_utils.read_file( instance_config.userdata['script_file']) except Exception as e: logger.warn('error reading userdata file %s - %s', instance_config.userdata, e) args = { 'name': instance_config.name, 'flavor': flavor, 'image': image, 'nics': nics, 'key_name': keypair_name, 'security_groups': instance_config.security_group_names, 'userdata': userdata } if instance_config.availability_zone: args['availability_zone'] = instance_config.availability_zone server = nova.servers.create(**args) return __map_os_server_obj_to_vm_inst(neutron, keystone, server, project_name) else: raise NovaException( 'Cannot create instance, image cannot be located with name %s', image_config.name)
def deploy_vnf(self): start_time = time.time() self.__logger.info("Upload VNFD") cfy_client = self.orchestrator['object'] descriptor = self.vnf['descriptor'] self.deployment_name = descriptor.get('name') cfy_client.blueprints.upload(descriptor.get('file_name'), descriptor.get('name')) self.__logger.info("Get or create flavor for vrouter") flavor_settings = FlavorConfig( name=self.vnf['requirements']['flavor']['name'], ram=self.vnf['requirements']['flavor']['ram_min'], disk=25, vcpus=1) flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings) flavor = flavor_creator.create() self.created_object.append(flavor_creator) # set image name glance = glance_utils.glance_client(self.snaps_creds) image = glance_utils.get_image(glance, "vyos1.1.7") user_creator = OpenStackUser( self.snaps_creds, UserConfig(name='cloudify_network_bug-{}'.format(self.uuid), password=str(uuid.uuid4()), project_name=self.tenant_name, domain=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.vnf['inputs'].update(dict(target_vnf_image_id=image.id)) self.vnf['inputs'].update(dict(reference_vnf_image_id=image.id)) self.vnf['inputs'].update(dict(target_vnf_flavor_id=flavor.id)) self.vnf['inputs'].update(dict(reference_vnf_flavor_id=flavor.id)) self.vnf['inputs'].update(dict(keystone_username=snaps_creds.username)) self.vnf['inputs'].update(dict(keystone_password=snaps_creds.password)) self.vnf['inputs'].update( dict(keystone_tenant_name=snaps_creds.project_name)) self.vnf['inputs'].update( dict(keystone_user_domain_name=snaps_creds.user_domain_name)) self.vnf['inputs'].update( dict(keystone_project_domain_name=snaps_creds.project_domain_name)) self.vnf['inputs'].update(dict(region=snaps_creds.region_name)) self.vnf['inputs'].update( dict(keystone_url=keystone_utils.get_endpoint( snaps_creds, 'identity'))) self.__logger.info("Create VNF Instance") cfy_client.deployments.create(descriptor.get('name'), descriptor.get('name'), self.vnf.get('inputs')) wait_for_execution(cfy_client, get_execution_id(cfy_client, descriptor.get('name')), self.__logger, timeout=7200) self.__logger.info("Start the VNF Instance deployment") execution = cfy_client.executions.start(descriptor.get('name'), 'install') # Show execution log execution = wait_for_execution(cfy_client, execution, self.__logger) duration = time.time() - start_time self.__logger.info(execution) if execution.status == 'terminated': self.details['vnf'].update(status='PASS', duration=duration) result = True else: self.details['vnf'].update(status='FAIL', duration=duration) result = False return result