def run_stress_boot(test, params, env):
"""
Boots VMs until one of them becomes unresponsive, and records the maximum
number of VMs successfully started:
1) boot the first vm
2) boot the second vm cloned from the first vm, check whether it boots up
and all booted vms respond to shell commands
3) go on until cannot create VM anymore or cannot allocate memory for VM
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment.
"""
error.base_context("waiting for the first guest to be up", logging.info)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
login_timeout = float(params.get("login_timeout", 240))
session = vm.wait_for_login(timeout=login_timeout)
num = 2
sessions = [session]
# Boot the VMs
try:
while num <= int(params.get("max_vms")):
# Clone vm according to the first one
error.base_context("booting guest #%d" % num, logging.info)
vm_name = "vm%d" % num
vm_params = vm.params.copy()
curr_vm = vm.clone(vm_name, vm_params)
env.register_vm(vm_name, curr_vm)
kvm_preprocessing.preprocess_vm(test, vm_params, env, vm_name)
params["vms"] += " " + vm_name
sessions.append(curr_vm.wait_for_login(timeout=login_timeout))
logging.info("Guest #%d booted up successfully", num)
# Check whether all previous shell sessions are responsive
for i, se in enumerate(sessions):
error.context("checking responsiveness of guest #%d" % (i + 1),
logging.debug)
se.cmd(params.get("alive_test_cmd"))
num += 1
finally:
for se in sessions:
se.close()
logging.info("Total number booted: %d" % (num -1))
def run_stress_boot(test, params, env):
"""
Boots VMs until one of them becomes unresponsive, and records the maximum
number of VMs successfully started:
1) boot the first vm
2) boot the second vm cloned from the first vm, check whether it boots up
and all booted vms respond to shell commands
3) go on until cannot create VM anymore or cannot allocate memory for VM
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment.
"""
error.base_context("waiting for the first guest to be up", logging.info)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
login_timeout = float(params.get("login_timeout", 240))
session = vm.wait_for_login(timeout=login_timeout)
num = 2
sessions = [session]
# Boot the VMs
try:
while num <= int(params.get("max_vms")):
# Clone vm according to the first one
error.base_context("booting guest #%d" % num, logging.info)
vm_name = "vm%d" % num
vm_params = vm.params.copy()
curr_vm = vm.clone(vm_name, vm_params)
env.register_vm(vm_name, curr_vm)
kvm_preprocessing.preprocess_vm(test, vm_params, env, vm_name)
params["vms"] += " " + vm_name
sessions.append(curr_vm.wait_for_login(timeout=login_timeout))
logging.info("Guest #%d booted up successfully", num)
# Check whether all previous shell sessions are responsive
for i, se in enumerate(sessions):
error.context("checking responsiveness of guest #%d" % (i + 1),
logging.debug)
se.cmd(params.get("alive_test_cmd"))
num += 1
finally:
for se in sessions:
se.close()
logging.info("Total number booted: %d" % (num - 1))
def commit_test(cmd):
"""
Subcommand 'qemu-img commit' test.
1) Create a backing file of the qemu harddisk specified by image_name.
2) Start a VM using the backing file as its harddisk.
3) Touch a file "commit_testfile" in the backing_file, and shutdown the
VM.
4) Make sure touching the file does not affect the original harddisk.
5) Commit the change to the original harddisk by executing
"qemu-img commit" command.
6) Start the VM using the original harddisk.
7) Check if the file "commit_testfile" exists.
@param cmd: qemu-img base command.
"""
cmd += " commit"
logging.info("Commit testing started!")
image_name = params.get("image_name", "image")
image_format = params.get("image_format", "qcow2")
backing_file_name = "%s_bak" % (image_name)
try:
# Remove the existing backing file
backing_file = "%s.%s" % (backing_file_name, image_format)
if os.path.isfile(backing_file):
os.remove(backing_file)
# Create the new backing file
create_cmd = "qemu-img create -b %s.%s -f %s %s.%s" % (image_name,
image_format,
image_format,
backing_file_name,
image_format)
try:
utils.system(create_cmd)
except error.CmdError, e:
raise error.TestFail("Could not create a backing file!")
logging.info("backing_file created!")
# Set the qemu harddisk to the backing file
logging.info("Original image_name is: %s", params.get('image_name'))
params['image_name'] = backing_file_name
logging.info("Param image_name changed to: %s",
params.get('image_name'))
# Start a new VM, using backing file as its harddisk
vm_name = params.get('main_vm')
kvm_preprocessing.preprocess_vm(test, params, env, vm_name)
vm = env.get_vm(vm_name)
vm.create()
timeout = int(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=timeout)
# Do some changes to the backing_file harddisk
try:
output = session.cmd("touch /commit_testfile")
logging.info("Output of touch /commit_testfile: %s", output)
output = session.cmd("ls / | grep commit_testfile")
logging.info("Output of ls / | grep commit_testfile: %s",
output)
except Exception, e:
raise error.TestFail("Could not create commit_testfile in the "
"backing file %s", e)
except Exception, e:
raise error.TestFail("Could not create commit_testfile in the "
"backing file %s", e)
vm.destroy()
# Make sure there is no effect on the original harddisk
# First, set the harddisk back to the original one
logging.info("Current image_name is: %s", params.get('image_name'))
params['image_name'] = image_name
logging.info("Param image_name reverted to: %s",
params.get('image_name'))
# Second, Start a new VM, using image_name as its harddisk
# Here, the commit_testfile should not exist
vm_name = params.get('main_vm')
kvm_preprocessing.preprocess_vm(test, params, env, vm_name)
vm = env.get_vm(vm_name)
vm.create()
timeout = int(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=timeout)
try:
output = session.cmd("[ ! -e /commit_testfile ] && echo $?")
logging.info("Output of [ ! -e /commit_testfile ] && echo $?: "
"%s", output)
except:
output = session.cmd("rm -f /commit_testfile")
raise error.TestFail("The commit_testfile exists on the "
"original file")
vm.destroy()
# Excecute the commit command
def _vm_create(no_console=3, no_serialport=3):
"""
Creates the VM and connects the specified number of consoles and serial
ports.
Ports are allocated by 2 per 1 virtio-serial-pci device starting with
console. (3+2 => CC|CS|S; 0+2 => SS; 3+4 => CC|CS|SS|S, ...) This way
it's easy to test communication on the same or different
virtio-serial-pci device.
Further in tests the consoles are being picked always from the first
available one (3+2: 2xC => CC|cs|s <communication on the same PCI>;
2xC,1xS => CC|cS|s <communication between 2 PCI devs)
@param no_console: Number of desired virtconsoles.
@param no_serialport: Number of desired virtserialports.
@return: Tuple with (guest information, consoles information)
guest informations = [vm, session, tmp_dir, kcrash]
consoles informations = [consoles[], serialports[]]
"""
consoles = []
serialports = []
tmp_dir = tempfile.mkdtemp(prefix="virtio-console-", dir="/tmp/")
if not params.get('extra_params'):
params['extra_params'] = ''
for i in range(0, no_console):
# Spread consoles between multiple PCI devices (2 per a dev)
if not i % 2:
pci = "virtio-serial-pci%d" % (i / 2)
params['extra_params'] += (" -device virtio-serial-pci,id=" +
pci)
pci += ".0"
params['extra_params'] += (" -chardev socket,path=%s/%d,id=vc%d,"
"server,nowait" % (tmp_dir, i, i))
params['extra_params'] += (" -device virtconsole,chardev=vc%d,"
"name=console-%d,id=c%d,bus=%s" %
(i, i, i, pci))
for i in range(no_console, no_console + no_serialport):
# Spread seroal ports between multiple PCI devices (2 per a dev)
if not i % 2:
pci = "virtio-serial-pci%d" % (i / 2)
params['extra_params'] += (" -device virtio-serial-pci,id=" +
pci)
pci += ".0"
params['extra_params'] += (" -chardev socket,path=%s/%d,id=vs%d,"
"server,nowait" % (tmp_dir, i, i))
params['extra_params'] += (" -device virtserialport,chardev=vs%d,"
"name=serialport-%d,id=p%d,bus=%s" %
(i, i, i, pci))
logging.debug("Booting first guest %s", params.get("main_vm"))
kvm_preprocessing.preprocess_vm(test, params, env,
params.get("main_vm"))
vm = env.get_vm(params.get("main_vm"))
session = vm.wait_for_login(
timeout=float(params.get("boot_timeout", 240)))
sserial = kvm_test_utils.wait_for_login(
vm, 0, float(params.get("boot_timeout", 240)), 0, 2, serial=True)
# connect the sockets
for i in range(0, no_console):
consoles.append(
Port(None, "console-%d" % i, "yes", "%s/%d" % (tmp_dir, i)))
for i in range(no_console, no_console + no_serialport):
serialports.append(
Port(None, "serialport-%d" % i, "no", "%s/%d" % (tmp_dir, i)))
kcrash = False
return [vm, session, tmp_dir, sserial, kcrash], [consoles, serialports]
def commit_test(cmd):
"""
Subcommand 'qemu-img commit' test.
1) Create a backing file of the qemu harddisk specified by image_name.
2) Start a VM using the backing file as its harddisk.
3) Touch a file "commit_testfile" in the backing_file, and shutdown the
VM.
4) Make sure touching the file does not affect the original harddisk.
5) Commit the change to the original harddisk by executing
"qemu-img commit" command.
6) Start the VM using the original harddisk.
7) Check if the file "commit_testfile" exists.
@param cmd: qemu-img base command.
"""
cmd += " commit"
logging.info("Commit testing started!")
image_name = params.get("image_name", "image")
image_format = params.get("image_format", "qcow2")
backing_file_name = "%s_bak" % (image_name)
try:
# Remove the existing backing file
backing_file = "%s.%s" % (backing_file_name, image_format)
if os.path.isfile(backing_file):
os.remove(backing_file)
# Create the new backing file
create_cmd = "qemu-img create -b %s.%s -f %s %s.%s" % (
image_name, image_format, image_format, backing_file_name,
image_format)
try:
utils.system(create_cmd)
except error.CmdError, e:
raise error.TestFail("Could not create a backing file!")
logging.info("backing_file created!")
# Set the qemu harddisk to the backing file
logging.info("Original image_name is: %s",
params.get('image_name'))
params['image_name'] = backing_file_name
logging.info("Param image_name changed to: %s",
params.get('image_name'))
# Start a new VM, using backing file as its harddisk
vm_name = params.get('main_vm')
kvm_preprocessing.preprocess_vm(test, params, env, vm_name)
vm = env.get_vm(vm_name)
vm.create()
timeout = int(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=timeout)
# Do some changes to the backing_file harddisk
try:
output = session.cmd("touch /commit_testfile")
logging.info("Output of touch /commit_testfile: %s", output)
output = session.cmd("ls / | grep commit_testfile")
logging.info("Output of ls / | grep commit_testfile: %s",
output)
except Exception, e:
raise error.TestFail(
"Could not create commit_testfile in the "
"backing file %s", e)
raise error.TestFail(
"Could not create commit_testfile in the "
"backing file %s", e)
vm.destroy()
# Make sure there is no effect on the original harddisk
# First, set the harddisk back to the original one
logging.info("Current image_name is: %s", params.get('image_name'))
params['image_name'] = image_name
logging.info("Param image_name reverted to: %s",
params.get('image_name'))
# Second, Start a new VM, using image_name as its harddisk
# Here, the commit_testfile should not exist
vm_name = params.get('main_vm')
kvm_preprocessing.preprocess_vm(test, params, env, vm_name)
vm = env.get_vm(vm_name)
vm.create()
timeout = int(params.get("login_timeout", 360))
session = vm.wait_for_login(timeout=timeout)
try:
output = session.cmd("[ ! -e /commit_testfile ] && echo $?")
logging.info(
"Output of [ ! -e /commit_testfile ] && echo $?: "
"%s", output)
except:
output = session.cmd("rm -f /commit_testfile")
raise error.TestFail("The commit_testfile exists on the "
"original file")
vm.destroy()
def run_unittest(test, params, env):
"""
KVM RHEL-6 style unit test:
1) Resume a stopped VM
2) Wait for VM to terminate
3) If qemu exited with code = 0, the unittest passed. Otherwise, it failed
4) Collect all logs generated
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment
"""
unittest_dir = os.path.join(test.bindir, 'unittests')
if not os.path.isdir(unittest_dir):
raise error.TestError("No unittest dir %s available (did you run the "
"build test first?)" % unittest_dir)
os.chdir(unittest_dir)
unittest_list = glob.glob('*.flat')
if not unittest_list:
raise error.TestError("No unittest files available (did you run the "
"build test first?)")
logging.debug('Flat file list: %s', unittest_list)
unittest_cfg = os.path.join(unittest_dir, 'unittests.cfg')
parser = ConfigParser.ConfigParser()
parser.read(unittest_cfg)
test_list = parser.sections()
if not test_list:
raise error.TestError("No tests listed on config file %s" %
unittest_cfg)
logging.debug('Unit test list: %s' % test_list)
if params.get('test_list', None):
test_list = kvm_utils.get_sub_dict_names(params, 'test_list')
logging.info('Original test list overriden by user')
logging.info('User defined unit test list: %s' % test_list)
nfail = 0
tests_failed = []
timeout = int(params.get('unittest_timeout', 600))
extra_params_original = params['extra_params']
for t in test_list:
logging.info('Running %s', t)
file = None
if parser.has_option(t, 'file'):
file = parser.get(t, 'file')
if file is None:
nfail += 1
tests_failed.append(t)
logging.error('Unittest config file %s has section %s but no '
'mandatory option file' % (unittest_cfg, t))
continue
if file not in unittest_list:
nfail += 1
tests_failed.append(t)
logging.error('Unittest file %s referenced in config file %s but '
'was not find under the unittest dir' %
(file, unittest_cfg))
continue
smp = None
if parser.has_option(t, 'smp'):
smp = int(parser.get(t, 'smp'))
params['smp'] = smp
extra_params = None
if parser.has_option(t, 'extra_params'):
extra_params = parser.get(t, 'extra_params')
params['extra_params'] += ' %s' % extra_params
vm_name = params.get("main_vm")
params['kernel'] = os.path.join(unittest_dir, file)
testlog_path = os.path.join(test.debugdir, "%s.log" % t)
try:
try:
vm_name = params.get('main_vm')
kvm_preprocessing.preprocess_vm(test, params, env, vm_name)
vm = kvm_utils.env_get_vm(env, vm_name)
vm.create()
vm.monitor.cmd("cont")
logging.info("Waiting for unittest %s to complete, timeout %s, "
"output in %s", t, timeout,
vm.get_testlog_filename())
if not kvm_utils.wait_for(vm.is_dead, timeout):
raise error.TestFail("Timeout elapsed (%ss)" % timeout)
# Check qemu's exit status
status = vm.process.get_status()
if status != 0:
nfail += 1
tests_failed.append(t)
logging.error("Unit test %s failed", t)
except Exception, e:
nfail += 1
tests_failed.append(t)
logging.error('Exception happened during %s: %s', t, str(e))
finally:
try:
shutil.copy(vm.get_testlog_filename(), testlog_path)
logging.info("Unit test log collected and available under %s",
testlog_path)
except NameError, IOError:
logging.error("Not possible to collect logs")
# Restore the extra params so other tests can run normally
params['extra_params'] = extra_params_original
def _vm_create(no_console=3, no_serialport=3):
"""
Creates the VM and connects the specified number of consoles and serial
ports.
Ports are allocated by 2 per 1 virtio-serial-pci device starting with
console. (3+2 => CC|CS|S; 0+2 => SS; 3+4 => CC|CS|SS|S, ...) This way
it's easy to test communication on the same or different
virtio-serial-pci device.
Further in tests the consoles are being picked always from the first
available one (3+2: 2xC => CC|cs|s <communication on the same PCI>;
2xC,1xS => CC|cS|s <communication between 2 PCI devs)
@param no_console: Number of desired virtconsoles.
@param no_serialport: Number of desired virtserialports.
@return: Tuple with (guest information, consoles information)
guest informations = [vm, session, tmp_dir]
consoles informations = [consoles[], serialports[]]
"""
consoles = []
serialports = []
tmp_dir = tempfile.mkdtemp(prefix="virtio-console-", dir="/tmp/")
if not params.get('extra_params'):
params['extra_params'] = ''
for i in range(0, no_console):
# Spread consoles between multiple PCI devices (2 per a dev)
if not i % 2:
pci = "virtio-serial-pci%d" % (i / 2)
params['extra_params'] += (" -device virtio-serial-pci,id="
+ pci)
pci += ".0"
params['extra_params'] += (" -chardev socket,path=%s/%d,id=vc%d,"
"server,nowait" % (tmp_dir, i, i))
params['extra_params'] += (" -device virtconsole,chardev=vc%d,"
"name=console-%d,id=c%d,bus=%s"
% (i, i, i, pci))
for i in range(no_console, no_console + no_serialport):
# Spread seroal ports between multiple PCI devices (2 per a dev)
if not i % 2:
pci = "virtio-serial-pci%d" % (i / 2)
params['extra_params'] += (" -device virtio-serial-pci,id="
+ pci)
pci += ".0"
params['extra_params'] += (" -chardev socket,path=%s/%d,id=vs%d,"
"server,nowait" % (tmp_dir, i, i))
params['extra_params'] += (" -device virtserialport,chardev=vs%d,"
"name=serialport-%d,id=p%d,bus=%s"
% (i, i, i, pci))
logging.debug("Booting first guest %s", params.get("main_vm"))
kvm_preprocessing.preprocess_vm(test, params, env,
params.get("main_vm"))
vm = kvm_utils.env_get_vm(env, params.get("main_vm"))
session = kvm_test_utils.wait_for_login(vm, 0,
float(params.get("boot_timeout", 240)),
0, 2)
# connect the sockets
for i in range(0, no_console):
consoles.append(Port(None ,"console-%d" % i,
"yes", "%s/%d" % (tmp_dir, i)))
for i in range(no_console, no_console + no_serialport):
serialports.append(Port(None ,"serialport-%d" % i,
"no", "%s/%d" % (tmp_dir, i)))
return [vm, session, tmp_dir], [consoles, serialports]
def run_unittest(test, params, env):
"""
KVM RHEL-6 style unit test:
1) Resume a stopped VM
2) Wait for VM to terminate
3) If qemu exited with code = 0, the unittest passed. Otherwise, it failed
4) Collect all logs generated
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment
"""
unittest_dir = os.path.join(test.bindir, 'unittests')
if not os.path.isdir(unittest_dir):
raise error.TestError("No unittest dir %s available (did you run the "
"build test first?)" % unittest_dir)
os.chdir(unittest_dir)
unittest_list = glob.glob('*.flat')
if not unittest_list:
raise error.TestError("No unittest files available (did you run the "
"build test first?)")
logging.debug('Flat file list: %s', unittest_list)
unittest_cfg = os.path.join(unittest_dir, 'unittests.cfg')
parser = ConfigParser.ConfigParser()
parser.read(unittest_cfg)
test_list = parser.sections()
if not test_list:
raise error.TestError("No tests listed on config file %s" %
unittest_cfg)
logging.debug('Unit test list: %s', test_list)
if params.get('test_list'):
test_list = params.get('test_list').split()
logging.info('Original test list overriden by user')
logging.info('User defined unit test list: %s', test_list)
nfail = 0
tests_failed = []
timeout = int(params.get('unittest_timeout', 600))
extra_params_original = params['extra_params']
for t in test_list:
logging.info('Running %s', t)
flat_file = None
if parser.has_option(t, 'file'):
flat_file = parser.get(t, 'file')
if flat_file is None:
nfail += 1
tests_failed.append(t)
logging.error(
'Unittest config file %s has section %s but no '
'mandatory option file', unittest_cfg, t)
continue
if flat_file not in unittest_list:
nfail += 1
tests_failed.append(t)
logging.error(
'Unittest file %s referenced in config file %s but '
'was not find under the unittest dir', flat_file, unittest_cfg)
continue
smp = None
if parser.has_option(t, 'smp'):
smp = int(parser.get(t, 'smp'))
params['smp'] = smp
extra_params = None
if parser.has_option(t, 'extra_params'):
extra_params = parser.get(t, 'extra_params')
params['extra_params'] += ' %s' % extra_params
vm_name = params.get("main_vm")
params['kernel'] = os.path.join(unittest_dir, flat_file)
testlog_path = os.path.join(test.debugdir, "%s.log" % t)
try:
try:
vm_name = params.get('main_vm')
kvm_preprocessing.preprocess_vm(test, params, env, vm_name)
vm = env.get_vm(vm_name)
vm.create()
vm.monitor.cmd("cont")
logging.info(
"Waiting for unittest %s to complete, timeout %s, "
"output in %s", t, timeout, vm.get_testlog_filename())
if not kvm_utils.wait_for(vm.is_dead, timeout):
raise error.TestFail("Timeout elapsed (%ss)" % timeout)
# Check qemu's exit status
status = vm.process.get_status()
if status != 0:
nfail += 1
tests_failed.append(t)
logging.error("Unit test %s failed", t)
except Exception, e:
nfail += 1
tests_failed.append(t)
logging.error('Exception happened during %s: %s', t, str(e))
finally:
try:
shutil.copy(vm.get_testlog_filename(), testlog_path)
logging.info("Unit test log collected and available under %s",
testlog_path)
except (NameError, IOError):
logging.error("Not possible to collect logs")
# Restore the extra params so other tests can run normally
params['extra_params'] = extra_params_original
if nfail != 0:
raise error.TestFail("Unit tests failed: %s" % " ".join(tests_failed))
def run_stress_boot(tests, params, env):
"""
Boots VMs until one of them becomes unresponsive, and records the maximum
number of VMs successfully started:
1) boot the first vm
2) boot the second vm cloned from the first vm, check whether it boots up
and all booted vms respond to shell commands
3) go on until cannot create VM anymore or cannot allocate memory for VM
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment.
"""
# boot the first vm
vm = kvm_test_utils.get_living_vm(env, params.get("main_vm"))
logging.info("Waiting for first guest to be up...")
login_timeout = float(params.get("login_timeout", 240))
session = kvm_utils.wait_for(vm.remote_login, login_timeout, 0, 2)
if not session:
raise error.TestFail("Could not log into first guest")
num = 2
sessions = [session]
# boot the VMs
while num <= int(params.get("max_vms")):
try:
# clone vm according to the first one
vm_name = "vm" + str(num)
vm_params = vm.get_params().copy()
curr_vm = vm.clone(vm_name, vm_params)
kvm_utils.env_register_vm(env, vm_name, curr_vm)
logging.info("Booting guest #%d" % num)
kvm_preprocessing.preprocess_vm(tests, vm_params, env, vm_name)
params['vms'] += " " + vm_name
curr_vm_session = kvm_utils.wait_for(curr_vm.remote_login,
login_timeout, 0, 2)
if not curr_vm_session:
raise error.TestFail("Could not log into guest #%d" % num)
logging.info("Guest #%d boots up successfully" % num)
sessions.append(curr_vm_session)
# check whether all previous shell sessions are responsive
for i, se in enumerate(sessions):
try:
se.cmd(params.get("alive_test_cmd"))
except kvm_subprocess.ShellError:
raise error.TestFail("Session #%d is not responsive" % i)
num += 1
except (error.TestFail, OSError):
for se in sessions:
se.close()
logging.info("Total number booted: %d" % (num - 1))
raise
else:
for se in sessions:
se.close()
logging.info("Total number booted: %d" % (num -1))
