def existing_vm(request): """ Fixture will be using for set\unset retirement date for existing vm instead of creation a new one """ list_of_existing_providers = providers.existing_providers() if list_of_existing_providers: test_provider = providers.get_crud(list_of_existing_providers[0]) else: test_provider = providers.setup_a_provider() all_vms = test_provider.mgmt.list_vm() need_to_create_vm = True for virtual_machine in all_vms: if test_provider.mgmt.is_vm_running(virtual_machine): need_vm = VM.factory(virtual_machine, test_provider) need_to_create_vm = False break if need_to_create_vm: machine_name = random_vm_name('retire') need_vm = VM.factory(machine_name, test_provider) need_vm.create_on_provider(find_in_cfme=True, allow_skip="default") @request.addfinalizer def _delete_vm(): if need_to_create_vm: test_provider.mgmt.delete_vm(need_vm.name) return need_vm
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 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(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 small_vm(provider, small_template_modscope): vm = VM.factory(random_vm_name(context='reconfig'), provider, small_template_modscope) vm.create_on_provider(find_in_cfme=True, allow_skip="default") vm.refresh_relationships() yield vm vm.delete_from_provider()
def new_vm(request, provider): vm = VM.factory(random_vm_name("timelines", max_length=16), provider) request.addfinalizer(vm.delete_from_provider) if not provider.mgmt.does_vm_exist(vm.name): logger.info("deploying %s on provider %s", vm.name, provider.key) vm.create_on_provider(allow_skip="default", find_in_cfme=True) return vm
def new_vm(setup_provider_modscope, provider, request): """Fixture to provision appliance to the provider being tested if necessary""" vm_name = random_vm_name(context='migrate') vm = VM.factory(vm_name, provider, template_name=provider.data['small_template']) if not provider.mgmt.does_vm_exist(vm_name): vm.create_on_provider(find_in_cfme=True, allow_skip="default") request.addfinalizer(vm.delete_from_provider) return vm
def vm(request, provider, setup_provider, small_template): vm_obj = VM.factory(random_vm_name('retire'), provider, template_name=small_template) @request.addfinalizer def _delete_vm(): if provider.mgmt.does_vm_exist(vm_obj.name): provider.mgmt.delete_vm(vm_obj.name) vm_obj.create_on_provider(find_in_cfme=True, allow_skip="default") return vm_obj
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 vm_name(provider): # also tries to delete the VM that gets made with this name vm_name = random_vm_name('scat') yield vm_name try: logger.info('Cleaning up VM %s on provider %s', vm_name, provider.key) provider.mgmt.delete_vm(vm_name) except: # The mgmt_sys classes raise Exception :\ logger.warning('Failed to clean up VM %s on provider %s', vm_name, provider.key)
def test_vm(small_template, provider): vm = VM.factory(random_vm_name('retire'), provider, template_name=small_template) vm.create_on_provider(find_in_cfme=True, allow_skip="default") yield vm try: if provider.mgmt.does_vm_exist(vm.name): provider.mgmt.delete_vm(vm.name) except Exception: logger.warning('Failed to delete vm from provider: {}'.format(vm.name))
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 vm_obj(request, provider, setup_provider_modscope, small_template_modscope): vm_obj = VM.factory(random_vm_name('pwrctl'), provider, template_name=small_template_modscope) @request.addfinalizer def _delete_vm(): try: provider.mgmt.delete_vm(vm_obj.name) except Exception: logger.warning("Failed to delete vm `{}`.".format(vm_obj.name)) vm_obj.create_on_provider(find_in_cfme=True, allow_skip="default") return vm_obj
def vm_obj(provider, setup_provider_modscope, small_template_modscope): """Creates new VM or instance""" vm_name = random_vm_name('snpsht') new_vm = VM.factory(vm_name, provider, template_name=small_template_modscope) if not provider.mgmt.does_vm_exist(vm_name): new_vm.create_on_provider(find_in_cfme=True, allow_skip='default') yield new_vm try: provider.mgmt.delete_vm(new_vm.name) except Exception: logger.warning("Failed to delete vm `{}`.".format(new_vm.name))
def provision_vm(provider, request, small_template=True): vm_name = random_vm_name(context="snapshot") if small_template: vm = VM.factory(vm_name, provider, template_name=provider.data['small_template']) else: vm = VM.factory(vm_name, provider, template_name=provider.data['full_template']['name']) if not provider.mgmt.does_vm_exist(vm_name): vm.create_on_provider(find_in_cfme=True, allow_skip="default") request.addfinalizer(vm.delete_from_provider) return vm
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 retire_ec2_s3_vm(provider): """Fixture for creating an S3 backed paravirtual instance, template is a public ec2 AMI Args: provider: provider crud object from fixture """ vm = VM.factory(random_vm_name('retire'), provider, template_name='amzn-ami-pv-2015.03.rc-1.x86_64-s3') vm.create_on_provider(find_in_cfme=True, allow_skip="default") yield vm try: if provider.mgmt.does_vm_exist(vm.name): provider.mgmt.delete_vm(vm.name) except Exception: logger.warning('Failed to delete vm from provider: {}'.format(vm.name))
def retire_vm(small_template, provider): """Fixture for creating a generic vm/instance Args: small_template: small template fixture, template on provider provider: provider crud object from fixture """ vm = VM.factory(random_vm_name('retire'), provider, template_name=small_template) vm.create_on_provider(find_in_cfme=True, allow_skip="default") yield vm try: if provider.mgmt.does_vm_exist(vm.name): provider.mgmt.delete_vm(vm.name) except Exception: logger.warning('Failed to delete vm from provider: {}'.format(vm.name))
def test_vm(virtualcenter_provider): """Fixture to provision appliance to the provider being tested if necessary""" vm_name = random_vm_name('distpwr') vm = VM.factory(vm_name, virtualcenter_provider) if not virtualcenter_provider.mgmt.does_vm_exist(vm_name): logger.info("deploying %r on provider %r", vm_name, virtualcenter_provider.key) vm.create_on_provider(allow_skip="default") else: logger.info("recycling deployed vm %r on provider %r", vm_name, virtualcenter_provider.key) vm.provider.refresh_provider_relationships() vm.wait_to_appear() yield vm try: virtualcenter_provider.mgmt.delete_vm(vm_name=vm_name) except Exception: logger.exception('Failed deleting VM "%r" on "%r"', vm_name, virtualcenter_provider.name)
def test_vm_capture(request, provider, setup_provider, register_event): """ tests that generalize and capture vm azure events are received and parsed by CFME """ mgmt = provider.mgmt vm = VM.factory(random_vm_name(context='capture'), provider) if not mgmt.does_vm_exist(vm.name): vm.create_on_provider(find_in_cfme=True, allow_skip="default") vm.refresh_relationships() # # deferred delete vm request.addfinalizer(vm.delete_from_provider) def cmp_function(_, y): data = yaml.load(y) return data['resourceId'].endswith( vm.name) and data['status']['value'] == 'Succeeded' full_data_attr = {'full_data': 'will be ignored', 'cmp_func': cmp_function} # generalize event register_event(full_data_attr, source='AZURE', event_type='virtualMachines_generalize_EndRequest') # capture event register_event(full_data_attr, source='AZURE', event_type='virtualMachines_capture_EndRequest') # capture vm image_name = vm.name resource_group = provider.data['provisioning']['resource_group'] mgmt.capture_vm(vm.name, resource_group, 'templates', image_name) # delete remaining image container = 'system' blob_images = mgmt.list_blob_images(container) # removing both json and vhd files test_image = [img for img in blob_images if image_name in img][-1] mgmt.remove_blob_image(test_image, container)
def test_vm_capture(request, provider, setup_provider, register_event): """ tests that generalize and capture vm azure events are received and parsed by CFME """ mgmt = provider.mgmt vm = VM.factory(random_vm_name(context='capture'), provider) if not mgmt.does_vm_exist(vm.name): vm.create_on_provider(find_in_cfme=True, allow_skip="default") vm.refresh_relationships() # # deferred delete vm request.addfinalizer(vm.delete_from_provider) # register event builder = EventBuilder(get_or_create_current_appliance()) capt_regexp = '^\s*resourceId:.*?{}.*?^\s*status:.*?^\s*value:\s*Succeeded'.format(vm.name) full_data_attr = {'full_data': 'will be ignored', 'cmp_func': lambda _, y: bool(re.search(capt_regexp, y, re.M | re.U | re.S))} generalize_event = builder.new_event(full_data_attr, source='AZURE', event_type='virtualMachines_generalize_EndRequest') register_event(generalize_event) capture_event = builder.new_event(full_data_attr, source='AZURE', event_type='virtualMachines_capture_EndRequest') register_event(capture_event) # capture vm image_name = vm.name resource_group = provider.data['provisioning']['resource_group'] mgmt.capture_vm(vm.name, resource_group, 'templates', image_name) # delete remaining image container = 'system' blob_images = mgmt.list_blob_images(container) # removing both json and vhd files test_image = [img for img in blob_images if image_name in img][-1] mgmt.remove_blob_image(test_image, container)
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_manage_nsg_group(provider, setup_provider, register_event): """ tests that create/remove azure network security groups events are received and parsed by CFME """ nsg_name = random_vm_name(context='nsg') resource_group = provider.data['provisioning']['resource_group'] # registering add/remove network security group events # we need to check raw data by regexps, since many azure events aren't parsed by CFME yet def add_cmp(_, y): data = yaml.load(y) return data['resourceId'].endswith(nsg_name) and data['status']['value'] == 'Accepted' and \ data['subStatus']['value'] == 'Created' fd_add_attr = {'full_data': 'will be ignored', 'cmp_func': add_cmp} # add network security group event register_event(fd_add_attr, source=provider.type.upper(), event_type='networkSecurityGroups_write_EndRequest') def rm_cmp(_, y): data = yaml.load(y) return data['resourceId'].endswith(nsg_name) and data['status']['value'] == 'Succeeded' \ and len(data['subStatus']['value']) == 0 fd_rm_attr = {'full_data': 'will be ignored', 'cmp_func': rm_cmp} # remove network security group register_event(fd_rm_attr, source=provider.type.upper(), event_type='networkSecurityGroups_delete_EndRequest') # creating and removing network security group provider.mgmt.create_netsec_group(nsg_name, resource_group) provider.mgmt.remove_netsec_group(nsg_name, resource_group)
def test_manage_nsg_group(provider, setup_provider, register_event): """ tests that create/remove azure network security groups events are received and parsed by CFME """ nsg_name = random_vm_name(context='nsg') resource_group = provider.data['provisioning']['resource_group'] # registering add/remove network security group events # we need to check raw data by regexps, since many azure events aren't parsed by CFME yet builder = EventBuilder(get_or_create_current_appliance()) fd_regexp = '^\s*resourceId:.*?{nsg}.*?^\s*status:.*?^\s*value:\s*{stat}.*?^' \ '\s*subStatus:.*?^\s*value:\s*{sstat}' def add_cmp(_, y): bool(re.search(fd_regexp.format(nsg=nsg_name, stat='Accepted', sstat='Created'), y, re.M | re.U | re.S)) fd_add_attr = {'full_data': 'will be ignored', 'cmp_func': add_cmp} def rm_cmp(_, y): bool(re.search(fd_regexp.format(nsg=nsg_name, stat='Succeeded', sstat=' '), y, re.M | re.U | re.S)) fd_rm_attr = {'full_data': 'will be ignored', 'cmp_func': rm_cmp} add_event = builder.new_event(fd_add_attr, source=provider.type.upper(), event_type='networkSecurityGroups_write_EndRequest') register_event(add_event) remove_event = builder.new_event(fd_rm_attr, source=provider.type.upper(), event_type='networkSecurityGroups_delete_EndRequest') register_event(remove_event) # creating and removing network security group provider.mgmt.create_netsec_group(nsg_name, resource_group) provider.mgmt.remove_netsec_group(nsg_name, resource_group)
def vmware_vm(full_template_modscope, provider): vm_obj = VM.factory(random_vm_name("ansible"), provider, template_name=full_template_modscope) vm_obj.create_on_provider(allow_skip="default") provider.mgmt.start_vm(vm_obj.name) provider.mgmt.wait_vm_running(vm_obj.name) # In order to have seamless SSH connection vm_ip, _ = wait_for(lambda: provider.mgmt.current_ip_address(vm_obj.name), num_sec=300, delay=5, fail_condition={None}, message="wait for testing VM IP address.") wait_for(net_check, [ports.SSH, vm_ip], {"force": True}, num_sec=300, delay=5, message="testing VM's SSH available") if not vm_obj.exists: provider.refresh_provider_relationships() vm_obj.wait_to_appear() yield vm_obj if provider.mgmt.does_vm_exist(vm_obj.name): provider.mgmt.delete_vm(vm_obj.name) provider.refresh_provider_relationships()
def vm_name(provider): return random_vm_name("action", max_length=16)
def vm_name(): return random_vm_name('pwrctl')
def vmware_vm(request, virtualcenter_provider): vm = VM.factory(random_vm_name("control"), virtualcenter_provider) vm.create_on_provider(find_in_cfme=True) request.addfinalizer(vm.delete_from_provider) return vm
def vm_name(): vm_name = random_vm_name('provd') return vm_name
def vm_name(): return random_vm_name('pwr-c')
def vm_name(provider): # Provider in order to keep the names provider-specific return random_vm_name('pwr-c')
def vm_name(): vm_name = random_vm_name('provt') return vm_name
def vm_name(request): return random_vm_name('prov')
def vm_name(request, provider): return random_vm_name('prov')
def vm_name(): return random_vm_name("dscvry")
def vm_crud(provider, small_template): return VM.factory(random_vm_name(context='genealogy'), provider, template_name=small_template)
def vm_name(): return random_vm_name(context="alert")