def test_set_hosts_storage_backing_min(instance_backing, number_of_hosts):
"""
Modify hosts storage backing if needed so that system has minimal number of hosts in given instance backing
Args:
instance_backing:
number_of_hosts:
Test Steps:
- Calculate the hosts to be configured based on test params
- Configure hosts to meet given criteria
- Check number of hosts in given instance backing is as specified
"""
LOG.tc_step("Determine the hosts to configure")
hosts = host_helper.get_up_hypervisors()
hosts_len = len(hosts)
host_num_mapping = {'all': hosts_len, 'two': 2, 'one': 1}
number_of_hosts = host_num_mapping[number_of_hosts]
hosts_with_backing = host_helper.get_hosts_in_storage_backing(
instance_backing)
if len(hosts_with_backing) >= number_of_hosts:
LOG.info("Already have {} hosts in {} backing. Do nothing".format(
len(hosts_with_backing), instance_backing))
return
candidate_hosts = get_candidate_hosts(number_of_hosts=number_of_hosts)
number_to_config = number_of_hosts - len(hosts_with_backing)
hosts_to_config = list(set(candidate_hosts) -
set(hosts_with_backing))[0:number_to_config]
LOG.tc_step(
"Delete vms if any to prepare for system configuration change with best effort"
)
vm_helper.delete_vms(fail_ok=True)
LOG.tc_step("Configure following hosts to {} backing: {}".format(
hosts_to_config, instance_backing))
for host in hosts_to_config:
HostsToRecover.add(host)
host_helper.set_host_storage_backing(host=host,
inst_backing=instance_backing,
unlock=False,
wait_for_configured=False)
host_helper.unlock_hosts(hosts_to_config,
check_hypervisor_up=True,
fail_ok=False)
LOG.tc_step("Waiting for hosts in {} aggregate".format(instance_backing))
for host in hosts_to_config:
host_helper.wait_for_host_in_instance_backing(
host, storage_backing=instance_backing)
LOG.tc_step("Check number of {} hosts is at least {}".format(
instance_backing, number_of_hosts))
assert number_of_hosts <= len(host_helper.get_hosts_in_storage_backing(instance_backing)), \
"Number of {} hosts is less than {} after configuration".format(instance_backing, number_of_hosts)
def get_hosts(self, ixia_required, skip_test_if_less_than_two_hosts):
hosts = host_helper.get_hosts_in_storage_backing()
if len(hosts) < 2:
skip(
"Lab not suitable for this test. Too many or too few hosts with local_image backing"
)
return hosts
def prepare_hosts(request):
"""
Setup:
Attempt to convert all computes to expected storage backing.
Skip test if unsuccessful.
Args:
request: expected host storage backing to run the test
Returns: hosts storage backing
Teardown:
Restore hosts to original state
"""
expected_storage_backing = request.param
avail_hosts = host_helper.get_hosts_in_storage_backing(
storage_backing=expected_storage_backing)
all_hosts = host_helper.get_hypervisors()
modified_hosts = {}
locked_hosts = []
avail_num = len(avail_hosts)
# Try to convert all available hypervisor hosts to the expected storage backing
for host in all_hosts:
if host not in avail_hosts:
original_storage = host_helper.get_host_instance_backing(host)
return_code, msg = host_helper.set_host_storage_backing(
host=host, inst_backing=expected_storage_backing, fail_ok=True)
if return_code == 0:
avail_num += 1
modified_hosts[host] = original_storage
elif return_code == 1: # Host locked, but cannot modify to the expected storage backing
locked_hosts.append(host)
else:
skip("Host {} cannot be locked. Error: {}".format(host, msg))
# Skip test if config failed
if avail_num < 2:
skip("Less than two hosts are successfully modified to {} backing".
format(expected_storage_backing))
# Teardown to restore hosts to original storage backing
def restore_hosts():
LOG.debug("Modifying hosts backing to original states..")
host_helper.unlock_hosts(locked_hosts)
for host in modified_hosts:
host_helper.set_host_storage_backing(host, modified_hosts[host])
request.addfinalizer(restore_hosts())
return request.param
def ensure_sufficient_4k_pages(request):
"""
Check if there is enough 4k pages on any compute node on any processors is a bit hassle
Returns:
"""
# check if any 4k pages greater than 600000 means more than 2G(~536871 4k pages) total.
storage_backing = request.param
hypervisors = host_helper.get_hosts_in_storage_backing(
storage_backing=storage_backing)
if len(hypervisors) < 2:
skip("Less than two hypersvisors with {} instance backing".format(
storage_backing))
hypervisors = hypervisors[:2]
LOG.fixture_step(
"Configure {} with sufficient 4k pages".format(hypervisors))
for host in hypervisors:
LOG.fixture_step(
"Modify 4k page numbers to 600000 for {}".format(host))
num_4k_pages = host_helper.get_host_memories(host, 'app_total_4K')
for proc, pages_4k in num_4k_pages.items():
if pages_4k[0] > 1024 * 1024 / 4:
break
else:
proc_to_set = 1 if len(num_4k_pages) > 1 else 0
HostsToRecover.add(host, scope='module')
host_helper.lock_host(host, swact=True)
host_helper.modify_host_memory(host,
proc=proc_to_set,
gib_4k_range=(2, 4))
host_helper.unlock_host(host,
check_hypervisor_up=True,
check_webservice_up=True)
return storage_backing, hypervisors
def test_ntfs(stx_openstack_required, host_type="controller"):
"""
This test will test NTFS mount and NTFS formatted device creation on a TiS
system.
Arguments:
- host_type (string) - host type to be tested, e.g. controller, compute,
storage
Returns:
- Nothing
Test Steps:
1. Check if desired host has USB inserted. If not, skip
2. Wipe USB
3. Change label of device
4. Create partitions on NTFS device
5. Format partitions
4. Copy large image to NTFS mount point
5. Test mount and big file creation on NTFS mounted device
"""
# Could pass these in through parametrize instead
mount_type = "ntfs"
mount_point = "/media/ntfs/"
guest_os = 'win_2012'
boot_source = "image"
host, usb_device = locate_usb(host_type, min_size=13)
if not host:
skip("No USB hardware found on {} host type".format(host_type))
hosts_with_image_backing = host_helper.get_hosts_in_storage_backing(storage_backing='image')
if len(hosts_with_image_backing) == 0:
skip("No hosts with image backing present")
# if the host with the USB is not the active controler, swact controllers
con_ssh = ControllerClient.get_active_controller()
active_controller = system_helper.get_active_controller_name(con_ssh)
if host != active_controller:
host_helper.swact_host()
with host_helper.ssh_to_host(host) as host_ssh:
wipe_usb(host_ssh, usb_device)
umount_usb(host_ssh, mount_point=mount_point)
create_usb_label(host_ssh, usb_device, label="msdos")
create_usb_partition(host_ssh, usb_device, startpt="0", endpt="2048")
format_usb(host_ssh, usb_device, partition="1")
create_usb_partition(host_ssh, usb_device, startpt="2049", endpt="100%")
format_usb(host_ssh, usb_device, partition="2")
mount_usb(host_ssh, usb_device, partition="2", mount_type=mount_type, mount_point=mount_point)
LOG.tc_step("Copy the windows guest image to the mount point")
src_img = glance_helper.scp_guest_image(img_os=guest_os, dest_dir=mount_point, con_ssh=con_ssh)
LOG.tc_step("Create flavor for windows guest image")
flv_id = nova_helper.create_flavor(name=guest_os, vcpus=4, ram=8192, storage_backing="local_image",
guest_os=guest_os)[1]
nova_helper.set_flavor(flv_id, **{FlavorSpec.CPU_POLICY: "dedicated"})
ResourceCleanup.add("flavor", flv_id)
LOG.tc_step("Import image into glance")
glance_helper.create_image(name=guest_os, source_image_file=src_img, disk_format="qcow2",
container_format="bare", con_ssh=con_ssh, cleanup="function")
LOG.tc_step("Boot VM")
vm_id = vm_helper.boot_vm(name=guest_os, flavor=flv_id, guest_os=guest_os, source=boot_source, cleanup="function")[1]
LOG.tc_step("Ping vm and ssh to it")
vm_helper.wait_for_vm_pingable_from_natbox(vm_id)
with vm_helper.ssh_to_vm_from_natbox(vm_id) as vm_ssh:
output = vm_ssh.exec_cmd('pwd', fail_ok=False)[1]
LOG.info(output)
def test_set_hosts_storage_backing_equal(instance_backing, number_of_hosts):
"""
Modify hosts storage backing if needed so that system has exact number
of hosts in given instance backing
Args:
instance_backing:
number_of_hosts:
Test Steps:
- Calculate the hosts to be configured based on test params
- Configure hosts to meet given criteria
- Check number of hosts in given instance backing is as specified
"""
host_num_mapping = {'zero': 0, 'one': 1, 'two': 2}
number_of_hosts = host_num_mapping[number_of_hosts]
LOG.tc_step("Calculate the hosts to be configured based on test params")
candidate_hosts = get_candidate_hosts(number_of_hosts=number_of_hosts)
hosts_with_backing = \
host_helper.get_hosts_in_storage_backing(instance_backing)
if len(hosts_with_backing) == number_of_hosts:
LOG.info("Already have {} hosts in {} backing. Do "
"nothing".format(number_of_hosts, instance_backing))
return
elif len(hosts_with_backing) < number_of_hosts:
backing_to_config = instance_backing
number_to_config = number_of_hosts - len(hosts_with_backing)
hosts_pool = list(set(candidate_hosts) - set(hosts_with_backing))
else:
backing_to_config = 'remote' if 'image' in instance_backing else \
'local_image'
number_to_config = len(hosts_with_backing) - number_of_hosts
hosts_pool = hosts_with_backing
LOG.tc_step("Delete vms if any to prepare for system configuration "
"change with best effort")
vm_helper.delete_vms(fail_ok=True)
hosts_to_config = hosts_pool[0:number_to_config]
LOG.tc_step("Configure following hosts to {} backing: "
"{}".format(hosts_to_config, backing_to_config))
for host in hosts_to_config:
host_helper.set_host_storage_backing(host=host,
inst_backing=backing_to_config,
unlock=False,
wait_for_configured=False)
HostsToRecover.add(host)
host_helper.unlock_hosts(hosts_to_config,
check_hypervisor_up=True,
fail_ok=False)
LOG.tc_step("Waiting for hosts in {} aggregate".format(backing_to_config))
for host in hosts_to_config:
host_helper.wait_for_host_in_instance_backing(
host, storage_backing=backing_to_config)
LOG.tc_step("Check number of {} hosts is {}".format(
instance_backing, number_of_hosts))
assert number_of_hosts == \
len(host_helper.get_hosts_in_storage_backing(instance_backing)), \
"Number of {} hosts is not {} after " \
"configuration".format(instance_backing, number_of_hosts)