def testing_instance(setup_provider, provider):
""" Fixture to provision instance on the provider
"""
instance = Instance.factory(random_vm_name('pwr-c'), provider)
if not provider.mgmt.does_vm_exist(instance.name):
instance.create_on_provider(allow_skip="default")
elif instance.provider.type == "ec2" and \
provider.mgmt.is_vm_state(instance.name, provider.mgmt.states['deleted']):
provider.mgmt.set_name(
instance.name, 'test_terminated_{}'.format(fauxfactory.gen_alphanumeric(8)))
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
provider.refresh_provider_relationships()
# Make sure the instance shows up
try:
wait_for(lambda: instance.exists,
fail_condition=False,
num_sec=600,
delay=15,
fail_func=provider.refresh_provider_relationships)
except TimedOutError:
pytest.fail('Failed to find instance in CFME after creating on provider: {}'
.format(instance.name))
yield instance
logger.info('Fixture cleanup, deleting test instance: %s', instance.name)
try:
provider.mgmt.delete_vm(instance.name)
except Exception:
logger.exception('Exception when deleting testing_instance: %s', instance.name)
def test_provision_from_template(request, setup_provider, provider,
provisioning, vm_name):
""" Tests instance provision from template
Metadata:
test_flag: provision
"""
image = provisioning['image']['name']
note = (
'Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
'instance_type': provisioning['instance_type'],
'availability_zone': provisioning['availability_zone'],
'security_groups': [provisioning['security_group']],
'guest_keypair': provisioning['guest_keypair']
}
if isinstance(provider, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
sel.force_navigate("clouds_instances_by_provider")
instance.create(**inst_args)
def test_tenant_quota_enforce_via_lifecycle_cloud(request, appliance, provider,
setup_provider,
set_roottenant_quota,
extra_msg, custom_prov_data,
approve, prov_data, vm_name,
template_name):
"""Test Tenant Quota in UI"""
prov_data.update(custom_prov_data)
prov_data['catalog']['vm_name'] = vm_name
prov_data.update({
'request': {
'email':
'test_{}@example.com'.format(fauxfactory.gen_alphanumeric())
},
'properties': {
'instance_type': partial_match('m1.large')
}
})
instance = Instance.factory(vm_name, provider, template_name)
instance.create(**prov_data)
# nav to requests page to check quota validation
request_description = 'Provision from [{}] to [{}{}]'.format(
template_name, vm_name, extra_msg)
provision_request = appliance.collections.requests.instantiate(
request_description)
if approve:
provision_request.approve_request(method='ui', reason="Approved")
provision_request.wait_for_request(method='ui')
assert provision_request.row.reason.text == "Quota Exceeded"
request.addfinalizer(provision_request.remove_request)
def testing_instance(request, setup_provider, provider):
""" Fixture to provision instance on the provider
"""
instance = Instance.factory(random_vm_name('pwr-c'), provider)
if not provider.mgmt.does_vm_exist(instance.name):
instance.create_on_provider(timeout=1000,
allow_skip="default",
find_in_cfme=True)
elif instance.provider.type == "ec2" and \
provider.mgmt.is_vm_state(instance.name, provider.mgmt.states['deleted']):
provider.mgmt.set_name(
instance.name,
'test_terminated_{}'.format(fauxfactory.gen_alphanumeric(8)))
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
provider.refresh_provider_relationships()
instance.wait_to_appear()
yield instance
try:
logger.info(
'Fixture cleanup, deleting test instance: {}'.format(instance))
instance.power_control_from_cfme(option=instance.TERMINATE)
except Exception as ex:
logger.warning(
'Exception when deleting testing_instance: {}'.format(ex))
def testing_instance(request, setup_provider, provider, provisioning, vm_name):
""" Fixture to prepare instance parameters for provisioning
"""
image = provisioning["image"]["name"]
note = "Testing provisioning from image {} to vm {} on provider {}".format(image, vm_name, provider.key)
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
"email": "*****@*****.**",
"first_name": "Image",
"last_name": "Provisioner",
"notes": note,
"instance_type": provisioning["instance_type"] if provider.type != "azure" else provisioning["vm_size"],
"availability_zone": provisioning["availability_zone"] if provider.type != "azure" else None,
"security_groups": [provisioning["security_group"]]
if provider.type != "azure"
else provisioning["network_nsg"],
"guest_keypair": provisioning["guest_keypair"] if provider.type != "azure" else None,
}
if isinstance(provider, OpenStackProvider):
inst_args["cloud_network"] = provisioning["cloud_network"]
if isinstance(provider, AzureProvider):
inst_args["cloud_network"] = provisioning["virtual_net"]
inst_args["cloud_subnet"] = provisioning["subnet_range"]
inst_args["security_groups"] = provisioning["network_nsg"]
inst_args["resource_groups"] = provisioning["resource_group"]
inst_args["instance_type"] = provisioning["vm_size"]
inst_args["admin_username"] = provisioning["vm_user"]
inst_args["admin_password"] = provisioning["vm_password"]
return instance, inst_args
def test_provision_from_template(request, setup_provider, provider, vm_name, provisioning):
""" Tests instance provision from template
Metadata:
test_flag: provision
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
'instance_type': provisioning['instance_type'],
'availability_zone': provisioning['availability_zone'],
'security_groups': [provisioning['security_group']],
'guest_keypair': provisioning['guest_keypair']
}
if isinstance(provider, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
sel.force_navigate("clouds_instances_by_provider")
instance.create(**inst_args)
def testing_instance(setup_provider, provider):
""" Fixture to provision instance on the provider
"""
instance = Instance.factory(random_vm_name('pwr-c'), provider)
if not provider.mgmt.does_vm_exist(instance.name):
instance.create_on_provider(allow_skip="default")
elif instance.provider.type == "ec2" and \
provider.mgmt.is_vm_state(instance.name, provider.mgmt.states['deleted']):
provider.mgmt.set_name(
instance.name,
'test_terminated_{}'.format(fauxfactory.gen_alphanumeric(8)))
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
provider.refresh_provider_relationships()
# Make sure the instance shows up
try:
wait_for(lambda: instance.exists,
fail_condition=False,
num_sec=600,
delay=15,
fail_func=provider.refresh_provider_relationships)
except TimedOutError:
pytest.fail(
'Failed to find instance in CFME after creating on provider: {}'.
format(instance.name))
yield instance
logger.info('Fixture cleanup, deleting test instance: %s', instance.name)
try:
provider.mgmt.delete_vm(instance.name)
except Exception:
logger.exception('Exception when deleting testing_instance: %s',
instance.name)
def test_instance(setup_provider_modscope, request, delete_instances_fin, provider, vm_name):
""" Fixture to provision instance on the provider
"""
instance = Instance.factory(vm_name, provider)
if not provider.mgmt.does_vm_exist(vm_name):
delete_instances_fin[provider.key] = instance
instance.create_on_provider(allow_skip="default")
return instance
def test_provision_with_boot_volume(request, setup_provider, provider, vm_name,
soft_assert, domain, copy_domains, provisioning, modified_request_class):
""" Tests provisioning from a template and attaching one booting volume.
Metadata:
test_flag: provision, volumes
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
with provider.mgmt.with_volume(1, imageRef=provider.mgmt.get_template_id(image)) as volume:
# Set up automate
method = modified_request_class.methods.instantiate(name="openstack_CustomizeRequest")
with update(method):
method.script = dedent('''\
$evm.root["miq_provision"].set_option(
:clone_options, {{
:image_ref => nil,
:block_device_mapping_v2 => [{{
:boot_index => 0,
:uuid => "{}",
:device_name => "vda",
:source_type => "volume",
:destination_type => "volume",
:delete_on_termination => false
}}]
}}
)
'''.format(volume))
@request.addfinalizer
def _finish_method():
with update(method):
method.script = """prov = $evm.root["miq_provision"]"""
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
'instance_type': provisioning['instance_type'],
"availability_zone": provisioning["availability_zone"],
'security_groups': [provisioning['security_group']],
'guest_keypair': provisioning['guest_keypair']
}
if isinstance(provider, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
instance.create(**inst_args)
soft_assert(vm_name in provider.mgmt.volume_attachments(volume))
soft_assert(provider.mgmt.volume_attachments(volume)[vm_name] == "vda")
instance.delete_from_provider() # To make it possible to delete the volume
wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5)
def test_provision_from_template_with_attached_disks(
request, setup_provider, provider, vm_name, provisioning,
disks, soft_assert, domain, modified_request_class, copy_domains):
""" Tests provisioning from a template and attaching disks
Metadata:
test_flag: provision
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
DEVICE_NAME = "/dev/sd{}"
device_mapping = []
with provider.mgmt.with_volumes(1, n=disks) as volumes:
for i, volume in enumerate(volumes):
device_mapping.append((volume, DEVICE_NAME.format(chr(ord("b") + i))))
# Set up automate
method = modified_request_class.methods.instantiate(name="openstack_PreProvision")
with update(method):
disk_mapping = []
for mapping in device_mapping:
disk_mapping.append(ONE_FIELD.format(*mapping))
method.script = VOLUME_METHOD.format(", ".join(disk_mapping))
def _finish_method():
with update(method):
method.script = """prov = $evm.root["miq_provision"]"""
request.addfinalizer(_finish_method)
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
'instance_type': provisioning['instance_type'],
"availability_zone": provisioning["availability_zone"] if provider.type != "azure" else
provisioning["av_set"],
'security_groups': [provisioning['security_group']],
'guest_keypair': provisioning['guest_keypair']
}
if isinstance(provider, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
instance.create(**inst_args)
for volume_id in volumes:
soft_assert(vm_name in provider.mgmt.volume_attachments(volume_id))
for volume, device in device_mapping:
soft_assert(provider.mgmt.volume_attachments(volume)[vm_name] == device)
instance.delete_from_provider() # To make it possible to delete the volume
wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5)
def new_vm(provider, request):
if provider.one_of(CloudProvider):
vm = Instance.factory(random_vm_name(context='cockpit'), provider)
else:
vm = Vm.factory(random_vm_name(context='cockpit'), provider)
if not provider.mgmt.does_vm_exist(vm.name):
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
request.addfinalizer(vm.cleanup_on_provider)
return vm
def new_instance(provider):
inst = Instance.factory(random_vm_name('cloud-timeline', max_length=20), provider)
logger.debug('Fixture new_instance set up! Name: %r Provider: %r', inst.name,
inst.provider.name)
inst.create_on_provider(allow_skip="default", find_in_cfme=True)
yield inst
logger.debug('Fixture new_vm teardown! Name: %r Provider: %r', inst.name, inst.provider.name)
if inst.provider.mgmt.does_vm_exist(inst.name):
inst.provider.mgmt.delete_vm(inst.name)
def new_vm(provider, request):
if provider.one_of(CloudProvider):
vm = Instance.factory(random_vm_name(context='cockpit'), provider)
else:
vm = InfraVm.factory(random_vm_name(context='cockpit'), provider)
if not provider.mgmt.does_vm_exist(vm.name):
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
request.addfinalizer(vm.cleanup_on_provider)
return vm
def testing_instance(request, setup_provider, provider, provisioning, vm_name):
""" Fixture to prepare instance parameters for provisioning
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
}
# TODO Move this into helpers on the provider classes
if not isinstance(provider, AzureProvider):
inst_args['instance_type'] = provisioning['instance_type']
inst_args['availability_zone'] = provisioning['availability_zone']
inst_args['security_groups'] = provisioning['security_group']
inst_args['guest_keypair'] = provisioning['guest_keypair']
if isinstance(provider, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
if isinstance(provider, GCEProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
inst_args['boot_disk_size'] = provisioning['boot_disk_size']
inst_args['is_preemtible'] = True if current_version() >= "5.7" else None
if isinstance(provider, AzureProvider):
inst_args['cloud_network'] = provisioning['virtual_net']
inst_args['cloud_subnet'] = provisioning['subnet_range']
inst_args['security_groups'] = provisioning['network_nsg']
inst_args['resource_groups'] = provisioning['resource_group']
inst_args['instance_type'] = provisioning['vm_size'].lower()
inst_args['admin_username'] = provisioning['vm_user']
inst_args['admin_password'] = provisioning['vm_password']
try:
auto = request.param
if auto:
inst_args['automatic_placement'] = True
inst_args['availability_zone'] = None
inst_args['virtual_private_cloud'] = None
inst_args['cloud_network'] = None
inst_args['cloud_subnet'] = None
inst_args['security_groups'] = None
inst_args['resource_groups'] = None
inst_args['public_ip_address'] = None
except AttributeError:
# in case nothing was passed just skip
pass
return instance, inst_args, image
def create_instance(provider):
instance = Instance.factory(random_vm_name('pwr-c'), provider)
if not provider.mgmt.does_vm_exist(instance.name):
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
elif instance.provider.type == "ec2" and \
provider.mgmt.is_vm_state(instance.name, provider.mgmt.states['deleted']):
provider.mgmt.set_name(
instance.name, 'test_terminated_{}'.format(fauxfactory.gen_alphanumeric(8)))
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
return instance
def test_instance(request, provider):
instance = Instance.factory(random_vm_name("timelines", max_length=16),
provider)
request.addfinalizer(instance.delete_from_provider)
if not provider.mgmt.does_vm_exist(instance.name):
logger.info("deploying %s on provider %s", instance.name, provider.key)
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
return instance
def create_instance(provider):
instance = Instance.factory(random_vm_name('pwr-c'), provider)
if not provider.mgmt.does_vm_exist(instance.name):
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
elif instance.provider.type == "ec2" and \
provider.mgmt.is_vm_state(instance.name, provider.mgmt.states['deleted']):
provider.mgmt.set_name(
instance.name, 'test_terminated_{}'.format(fauxfactory.gen_alphanumeric(8)))
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
return instance
def new_instance(request, provider):
instance = Instance.factory(random_vm_name("timelines", max_length=16), provider)
request.addfinalizer(instance.delete_from_provider)
if not provider.mgmt.does_vm_exist(instance.name):
logger.info("deploying %s on provider %s", instance.name, provider.key)
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
if instance.provider.one_of(EC2Provider):
ec2_sleep()
return instance
def new_instance(provider):
inst = Instance.factory(random_vm_name('cloud-timeline', max_length=20),
provider)
logger.debug('Fixture new_instance set up! Name: %r Provider: %r',
inst.name, inst.provider.name)
inst.create_on_provider(allow_skip="default", find_in_cfme=True)
yield inst
logger.debug('Fixture new_vm teardown! Name: %r Provider: %r', inst.name,
inst.provider.name)
if inst.provider.mgmt.does_vm_exist(inst.name):
inst.provider.mgmt.delete_vm(inst.name)
def test_provision_cloud_init(request, setup_provider, provider, provisioning,
setup_ci_template, vm_name):
""" Tests provisioning from a template with cloud_init
Metadata:
test_flag: cloud_init, provision
"""
image = provisioning.get('ci-image', None) or provisioning['image']['name']
note = (
'Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
logger.info(note)
mgmt_system = provider.mgmt
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
'instance_type': provisioning['instance_type'],
'availability_zone': provisioning['availability_zone'],
'security_groups': [provisioning['security_group']],
'guest_keypair': provisioning['guest_keypair'],
'custom_template': {
'name': [provisioning['ci-template']]
},
}
if provider.type == "openstack":
floating_ip = mgmt_system.get_first_floating_ip()
inst_args['cloud_network'] = provisioning['cloud_network']
inst_args['public_ip_address'] = floating_ip
logger.info('Instance args: {}'.format(inst_args))
instance.create(**inst_args)
connect_ip, tc = wait_for(mgmt_system.get_ip_address, [vm_name],
num_sec=300,
handle_exception=True)
# Check that we can at least get the uptime via ssh this should only be possible
# if the username and password have been set via the cloud-init script so
# is a valid check
with ssh.SSHClient(hostname=connect_ip,
username=provisioning['ci-username'],
password=provisioning['ci-pass']) as ssh_client:
wait_for(ssh_client.uptime, num_sec=200, handle_exception=True)
def testing_instance(request, setup_provider, provider):
""" Fixture to provision instance on the provider
"""
instance = Instance.factory("test_inst_pwrctl_{}".format(fauxfactory.gen_alpha(8)), provider)
if not provider.mgmt.does_vm_exist(instance.name):
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
request.addfinalizer(instance.delete_from_provider)
elif instance.provider.type == "ec2" and \
provider.mgmt.is_vm_state(instance.name, provider.mgmt.states['deleted']):
provider.mgmt.set_name(
instance.name, 'test_terminated_{}'.format(fauxfactory.gen_alphanumeric(8)))
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
request.addfinalizer(instance.delete_from_provider)
return instance
def testing_instance(request, setup_provider, provider):
""" Fixture to provision instance on the provider
"""
instance = Instance.factory("test_inst_pwrctl_{}".format(fauxfactory.gen_alpha(8)), provider)
if not provider.mgmt.does_vm_exist(instance.name):
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
request.addfinalizer(instance.delete_from_provider)
elif instance.provider.type == "ec2" and \
provider.mgmt.is_vm_state(instance.name, provider.mgmt.states['deleted']):
provider.mgmt.set_name(
instance.name, 'test_terminated_{}'.format(fauxfactory.gen_alphanumeric(8)))
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
request.addfinalizer(instance.delete_from_provider)
return instance
def test_provision_cloud_init(request, setup_provider, provider, provisioning,
setup_ci_template, vm_name):
""" Tests provisioning from a template with cloud_init
Metadata:
test_flag: cloud_init, provision
"""
image = provisioning.get('ci-image') or provisioning['image']['name']
note = ('Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
logger.info(note)
mgmt_system = provider.mgmt
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.cleanup_on_provider)
# TODO: extend inst_args for other providers except EC2 if needed
inst_args = {
'request': {'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note},
'catalog': {'vm_name': vm_name},
'properties': {'instance_type': provisioning['instance_type'],
'guest_keypair': provisioning['guest_keypair']},
'environment': {'availability_zone': provisioning['availability_zone'],
'cloud_network': provisioning['cloud_network'],
'security_groups': [provisioning['security_group']]},
'customize': {'custom_template': {'name': provisioning['ci-template']}}
}
if provider.one_of(OpenStackProvider):
floating_ip = mgmt_system.get_first_floating_ip()
inst_args['environment']['public_ip_address'] = floating_ip
logger.info('Instance args: {}'.format(inst_args))
instance.create(**inst_args)
provision_request = provider.appliance.collections.requests.instantiate(vm_name,
partial_check=True)
provision_request.wait_for_request()
connect_ip = mgmt_system.get_ip_address(vm_name)
# Check that we can at least get the uptime via ssh this should only be possible
# if the username and password have been set via the cloud-init script so
# is a valid check
with ssh.SSHClient(hostname=connect_ip, username=provisioning['ci-username'],
password=provisioning['ci-pass']) as ssh_client:
wait_for(ssh_client.uptime, num_sec=200, handle_exception=True)
def test_provision_cloud_init(request, setup_provider, provider, provisioning,
setup_ci_template, vm_name):
""" Tests provisioning from a template with cloud_init
Metadata:
test_flag: cloud_init, provision
"""
image = provisioning.get('ci-image', None) or provisioning['image']['name']
note = ('Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
logger.info(note)
mgmt_system = provider.mgmt
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
'instance_type': provisioning['instance_type'],
'availability_zone': provisioning['availability_zone'],
'security_groups': [provisioning['security_group']],
'guest_keypair': provisioning['guest_keypair'],
'custom_template': {'name': [provisioning['ci-template']]},
}
if provider.type == "openstack":
floating_ip = mgmt_system.get_first_floating_ip()
inst_args['cloud_network'] = provisioning['cloud_network']
inst_args['public_ip_address'] = floating_ip
logger.info('Instance args: {}'.format(inst_args))
instance.create(**inst_args)
connect_ip, tc = wait_for(mgmt_system.get_ip_address, [vm_name], num_sec=300,
handle_exception=True)
# Check that we can at least get the uptime via ssh this should only be possible
# if the username and password have been set via the cloud-init script so
# is a valid check
sshclient = ssh.SSHClient(hostname=connect_ip, username=provisioning['ci-username'],
password=provisioning['ci-pass'])
wait_for(sshclient.uptime, num_sec=200, handle_exception=True)
def testing_instance(request, setup_provider, provider):
""" Fixture to provision instance on the provider
"""
instance = Instance.factory(random_vm_name('pwr-c'), provider)
if not provider.mgmt.does_vm_exist(instance.name):
instance.create_on_provider(timeout=1000, allow_skip="default", find_in_cfme=True)
request.addfinalizer(instance.delete_from_provider)
provider.refresh_provider_relationships()
elif instance.provider.type == "ec2" and \
provider.mgmt.is_vm_state(instance.name, provider.mgmt.states['deleted']):
provider.mgmt.set_name(
instance.name, 'test_terminated_{}'.format(fauxfactory.gen_alphanumeric(8)))
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
request.addfinalizer(instance.delete_from_provider)
provider.refresh_provider_relationships()
instance.wait_to_appear()
return instance
def testing_instance(setup_provider, provider):
""" Fixture to provision instance on the provider
"""
instance = Instance.factory(random_vm_name('pwr-c'), provider)
if not provider.mgmt.does_vm_exist(instance.name):
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
elif instance.provider.type == "ec2" and \
provider.mgmt.is_vm_state(instance.name, provider.mgmt.states['deleted']):
provider.mgmt.set_name(
instance.name, 'test_terminated_{}'.format(fauxfactory.gen_alphanumeric(8)))
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
yield instance
logger.info('Fixture cleanup, deleting test instance: %s', instance.name)
try:
provider.mgmt.delete_vm(instance.name)
except Exception:
logger.exception('Exception when deleting testing_instance: %s', instance.name)
def test_tenant_quota_enforce_via_lifecycle_cloud(request, appliance, provider, setup_provider,
set_roottenant_quota, extra_msg, custom_prov_data,
approve, prov_data, vm_name, template_name):
"""Test Tenant Quota in UI"""
prov_data.update(custom_prov_data)
prov_data['catalog']['vm_name'] = vm_name
prov_data.update({
'request': {'email': 'test_{}@example.com'.format(fauxfactory.gen_alphanumeric())}})
instance = Instance.factory(vm_name, provider, template_name)
instance.create(**prov_data)
# nav to requests page to check quota validation
request_description = 'Provision from [{}] to [{}{}]'.format(template_name, vm_name, extra_msg)
provision_request = appliance.collections.requests.instantiate(request_description)
if approve:
provision_request.approve_request(method='ui', reason="Approved")
provision_request.wait_for_request(method='ui')
assert provision_request.row.reason.text == "Quota Exceeded"
request.addfinalizer(provision_request.remove_request)
def testing_instance(request, setup_provider, provider, provisioning, vm_name):
""" Fixture to prepare instance parameters for provisioning
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
}
if not isinstance(provider, AzureProvider):
inst_args['instance_type'] = provisioning['instance_type']
inst_args['availability_zone'] = provisioning['availability_zone']
inst_args['security_groups'] = [provisioning['security_group']]
inst_args['guest_keypair'] = provisioning['guest_keypair']
if isinstance(provider, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
if isinstance(provider, GCEProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
inst_args['boot_disk_size'] = provisioning['boot_disk_size']
inst_args['is_preemtible'] = True if current_version() >= "5.7" else None
if isinstance(provider, AzureProvider):
inst_args['cloud_network'] = provisioning['virtual_net']
inst_args['cloud_subnet'] = provisioning['subnet_range']
inst_args['security_groups'] = provisioning['network_nsg']
inst_args['resource_groups'] = provisioning['resource_group']
inst_args['instance_type'] = provisioning['vm_size'].lower() \
if current_version() >= "5.7" else provisioning['vm_size']
inst_args['admin_username'] = provisioning['vm_user']
inst_args['admin_password'] = provisioning['vm_password']
return instance, inst_args
def testing_instance(request, setup_provider, provider):
""" Fixture to provision instance on the provider
"""
instance = Instance.factory(random_vm_name('pwr-c'), provider)
if not provider.mgmt.does_vm_exist(instance.name):
instance.create_on_provider(timeout=1000, allow_skip="default", find_in_cfme=True)
elif instance.provider.type == "ec2" and \
provider.mgmt.is_vm_state(instance.name, provider.mgmt.states['deleted']):
provider.mgmt.set_name(
instance.name, 'test_terminated_{}'.format(fauxfactory.gen_alphanumeric(8)))
instance.create_on_provider(allow_skip="default", find_in_cfme=True)
provider.refresh_provider_relationships()
instance.wait_to_appear()
yield instance
try:
logger.info('Fixture cleanup, deleting test instance: {}'.format(instance))
instance.power_control_from_cfme(option=instance.TERMINATE)
except Exception as ex:
logger.warning('Exception when deleting testing_instance: {}'.format(ex))
def test_provision_with_additional_volume(request, setup_provider, provider, vm_name,
soft_assert, copy_domains, domain, provisioning):
""" Tests provisioning with setting specific image from AE and then also making it create and
attach an additional 3G volume.
Metadata:
test_flag: provision, volumes
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
# Set up automate
cls = automate.Class(
name="Methods",
namespace=automate.Namespace.make_path("Cloud", "VM", "Provisioning", "StateMachines",
parent=domain))
method = automate.Method(
name="openstack_CustomizeRequest",
cls=cls)
try:
image_id = provider.mgmt.get_template_id(provider.data["small_template"])
except KeyError:
pytest.skip("No small_template in provider adta!")
with update(method):
method.data = dedent('''\
$evm.root["miq_provision"].set_option(
:clone_options, {{
:image_ref => nil,
:block_device_mapping_v2 => [{{
:boot_index => 0,
:uuid => "{}",
:device_name => "vda",
:source_type => "image",
:destination_type => "volume",
:volume_size => 3,
:delete_on_termination => false
}}]
}}
)
'''.format(image_id))
def _finish_method():
with update(method):
method.data = """prov = $evm.root["miq_provision"]"""
request.addfinalizer(_finish_method)
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
'instance_type': provisioning['instance_type'],
'availability_zone': provisioning['availability_zone'],
'security_groups': [provisioning['security_group']],
'guest_keypair': provisioning['guest_keypair']
}
if isinstance(provider, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
sel.force_navigate("clouds_instances_by_provider")
instance.create(**inst_args)
prov_instance = provider.mgmt._find_instance_by_name(vm_name)
try:
assert hasattr(prov_instance, 'os-extended-volumes:volumes_attached')
volumes_attached = getattr(prov_instance, 'os-extended-volumes:volumes_attached')
assert len(volumes_attached) == 1
volume_id = volumes_attached[0]["id"]
assert provider.mgmt.volume_exists(volume_id)
volume = provider.mgmt.get_volume(volume_id)
assert volume.size == 3
finally:
instance.delete_from_provider()
wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5)
if "volume_id" in locals(): # To handle the case of 1st or 2nd assert
if provider.mgmt.volume_exists(volume_id):
provider.mgmt.delete_volume(volume_id)
def test_provision_with_boot_volume(request, setup_provider, provider, vm_name,
soft_assert, domain, copy_domains, provisioning):
""" Tests provisioning from a template and attaching one booting volume.
Metadata:
test_flag: provision, volumes
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
with provider.mgmt.with_volume(1, imageRef=provider.mgmt.get_template_id(image)) as volume:
# Set up automate
cls = automate.Class(
name="Methods",
namespace=automate.Namespace.make_path("Cloud", "VM", "Provisioning", "StateMachines",
parent=domain))
method = automate.Method(
name="openstack_CustomizeRequest",
cls=cls)
with update(method):
method.data = dedent('''\
$evm.root["miq_provision"].set_option(
:clone_options, {{
:image_ref => nil,
:block_device_mapping_v2 => [{{
:boot_index => 0,
:uuid => "{}",
:device_name => "vda",
:source_type => "volume",
:destination_type => "volume",
:delete_on_termination => false
}}]
}}
)
'''.format(volume))
def _finish_method():
with update(method):
method.data = """prov = $evm.root["miq_provision"]"""
request.addfinalizer(_finish_method)
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
'instance_type': provisioning['instance_type'],
'availability_zone': provisioning['availability_zone'],
'security_groups': [provisioning['security_group']],
'guest_keypair': provisioning['guest_keypair']
}
if isinstance(provider, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
sel.force_navigate("clouds_instances_by_provider")
instance.create(**inst_args)
soft_assert(vm_name in provider.mgmt.volume_attachments(volume))
soft_assert(provider.mgmt.volume_attachments(volume)[vm_name] == "vda")
instance.delete_from_provider() # To make it possible to delete the volume
wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5)
def test_provision_from_template_with_attached_disks(
request, setup_provider, provider, vm_name, provisioning,
disks, soft_assert, domain, cls, copy_domains):
""" Tests provisioning from a template and attaching disks
Metadata:
test_flag: provision
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
DEVICE_NAME = "/dev/sd{}"
device_mapping = []
with provider.mgmt.with_volumes(1, n=disks) as volumes:
for i, volume in enumerate(volumes):
device_mapping.append((volume, DEVICE_NAME.format(chr(ord("b") + i))))
# Set up automate
cls = automate.Class(name="Methods",
namespace=automate.Namespace.make_path("Cloud", "VM", "Provisioning", "StateMachines",
parent=domain))
method = automate.Method(
name="openstack_PreProvision",
cls=cls)
with update(method):
disk_mapping = []
for mapping in device_mapping:
disk_mapping.append(ONE_FIELD.format(*mapping))
method.data = VOLUME_METHOD.format(", ".join(disk_mapping))
def _finish_method():
with update(method):
method.data = """prov = $evm.root["miq_provision"]"""
request.addfinalizer(_finish_method)
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
'instance_type': provisioning['instance_type'],
'availability_zone': provisioning['availability_zone'],
'security_groups': [provisioning['security_group']],
'guest_keypair': provisioning['guest_keypair']
}
if isinstance(provider, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
sel.force_navigate("clouds_instances_by_provider")
instance.create(**inst_args)
for volume_id in volumes:
soft_assert(vm_name in provider.mgmt.volume_attachments(volume_id))
for volume, device in device_mapping:
soft_assert(provider.mgmt.volume_attachments(volume)[vm_name] == device)
instance.delete_from_provider() # To make it possible to delete the volume
wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5)
def test_provision_with_additional_volume(request, setup_provider, provider,
vm_name, soft_assert, copy_domains,
domain, provisioning,
modified_request_class):
""" Tests provisioning with setting specific image from AE and then also making it create and
attach an additional 3G volume.
Metadata:
test_flag: provision, volumes
"""
image = provisioning['image']['name']
note = (
'Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
# Set up automate
method = modified_request_class.methods.instantiate(
name="openstack_CustomizeRequest")
try:
image_id = provider.mgmt.get_template_id(
provider.data["small_template"])
except KeyError:
pytest.skip("No small_template in provider adta!")
with update(method):
method.script = dedent('''\
$evm.root["miq_provision"].set_option(
:clone_options, {{
:image_ref => nil,
:block_device_mapping_v2 => [{{
:boot_index => 0,
:uuid => "{}",
:device_name => "vda",
:source_type => "image",
:destination_type => "volume",
:volume_size => 3,
:delete_on_termination => false
}}]
}}
)
'''.format(image_id))
def _finish_method():
with update(method):
method.script = """prov = $evm.root["miq_provision"]"""
request.addfinalizer(_finish_method)
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
'instance_type': provisioning['instance_type'],
"availability_zone": provisioning["availability_zone"],
'security_groups': [provisioning['security_group']],
'guest_keypair': provisioning['guest_keypair']
}
if isinstance(provider, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
instance.create(**inst_args)
prov_instance = provider.mgmt._find_instance_by_name(vm_name)
try:
assert hasattr(prov_instance, 'os-extended-volumes:volumes_attached')
volumes_attached = getattr(prov_instance,
'os-extended-volumes:volumes_attached')
assert len(volumes_attached) == 1
volume_id = volumes_attached[0]["id"]
assert provider.mgmt.volume_exists(volume_id)
volume = provider.mgmt.get_volume(volume_id)
assert volume.size == 3
finally:
instance.delete_from_provider()
wait_for(lambda: not instance.does_vm_exist_on_provider(),
num_sec=180,
delay=5)
if "volume_id" in locals(): # To handle the case of 1st or 2nd assert
if provider.mgmt.volume_exists(volume_id):
provider.mgmt.delete_volume(volume_id)
def test_provision_from_template_with_attached_disks(request, setup_provider,
provider, provisioning,
vm_name, disks,
soft_assert, domain, cls,
copy_domains):
""" Tests provisioning from a template and attaching disks
Metadata:
test_flag: provision
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image %s to vm %s on provider %s' %
(image, vm_name, provider.key))
DEVICE_NAME = "/dev/sd{}"
device_mapping = []
with provider.mgmt.with_volumes(1, n=disks) as volumes:
for i, volume in enumerate(volumes):
device_mapping.append(
(volume, DEVICE_NAME.format(chr(ord("b") + i))))
# Set up automate
cls = automate.Class(name="Methods",
namespace=automate.Namespace.make_path(
"Cloud",
"VM",
"Provisioning",
"StateMachines",
parent=domain))
method = automate.Method(name="openstack_PreProvision", cls=cls)
with update(method):
disk_mapping = []
for mapping in device_mapping:
disk_mapping.append(ONE_FIELD % mapping)
method.data = VOLUME_METHOD % ", ".join(disk_mapping)
def _finish_method():
with update(method):
method.data = """prov = $evm.root["miq_provision"]"""
request.addfinalizer(_finish_method)
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
'instance_type': provisioning['instance_type'],
'availability_zone': provisioning['availability_zone'],
'security_groups': [provisioning['security_group']],
'guest_keypair': provisioning['guest_keypair']
}
if isinstance(provider, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
sel.force_navigate("clouds_instances_by_provider")
instance.create(**inst_args)
for volume_id in volumes:
soft_assert(vm_name in provider.mgmt.volume_attachments(volume_id))
for volume, device in device_mapping:
soft_assert(
provider.mgmt.volume_attachments(volume)[vm_name] == device)
instance.delete_from_provider(
) # To make it possible to delete the volume
wait_for(lambda: not instance.does_vm_exist_on_provider(),
num_sec=180,
delay=5)
def testing_instance(request, setup_provider, provider, provisioning, vm_name,
tag):
""" Fixture to prepare instance parameters for provisioning
"""
image = provisioning['image']['name']
note = (
'Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
instance = Instance.factory(vm_name, provider, image)
inst_args = dict()
# Base instance info
inst_args['request'] = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
}
# TODO Move this into helpers on the provider classes
recursive_update(inst_args, {'catalog': {'vm_name': vm_name}})
# Check whether auto-selection of environment is passed
auto = False # By default provisioning will be manual
try:
parameter = request.param
if parameter == 'tag':
inst_args['purpose'] = {
'apply_tags':
('{} *'.format(tag.category.display_name), tag.display_name)
}
else:
auto = parameter
except AttributeError:
# in case nothing was passed just skip
pass
# All providers other than Azure
if not provider.one_of(AzureProvider):
recursive_update(
inst_args, {
'properties': {
'instance_type': partial_match(
provisioning['instance_type']),
'guest_keypair': provisioning['guest_keypair']
}
})
if provider.one_of(OpenStackProvider):
recursive_update(inst_args,
{'environment': {
'automatic_placement': True
}})
else:
recursive_update(
inst_args, {
'environment': {
'availability_zone':
None if auto else provisioning['availability_zone'],
'security_groups':
None if auto else provisioning['security_group'],
'automatic_placement':
auto
}
})
# GCE specific
if provider.one_of(GCEProvider):
recursive_update(
inst_args, {
'environment': {
'cloud_network':
None if auto else provisioning['cloud_network']
},
'properties': {
'boot_disk_size': provisioning['boot_disk_size'],
'is_preemptible':
True if current_version() >= "5.7" else None
}
})
# Azure specific
if provider.one_of(AzureProvider):
# Azure uses different provisioning keys for some reason
try:
template = provider.data.templates.small_template
vm_user = credentials[template.creds].username
vm_password = credentials[template.creds].password
except AttributeError:
pytest.skip(
'Could not find small_template or credentials for {}'.format(
provider.name))
recursive_update(
inst_args, {
'environment': {
'automatic_placement':
auto,
'cloud_network':
None
if auto else partial_match(provisioning['virtual_net']),
'cloud_subnet':
None
if auto else partial_match(provisioning['subnet_range']),
'security_groups':
None
if auto else [partial_match(provisioning['network_nsg'])],
'resource_groups':
None
if auto else partial_match(provisioning['resource_group'])
},
'properties': {
'instance_type': provisioning['vm_size'].lower()
},
'customize': {
'admin_username': vm_user,
'root_password': vm_password
}
})
yield instance, inst_args, image
try:
if instance.does_vm_exist_on_provider():
instance.delete_from_provider()
except Exception as ex:
logger.warning(
'Exception while deleting instance fixture, continuing: {}'.format(
ex.message))
def test_provision_with_boot_volume(request, setup_provider, provider,
provisioning, vm_name, soft_assert, domain,
copy_domains):
""" Tests provisioning from a template and attaching one booting volume.
Metadata:
test_flag: provision, volumes
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image %s to vm %s on provider %s' %
(image, vm_name, provider.key))
with provider.mgmt.with_volume(
1, imageRef=provider.mgmt.get_template_id(image)) as volume:
# Set up automate
cls = automate.Class(name="Methods",
namespace=automate.Namespace.make_path(
"Cloud",
"VM",
"Provisioning",
"StateMachines",
parent=domain))
method = automate.Method(name="openstack_CustomizeRequest", cls=cls)
with update(method):
method.data = dedent('''\
$evm.root["miq_provision"].set_option(
:clone_options, {
:image_ref => nil,
:block_device_mapping_v2 => [{
:boot_index => 0,
:uuid => "%s",
:device_name => "vda",
:source_type => "volume",
:destination_type => "volume",
:delete_on_termination => false
}]
}
)
''' % (volume, ))
def _finish_method():
with update(method):
method.data = """prov = $evm.root["miq_provision"]"""
request.addfinalizer(_finish_method)
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.delete_from_provider)
inst_args = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
'instance_type': provisioning['instance_type'],
'availability_zone': provisioning['availability_zone'],
'security_groups': [provisioning['security_group']],
'guest_keypair': provisioning['guest_keypair']
}
if isinstance(provider, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
sel.force_navigate("clouds_instances_by_provider")
instance.create(**inst_args)
soft_assert(vm_name in provider.mgmt.volume_attachments(volume))
soft_assert(provider.mgmt.volume_attachments(volume)[vm_name] == "vda")
instance.delete_from_provider(
) # To make it possible to delete the volume
wait_for(lambda: not instance.does_vm_exist_on_provider(),
num_sec=180,
delay=5)
def test_provision_cloud_init(request, setup_provider, provider, provisioning,
setup_ci_template, vm_name):
""" Tests provisioning from a template with cloud_init
Metadata:
test_flag: cloud_init, provision
"""
image = provisioning.get('ci-image') or provisioning['image']['name']
note = (
'Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
logger.info(note)
mgmt_system = provider.mgmt
instance = Instance.factory(vm_name, provider, image)
request.addfinalizer(instance.cleanup_on_provider)
# TODO: extend inst_args for other providers except EC2 if needed
inst_args = {
'request': {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note
},
'catalog': {
'vm_name': vm_name
},
'properties': {
'instance_type': provisioning['instance_type'],
'guest_keypair': provisioning['guest_keypair']
},
'environment': {
'availability_zone': provisioning['availability_zone'],
'cloud_network': provisioning['cloud_network'],
'security_groups': [provisioning['security_group']]
},
'customize': {
'custom_template': {
'name': provisioning['ci-template']
}
}
}
if provider.one_of(OpenStackProvider):
floating_ip = mgmt_system.get_first_floating_ip()
inst_args['environment']['public_ip_address'] = floating_ip
logger.info('Instance args: {}'.format(inst_args))
instance.create(**inst_args)
provision_request = provider.appliance.collections.requests.instantiate(
vm_name, partial_check=True)
provision_request.wait_for_request()
connect_ip = mgmt_system.get_ip_address(vm_name)
# Check that we can at least get the uptime via ssh this should only be possible
# if the username and password have been set via the cloud-init script so
# is a valid check
with ssh.SSHClient(hostname=connect_ip,
username=provisioning['ci-username'],
password=provisioning['ci-pass']) as ssh_client:
wait_for(ssh_client.uptime, num_sec=200, handle_exception=True)
def testing_instance(request, setup_provider, provider, provisioning, vm_name):
""" Fixture to prepare instance parameters for provisioning
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
instance = Instance.factory(vm_name, provider, image)
inst_args = dict()
# Base instance info
inst_args['request'] = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
}
# TODO Move this into helpers on the provider classes
recursive_update(inst_args, {'catalog': {'vm_name': vm_name}})
# Check whether auto-selection of environment is passed
try:
auto = request.param
except AttributeError:
# in case nothing was passed just skip
auto = False
# All providers other than Azure
if not provider.one_of(AzureProvider):
recursive_update(inst_args, {
'properties': {
'instance_type': provisioning['instance_type'],
'guest_keypair': provisioning['guest_keypair']},
'environment': {
'availability_zone': None if auto else provisioning['availability_zone'],
'security_groups': None if auto else provisioning['security_group'],
'automatic_placement': auto
}
})
# Openstack specific
if provider.one_of(OpenStackProvider):
recursive_update(inst_args, {
'environment': {
'cloud_network': None if auto else provisioning['cloud_network']
}
})
# GCE specific
if provider.one_of(GCEProvider):
recursive_update(inst_args, {
'environment': {
'cloud_network': None if auto else provisioning['cloud_network']
},
'properties': {
'boot_disk_size': provisioning['boot_disk_size'],
'is_preemptible': True if current_version() >= "5.7" else None}
})
# Azure specific
if provider.one_of(AzureProvider):
# Azure uses different provisioning keys for some reason
recursive_update(inst_args, {
'environment': {
'automatic_placement': auto,
'cloud_network': None if auto else provisioning['virtual_net'],
'cloud_subnet': None if auto else provisioning['subnet_range'],
'security_groups': None if auto else [provisioning['network_nsg']],
'resource_groups': None if auto else provisioning['resource_group']
},
'properties': {
'instance_type': provisioning['vm_size'].lower()},
'customize': {
'admin_username': provisioning['vm_user'],
'admin_password': provisioning['vm_password']}})
yield instance, inst_args, image
try:
if instance.does_vm_exist_on_provider():
instance.delete_from_provider()
except Exception as ex:
logger.warning('Exception while deleting instance fixture, continuing: {}'
.format(ex.message))
def testing_instance(request, setup_provider, provider, provisioning, vm_name, tag):
""" Fixture to prepare instance parameters for provisioning
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
instance = Instance.factory(vm_name, provider, image)
inst_args = dict()
# Base instance info
inst_args['request'] = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
}
# TODO Move this into helpers on the provider classes
recursive_update(inst_args, {'catalog': {'vm_name': vm_name}})
# Check whether auto-selection of environment is passed
auto = False # By default provisioning will be manual
try:
parameter = request.param
if parameter == 'tag':
inst_args['purpose'] = {
'apply_tags': Check_tree.CheckNode(
['{} *'.format(tag.category.display_name), tag.display_name])
}
else:
auto = parameter
except AttributeError:
# in case nothing was passed just skip
pass
recursive_update(inst_args, {
'environment': {
'availability_zone': provisioning.get('availability_zone', None),
'security_groups': [provisioning.get('security_group', None)],
'cloud_network': provisioning.get('cloud_network', None),
'cloud_subnet': provisioning.get('cloud_subnet', None),
'resource_groups': provisioning.get('resource_group', None)
},
'properties': {
'instance_type': partial_match(provisioning.get('instance_type', None)),
'guest_keypair': provisioning.get('guest_keypair', None)}
})
# GCE specific
if provider.one_of(GCEProvider):
recursive_update(inst_args, {
'properties': {
'boot_disk_size': provisioning['boot_disk_size'],
'is_preemptible': True}
})
# Azure specific
if provider.one_of(AzureProvider):
# Azure uses different provisioning keys for some reason
try:
template = provider.data.templates.small_template
vm_user = credentials[template.creds].username
vm_password = credentials[template.creds].password
except AttributeError:
pytest.skip('Could not find small_template or credentials for {}'.format(provider.name))
recursive_update(inst_args, {
'customize': {
'admin_username': vm_user,
'root_password': vm_password}})
if auto:
inst_args.update({'environment': {'automatic_placement': auto}})
yield instance, inst_args, image
logger.info('Fixture cleanup, deleting test instance: %s', instance.name)
try:
instance.delete_from_provider()
except Exception as ex:
logger.warning('Exception while deleting instance fixture, continuing: {}'
.format(ex.message))
def testing_instance(request, setup_provider, provider, provisioning, vm_name):
""" Fixture to prepare instance parameters for provisioning
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image {} to vm {} on provider {}'.format(
image, vm_name, provider.key))
instance = Instance.factory(vm_name, provider, image)
inst_args = dict()
# Base instance info
inst_args['request'] = {
'email': '*****@*****.**',
'first_name': 'Image',
'last_name': 'Provisioner',
'notes': note,
}
# TODO Move this into helpers on the provider classes
recursive_update(inst_args, {'catalog': {'vm_name': vm_name}})
# Check whether auto-selection of environment is passed
try:
auto = request.param
except AttributeError:
# in case nothing was passed just skip
auto = False
# All providers other than Azure
if not isinstance(provider, AzureProvider):
recursive_update(inst_args, {
'properties': {
'instance_type': provisioning['instance_type'],
'guest_keypair': provisioning['guest_keypair']},
'environment': {
'availability_zone': None if auto else provisioning['availability_zone'],
'security_groups': None if auto else provisioning['security_group'],
'automatic_placement': auto
}
})
# Openstack specific
if isinstance(provider, OpenStackProvider):
recursive_update(inst_args, {
'environment': {
'cloud_network': None if auto else provisioning['cloud_network']
}
})
# GCE specific
if isinstance(provider, GCEProvider):
recursive_update(inst_args, {
'environment': {
'cloud_network': None if auto else provisioning['cloud_network']
},
'properties': {
'boot_disk_size': provisioning['boot_disk_size'],
'is_preemptible': True if current_version() >= "5.7" else None}
})
# Azure specific
if isinstance(provider, AzureProvider):
# Azure uses different provisioning keys for some reason
recursive_update(inst_args, {
'environment': {
'automatic_placement': auto,
'cloud_network': None if auto else provisioning['virtual_net'],
'cloud_subnet': None if auto else provisioning['subnet_range'],
'security_groups': None if auto else [provisioning['network_nsg']],
'resource_groups': None if auto else provisioning['resource_group']
},
'properties': {
'instance_type': provisioning['vm_size'].lower()},
'customize': {
'admin_username': provisioning['vm_user'],
'admin_password': provisioning['vm_password']}})
yield instance, inst_args, image
try:
if instance.does_vm_exist_on_provider():
instance.delete_from_provider()
except Exception as ex:
logger.warning('Exception while deleting instance fixture, continuing: {}'
.format(ex.message))