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 test_create_two_vol_same_name_diff_proj(self):
"""
Creates a volume as admin to the project of os_creds then instantiates
a creator object with the os_creds project to ensure it initializes
without creation
"""
vol_name = self.guid + '-vol'
self.volume_creators.append(
OpenStackVolume(self.admin_os_creds, VolumeConfig(name=vol_name)))
admin_vol = self.volume_creators[0].create(block=True)
self.assertIsNotNone(admin_vol)
admin_key = keystone_utils.keystone_client(self.admin_os_creds,
self.admin_os_session)
admin_proj = keystone_utils.get_project(
admin_key, project_name=self.admin_os_creds.project_name)
self.assertEqual(admin_vol.project_id, admin_proj.id)
admin_cinder = cinder_utils.cinder_client(self.admin_os_creds,
self.admin_os_session)
admin_vol_get = cinder_utils.get_volume(
admin_cinder,
admin_key,
volume_name=vol_name,
project_name=self.admin_os_creds.project_name)
self.assertIsNotNone(admin_vol_get)
self.assertEqual(admin_vol, admin_vol_get)
self.volume_creators.append(
OpenStackVolume(self.os_creds, VolumeConfig(name=vol_name)))
proj_vol = self.volume_creators[1].create(block=True)
self.assertIsNotNone(proj_vol)
self.assertNotEqual(admin_vol, proj_vol)
proj_key = keystone_utils.keystone_client(self.os_creds,
self.os_session)
proj_cinder = cinder_utils.cinder_client(self.os_creds,
self.os_session)
proj_vol_get = cinder_utils.get_volume(
proj_cinder,
proj_key,
volume_name=vol_name,
project_name=self.os_creds.project_name)
self.assertIsNotNone(proj_vol_get)
self.assertEqual(proj_vol, proj_vol_get)
def test_cinder_connect_success(self):
"""
Tests to ensure that the proper credentials can connect.
"""
cinder = cinder_utils.cinder_client(self.os_creds, self.os_session)
volumes = cinder.volumes.list()
self.assertIsNotNone(volumes)
self.assertTrue(isinstance(volumes, list))
def setUp(self):
"""
Creates objects for testing cinder_utils.py
"""
guid = uuid.uuid4()
self.qos_name = self.__class__.__name__ + '-' + str(guid)
self.specs = {'foo': 'bar '}
self.qos = None
self.cinder = cinder_utils.cinder_client(
self.os_creds, self.os_session)
def setUp(self):
"""
Instantiates the CreateVolume object that is responsible for
downloading and creating an OS volume file within OpenStack
"""
super(self.__class__, self).__start__()
self.guid = uuid.uuid4()
self.cinder = cinder_utils.cinder_client(self.os_creds,
self.os_session)
self.volume_creator = None
def test_cinder_connect_fail(self):
"""
Tests to ensure that the improper credentials cannot connect.
"""
from snaps.openstack.os_credentials import OSCreds
with self.assertRaises(Exception):
cinder = cinder_utils.cinder_client(OSCreds(
username='******', password='******', auth_url='url',
project_name='project'))
cinder.volumes.list()
def setUp(self):
"""
Instantiates the CreateVolume object that is responsible for
downloading and creating an OS volume file within OpenStack
"""
guid = uuid.uuid4()
volume_type_name = self.__class__.__name__ + '-' + str(guid)
self.volume_type_settings = VolumeTypeConfig(name=volume_type_name)
self.volume_type = None
self.cinder = cinder_utils.cinder_client(
self.os_creds, self.os_session)
def setUp(self):
"""
Creates objects for testing cinder_utils.py
"""
guid = uuid.uuid4()
self.qos_name = self.__class__.__name__ + '-' + str(guid) + '-qos'
self.vol_type_name = self.__class__.__name__ + '-' + str(guid)
self.specs = {'foo': 'bar'}
self.cinder = cinder_utils.cinder_client(
self.os_creds, self.os_session)
qos_settings = QoSConfig(
name=self.qos_name, specs=self.specs, consumer=Consumer.both)
self.qos = cinder_utils.create_qos(self.cinder, qos_settings)
self.volume_type = None
def setUp(self):
super(self.__class__, self).__start__()
self.cinder = cinder_utils.cinder_client(self.admin_os_creds,
self.admin_os_session)
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.volume_type_name = guid + '-vol_type'
self.volume_type_creator = None
qos_settings = QoSConfig(name=guid + '-qos-spec',
consumer=Consumer.both)
self.qos_creator = OpenStackQoS(self.admin_os_creds, qos_settings)
self.qos_creator.create()
def setUp(self):
"""
Instantiates the CreateVolumeType object that is responsible for
downloading and creating an OS volume type file within OpenStack
"""
super(self.__class__, self).__start__()
guid = uuid.uuid4()
self.volume_type_settings = VolumeTypeConfig(
name=self.__class__.__name__ + '-' + str(guid))
self.cinder = cinder_utils.cinder_client(self.admin_os_creds,
self.admin_os_session)
self.volume_type_creator = OpenStackVolumeType(
self.admin_os_creds, self.volume_type_settings)
def setUp(self):
"""
Instantiates the CreateQoS object that is responsible for
downloading and creating an OS QoS Spec file within OpenStack
"""
super(self.__class__, self).__start__()
guid = uuid.uuid4()
qos_settings = QoSConfig(name=self.__class__.__name__ + '-' +
str(guid),
consumer=Consumer.both)
self.cinder = cinder_utils.cinder_client(self.admin_os_creds,
self.admin_os_session)
self.qos_creator = create_qos.OpenStackQoS(self.admin_os_creds,
qos_settings)
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 initialize(self):
"""
Loads the existing VMInst, Port, FloatingIps
:return: VMInst domain object
"""
super(self.__class__, self).initialize()
self.__neutron = neutron_utils.neutron_client(self._os_creds,
self._os_session)
self.__keystone = keystone_utils.keystone_client(
self._os_creds, self._os_session)
self.__cinder = cinder_utils.cinder_client(self._os_creds,
self._os_session)
self.__glance = glance_utils.glance_client(self._os_creds,
self._os_session)
self.__ports = self.__query_ports(self.instance_settings.port_settings)
self.__lookup_existing_vm_by_name()
def initialize(self):
"""
Loads the existing heat stack
:return: The Stack domain object or None
"""
super(self.__class__, self).initialize()
self.__neutron = neutron_utils.neutron_client(self._os_creds,
self._os_session)
self.__nova = nova_utils.nova_client(self._os_creds, self._os_session)
self.__glance = glance_utils.glance_client(self._os_creds,
self._os_session)
self.__cinder = cinder_utils.cinder_client(self._os_creds,
self._os_session)
self.__heat_cli = heat_utils.heat_client(self._os_creds,
self._os_session)
self.__stack = heat_utils.get_stack(self.__heat_cli,
stack_settings=self.stack_settings)
if self.__stack:
logger.info('Found stack with name - ' + self.stack_settings.name)
return self.__stack
def setUp(self):
"""
Instantiates OpenStack instances that cannot be spawned by Heat
"""
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
stack_name = guid + '-stack'
self.volume_name = guid + '-vol'
self.volume_type_name = guid + '-vol-type'
env_values = {
'volume_name': self.volume_name,
'volume_type_name': self.volume_type_name
}
heat_tmplt_path = pkg_resources.resource_filename(
'snaps.openstack.tests.heat', 'volume_heat_template.yaml')
self.stack_settings = StackConfig(name=stack_name,
template_path=heat_tmplt_path,
env_values=env_values)
self.stack = None
self.heat_client = heat_utils.heat_client(self.os_creds,
self.os_session)
self.cinder = cinder_utils.cinder_client(self.os_creds,
self.os_session)
def initialize(self):
super(OpenStackVolumeObject, self).initialize()
self._cinder = cinder_utils.cinder_client(self._os_creds,
self._os_session)
