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
