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 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 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 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))