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_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 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_bad_image_file(self):
"""
Expect an ImageCreationError when the image file does not exist
"""
os_image_settings = openstack_tests.cirros_image_settings(
name=self.image_name)
self.image_creator = create_image.OpenStackImage(
self.os_creds,
ImageConfig(
name=os_image_settings.name,
image_user=os_image_settings.image_user,
img_format=os_image_settings.format, image_file="/foo/bar.qcow"))
with self.assertRaises(IOError):
self.image_creator.create()
def test_bad_image_image_type(self):
"""
Expect an ImageCreationError when the image type bad
"""
os_image_settings = openstack_tests.cirros_image_settings(
name=self.image_name)
self.image_creator = create_image.OpenStackImage(
self.os_creds,
ImageConfig(
name=os_image_settings.name,
image_user=os_image_settings.image_user,
img_format='foo', url=os_image_settings.url))
with self.assertRaises(Exception):
self.image_creator.create()
def test_bad_image_name(self):
"""
Expect an ImageCreationError when the image name does not exist when a
file or URL has not been configured
"""
os_image_settings = ImageConfig(name='foo', image_user='******',
exists=True)
self.image_creator = create_image.OpenStackImage(self.os_creds,
os_image_settings)
with self.assertRaises(ImageCreationError):
self.image_creator.create()
self.fail('ImageCreationError should have been raised prior to'
'this line')
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_bad_image_url(self):
"""
Expect an ImageCreationError when the image download url is bad
"""
os_image_settings = openstack_tests.cirros_image_settings(
name=self.image_name)
self.image_creator = create_image.OpenStackImage(
self.os_creds,
ImageConfig(
name=os_image_settings.name,
image_user=os_image_settings.image_user,
img_format=os_image_settings.format,
url="http://foo.bar"))
try:
self.image_creator.create()
except HTTPBadRequest:
pass
except URLError:
pass
except Exception as e:
self.fail('Invalid Exception ' + str(e))
def setUp(self):
"""
Instantiates the CreateImage object that is responsible for downloading
and creating an OS image file within OpenStack
"""
super(self.__class__, self).__start__()
self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.keypair_priv_filepath = 'tmp/' + guid
self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
self.keypair_name = guid + '-kp'
self.vm_inst_name = guid + '-inst'
self.test_file_local_path = 'tmp/' + guid + '-hello.txt'
self.port_1_name = guid + '-port-1'
self.port_2_name = guid + '-port-2'
self.floating_ip_name = guid + 'fip1'
# Setup members to cleanup just in case they don't get created
self.inst_creator = None
self.keypair_creator = None
self.sec_grp_creator = None
self.flavor_creator = None
self.router_creator = None
self.network_creator = None
self.image_creator = None
try:
# Create Image
os_image_settings = openstack_tests.ubuntu_image_settings(
name=guid + '-' + '-image', image_metadata=self.image_metadata)
self.image_creator = create_image.OpenStackImage(
self.os_creds, os_image_settings)
self.image_creator.create()
# First network is public
self.pub_net_config = openstack_tests.get_pub_net_config(
project_name=self.os_creds.project_name,
net_name=guid + '-pub-net',
mtu=1442,
subnet_name=guid + '-pub-subnet',
router_name=guid + '-pub-router',
external_net=self.ext_net_name)
self.network_creator = create_network.OpenStackNetwork(
self.os_creds, self.pub_net_config.network_settings)
self.network_creator.create()
# Create routers
self.router_creator = create_router.OpenStackRouter(
self.os_creds, self.pub_net_config.router_settings)
self.router_creator.create()
# Create Flavor
flavor_config = openstack_tests.get_flavor_config(
name=guid + '-flavor-name',
ram=2048,
disk=10,
vcpus=2,
metadata=self.flavor_metadata)
self.flavor_creator = create_flavor.OpenStackFlavor(
self.admin_os_creds, flavor_config)
self.flavor_creator.create()
# Create Key/Pair
self.keypair_creator = create_keypairs.OpenStackKeypair(
self.os_creds,
KeypairConfig(name=self.keypair_name,
public_filepath=self.keypair_pub_filepath,
private_filepath=self.keypair_priv_filepath))
self.keypair_creator.create()
# Create Security Group
sec_grp_name = guid + '-sec-grp'
rule1 = SecurityGroupRuleConfig(sec_grp_name=sec_grp_name,
direction=Direction.ingress,
protocol=Protocol.icmp)
rule2 = SecurityGroupRuleConfig(sec_grp_name=sec_grp_name,
direction=Direction.ingress,
protocol=Protocol.tcp,
port_range_min=22,
port_range_max=22)
self.sec_grp_creator = OpenStackSecurityGroup(
self.os_creds,
SecurityGroupConfig(name=sec_grp_name,
rule_settings=[rule1, rule2]))
self.sec_grp_creator.create()
# Create instance
ports_settings = list()
ports_settings.append(
PortConfig(
name=self.port_1_name,
network_name=self.pub_net_config.network_settings.name))
instance_settings = VmInstanceConfig(
name=self.vm_inst_name,
flavor=self.flavor_creator.flavor_settings.name,
port_settings=ports_settings,
floating_ip_settings=[
FloatingIpConfig(
name=self.floating_ip_name,
port_name=self.port_1_name,
router_name=self.pub_net_config.router_settings.name)
])
self.inst_creator = create_instance.OpenStackVmInstance(
self.os_creds,
instance_settings,
self.image_creator.image_settings,
keypair_settings=self.keypair_creator.keypair_settings)
except:
self.tearDown()
raise
def 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)