def generate_creator(os_creds,
vm_inst,
image_config,
project_name,
keypair_config=None):
"""
Initializes an OpenStackVmInstance object
:param os_creds: the OpenStack credentials
:param vm_inst: the SNAPS-OO VmInst domain object
:param image_config: the associated ImageConfig object
:param project_name: the associated project ID
:param keypair_config: the associated KeypairConfig object (optional)
:return: an initialized OpenStackVmInstance object
"""
session = keystone_utils.keystone_session(os_creds)
nova = nova_utils.nova_client(os_creds, session)
keystone = keystone_utils.keystone_client(os_creds, session)
neutron = neutron_utils.neutron_client(os_creds, session)
try:
derived_inst_config = settings_utils.create_vm_inst_config(
nova, keystone, neutron, vm_inst, project_name)
derived_inst_creator = OpenStackVmInstance(os_creds,
derived_inst_config,
image_config,
keypair_config)
derived_inst_creator.initialize()
return derived_inst_creator
finally:
keystone_utils.close_session(session)
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 __reboot_openstack_node(vm_info):
creds_dict = vm_info.get('os_creds')
os_creds = OSCreds(**creds_dict)
logger.debug('Retrieving keystone session %s', creds_dict)
os_sess = keystone_utils.keystone_session(os_creds)
try:
logger.debug('Retrieving OpenStack clients with %s', creds_dict)
nova = nova_utils.nova_client(os_creds, os_sess)
neutron = neutron_utils.neutron_client(os_creds, os_sess)
keystone = keystone_utils.keystone_client(os_creds, os_sess)
logger.info('Retrieved OpenStack clients')
vm_inst = nova_utils.get_server_object_by_id(nova, neutron, keystone,
vm_info['id'])
logger.info('Looking up VM named [%s]', vm_inst.name)
if vm_inst:
logger.debug('Generating VM SNAPS creator with creds [%s]',
creds_dict)
snaps_vm = create_instance.generate_creator(
os_creds, vm_inst, None, os_creds.project_name)
if snaps_vm:
logger.info('Rebooting VM with name %s', vm_inst.name)
snaps_vm.reboot(RebootType.hard)
else:
logger.warn('Unable to obtain a SNAPS-OO VM creator [%s]',
vm_inst.name)
else:
logger.warn('Unable to locate VM with name %s', vm_inst.name)
finally:
logger.info('Closing keystone session')
keystone_utils.close_session(os_sess)
def test_update_quotas(self):
"""
Tests the creation of an OpenStack project where the quotas get
updated.
"""
self.project_creator = OpenStackProject(self.os_creds,
self.project_settings)
created_project = self.project_creator.create()
self.assertIsNotNone(created_project)
retrieved_project = keystone_utils.get_project(
keystone=self.keystone, project_settings=self.project_settings)
self.assertIsNotNone(retrieved_project)
self.assertEqual(created_project, retrieved_project)
self.assertTrue(
validate_project(self.keystone, self.project_settings,
created_project))
update_compute_quotas = ComputeQuotas(
**{
'metadata_items': 64,
'cores': 5,
'instances': 5,
'injected_files': 3,
'injected_file_content_bytes': 5120,
'ram': 25600,
'fixed_ips': 100,
'key_pairs': 50
})
self.project_creator.update_compute_quotas(update_compute_quotas)
update_network_quotas = NetworkQuotas(
**{
'security_group': 5,
'security_group_rule': 50,
'floatingip': 25,
'network': 5,
'port': 25,
'router': 6,
'subnet': 7
})
self.project_creator.update_network_quotas(update_network_quotas)
self.assertEqual(update_compute_quotas,
self.project_creator.get_compute_quotas())
self.assertEqual(update_network_quotas,
self.project_creator.get_network_quotas())
nova = nova_utils.nova_client(self.os_creds, self.os_session)
new_compute_quotas = nova_utils.get_compute_quotas(
nova,
self.project_creator.get_project().id)
self.assertEqual(update_compute_quotas, new_compute_quotas)
neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
new_network_quotas = neutron_utils.get_network_quotas(
neutron,
self.project_creator.get_project().id)
self.assertEqual(update_network_quotas, new_network_quotas)
def __init__(self):
self.os_creds = openstack_tests.get_credentials(
os_env_file=constants.ENV_FILE)
self.creators = []
self.nova = nova_utils.nova_client(self.os_creds)
self.neutron = neutron_utils.neutron_client(self.os_creds)
self.heat = heat_utils.heat_client(self.os_creds)
self.keystone = keystone_utils.keystone_client(self.os_creds)
def test_nova_connect_success(self):
"""
Tests to ensure that the proper credentials can connect.
"""
nova = nova_utils.nova_client(self.os_creds, self.os_session)
# This should not throw an exception
nova.flavors.list()
def get_active_compute_cnt(os_creds):
"""
Returns the number of active compute servers
:param: os_creds: an instance of snaps OSCreds object
:return: the number of active compute servers
"""
nova = nova_utils.nova_client(os_creds)
computes = nova_utils.get_availability_zone_hosts(nova, zone_name='nova')
return len(computes)
def test_nova_get_hypervisor_hosts(self):
"""
Tests to ensure that get_hypervisors() function works.
"""
nova = nova_utils.nova_client(self.os_creds, self.os_session)
hosts = nova_utils.get_hypervisor_hosts(nova)
# This should not throw an exception
self.assertGreaterEqual(len(hosts), 1)
def check_nova(self):
""" checks that a simple nova operation works """
try:
client = nova_utils.nova_client(self.os_creds)
client.servers.list()
LOGGER.info("Nova service ...OK")
except Exception as error:
LOGGER.error("Nova service ...FAILED")
raise error
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 setUp(self):
super(self.__class__, self).__start__()
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.priv_file_path = 'tmp/' + guid
self.pub_file_path = self.priv_file_path + '.pub'
self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
self.keypair_name = guid
self.keypair_creator = None
def update_compute_quotas(self, compute_quotas):
"""
Updates the compute quotas for this project
:param compute_quotas: a ComputeQuotas object.
"""
nova = nova_utils.nova_client(self._os_creds, self._os_session)
try:
nova_utils.update_quotas(nova, self.__project.id, compute_quotas)
finally:
nova.client.session.session.close()
def setUp(self):
"""
Instantiates the CreateImage object that is responsible for downloading
and creating an OS image file within OpenStack
"""
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.flavor_settings = FlavorConfig(
name=guid + '-name', flavor_id=guid + '-id', ram=1, disk=1,
vcpus=1, ephemeral=1, swap=2, rxtx_factor=3.0, is_public=False)
self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
self.flavor = None
def deploy_vnf(self):
"""Deploy ABOT-OAI-EPC."""
self.__logger.info("Upload VNFD")
descriptor = self.vnf['descriptor']
self.__logger.info("Get or create flavor for all Abot-EPC")
flavor_settings = FlavorConfig(
name=self.vnf['requirements']['flavor']['name'],
ram=self.vnf['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("Deploying Abot-epc bundle file ...")
os.system('juju deploy {}'.format('/' + descriptor.get('file_name')))
self.__logger.info("Waiting for instances .....")
status = os.system('juju-wait')
self.__logger.info("juju wait completed: %s", status)
self.__logger.info("Deployed Abot-epc on Openstack")
nova_client = nova_utils.nova_client(self.snaps_creds)
neutron_client = neutron_utils.neutron_client(self.snaps_creds)
if status == 0:
instances = os_utils.get_instances(nova_client)
for items in instances:
metadata = get_instance_metadata(nova_client, items)
if 'juju-units-deployed' in metadata:
sec_group = ('juju-' + metadata['juju-controller-uuid'] +
'-' + metadata['juju-model-uuid'])
self.sec_group_id = os_utils.get_security_group_id(
neutron_client, sec_group)
break
self.__logger.info("Adding Security group rule....")
os_utils.create_secgroup_rule(
neutron_client, self.sec_group_id, 'ingress', 132)
self.__logger.info("Copying the feature files to Abot_node ")
os.system('juju scp -- -r {}/featureFiles abot-'
'epc-basic/0:~/'.format(self.case_dir))
self.__logger.info("Copying the feature files in Abot_node ")
os.system("juju ssh abot-epc-basic/0 'sudo rsync -azvv "
"~/featureFiles /etc/rebaca-test-suite"
"/featureFiles'")
count = 0
while count < 10:
epcstatus = os.system('juju status oai-epc | '
'grep {} | grep {} | grep {}'
.format('EPC', 'is', 'running'))
if epcstatus == 0:
break
else:
time.sleep(60)
count = count + 1
os.system('juju-wait')
return True
return False
def get_compute_quotas(self):
"""
Returns the compute quotas as an instance of the ComputeQuotas class
:return:
"""
nova = nova_utils.nova_client(self._os_creds, self._os_session)
try:
return nova_utils.get_compute_quotas(nova, self.__project.id)
finally:
nova.client.session.session.close()
def setUp(self):
"""
Instantiates the CreateSecurityGroup object that is responsible for
downloading and creating an OS image file within OpenStack
"""
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.flavor_name = guid + 'name'
self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
# Initialize for cleanup
self.flavor_creator = None
def setUp(self):
"""
Instantiates the CreateImage object that is responsible for downloading
and creating an OS image file within OpenStack
"""
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.priv_key_file_path = 'tmp/' + guid
self.pub_key_file_path = self.priv_key_file_path + '.pub'
self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
self.keys = nova_utils.create_keys()
self.public_key = nova_utils.public_key_openssh(self.keys)
self.keypair_name = guid
self.keypair = None
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_nova_connect_fail(self):
"""
Tests to ensure that the improper credentials cannot connect.
"""
from snaps.openstack.os_credentials import OSCreds
nova = nova_utils.nova_client(
OSCreds(username='******', password='******',
auth_url=self.os_creds.auth_url,
project_name=self.os_creds.project_name,
proxy_settings=self.os_creds.proxy_settings))
# This should throw an exception
with self.assertRaises(Exception):
nova.flavors.list()
def setUp(self):
"""
Instantiates OpenStack instances that cannot be spawned by Heat
"""
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.name_prefix = guid
stack_name = guid + '-stack'
heat_tmplt_path = pkg_resources.resource_filename(
'snaps.openstack.tests.heat', 'flavor_heat_template.yaml')
self.stack_settings = StackConfig(name=stack_name,
template_path=heat_tmplt_path)
self.stack = None
self.heat_client = heat_utils.heat_client(self.os_creds,
self.os_session)
self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
def create(self):
"""
Creates a Project/Tenant in OpenStack if it does not already exist
:return: The Project domain object
"""
self.initialize()
if not self.__project:
self.__project = keystone_utils.create_project(
self._keystone, self.project_settings)
for username in self.project_settings.users:
user = keystone_utils.get_user(self._keystone, username)
if user:
try:
self.assoc_user(user)
except Conflict as e:
logger.warn('Unable to associate user %s due to %s',
user.name, e)
if self.project_settings.quotas:
quota_dict = self.project_settings.quotas
nova = nova_utils.nova_client(self._os_creds, self._os_session)
quotas = nova_utils.get_compute_quotas(nova, self.__project.id)
if quotas:
if 'cores' in quota_dict:
quotas.cores = quota_dict['cores']
if 'instances' in quota_dict:
quotas.instances = quota_dict['instances']
if 'injected_files' in quota_dict:
quotas.injected_files = quota_dict['injected_files']
if 'injected_file_content_bytes' in quota_dict:
quotas.injected_file_content_bytes = \
quota_dict['injected_file_content_bytes']
if 'ram' in quota_dict:
quotas.ram = quota_dict['ram']
if 'fixed_ips' in quota_dict:
quotas.fixed_ips = quota_dict['fixed_ips']
if 'key_pairs' in quota_dict:
quotas.key_pairs = quota_dict['key_pairs']
nova_utils.update_quotas(nova, self.__project.id, quotas)
return self.__project
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 test_create_project_quota_override(self):
"""
Tests the creation of an OpenStack project with new quotas.
"""
quotas = {
'cores': 4,
'instances': 5,
'injected_files': 6,
'injected_file_content_bytes': 60000,
'ram': 70000,
'fixed_ips': 7,
'key_pairs': 8
}
self.project_settings.quotas = quotas
self.project_creator = OpenStackProject(self.os_creds,
self.project_settings)
created_project = self.project_creator.create()
self.assertIsNotNone(created_project)
retrieved_project = keystone_utils.get_project(
keystone=self.keystone, project_settings=self.project_settings)
self.assertIsNotNone(retrieved_project)
self.assertEqual(created_project, retrieved_project)
self.assertTrue(
validate_project(self.keystone, self.project_settings,
created_project))
nova = nova_utils.nova_client(self.os_creds, self.os_session)
new_quotas = nova_utils.get_compute_quotas(nova, created_project.id)
self.assertEqual(4, new_quotas.cores)
self.assertEqual(5, new_quotas.instances)
self.assertEqual(6, new_quotas.injected_files)
self.assertEqual(60000, new_quotas.injected_file_content_bytes)
self.assertEqual(70000, new_quotas.ram)
self.assertEqual(7, new_quotas.fixed_ips)
self.assertEqual(8, new_quotas.key_pairs)
def deploy_vnf(self):
"""Deploy ABOT-OAI-EPC."""
self.__logger.info("Upload VNFD")
descriptor = self.vnf['descriptor']
self.__logger.info("Get or create flavor for all Abot-EPC")
flavor_settings = FlavorConfig(
name=self.vnf['requirements']['flavor']['name'],
ram=self.vnf['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("Deploying Abot-epc bundle file ...")
cmd = [
'timeout', '-t', JujuEpc.juju_timeout, 'juju', 'deploy',
'{}'.format(descriptor.get('file_name'))
]
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
self.__logger.info("%s\n%s", " ".join(cmd), output)
self.__logger.info("Waiting for instances .....")
cmd = ['timeout', '-t', JujuEpc.juju_timeout, 'juju-wait']
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
self.__logger.info("%s\n%s", " ".join(cmd), output)
self.__logger.info("Deployed Abot-epc on Openstack")
nova_client = nova_utils.nova_client(self.snaps_creds)
instances = get_instances(nova_client)
self.__logger.info("List of Instance: %s", instances)
for items in instances:
metadata = get_instance_metadata(nova_client, items)
if 'juju-units-deployed' in metadata:
sec_group = 'juju-{}-{}'.format(
metadata['juju-controller-uuid'],
metadata['juju-model-uuid'])
self.__logger.info("Instance: %s", sec_group)
break
self.__logger.info("Adding Security group rule....")
# This will add sctp rule to a common Security Group Created
# by juju and shared to all deployed units.
self._add_custom_rule(sec_group)
cmd = ['juju', 'status']
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
self.__logger.debug("%s\n%s", " ".join(cmd), output)
for app in ['abot-epc-basic', 'oai-epc', 'oai-hss']:
if not self.check_app(app):
return False
self.__logger.info("Copying the feature files to Abot_node ")
cmd = [
'timeout', '-t', JujuEpc.juju_timeout, 'juju', 'scp', '--', '-r',
'-v', '{}/featureFiles'.format(self.case_dir),
'abot-epc-basic/0:~/'
]
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
self.__logger.info("%s\n%s", " ".join(cmd), output)
self.__logger.info("Copying the feature files in Abot_node ")
cmd = [
'timeout', '-t', JujuEpc.juju_timeout, 'juju', 'ssh',
'abot-epc-basic/0', 'sudo', 'rsync', '-azvv', '~/featureFiles',
'/etc/rebaca-test-suite/featureFiles'
]
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
self.__logger.info("%s\n%s", " ".join(cmd), output)
return True
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 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 initialize(self):
super(OpenStackComputeObject, self).initialize()
self._nova = nova_utils.nova_client(self._os_creds, self._os_session)
def get_nova_client(self):
nova_client = nova_utils.nova_client(self.snaps_creds)
return nova_client
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)
