def run_once(self, disks=None, gigabytes=None, chunk_mb=None):
"""
Runs one iteration of disktest.
:param disks: List of directories (usually mountpoints) to be passed
to the test.
:param gigabytes: Disk space that will be used for the test to run.
:param chunk_mb: Size of the portion of the disk used to run the test.
Cannot be larger than the total amount of free RAM.
"""
os.chdir(self.disk_srcdir)
if chunk_mb is None:
chunk_mb = utils_memory.memtotal() / 1024 / 8
if disks is None:
disks = [self.tmpdir]
if gigabytes is None:
free = 100 # cap it at 100GB by default
for disk in disks:
free = min(utils.freespace(disk) / 1024**3, free)
gigabytes = free
logging.info("Resizing to %s GB", gigabytes)
sys.stdout.flush()
self.chunk_mb = chunk_mb
self.memory_mb = utils_memory.memtotal() / 1024 / 8
if self.memory_mb > chunk_mb:
raise error.TestError("Too much RAM (%dMB) for this test to work" %
self.memory_mb)
chunks = (1024 * gigabytes) / chunk_mb
logging.info("Total of disk chunks that will be used: %s", chunks)
for i in range(chunks):
pids = []
for disk in disks:
pid = self.test_one_disk_chunk(disk, i)
pids.append(pid)
errors = []
for pid in pids:
(junk, retval) = os.waitpid(pid, 0)
if (retval != 0):
errors.append(retval)
if errors:
raise error.TestError("Errors from children: %s" % errors)
def run_once(self, disks=None, gigabytes=None, chunk_mb=None):
"""
Runs one iteration of disktest.
:param disks: List of directories (usually mountpoints) to be passed
to the test.
:param gigabytes: Disk space that will be used for the test to run.
:param chunk_mb: Size of the portion of the disk used to run the test.
Cannot be larger than the total amount of free RAM.
"""
os.chdir(self.disk_srcdir)
if chunk_mb is None:
chunk_mb = utils_memory.memtotal() / 1024 / 8
if disks is None:
disks = [self.tmpdir]
if gigabytes is None:
free = 100 # cap it at 100GB by default
for disk in disks:
free = min(utils.freespace(disk) / 1024 ** 3, free)
gigabytes = free
logging.info("Resizing to %s GB", gigabytes)
sys.stdout.flush()
self.chunk_mb = chunk_mb
self.memory_mb = utils_memory.memtotal() / 1024 / 8
if self.memory_mb > chunk_mb:
raise error.TestError("Too much RAM (%dMB) for this test to work" %
self.memory_mb)
chunks = (1024 * gigabytes) / chunk_mb
logging.info("Total of disk chunks that will be used: %s", chunks)
for i in range(chunks):
pids = []
for disk in disks:
pid = self.test_one_disk_chunk(disk, i)
pids.append(pid)
errors = []
for pid in pids:
(junk, retval) = os.waitpid(pid, 0)
if (retval != 0):
errors.append(retval)
if errors:
raise error.TestError("Errors from children: %s" % errors)
def output_check(nodeinfo_output):
# Check CPU model
cpu_model_nodeinfo = _check_nodeinfo(nodeinfo_output, "CPU model", 3)
cpu_model_os = utils.get_current_kernel_arch()
if not re.match(cpu_model_nodeinfo, cpu_model_os):
raise error.TestFail("Virsh nodeinfo output didn't match CPU model")
# Check number of CPUs
cpus_nodeinfo = _check_nodeinfo(nodeinfo_output, "CPU(s)", 2)
cpus_os = utils.count_cpus()
if int(cpus_nodeinfo) != cpus_os:
raise error.TestFail("Virsh nodeinfo output didn't match number of "
"CPU(s)")
# Check CPU frequency
cpu_frequency_nodeinfo = _check_nodeinfo(nodeinfo_output, 'CPU frequency', 3)
cmd = ("cat /proc/cpuinfo | grep 'cpu MHz' | head -n1 | "
"awk '{print $4}' | awk -F. '{print $1}'")
cmd_result = utils.run(cmd, ignore_status=True)
cpu_frequency_os = cmd_result.stdout.strip()
print cpu_frequency_os
if not re.match(cpu_frequency_nodeinfo, cpu_frequency_os):
raise error.TestFail("Virsh nodeinfo output didn't match CPU "
"frequency")
# Check CPU socket(s)
cpu_sockets_nodeinfo = int(_check_nodeinfo(nodeinfo_output, 'CPU socket(s)', 3))
cmd = "grep 'physical id' /proc/cpuinfo | uniq | sort | uniq |wc -l"
cmd_result = utils.run(cmd, ignore_status=True)
cpu_NUMA_nodeinfo = _check_nodeinfo(nodeinfo_output, 'NUMA cell(s)', 3)
cpu_sockets_os = int(cmd_result.stdout.strip())/int(cpu_NUMA_nodeinfo)
if cpu_sockets_os != cpu_sockets_nodeinfo:
raise error.TestFail("Virsh nodeinfo output didn't match CPU "
"socket(s)")
# Check Core(s) per socket
cores_per_socket_nodeinfo = _check_nodeinfo(nodeinfo_output, 'Core(s) per socket', 4)
cmd = "grep 'cpu cores' /proc/cpuinfo | head -n1 | awk '{print $4}'"
cmd_result = utils.run(cmd, ignore_status=True)
cores_per_socket_os = cmd_result.stdout.strip()
if not re.match(cores_per_socket_nodeinfo, cores_per_socket_os):
raise error.TestFail("Virsh nodeinfo output didn't match Core(s) "
"per socket")
# Check Memory size
memory_size_nodeinfo = int(_check_nodeinfo(nodeinfo_output, 'Memory size', 3))
memory_size_os = utils_memory.memtotal()
if memory_size_nodeinfo != memory_size_os:
raise error.TestFail("Virsh nodeinfo output didn't match "
"Memory size")
def run_the_test(self, iterations):
utils.write_one_line('/proc/sys/vm/dirty_ratio', '4')
utils.write_one_line('/proc/sys/vm/dirty_background_ratio', '2')
cmd = os.path.join(self.srcdir, 'linus_stress')
args = "%d" % (utils_memory.memtotal() / 32)
profilers = self.job.profilers
if profilers.present():
profilers.start(self)
for i in range(iterations):
utils.system(cmd + ' ' + args)
if profilers.present():
profilers.stop(self)
profilers.report(self)
def run_the_test(self, iterations):
utils.write_one_line('/proc/sys/vm/dirty_ratio', '4')
utils.write_one_line('/proc/sys/vm/dirty_background_ratio', '2')
cmd = os.path.join(self.srcdir, 'linus_stress')
args = "%d" % (utils_memory.memtotal() / 32)
profilers = self.job.profilers
if profilers.present():
profilers.start(self)
for i in range(iterations):
utils.system(cmd + ' ' + args)
if profilers.present():
profilers.stop(self)
profilers.report(self)
def discover_container_style():
global super_root_path, cpuset_prefix
global mem_isolation_on, fake_numa_containers
global node_mbytes, root_container_bytes
if super_root_path != '':
return # already looked up
if os.path.exists('/dev/cgroup/tasks'):
# running on 2.6.26 or later kernel with containers on:
super_root_path = '/dev/cgroup'
cpuset_prefix = 'cpuset.'
if get_boot_numa():
mem_isolation_on = fake_numa_containers = True
else: # memcg containers IFF compiled-in & mounted & non-fakenuma boot
fake_numa_containers = False
mem_isolation_on = os.path.exists(
'/dev/cgroup/memory.limit_in_bytes')
# TODO: handle possibility of where memcg is mounted as its own
# cgroup hierarchy, separate from cpuset??
elif os.path.exists('/dev/cpuset/tasks'):
# running on 2.6.18 kernel with containers on:
super_root_path = '/dev/cpuset'
cpuset_prefix = ''
mem_isolation_on = fake_numa_containers = get_boot_numa() != ''
else:
# neither cpuset nor cgroup filesystem active:
super_root_path = None
cpuset_prefix = 'no_cpusets_or_cgroups_exist'
mem_isolation_on = fake_numa_containers = False
logging.debug('mem_isolation: %s', mem_isolation_on)
logging.debug('fake_numa_containers: %s', fake_numa_containers)
if fake_numa_containers:
node_mbytes = int(mbytes_per_mem_node())
elif mem_isolation_on: # memcg-style containers
# For now, limit total of all containers to using just 98% of system's
# visible total ram, to avoid oom events at system level, and avoid
# page reclaim overhead from going above kswapd highwater mark.
system_visible_pages = utils_memory.memtotal() >> 2
usable_pages = int(system_visible_pages * 0.98)
root_container_bytes = usable_pages << 12
logging.debug('root_container_bytes: %s',
utils.human_format(root_container_bytes))
def execute(self, testdir=None, iterations=10000):
if not testdir:
testdir = self.tmpdir
os.chdir(testdir)
file = os.path.join(testdir, 'foo')
# Want to use 3/4 of all memory for each of
# bash-shared-mapping and usemem
kilobytes = (3 * utils_memory.memtotal()) / 4
# Want two usemem -m megabytes in parallel in background.
pid = [None, None]
usemem = os.path.join(self.srcdir, 'usemem')
args = ('usemem', '-N', '-m', '%d' % (kilobytes / 1024))
# print_to_tty ('2 x ' + ' '.join(args))
for i in (0, 1):
pid[i] = os.spawnv(os.P_NOWAIT, usemem, args)
cmd = "%s/bash-shared-mapping %s %d -t %d -n %d" % \
(self.srcdir, file, kilobytes,
utils.count_cpus(), iterations)
os.system(cmd)
for i in (0, 1):
os.kill(pid[i], signal.SIGKILL)
def run_once(self, size=0, loop=10):
"""
Executes the test and logs the output.
@param size: size to test in KB. 0 means all usable
@param loop: number of iteration to test memory
"""
if size == 0:
size = utils_memory.freememtotal()
# leave some memory for kernel
size = int(size * 0.8)
elif size > utils_memory.memtotal():
raise error.TestFail('Specified size is more than total memory.')
if size <= 0:
raise error.TestFail('Size must be more than zero.')
logging.info('Memory test size: %dK', size)
cmd = 'memtester %dK %d' % (size, loop)
logging.info('cmd: %s', cmd)
with open(os.path.join(self.resultsdir, 'memtester_stdout'), 'w') as f:
utils.run(cmd, stdout_tee=f)
def run(test, params, env):
"""
Test migration under stress.
"""
vm_names = params.get("migration_vms").split()
if len(vm_names) < 2:
raise error.TestNAError("Provide enough vms for migration first.")
src_uri = params.get("migrate_src_uri", "qemu+ssh://EXAMPLE/system")
if src_uri.count('///') or src_uri.count('EXAMPLE'):
raise error.TestNAError("The src_uri '%s' is invalid", src_uri)
dest_uri = params.get("migrate_dest_uri", "qemu+ssh://EXAMPLE/system")
if dest_uri.count('///') or dest_uri.count('EXAMPLE'):
raise error.TestNAError("The dest_uri '%s' is invalid", dest_uri)
# Migrated vms' instance
vms = []
for vm_name in vm_names:
vms.append(
libvirt_vm.VM(vm_name, params, test.bindir,
env.get("address_cache")))
load_vm_names = params.get("load_vms").split()
# vms for load
load_vms = []
for vm_name in load_vm_names:
load_vms.append(
libvirt_vm.VM(vm_name, params, test.bindir,
env.get("address_cache")))
params['load_vms'] = load_vms
cpu = int(params.get("smp", 1))
memory = int(params.get("mem")) * 1024
stress_type = params.get("migration_stress_type")
vm_bytes = params.get("stress_vm_bytes")
stress_args = params.get("stress_args")
migration_type = params.get("migration_type")
start_migration_vms = "yes" == params.get("start_migration_vms", "yes")
thread_timeout = int(params.get("thread_timeout", 120))
remote_host = params.get("migrate_dest_host")
username = params.get("migrate_dest_user", "root")
password = params.get("migrate_dest_pwd")
prompt = params.get("shell_prompt", r"[\#\$]")
# Set vm_bytes for start_cmd
mem_total = utils_memory.memtotal()
vm_reserved = len(vms) * memory
if vm_bytes == "half":
vm_bytes = (mem_total - vm_reserved) / 2
elif vm_bytes == "shortage":
vm_bytes = mem_total - vm_reserved + 524288
if vm_bytes is not None:
params["stress_args"] = stress_args % vm_bytes
for vm in vms:
# Keep vm dead for edit
if vm.is_alive():
vm.destroy()
set_cpu_memory(vm.name, cpu, memory)
try:
vm_ipaddr = {}
if start_migration_vms:
for vm in vms:
vm.start()
vm.wait_for_login()
vm_ipaddr[vm.name] = vm.get_address()
# TODO: recover vm if start failed?
# Config ssh autologin for remote host
ssh_key.setup_ssh_key(remote_host, username, password, port=22)
do_stress_migration(vms, src_uri, dest_uri, stress_type,
migration_type, params, thread_timeout)
# Check network of vms on destination
if start_migration_vms and migration_type != "cross":
for vm in vms:
check_dest_vm_network(vm, vm_ipaddr[vm.name], remote_host,
username, password, prompt)
finally:
logging.debug("Cleanup vms...")
for vm_name in vm_names:
vm = libvirt_vm.VM(vm_name, params, test.bindir,
env.get("address_cache"))
utlv.MigrationTest().cleanup_dest_vm(vm, None, dest_uri)
if vm.is_alive():
vm.destroy(gracefully=False)
env.clean_objects()
def run_stress_kernel_compile(tests, params, env):
"""
Boot VMs and run kernel compile inside VM parallel.
1) Boot up VMs:
Every VM has 4G vmem, the total vmem of VMs' are
$overcommit times as host's mem.
2) Launch kernel compile inside every guest.
@param test: QEMU test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
def kernelcompile(session, vm_name):
vm = env.get_vm(vm_name)
ip = vm.get_address()
path = params.get("download_url")
logging.info("kernel path = %s" % path)
get_kernel_cmd = "wget %s" % path
try:
status, output = session.cmd_status_output(get_kernel_cmd,
timeout=240)
if status != 0:
logging.error(output)
raise error.TestFail("Fail to download the kernel"
" in %s" % vm_name)
else:
logging.info("Completed download the kernel src"
" in %s" %vm_name)
test_cmd = params.get("test_cmd")
status, output = session.cmd_status_output(test_cmd, timeout=1200)
if status != 0:
logging.error(output)
finally:
status, _ = utils_test.ping(ip, count=10, timeout=30)
if status != 0:
raise error.TestFail("vm no response, pls check serial log")
over_c = float(params.get("overcommit", 1.5))
guest_number = int(params.get("guest_number", "1"))
if guest_number < 1:
logging.warn("At least boot up one guest for this test,"
" set up guest number to 1")
guest_number = 1
for tag in range(1, guest_number):
params["vms"] += " stress_guest_%s" % tag
mem_host = utils_memory.memtotal() / 1024
vmem = int(mem_host * over_c / guest_number)
if vmem < 256:
raise error.TestNAError("The memory size set for guest is too small."
" Please try less than %s guests"
" in this host." % guest_number)
params["mem"] = vmem
params["start_vm"] = "yes"
login_timeout = int(params.get("login_timeout", 360))
env_process.preprocess(tests, params, env)
sessions_info = []
for vm_name in params["vms"].split():
vm = env.get_vm(vm_name)
vm.verify_alive()
session = vm.wait_for_login(timeout=login_timeout)
if not session:
raise error.TestFail("Could not log into guest %s" % vm_name)
sessions_info.append([session, vm_name])
# run kernel compile in vms
try:
logging.info("run kernel compile in vms")
bg_threads = []
for session_info in sessions_info:
session = session_info[0]
vm_name = session_info[1]
bg_thread = utils_test.BackgroundTest(kernelcompile,
(session, vm_name))
bg_thread.start()
bg_threads.append(bg_thread)
completed = False
while not completed:
completed = True
for bg_thread in bg_threads:
if bg_thread.is_alive():
completed = False
finally:
try:
for bg_thread in bg_threads:
if bg_thread:
bg_thread.join()
finally:
for session_info in sessions_info:
session_info[0].close()
def run_stress_kernel_compile(tests, params, env):
"""
Boot VMs and run kernel compile inside VM parallel.
1) Boot up VMs:
Every VM has 4G vmem, the total vmem of VMs' are
$overcommit times as host's mem.
2) Launch kernel compile inside every guest.
@param test: QEMU test object.
@param params: Dictionary with the test parameters.
@param env: Dictionary with test environment.
"""
def kernelcompile(session, vm_name):
vm = env.get_vm(vm_name)
ip = vm.get_address()
path = params.get("download_url")
logging.info("kernel path = %s" % path)
get_kernel_cmd = "wget %s" % path
try:
status, output = session.cmd_status_output(get_kernel_cmd,
timeout=240)
if status != 0:
logging.error(output)
raise error.TestFail("Fail to download the kernel"
" in %s" % vm_name)
else:
logging.info("Completed download the kernel src"
" in %s" % vm_name)
test_cmd = params.get("test_cmd")
status, output = session.cmd_status_output(test_cmd, timeout=1200)
if status != 0:
logging.error(output)
finally:
status, _ = utils_test.ping(ip, count=10, timeout=30)
if status != 0:
raise error.TestFail("vm no response, pls check serial log")
over_c = float(params.get("overcommit", 1.5))
guest_number = int(params.get("guest_number", "1"))
if guest_number < 1:
logging.warn("At least boot up one guest for this test,"
" set up guest number to 1")
guest_number = 1
for tag in range(1, guest_number):
params["vms"] += " stress_guest_%s" % tag
mem_host = utils_memory.memtotal() / 1024
vmem = int(mem_host * over_c / guest_number)
if vmem < 256:
raise error.TestNAError("The memory size set for guest is too small."
" Please try less than %s guests"
" in this host." % guest_number)
params["mem"] = vmem
params["start_vm"] = "yes"
login_timeout = int(params.get("login_timeout", 360))
env_process.preprocess(tests, params, env)
sessions_info = []
for vm_name in params["vms"].split():
vm = env.get_vm(vm_name)
vm.verify_alive()
session = vm.wait_for_login(timeout=login_timeout)
if not session:
raise error.TestFail("Could not log into guest %s" % vm_name)
sessions_info.append([session, vm_name])
# run kernel compile in vms
try:
logging.info("run kernel compile in vms")
bg_threads = []
for session_info in sessions_info:
session = session_info[0]
vm_name = session_info[1]
bg_thread = utils_test.BackgroundTest(kernelcompile,
(session, vm_name))
bg_thread.start()
bg_threads.append(bg_thread)
completed = False
while not completed:
completed = True
for bg_thread in bg_threads:
if bg_thread.is_alive():
completed = False
finally:
try:
for bg_thread in bg_threads:
if bg_thread:
bg_thread.join()
finally:
for session_info in sessions_info:
session_info[0].close()
def count_vm_bytes(self):
mem_total = utils_memory.memtotal()
if self.vm_bytes == "half":
self.vm_bytes = (mem_total - self.vm_reserved) / 2
elif self.vm_bytes == "shortage":
self.vm_bytes = mem_total - self.vm_reserved + 524288
def run(test, params, env):
"""
Test migration under stress.
"""
vm_names = params.get("migration_vms").split()
if len(vm_names) < 2:
raise error.TestNAError("Provide enough vms for migration first.")
src_uri = params.get("migrate_src_uri", "qemu+ssh://EXAMPLE/system")
if src_uri.count('///') or src_uri.count('EXAMPLE'):
raise error.TestNAError("The src_uri '%s' is invalid", src_uri)
dest_uri = params.get("migrate_dest_uri", "qemu+ssh://EXAMPLE/system")
if dest_uri.count('///') or dest_uri.count('EXAMPLE'):
raise error.TestNAError("The dest_uri '%s' is invalid", dest_uri)
# Migrated vms' instance
vms = []
for vm_name in vm_names:
vms.append(libvirt_vm.VM(vm_name, params, test.bindir,
env.get("address_cache")))
load_vm_names = params.get("load_vms").split()
# vms for load
load_vms = []
for vm_name in load_vm_names:
load_vms.append(libvirt_vm.VM(vm_name, params, test.bindir,
env.get("address_cache")))
params['load_vms'] = load_vms
cpu = int(params.get("smp", 1))
memory = int(params.get("mem")) * 1024
stress_type = params.get("migration_stress_type")
vm_bytes = params.get("stress_vm_bytes")
stress_args = params.get("stress_args")
migration_type = params.get("migration_type")
start_migration_vms = "yes" == params.get("start_migration_vms", "yes")
thread_timeout = int(params.get("thread_timeout", 120))
remote_host = params.get("migrate_dest_host")
username = params.get("migrate_dest_user", "root")
password = params.get("migrate_dest_pwd")
prompt = params.get("shell_prompt", r"[\#\$]")
# Set vm_bytes for start_cmd
mem_total = utils_memory.memtotal()
vm_reserved = len(vms) * memory
if vm_bytes == "half":
vm_bytes = (mem_total - vm_reserved) / 2
elif vm_bytes == "shortage":
vm_bytes = mem_total - vm_reserved + 524288
if vm_bytes is not None:
params["stress_args"] = stress_args % vm_bytes
for vm in vms:
# Keep vm dead for edit
if vm.is_alive():
vm.destroy()
set_cpu_memory(vm.name, cpu, memory)
try:
vm_ipaddr = {}
if start_migration_vms:
for vm in vms:
vm.start()
vm.wait_for_login()
vm_ipaddr[vm.name] = vm.get_address()
# TODO: recover vm if start failed?
# Config ssh autologin for remote host
ssh_key.setup_ssh_key(remote_host, username, password, port=22)
do_stress_migration(vms, src_uri, dest_uri, stress_type,
migration_type, params, thread_timeout)
# Check network of vms on destination
if start_migration_vms and migration_type != "cross":
for vm in vms:
check_dest_vm_network(vm, vm_ipaddr[vm.name], remote_host,
username, password, prompt)
finally:
logging.debug("Cleanup vms...")
for vm_name in vm_names:
vm = libvirt_vm.VM(vm_name, params, test.bindir,
env.get("address_cache"))
utlv.MigrationTest().cleanup_dest_vm(vm, None, dest_uri)
if vm.is_alive():
vm.destroy(gracefully=False)
env.clean_objects()
if os.path.exists(e_rh):
utils.run("echo 'never' > %s" % e_rh)
new_ksm = True
else:
try:
utils.run("modprobe ksm")
utils.run("ksmctl start 5000 100")
except error.CmdError, details:
raise error.TestFail("Failed to load KSM: %s" % details)
# host_reserve: mem reserve kept for the host system to run
host_reserve = int(params.get("ksm_host_reserve", -1))
if (host_reserve == -1):
# default host_reserve = MemAvailable + one_minimal_guest(128MB)
# later we add 64MB per additional guest
host_reserve = ((utils_memory.memtotal()
- utils_memory.read_from_meminfo("MemFree"))
/ 1024 + 128)
# using default reserve
_host_reserve = True
else:
_host_reserve = False
# guest_reserve: mem reserve kept to avoid guest OS to kill processes
guest_reserve = int(params.get("ksm_guest_reserve", -1))
if (guest_reserve == -1):
# default guest_reserve = minimal_system_mem(256MB)
# later we add tmpfs overhead
guest_reserve = 256
# using default reserve
_guest_reserve = True
def count_vm_bytes(self):
mem_total = utils_memory.memtotal()
if self.vm_bytes == "half":
self.vm_bytes = (mem_total - self.vm_reserved) / 2
elif self.vm_bytes == "shortage":
self.vm_bytes = mem_total - self.vm_reserved + 524288
def run_virsh_nodememstats(test, params, env):
"""
Test the command virsh nodememstats
(1) Call the virsh nodememstats command
(2) Get the output
(3) Check the against /proc/meminfo output
(4) Call the virsh nodememstats command with an unexpected option
(5) Call the virsh nodememstats command with libvirtd service stop
"""
# Initialize the variables
expected = {}
actual = {}
deltas = []
name_stats = ['total', 'free', 'buffers', 'cached']
itr = int(params.get("itr"))
def virsh_check_nodememtats(actual_stats, expected_stats, delta):
"""
Check the nodememstats output value with /proc/meminfo value
"""
delta_stats = {}
for name in name_stats:
delta_stats[name] = abs(actual_stats[name] - expected_stats[name])
if 'total' in name:
if not delta_stats[name] == 0:
raise error.TestFail("Command 'virsh nodememstats' not"
" succeeded as the value for %s is "
"deviated by %d\nThe total memory "
"value is deviating-check" %
(name, delta_stats[name]))
else:
if delta_stats[name] > delta:
raise error.TestFail("Command 'virsh nodememstats' not "
"succeeded as the value for %s"
" is deviated by %d" %
(name, delta_stats[name]))
return delta_stats
# Prepare libvirtd service
check_libvirtd = params.has_key("libvirtd")
if check_libvirtd:
libvirtd = params.get("libvirtd")
if libvirtd == "off":
utils_libvirtd.libvirtd_stop()
# Get the option for the test case
option = params.get("virsh_nodememstats_options")
# Run test case for 10 iterations
# (default can be changed in subtests.cfg file)
# and print the final statistics
for i in range(itr):
output = virsh.nodememstats(option)
# Get the status of the virsh command executed
status = output.exit_status
# Get status_error option for the test case
status_error = params.get("status_error")
if status_error == "yes":
if status == 0:
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
raise error.TestFail("Command 'virsh nodememstats' "
"succeeded with libvirtd service"
" stopped, incorrect")
else:
raise error.TestFail("Command 'virsh nodememstats %s' "
"succeeded (incorrect command)" %
option)
elif status_error == "no":
if status == 0:
# From the beginning of a line, group 1 is one or
# more word-characters, followed by zero or more
# whitespace characters and a ':', then one or
# more whitespace characters, followed by group 2,
# which is one or more digit characters,
# then one or more whitespace characters followed by
# a literal 'kB' or 'KiB' sequence, e.g as below
# total : 3809340 kB
# total : 3809340 KiB
# Normalise the value to MBs
regex_obj = re.compile(r"^(\w+)\s*:\s+(\d+)\s\w+")
expected = {}
for line in output.stdout.split('\n'):
match_obj = regex_obj.search(line)
# Due to the extra space in the list
if match_obj is not None:
name = match_obj.group(1)
value = match_obj.group(2)
expected[name] = int(value) / 1024
# Get the actual value from /proc/meminfo and normalise to MBs
actual['total'] = int(utils_memory.memtotal()) / 1024
actual['free'] = int(utils_memory.freememtotal()) / 1024
actual['buffers'] = int(
utils_memory.read_from_meminfo('Buffers')) / 1024
actual['cached'] = int(
utils_memory.read_from_meminfo('Cached')) / 1024
# Currently the delta value is kept at 200 MB this can be
# tuned based on the accuracy
# Check subtests.cfg for more details
delta = int(params.get("delta"))
output = virsh_check_nodememtats(actual, expected, delta)
deltas.append(output)
else:
raise error.TestFail("Command virsh nodememstats %s not "
"succeeded:\n%s" % (option, status))
# Recover libvirtd service start
if libvirtd == "off":
utils_libvirtd.libvirtd_start()
# Print the deviated values for all iterations
if status_error == "no":
logging.debug("The following is the deviations from "
"the actual(/proc/meminfo) and expected"
" value(output of virsh nodememstats)")
for i in range(itr):
logging.debug("iteration %d:", i)
for index, name in enumerate(name_stats):
logging.debug("%19s : %d", name, deltas[i][name])