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 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 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 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_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 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_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 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 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 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 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 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 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(provider):
return random_vm_name("action", max_length=16)
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(request):
return random_vm_name('prov')
def vm_name():
return random_vm_name('pwr-c')
def vm_name():
return random_vm_name("dscvry")
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_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")
def vm_name(request, provider):
return random_vm_name('prov')
def vm_name():
return random_vm_name("dscvry")
