def test_cloud_instance_discovery(request, provider_crud, provider_init, provider_mgmt,
instance_name):
"""
Tests whether cfme will successfully discover a cloud instance change
(add/delete).
As there is currently no way to listen to AWS events,
CFME must be refreshed manually to see the changes.
Metadata:
test_flag: discovery
"""
if not provider_mgmt.does_vm_exist(instance_name):
deploy_template(provider_crud.key, instance_name, allow_skip="default")
test_instance = instance.instance_factory(instance_name, provider_crud)
request.addfinalizer(test_instance.delete_from_provider)
try:
wait_for(_does_instance_exist_in_CFME, [test_instance], num_sec=800, delay=30,
fail_func=test_instance.provider_crud.refresh_provider_relationships,
handle_exception=True)
except TimedOutError:
pytest.fail("Instance was not found in CFME")
test_instance.delete_from_provider()
try:
wait_for(_is_instance_archived, [test_instance], num_sec=800, delay=30,
fail_func=test_instance.provider_crud.refresh_provider_relationships,
handle_exception=True)
except TimedOutError:
pytest.fail("instance was not found in Archives")
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 %s to vm %s on provider %s' %
(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_provision_from_template(request, setup_provider, provider_crud, provisioning, vm_name):
""" Tests instance provision from template
Metadata:
test_flag: provision
"""
image = provisioning['image']['name']
note = ('Testing provisioning from image %s to vm %s on provider %s' %
(image, vm_name, provider_crud.key))
instance = instance_factory(vm_name, provider_crud, 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_crud, OpenStackProvider):
inst_args['cloud_network'] = provisioning['cloud_network']
sel.force_navigate("clouds_instances_by_provider")
instance.create(**inst_args)
def test_provision_from_template(request, setup_provider, provider_crud, provisioning, vm_name):
""" Tests instance provision from template
Metadata:
test_flag: provision
"""
image = provisioning["image"]["name"]
note = "Testing provisioning from image %s to vm %s on provider %s" % (image, vm_name, provider_crud.key)
instance = instance_factory(vm_name, provider_crud, 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_crud, OpenStackProvider):
inst_args["cloud_network"] = provisioning["cloud_network"]
sel.force_navigate("clouds_instances_by_provider")
instance.create(**inst_args)
def test_instance(setup_provider, 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_instance(setup_provider, request, delete_instances_fin, provider_crud,
provider_mgmt, vm_name):
""" Fixture to provision instance on the provider
"""
instance = instance_factory(vm_name, provider_crud)
if not provider_mgmt.does_vm_exist(vm_name):
delete_instances_fin[provider_crud.key] = instance
instance.create_on_provider(allow_skip="default")
return instance
def test_delete_instance(setup_provider, provider, remove_test):
""" Tests delete instance
Metadata:
test_flag: delete_object
"""
instance_name = remove_test['instance']
test_instance = instance.instance_factory(instance_name, provider)
test_instance.remove_from_cfme(cancel=False)
test_instance.wait_for_delete()
provider.refresh_provider_relationships()
test_instance.wait_for_vm_to_appear()
def test_delete_instance(setup_provider, provider_crud, remove_test):
""" Tests delete instance
Metadata:
test_flag: delete_object
"""
instance_name = remove_test['instance']
test_instance = instance.instance_factory(instance_name, provider_crud)
test_instance.remove_from_cfme(cancel=False)
test_instance.wait_for_delete()
provider_crud.refresh_provider_relationships()
test_instance.wait_for_vm_to_appear()
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 %s to vm %s on provider %s' %
(image, vm_name, provider.key))
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 isinstance(provider, OpenStackProvider):
floating_ip = mgmt_system.get_first_floating_ip()
inst_args['cloud_network'] = provisioning['cloud_network']
inst_args['public_ip_address'] = floating_ip
sel.force_navigate("clouds_instances_by_provider")
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 test_instance(request, delete_instances_fin, setup_provider, 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")
elif isinstance(instance, EC2Instance) and \
provider.mgmt.is_vm_state(vm_name, provider.mgmt.states['deleted']):
provider.mgmt.set_name(
vm_name, 'test_terminated_{}'.format(fauxfactory.gen_alphanumeric(8)))
delete_instances_fin[provider.key] = instance
instance.create_on_provider(allow_skip="default")
return instance
def test_instance(request, delete_instances_fin, setup_provider, 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")
elif isinstance(instance, EC2Instance) and \
provider.mgmt.is_vm_state(vm_name, provider.mgmt.states['deleted']):
provider.mgmt.set_name(
vm_name,
'test_terminated_{}'.format(fauxfactory.gen_alphanumeric(8)))
delete_instances_fin[provider.key] = instance
instance.create_on_provider(allow_skip="default")
return instance
def test_provision_cloud_init(request, setup_provider, provider_crud, 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 %s to vm %s on provider %s' %
(image, vm_name, provider_crud.key))
mgmt_system = provider_crud.get_mgmt_system()
instance = instance_factory(vm_name, provider_crud, 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 isinstance(provider_crud, OpenStackProvider):
floating_ip = mgmt_system.get_first_floating_ip()
inst_args['cloud_network'] = provisioning['cloud_network']
inst_args['public_ip_address'] = floating_ip
sel.force_navigate("clouds_instances_by_provider")
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 test_provision_from_template(request, setup_providers, provider_crud, provisioning, vm_name):
image = provisioning['image']['name']
note = ('Testing provisioning from image %s to vm %s on provider %s' %
(image, vm_name, provider_crud.key))
instance = instance_factory(vm_name, provider_crud, image)
request.addfinalizer(instance.delete_from_provider)
instance.create(
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']
)
def test_provision_from_template_with_attached_disks(
request,
setup_provider,
provider_crud,
provisioning,
vm_name,
provider_mgmt,
disks,
soft_assert,
provider_type,
domain,
cls,
):
""" 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_crud.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 = 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_crud, 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_crud, 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,
provisioning, provider, vm_name,
soft_assert, copy_domains, domain):
""" 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 %s to vm %s on provider %s' %
(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 => "%s",
:device_name => "vda",
:source_type => "image",
:destination_type => "volume",
:volume_size => 3,
:delete_on_termination => false
}]
}
)
''' % (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_additional_volume(
request, setup_provider, provider_crud, provisioning, vm_name, provider_mgmt, soft_assert,
provider_type, default_domain_enabled, provider_data):
""" 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 %s to vm %s on provider %s' %
(image, vm_name, provider_crud.key))
# Set up automate
cls = automate.Class(
name="Methods",
namespace=automate.Namespace.make_path("Cloud", "VM", "Provisioning", "StateMachines"))
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 => "%s",
:device_name => "vda",
:source_type => "image",
:destination_type => "volume",
:volume_size => 3,
:delete_on_termination => false
}]
}
)
''' % (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_crud, 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_crud, 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():
if provider_mgmt.volume_exists(volume_id):
provider_mgmt.delete_volume(volume_id)
def test_provision_with_boot_volume(
request, setup_provider, provider_crud, provisioning, vm_name, provider_mgmt, soft_assert,
provider_type, default_domain_enabled):
""" 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_crud.key))
with provider_mgmt.with_volume(1) as volume:
# Set up automate
cls = automate.Class(
name="Methods",
namespace=automate.Namespace.make_path("Cloud", "VM", "Provisioning", "StateMachines"))
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_crud, 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_crud, 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_crud, provisioning, vm_name, provider_mgmt, disks,
soft_assert, provider_type, default_domain_enabled):
""" 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_crud.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"))
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_crud, 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_crud, 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_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_with_boot_volume(
request, setup_provider, provider_crud, provisioning, vm_name, provider_mgmt, soft_assert, provider_type
):
""" 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_crud.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")
)
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_crud, 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_crud, 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, 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)
