def finalize():
policy_for_testing.assign_events()
with update(policy_for_testing):
policy_for_testing.scope = (
"fill_field(VM and Instance : Name, INCLUDES, {})".format(vm_name))
with update(compliance_policy):
compliance_policy.scope = (
"fill_field(VM and Instance : Name, INCLUDES, {})".format(vm_name))
cleanup_vm(clone_vm_name, provider)
def test_vm_clone(provider, clone_vm_name, request, create_vm):
vm_name = create_vm + "_0001"
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
request.addfinalizer(lambda: cleanup_vm(clone_vm_name, provider))
vm = VM.factory(vm_name, provider)
if provider.type == "rhevm":
provision_type = "Native Clone"
elif provider.type == "virtualcenter":
provision_type = "VMware"
vm.clone_vm("*****@*****.**", "first", "last", clone_vm_name, provision_type)
row_description = clone_vm_name
cells = {"Description": row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True], fail_func=requests.reload, num_sec=4000, delay=20)
assert row.last_message.text == "Vm Provisioned Successfully"
def _provisioner(template, provisioning_data, delayed=None):
pytest.sel.force_navigate('infrastructure_provision_vms', context={
'provider': provider,
'template_name': template,
})
vm_name = provisioning_data["vm_name"]
fill(provisioning_form, provisioning_data, action=provisioning_form.submit_button)
flash.assert_no_errors()
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
if delayed is not None:
total_seconds = (delayed - datetime.utcnow()).total_seconds()
row_description = 'Provision from [{}] to [{}]'.format(template, vm_name)
cells = {'Description': row_description}
try:
row, __ = wait_for(requests.wait_for_request, [cells],
fail_func=requests.reload, num_sec=total_seconds, delay=5)
pytest.fail("The provisioning was not postponed")
except TimedOutError:
pass
logger.info('Waiting for vm %s to appear on provider %s', vm_name, provider.key)
wait_for(provider.mgmt.does_vm_exist, [vm_name], handle_exception=True, num_sec=600)
# nav to requests page happens on successful provision
logger.info('Waiting for cfme provision request for vm %s', vm_name)
row_description = 'Provision from [{}] to [{}]'.format(template, vm_name)
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells],
fail_func=requests.reload, num_sec=900, delay=20)
assert row.last_message.text == 'Vm Provisioned Successfully'
return VM.factory(vm_name, provider)
def test_iso_provision_from_template(appliance, provider, vm_name, smtp_test, datastore_init,
request, setup_provider):
"""Tests ISO provisioning
Metadata:
test_flag: iso, provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
iso_template, host, datastore, iso_file, iso_kickstart,\
iso_root_password, iso_image_type, vlan = map(provider.data['provisioning'].get,
('pxe_template', 'host', 'datastore', 'iso_file', 'iso_kickstart',
'iso_root_password', 'iso_image_type', 'vlan'))
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provisioning_data = {
'catalog': {
'vm_name': vm_name,
'provision_type': 'ISO',
'iso_file': {'name': iso_file}},
'environment': {
'host_name': {'name': host},
'datastore_name': {'name': datastore}},
'customize': {
'custom_template': {'name': iso_kickstart},
'root_password': iso_root_password},
'network': {
'vlan': vlan}}
do_vm_provisioning(appliance, iso_template, provider, vm_name, provisioning_data, request,
smtp_test, num_sec=1500)
def test_provision_from_template(appliance, setup_provider, provider, vm_name, smtp_test,
request, provisioning, auto):
""" Tests provisioning from a template
Metadata:
test_flag: provision
suite: infra_provisioning
rbac:
roles:
default:
evmgroup-super_administrator:
evmgroup-administrator:
evmgroup-operator: NoSuchElementException
evmgroup-auditor: NoSuchElementException
"""
template = provisioning['template']
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provisioning_data = {
'catalog': {
'vm_name': vm_name
},
'environment':
{'vm_name': vm_name,
'host_name': {'name': provisioning['host']} if not auto else None,
'datastore_name': {'name': provisioning['datastore']} if not auto else None,
'automatic_placement': True if auto else None},
'network':
{'vlan': provisioning['vlan']}}
do_vm_provisioning(appliance, template, provider, vm_name, provisioning_data, request,
smtp_test, num_sec=900)
def _provisioner(template, provisioning_data, delayed=None):
vm = Vm(name=vm_name, provider=provider, template_name=template)
view = navigate_to(vm, 'Provision')
view.form.fill_with(provisioning_data, on_change=view.form.submit_button)
base_view = vm.appliance.browser.create_view(BaseLoggedInPage)
base_view.flash.assert_no_error()
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
request_description = 'Provision from [{}] to [{}]'.format(template, vm_name)
provision_request = appliance.collections.requests.instantiate(
description=request_description)
if delayed is not None:
total_seconds = (delayed - datetime.utcnow()).total_seconds()
try:
wait_for(provision_request.is_finished,
fail_func=provision_request.update, num_sec=total_seconds, delay=5)
pytest.fail("The provisioning was not postponed")
except TimedOutError:
pass
logger.info('Waiting for vm %s to appear on provider %s', vm_name, provider.key)
wait_for(
provider.mgmt.does_vm_exist, [vm_name],
fail_func=provider.refresh_provider_relationships,
handle_exception=True, num_sec=600
)
# nav to requests page happens on successful provision
logger.info('Waiting for cfme provision request for vm %s', vm_name)
provision_request.wait_for_request()
assert provision_request.is_succeeded(method='ui')
return vm
def test_pxe_provision_from_template(provider, vm_name, smtp_test, setup_provider,
request, setup_pxe_servers_vm_prov):
"""Tests provisioning via PXE
Metadata:
test_flag: pxe, provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
pxe_template, host, datastore, pxe_server, pxe_image, pxe_kickstart,\
pxe_root_password, pxe_image_type, pxe_vlan = map(provider.data['provisioning'].get,
('pxe_template', 'host', 'datastore', 'pxe_server', 'pxe_image', 'pxe_kickstart',
'pxe_root_password', 'pxe_image_type', 'vlan'))
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provisioning_data = {
'vm_name': vm_name,
'host_name': {'name': [host]},
'datastore_name': {'name': [datastore]},
'provision_type': 'PXE',
'pxe_server': pxe_server,
'pxe_image': {'name': [pxe_image]},
'custom_template': {'name': [pxe_kickstart]},
'root_password': pxe_root_password,
'vlan': pxe_vlan,
}
do_vm_provisioning(pxe_template, provider, vm_name, provisioning_data, request, smtp_test,
num_sec=2100)
def test_iso_provision_from_template(provider, provisioning, vm_name, smtp_test, datastore_init,
request, setup_provider):
"""Tests ISO provisioning
Metadata:
test_flag: iso, provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
iso_template, host, datastore, iso_file, iso_kickstart,\
iso_root_password, iso_image_type, vlan = map(provisioning.get, ('pxe_template', 'host',
'datastore', 'iso_file', 'iso_kickstart',
'iso_root_password', 'iso_image_type', 'vlan'))
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provisioning_data = {
'vm_name': vm_name,
'host_name': {'name': [host]},
'datastore_name': {'name': [datastore]},
'provision_type': 'ISO',
'iso_file': {'name': [iso_file]},
'custom_template': {'name': [iso_kickstart]},
'root_password': iso_root_password,
'vlan': vlan,
}
do_vm_provisioning(iso_template, provider, vm_name, provisioning_data, request, smtp_test,
num_sec=1500)
def test_order_catalog_item_via_rest(
request, appliance, provider, setup_provider, catalog_item, catalog):
"""Same as :py:func:`test_order_catalog_item`, but using REST.
Metadata:
test_flag: provision, rest
"""
vm_name = catalog_item.provisioning_data['catalog']["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
catalog_item.create()
request.addfinalizer(catalog_item.delete)
catalog = appliance.rest_api.collections.service_catalogs.find_by(name=catalog.name)
assert len(catalog) == 1
catalog, = catalog
template = catalog.service_templates.find_by(name=catalog_item.name)
assert len(template) == 1
template, = template
req = template.action.order()
assert appliance.rest_api.response.status_code == 200
@wait_for_decorator(timeout="15m", delay=5)
def request_finished():
req.reload()
logger.info("Request status: {}, Request state: {}, Request message: {}".format(
req.status, req.request_state, req.message))
return req.status.lower() == "ok" and req.request_state.lower() == "finished"
def ssa_vm(request, local_setup_provider, provider, vm_analysis_provisioning_data,
appliance, analysis_type):
""" Fixture to provision instance on the provider """
vm_name = 'test-ssa-{}-{}'.format(fauxfactory.gen_alphanumeric(), analysis_type)
vm = VM.factory(vm_name, provider, template_name=vm_analysis_provisioning_data.image)
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provision_data = vm_analysis_provisioning_data.copy()
del provision_data['image']
vm.create_on_provider(find_in_cfme=True, **provision_data)
if provider.one_of(OpenStackProvider):
public_net = provider.data['public_network']
vm.provider.mgmt.assign_floating_ip(vm.name, public_net)
logger.info("VM %s provisioned, waiting for IP address to be assigned", vm_name)
@wait_for_decorator(timeout="20m", delay=5)
def get_ip_address():
logger.info("Power state for {} vm: {}, is_vm_stopped: {}".format(
vm_name, provider.mgmt.vm_status(vm_name), provider.mgmt.is_vm_stopped(vm_name)))
if provider.mgmt.is_vm_stopped(vm_name):
provider.mgmt.start_vm(vm_name)
ip = provider.mgmt.current_ip_address(vm_name)
logger.info("Fetched IP for %s: %s", vm_name, ip)
return ip is not None
connect_ip = provider.mgmt.get_ip_address(vm_name)
assert connect_ip is not None
# 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
if vm_analysis_provisioning_data['fs-type'] not in ['ntfs', 'fat32']:
logger.info("Waiting for %s to be available via SSH", connect_ip)
ssh_client = ssh.SSHClient(
hostname=connect_ip, username=vm_analysis_provisioning_data['username'],
password=vm_analysis_provisioning_data['password'], port=22)
wait_for(ssh_client.uptime, num_sec=3600, handle_exception=True)
vm.ssh = ssh_client
vm.system_type = detect_system_type(vm)
logger.info("Detected system type: %s", vm.system_type)
vm.image = vm_analysis_provisioning_data['image']
vm.connect_ip = connect_ip
# TODO: if rhev and iscsi, it need direct_lun
if provider.type == 'rhevm':
logger.info("Setting a relationship between VM and appliance")
cfme_rel = VM.CfmeRelationship(vm)
server_name = appliance.server.name
cfme_rel.set_relationship(str(server_name), configuration.server_id())
yield vm
# Close the SSH client if we have one
if getattr(vm, 'ssh', None):
vm.ssh.close()
def test_vm_clone(appliance, provider, clone_vm_name, request, create_vm):
request.addfinalizer(lambda: cleanup_vm(clone_vm_name, provider))
provision_type = 'VMware'
create_vm.clone_vm("*****@*****.**", "first", "last", clone_vm_name, provision_type)
request_description = clone_vm_name
request_row = appliance.collections.requests.instantiate(request_description,
partial_check=True)
request_row.wait_for_request(method='ui')
assert request_row.is_succeeded(method='ui')
def test_cloud_catalog_item(appliance, setup_provider, provider, dialog, catalog, request,
provisioning):
"""Tests cloud catalog item
Metadata:
test_flag: provision
"""
vm_name = 'test{}'.format(fauxfactory.gen_alphanumeric())
# GCE accepts only lowercase letters in VM name
vm_name = vm_name.lower()
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
image = provisioning['image']['name']
item_name = fauxfactory.gen_alphanumeric()
provisioning_data = {
'catalog': {'vm_name': vm_name,
},
'properties': {'instance_type': provisioning['instance_type'],
},
'environment': {'security_groups': [provisioning['security_group']],
},
}
if provider.type == "azure":
env_updates = dict(
cloud_network=provisioning['virtual_private_cloud'],
cloud_subnet=provisioning['cloud_subnet'],
resource_groups=[provisioning['resource_group']],
)
else:
provisioning_data['properties']['guest_keypair'] = provisioning['guest_keypair']
provisioning_data['properties']['boot_disk_size'] = provisioning['boot_disk_size']
env_updates = dict(
availability_zone=provisioning['availability_zone'],
cloud_tenant=provisioning['cloud_tenant'],
cloud_network=provisioning['cloud_network'])
provisioning_data['environment'].update(env_updates)
catalog_item = CatalogItem(item_type=provisioning['item_type'],
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog,
dialog=dialog,
catalog_name=image,
provider=provider,
prov_data=provisioning_data)
catalog_item.create()
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog, catalog_item.name)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service %s', item_name)
request_description = item_name
provision_request = appliance.collections.requests.instantiate(request_description,
partial_check=True)
provision_request.wait_for_request()
assert provision_request.is_succeeded()
def myservice(appliance, setup_provider, provider, catalog_item, request):
"""Tests my service
Metadata:
test_flag: provision
"""
vm_name = catalog_item.provisioning_data["catalog"]["vm_name"] + '0001'
catalog_item.create()
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog, catalog_item.name)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service %s', catalog_item.name)
request_description = catalog_item.name
service_request = appliance.collections.requests.instantiate(request_description,
partial_check=True)
service_request.wait_for_request()
assert service_request.is_succeeded()
yield catalog_item.name, vm_name
cleanup_vm(vm_name, provider)
def test_copy_request(appliance, setup_provider, provider, catalog_item, request):
"""Automate BZ 1194479"""
vm_name = catalog_item.provisioning_data["catalog"]["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog, catalog_item.name)
service_catalogs.order()
request_description = catalog_item.name
service_request = appliance.collections.requests.instantiate(request_description,
partial_check=True)
service_request.wait_for_request()
assert navigate_to(service_request, 'Details')
def test_copy_request(setup_provider, provider, catalog_item, request):
"""Automate BZ 1194479"""
vm_name = catalog_item.provisioning_data["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_item)
row_description = catalog_item.name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload, num_sec=1800, delay=20)
requests.go_to_request(cells)
def myservice(setup_provider, provider, catalog_item, request):
"""Tests my service
Metadata:
test_flag: provision
"""
vm_name = version.pick({
version.LOWEST: catalog_item.provisioning_data["vm_name"] + '_0001',
'5.7': catalog_item.provisioning_data["vm_name"] + '0001'})
catalog_item.create()
service_catalogs = ServiceCatalogs(catalog_item.catalog, catalog_item.name)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service %s', catalog_item.name)
row_description = catalog_item.name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=tb.refresh, num_sec=2000, delay=60)
assert row.request_state.text == 'Finished'
yield MyService(catalog_item.name, vm_name)
cleanup_vm(vm_name, provider)
def myservice(setup_provider, provider, catalog_item, request):
vm_name = catalog_item.provisioning_data["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog.name, catalog_item)
logger.info('Waiting for cfme provision request for service %s', catalog_item.name)
row_description = catalog_item.name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload, num_sec=900, delay=20)
assert row.request_state.text == 'Finished'
return MyService(catalog_item.name, vm_name)
def test_cloud_catalog_item(setup_provider, provider, dialog, catalog, request, provisioning):
"""Tests cloud catalog item
Metadata:
test_flag: provision
"""
vm_name = 'test{}'.format(fauxfactory.gen_alphanumeric())
# GCE accepts only lowercase letters in VM name
vm_name = vm_name.lower()
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
image = provisioning['image']['name']
item_name = fauxfactory.gen_alphanumeric()
provisioning_data = dict(
vm_name=vm_name,
instance_type=provisioning['instance_type'],
security_groups=[provisioning['security_group']],
)
if provider.type == "azure":
updates = dict(
virtual_private_cloud=provisioning['virtual_private_cloud'],
cloud_subnet=provisioning['cloud_subnet'],
resource_group=[provisioning['resource_group']],
)
else:
updates = dict(
availability_zone=provisioning['availability_zone'],
cloud_tenant=provisioning['cloud_tenant'],
cloud_network=provisioning['cloud_network'],
guest_keypair=provisioning['guest_keypair'],
boot_disk_size=provisioning['boot_disk_size']
)
provisioning_data.update(updates)
catalog_item = CatalogItem(item_type=provisioning['item_type'],
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog.name,
dialog=dialog,
catalog_name=image,
provider=provider,
prov_data=provisioning_data)
catalog_item.create()
service_catalogs = ServiceCatalogs(catalog_item.name)
service_catalogs.order()
flash.assert_no_errors()
logger.info('Waiting for cfme provision request for service %s', item_name)
row_description = item_name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload, num_sec=1200, delay=20)
assert row.request_state.text == 'Finished'
def test_cloud_catalog_item(setup_provider, provider, dialog, catalog, request, provisioning):
"""Tests cloud catalog item
Metadata:
test_flag: provision
"""
vm_name = 'test_servicecatalog-{}'.format(fauxfactory.gen_alphanumeric())
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
image = provisioning['image']['name']
item_name = fauxfactory.gen_alphanumeric()
data = dict(
item_type=provisioning['item_type'],
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog.name,
dialog=dialog,
catalog_name=image,
vm_name=vm_name,
provider_mgmt=provider.mgmt,
provider=provider.name,
instance_type=provisioning['instance_type'],
security_groups=[provisioning['security_group']],
)
if provider.type == "azure":
updates = dict(
virtual_private_cloud=provisioning['virtual_private_cloud'],
cloud_subnet=provisioning['cloud_subnet'],
resource_group=[provisioning['resource_group']],
)
else:
updates = dict(
availability_zone=provisioning['availability_zone'],
cloud_tenant=provisioning['cloud_tenant'],
cloud_network=provisioning['cloud_network'],
guest_keypair=provisioning['guest_keypair']
)
data.update(updates)
cloud_catalog_item = cct.Instance(**data)
cloud_catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog.name, cloud_catalog_item)
flash.assert_no_errors()
logger.info('Waiting for cfme provision request for service %s', item_name)
row_description = item_name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload, num_sec=1000, delay=20)
assert row.last_message.text == 'Request complete'
def test_action_cancel_clone(request, provider, assign_policy_for_testing_vm_big, vm_big):
"""This test checks if 'Cancel vCenter task' action works.
For this test we need big template otherwise CFME won't have enough time
to cancel the task https://bugzilla.redhat.com/show_bug.cgi?id=1383372#c9
"""
assign_policy_for_testing_vm_big.assign_events("VM Clone Start")
assign_policy_for_testing_vm_big.assign_actions_to_event(
"VM Clone Start", ["Cancel vCenter Task"])
clone_vm_name = "{}-clone".format(vm_big.name)
request.addfinalizer(lambda: assign_policy_for_testing_vm_big.assign_events())
request.addfinalizer(lambda: cleanup_vm(clone_vm_name, provider))
vm_big.crud.clone_vm(fauxfactory.gen_email(), "first", "last", clone_vm_name, "VMware")
cells = {"Description": clone_vm_name}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload, num_sec=4000, delay=20)
assert row.status.text == "Error"
def test_tagdialog_catalog_item(provider, setup_provider, catalog_item, request):
"""Tests tag dialog catalog item
Metadata:
test_flag: provision
"""
vm_name = catalog_item.provisioning_data["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
service_catalogs = ServiceCatalogs(catalog_item.name)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service %s', catalog_item.name)
row_description = catalog_item.name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload, num_sec=1400, delay=20)
assert row.request_state.text == 'Finished'
def test_order_catalog_item(provider, setup_provider, catalog_item, request, register_event):
"""Tests order catalog item
Metadata:
test_flag: provision
"""
vm_name = catalog_item.provisioning_data["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_item)
logger.info('Waiting for cfme provision request for service %s', catalog_item.name)
row_description = catalog_item.name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload, num_sec=1400, delay=20)
assert row.last_message.text == 'Request complete'
register_event('Service', catalog_item.name, 'service_provisioned')
def test_service_manual_approval(appliance, provider, setup_provider, modify_instance,
catalog_item, request):
"""Tests order catalog item
Metadata:
test_flag: provision
"""
vm_name = catalog_item.provisioning_data['catalog']["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog, catalog_item.name)
service_catalogs.order()
logger.info("Waiting for cfme provision request for service {}".format(catalog_item.name))
request_description = catalog_item.name
service_request = appliance.collections.requests.instantiate(description=request_description,
partial_check=True)
service_request.update(method='ui')
assert service_request.row.approval_state.text == 'Pending Approval'
def test_pxe_servicecatalog(appliance, setup_provider, provider, catalog_item, request):
"""Tests RHEV PXE service catalog
Metadata:
test_flag: pxe, provision
"""
vm_name = catalog_item.provisioning_data['catalog']["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog, catalog_item.name)
service_catalogs.order()
# nav to requests page happens on successful provision
logger.info('Waiting for cfme provision request for service %s', catalog_item.name)
request_description = catalog_item.name
provision_request = appliance.collections.requests.instantiate(request_description,
partial_check=True)
provision_request.wait_for_request(num_sec=3600)
assert provision_request.is_succeeded()
def myservice(setup_provider, provider, catalog_item, request):
vm_name = catalog_item.provisioning_data["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
service_catalogs = ServiceCatalogs(catalog_item.name)
service_catalogs.order()
logger.info("Waiting for cfme provision request for service %s", catalog_item.name)
row_description = catalog_item.name
cells = {"Description": row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True], fail_func=requests.reload, num_sec=900, delay=20)
assert row.request_state.text == "Finished"
service = MyService(catalog_item.name, vm_name)
yield service
try:
service.delete()
except Exception as ex:
logger.warning("Exception while deleting MyService, continuing: {}".format(ex.message))
def test_pxe_servicecatalog(setup_provider, provider, catalog_item, request):
"""Tests RHEV PXE service catalog
Metadata:
test_flag: pxe, provision
"""
vm_name = catalog_item.provisioning_data["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
service_catalogs = ServiceCatalogs(catalog_item.name)
service_catalogs.order()
# nav to requests page happens on successful provision
logger.info('Waiting for cfme provision request for service %s', catalog_item.name)
row_description = catalog_item.name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload, num_sec=3100, delay=20)
assert row.last_message.text == 'Request complete'
def test_provision_cloud_init(setup_provider, provider, setup_ci_template, provisioning,
vm_name, smtp_test, request):
"""Tests cloud init provisioning
Metadata:
test_flag: cloud_init, provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
template = provisioning.get('ci-image', None) or provisioning['image']['name']
host, datastore = map(provisioning.get, ('host', 'datastore'))
mgmt_system = provider.get_mgmt_system()
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provisioning_data = {
'vm_name': vm_name,
'host_name': {'name': [host]},
'datastore_name': {'name': [datastore]},
'provision_type': 'Native Clone',
'custom_template': {'name': [provisioning['ci-template']]},
}
try:
provisioning_data['vlan'] = provisioning['vlan']
except KeyError:
# provisioning['vlan'] is required for rhevm provisioning
if provider.type == 'rhevm':
raise pytest.fail('rhevm requires a vlan value in provisioning info')
do_vm_provisioning(template, provider, vm_name, provisioning_data, request, smtp_test,
num_sec=900)
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 myservice(setup_provider, provider, catalog_item, request):
"""Tests my service
Metadata:
test_flag: provision
"""
vm_name = catalog_item.provisioning_data["vm_name"] + "_0001"
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
catalog_item.create()
service_catalogs = ServiceCatalogs("service_name")
service_catalogs.order(catalog_item.catalog, catalog_item)
logger.info('Waiting for cfme provision request for service {}'
.format(catalog_item.name))
row_description = catalog_item.name
cells = {'Description': row_description}
row, __ = wait_for(requests.wait_for_request, [cells, True],
fail_func=requests.reload, num_sec=2000, delay=20)
assert row.last_message.text == 'Request complete'
return MyService(catalog_item.name, vm_name)
def test_rhev_iso_servicecatalog(appliance, setup_provider, provider, catalog_item, request):
"""Tests RHEV ISO service catalog
Metadata:
test_flag: iso, provision
"""
vm_name = catalog_item.provisioning_data['catalog']["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog, catalog_item.name)
service_catalogs.order()
# nav to requests page happens on successful provision
logger.info('Waiting for cfme provision request for service %s', catalog_item.name)
request_description = catalog_item.name
provision_request = appliance.collections.requests.instantiate(request_description,
partial_check=True)
provision_request.wait_for_request()
msg = "Provisioning failed with the message {}".format(provision_request.rest.message)
assert provision_request.is_succeeded(), msg
def myservice(appliance, setup_provider, provider, catalog_item, request):
vm_name = catalog_item.provisioning_data["catalog"]["vm_name"]
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
catalog_item.create()
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog, catalog_item.name)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service %s', catalog_item.name)
request_description = catalog_item.name
provision_request = appliance.collections.requests.instantiate(request_description,
partial_check=True)
provision_request.wait_for_request()
assert provision_request.is_finished()
service = MyService(appliance, catalog_item.name, vm_name)
yield service
try:
service.delete()
except Exception as ex:
logger.warning('Exception while deleting MyService, continuing: {}'.format(ex.message))
def test_cloud_catalog_item(appliance, vm_name, setup_provider, provider,
dialog, catalog, request, provisioning):
"""Tests cloud catalog item
Metadata:
test_flag: provision
"""
wait_for(provider.is_refreshed,
func_kwargs=dict(refresh_delta=10),
timeout=600)
request.addfinalizer(
lambda: cleanup_vm("{}0001".format(vm_name), provider))
image = provisioning['image']['name']
item_name = "{}-service-{}".format(provider.name,
fauxfactory.gen_alphanumeric())
inst_args = {
'catalog': {
'catalog_name': {
'name': image,
'provider': provider.name
},
'vm_name': vm_name
},
'environment': {
'availability_zone': provisioning.get('availability_zone', None),
'security_groups': [provisioning.get('security_group', None)],
'cloud_tenant': provisioning.get('cloud_tenant', 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):
recursive_update(
inst_args, {
'customize': {
'admin_username': provisioning['customize_username'],
'root_password': provisioning['customize_password']
}
})
catalog_item = appliance.collections.catalog_items.create(
provider.catalog_item_type,
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog,
dialog=dialog,
prov_data=inst_args)
request.addfinalizer(catalog_item.delete)
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog,
catalog_item.name)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service %s', item_name)
request_description = item_name
provision_request = appliance.collections.requests.instantiate(
request_description, partial_check=True)
provision_request.wait_for_request()
msg = "Request failed with the message {}".format(
provision_request.rest.message)
assert provision_request.is_succeeded(), msg
def test_provision_approval(appliance, setup_provider, provider, vm_name,
smtp_test, request, edit, provisioning):
""" Tests provisioning approval. Tests couple of things.
* Approve manually
* Approve by editing the request to conform
Prerequisities:
* A provider that can provision.
* Automate role enabled
* User with e-mail set so you can receive and view them
Steps:
* Create a provisioning request that does not get automatically approved (eg. ``num_vms``
bigger than 1)
* Wait for an e-mail to come, informing you that the auto-approval was unsuccessful.
* Depending on whether you want to do manual approval or edit approval, do:
* MANUAL: manually approve the request in UI
* EDIT: Edit the request in UI so it conforms the rules for auto-approval.
* Wait for an e-mail with approval
* Wait until the request finishes
* Wait until an email, informing about finished provisioning, comes.
Metadata:
test_flag: provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
template, host, datastore = map(provisioning.get,
('template', 'host', 'datastore'))
# It will provision two of them
vm_names = [vm_name + "001", vm_name + "002"]
request.addfinalizer(
lambda: [cleanup_vm(vmname, provider) for vmname in vm_names])
provisioning_data = {
'catalog': {
'vm_name': vm_name,
'num_vms': '2'
},
'environment': {
'host_name': {
'name': provisioning['host']
},
'datastore_name': {
'name': provisioning['datastore']
}
},
'network': {
'vlan': provisioning['vlan']
}
}
do_vm_provisioning(appliance,
template,
provider,
vm_name,
provisioning_data,
request,
smtp_test,
wait=False)
wait_for(lambda: len(
filter(
lambda mail: "your request for a new vms was not autoapproved" in
normalize_text(mail["subject"]), smtp_test.get_emails())) > 0,
num_sec=90,
delay=5)
wait_for(lambda: len(
filter(
lambda mail: "virtual machine request was not approved" in
normalize_text(mail["subject"]), smtp_test.get_emails())) > 0,
num_sec=90,
delay=5)
cells = {
'Description':
'Provision from [{}] to [{}###]'.format(template, vm_name)
}
provision_request = appliance.collections.requests.instantiate(cells=cells)
navigate_to(provision_request, 'Details')
if edit:
# Automatic approval after editing the request to conform
new_vm_name = vm_name + "-xx"
modifications = {
'catalog': {
'num_vms': "1",
'vm_name': new_vm_name
},
'Description':
'Provision from [{}] to [{}]'.format(template, new_vm_name)
}
provision_request.edit_request(values=modifications)
vm_names = [new_vm_name] # Will be just one now
request.addfinalizer(lambda: cleanup_vm(new_vm_name, provider))
else:
# Manual approval
provision_request.approve_request(method='ui', reason="Approved")
vm_names = [vm_name + "001", vm_name + "002"] # There will be two VMs
request.addfinalizer(
lambda: [cleanup_vm(vmname, provider) for vmname in vm_names])
wait_for(lambda: len(
filter(
lambda mail: "your virtual machine configuration was approved" in
normalize_text(mail["subject"]), smtp_test.get_emails())) > 0,
num_sec=120,
delay=5)
# Wait for the VM to appear on the provider backend before proceeding to ensure proper cleanup
logger.info('Waiting for vms %s to appear on provider %s',
", ".join(vm_names), provider.key)
wait_for(lambda: all(map(provider.mgmt.does_vm_exist, vm_names)),
handle_exception=True,
num_sec=600)
provision_request.wait_for_request(method='ui')
assert provision_request.is_succeeded(method='ui')
# Wait for e-mails to appear
def verify():
return (len(
filter(
lambda mail: "your virtual machine request has completed vm {}"
.format(normalize_text(vm_name)) in normalize_text(mail[
"subject"]), smtp_test.get_emails())) == len(vm_names))
wait_for(verify, message="email receive check", delay=5)
def instance(request, local_setup_provider, provider, vm_name,
vm_analysis_data):
""" Fixture to provision instance on the provider """
template = vm_analysis_data.get('image', None)
host_name, datastore_name = map(vm_analysis_data.get,
('host', 'datastore'))
mgmt_system = provider.get_mgmt_system()
provisioning_data = {
'vm_name': vm_name,
'host_name': {
'name': [host_name]
},
'datastore_name': {
'name': [datastore_name]
},
}
try:
provisioning_data['vlan'] = vm_analysis_data['vlan']
except KeyError:
# provisioning['vlan'] is required for rhevm provisioning
if provider.type == 'rhevm':
raise pytest.fail(
'rhevm requires a vlan value in provisioning info')
vm = VM.factory(vm_name, provider)
connect_ip = None
if provider.type == "openstack":
image = vm_analysis_data['image']
vm = VM.factory(vm_name, provider, image)
request.addfinalizer(vm.delete_from_provider)
connect_ip = mgmt_system.get_first_floating_ip()
provider.refresh_provider_relationships(method='ui')
inst_args = {
'email':
'*****@*****.**',
'first_name':
'Image',
'last_name':
'Provisioner',
'template_name':
image,
'notes':
('Testing provisioning from image {} to vm {} on provider {}'.
format(image, vm_name, provider.key)),
'instance_type':
vm_analysis_data['instance_type'],
'availability_zone':
vm_analysis_data['availability_zone'],
'security_groups': [vm_analysis_data['security_group']],
'cloud_network':
vm_analysis_data['cloud_network'],
'public_ip_address':
connect_ip,
}
vm.create(**inst_args)
else:
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
do_vm_provisioning(template,
provider,
vm_name,
provisioning_data,
request,
None,
num_sec=6000)
logger.info("VM %s provisioned, waiting for IP address to be assigned",
vm_name)
@pytest.wait_for(timeout="20m", delay=5)
def get_ip_address():
logger.info("Power state for {} vm: {}, is_vm_stopped: {}".format(
vm_name, mgmt_system.vm_status(vm_name),
mgmt_system.is_vm_stopped(vm_name)))
if mgmt_system.is_vm_stopped(vm_name):
mgmt_system.start_vm(vm_name)
ip = mgmt_system.current_ip_address(vm_name)
logger.info("Fetched IP for %s: %s", vm_name, ip)
return ip is not None
connect_ip = mgmt_system.get_ip_address(vm_name)
assert connect_ip is not None
# 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
if vm_analysis_data['fs-type'] not in ['ntfs', 'fat32']:
logger.info("Waiting for %s to be available via SSH", connect_ip)
ssh_client = ssh.SSHClient(hostname=connect_ip,
username=vm_analysis_data['username'],
password=vm_analysis_data['password'],
port=22)
wait_for(ssh_client.uptime, num_sec=3600, handle_exception=False)
vm.ssh = ssh_client
vm.system_type = detect_system_type(vm)
logger.info("Detected system type: %s", vm.system_type)
vm.image = vm_analysis_data['image']
vm.connect_ip = connect_ip
if provider.type == 'rhevm':
logger.info("Setting a relationship between VM and appliance")
from cfme.infrastructure.virtual_machines import Vm
cfme_rel = Vm.CfmeRelationship(vm)
cfme_rel.set_relationship(str(configuration.server_name()),
configuration.server_id())
return vm
def instance(request, local_setup_provider, provider, vm_name, vm_analysis_data, appliance):
""" Fixture to provision instance on the provider """
vm = VM.factory(vm_name, provider, template_name=vm_analysis_data['image'])
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provision_data = vm_analysis_data.copy()
del provision_data['image']
vm.create_on_provider(find_in_cfme=True, **provision_data)
if provider.type == "openstack":
vm.provider.mgmt.assign_floating_ip(vm.name, 'public')
logger.info("VM %s provisioned, waiting for IP address to be assigned", vm_name)
mgmt_system = provider.get_mgmt_system()
@wait_for_decorator(timeout="20m", delay=5)
def get_ip_address():
logger.info("Power state for {} vm: {}, is_vm_stopped: {}".format(
vm_name, mgmt_system.vm_status(vm_name), mgmt_system.is_vm_stopped(vm_name)))
if mgmt_system.is_vm_stopped(vm_name):
mgmt_system.start_vm(vm_name)
ip = mgmt_system.current_ip_address(vm_name)
logger.info("Fetched IP for %s: %s", vm_name, ip)
return ip is not None
connect_ip = mgmt_system.get_ip_address(vm_name)
assert connect_ip is not None
# 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
if vm_analysis_data['fs-type'] not in ['ntfs', 'fat32']:
logger.info("Waiting for %s to be available via SSH", connect_ip)
ssh_client = ssh.SSHClient(hostname=connect_ip, username=vm_analysis_data['username'],
password=vm_analysis_data['password'], port=22)
wait_for(ssh_client.uptime, num_sec=3600, handle_exception=True)
vm.ssh = ssh_client
vm.system_type = detect_system_type(vm)
logger.info("Detected system type: %s", vm.system_type)
vm.image = vm_analysis_data['image']
vm.connect_ip = connect_ip
# TODO: This is completely wrong and needs to be fixed
# CFME relationship is suppose to be set to the appliance, which is required
# to be placed within the same datastore that the VM resides
#
# Also, if rhev and iscsi, it need direct_lun
if provider.type == 'rhevm':
logger.info("Setting a relationship between VM and appliance")
from cfme.infrastructure.virtual_machines import Vm
cfme_rel = Vm.CfmeRelationship(vm)
server_name = appliance.server_name()
cfme_rel.set_relationship(str(server_name), configuration.server_id())
yield vm
# Close the SSH client if we have one
if getattr(vm, 'ssh', None):
vm.ssh.close()
def test_provision_approval(
setup_provider, provider, vm_name, smtp_test, request, edit, provisioning):
""" Tests provisioning approval. Tests couple of things.
* Approve manually
* Approve by editing the request to conform
Prerequisities:
* A provider that can provision.
* Automate role enabled
* User with e-mail set so you can receive and view them
Steps:
* Create a provisioning request that does not get automatically approved (eg. ``num_vms``
bigger than 1)
* Wait for an e-mail to come, informing you that the auto-approval was unsuccessful.
* Depending on whether you want to do manual approval or edit approval, do:
* MANUAL: manually approve the request in UI
* EDIT: Edit the request in UI so it conforms the rules for auto-approval.
* Wait for an e-mail with approval
* Wait until the request finishes
* Wait until an email, informing about finished provisioning, comes.
Metadata:
test_flag: provision
suite: infra_provisioning
"""
# generate_tests makes sure these have values
template, host, datastore = map(provisioning.get, ('template', 'host', 'datastore'))
# It will provision two of them
vm_names = [vm_name + "001", vm_name + "002"]
request.addfinalizer(
lambda: [cleanup_vm(vmname, provider) for vmname in vm_names])
provisioning_data = {
'vm_name': vm_name,
'host_name': {'name': [host]},
'datastore_name': {'name': [datastore]},
'num_vms': "2",
}
# Same thing, different names. :\
if provider.type == 'rhevm':
provisioning_data['provision_type'] = 'Native Clone'
elif provider.type == 'virtualcenter':
provisioning_data['provision_type'] = 'VMware'
try:
provisioning_data['vlan'] = provisioning['vlan']
except KeyError:
# provisioning['vlan'] is required for rhevm provisioning
if provider.type == 'rhevm':
raise pytest.fail('rhevm requires a vlan value in provisioning info')
do_vm_provisioning(template, provider, vm_name, provisioning_data, request, smtp_test,
wait=False)
wait_for(
lambda:
len(filter(
lambda mail:
"your request for a new vms was not autoapproved" in normalize_text(mail["subject"]),
smtp_test.get_emails())) > 0,
num_sec=90, delay=5)
wait_for(
lambda:
len(filter(
lambda mail:
"virtual machine request was not approved" in normalize_text(mail["subject"]),
smtp_test.get_emails())) > 0,
num_sec=90, delay=5)
cells = {'Description': 'Provision from [{}] to [{}###]'.format(template, vm_name)}
wait_for(lambda: requests.go_to_request(cells), num_sec=80, delay=5)
if edit:
# Automatic approval after editing the request to conform
with requests.edit_request(cells) as form:
fill(form.num_vms, "1")
new_vm_name = vm_name + "-xx"
fill(form.vm_name, new_vm_name)
vm_names = [new_vm_name] # Will be just one now
cells = {'Description': 'Provision from [{}] to [{}]'.format(template, new_vm_name)}
request.addfinalizer(
lambda: cleanup_vm(new_vm_name, provider))
else:
# Manual approval
requests.approve_request(cells, "Approved")
vm_names = [vm_name + "001", vm_name + "002"] # There will be two VMs
request.addfinalizer(
lambda: [cleanup_vm(vmname, provider) for vmname in vm_names])
wait_for(
lambda:
len(filter(
lambda mail:
"your virtual machine configuration was approved" in normalize_text(mail["subject"]),
smtp_test.get_emails())) > 0,
num_sec=120, delay=5)
# Wait for the VM to appear on the provider backend before proceeding to ensure proper cleanup
logger.info('Waiting for vms %s to appear on provider %s', ", ".join(vm_names), provider.key)
wait_for(
lambda: all(map(provider.mgmt.does_vm_exist, vm_names)),
handle_exception=True, num_sec=600)
row, __ = wait_for(requests.wait_for_request, [cells],
fail_func=requests.reload, num_sec=1500, delay=20)
assert normalize_text(row.status.text) == 'ok' \
and normalize_text(row.request_state.text) == 'finished'
# Wait for e-mails to appear
def verify():
return (
len(filter(
lambda mail:
"your virtual machine request has completed vm {}".format(normalize_text(vm_name))
in normalize_text(mail["subject"]),
smtp_test.get_emails())) == len(vm_names)
)
wait_for(verify, message="email receive check", delay=5)
def finalize():
policy_for_testing.assign_events()
with update(policy_for_testing):
policy_for_testing.scope = (
"fill_field(VM and Instance : Name, INCLUDES, {})".format(vm_name))
cleanup_vm(clone_vm_name, provider)
def ssa_vm(request, local_setup_provider, provider,
vm_analysis_provisioning_data, appliance, analysis_type):
""" Fixture to provision instance on the provider """
vm_name = 'test-ssa-{}-{}'.format(fauxfactory.gen_alphanumeric(),
analysis_type)
vm = VM.factory(vm_name,
provider,
template_name=vm_analysis_provisioning_data.image)
request.addfinalizer(lambda: cleanup_vm(vm_name, provider))
provision_data = vm_analysis_provisioning_data.copy()
del provision_data['image']
vm.create_on_provider(find_in_cfme=True, **provision_data)
if provider.one_of(OpenStackProvider):
public_net = provider.data['public_network']
vm.provider.mgmt.assign_floating_ip(vm.name, public_net)
logger.info("VM %s provisioned, waiting for IP address to be assigned",
vm_name)
@wait_for_decorator(timeout="20m", delay=5)
def get_ip_address():
logger.info("Power state for {} vm: {}, is_vm_stopped: {}".format(
vm_name, provider.mgmt.vm_status(vm_name),
provider.mgmt.is_vm_stopped(vm_name)))
if provider.mgmt.is_vm_stopped(vm_name):
provider.mgmt.start_vm(vm_name)
ip = provider.mgmt.current_ip_address(vm_name)
logger.info("Fetched IP for %s: %s", vm_name, ip)
return ip is not None
connect_ip = provider.mgmt.get_ip_address(vm_name)
assert connect_ip is not None
# 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
if vm_analysis_provisioning_data['fs-type'] not in ['ntfs', 'fat32']:
logger.info("Waiting for %s to be available via SSH", connect_ip)
ssh_client = ssh.SSHClient(
hostname=connect_ip,
username=vm_analysis_provisioning_data['username'],
password=vm_analysis_provisioning_data['password'],
port=22)
wait_for(ssh_client.uptime, num_sec=3600, handle_exception=True)
vm.ssh = ssh_client
vm.system_type = detect_system_type(vm)
logger.info("Detected system type: %s", vm.system_type)
vm.image = vm_analysis_provisioning_data['image']
vm.connect_ip = connect_ip
# TODO: if rhev and iscsi, it need direct_lun
if provider.type == 'rhevm':
logger.info("Setting a relationship between VM and appliance")
cfme_rel = VM.CfmeRelationship(vm)
server_name = appliance.server.name
cfme_rel.set_relationship(str(server_name), configuration.server_id())
yield vm
# Close the SSH client if we have one
if getattr(vm, 'ssh', None):
vm.ssh.close()
def test_cloud_catalog_item(appliance, setup_provider, provider, dialog,
catalog, request, provisioning):
"""Tests cloud catalog item
Metadata:
test_flag: provision
"""
# azure accepts only 15 chars vm name
vm_name = 'test{}'.format(fauxfactory.gen_string('alphanumeric', 5))
# GCE accepts only lowercase letters in VM name
vm_name = vm_name.lower()
request.addfinalizer(lambda: cleanup_vm(vm_name + "_0001", provider))
image = provisioning['image']['name']
item_name = fauxfactory.gen_alphanumeric()
provisioning_data = {
'catalog': {
'vm_name': vm_name,
},
'properties': {
'instance_type': partial_match(provisioning['instance_type']),
},
'environment': {}
}
if not provider.one_of(GCEProvider):
provisioning_data['environment'].update(
{'security_groups': partial_match(provisioning['security_group'])})
if not provider.one_of(AzureProvider) and not provider.one_of(GCEProvider):
provisioning_data['environment'].update(
{'cloud_tenant': provisioning['cloud_tenant']})
if provider.one_of(AzureProvider):
env_updates = dict(
cloud_network=partial_match(provisioning['virtual_private_cloud']),
cloud_subnet=provisioning['cloud_subnet'],
resource_groups=provisioning['resource_group'],
)
provisioning_data['environment'].update(env_updates)
provisioning_data.update({
'customize': {
'admin_username': provisioning['customize_username'],
'root_password': provisioning['customize_password']
}
})
else:
provisioning_data['properties']['guest_keypair'] = provisioning[
'guest_keypair']
provisioning_data['properties']['boot_disk_size'] = provisioning[
'boot_disk_size']
env_updates = dict(availability_zone=provisioning['availability_zone'],
cloud_network=provisioning['cloud_network'])
provisioning_data['environment'].update(env_updates)
catalog_item = CatalogItem(item_type=provisioning['item_type'],
name=item_name,
description="my catalog",
display_in=True,
catalog=catalog,
dialog=dialog,
catalog_name=image,
provider=provider,
prov_data=provisioning_data)
catalog_item.create()
service_catalogs = ServiceCatalogs(appliance, catalog_item.catalog,
catalog_item.name)
service_catalogs.order()
logger.info('Waiting for cfme provision request for service %s', item_name)
request_description = item_name
provision_request = appliance.collections.requests.instantiate(
request_description, partial_check=True)
provision_request.wait_for_request()
assert provision_request.is_succeeded()
