def check_numa_params(guestname, mode, node_tuple):
"""dump domain live xml description to check numa params and
check memory allowed list of domain pid
"""
cmd = "cat /var/run/libvirt/qemu/%s.pid" % guestname
status, pid = utils.exec_cmd(cmd, shell=True)
if status:
logger.error("failed to get the pid of domain %s" % guestname)
return 1
cmd = "grep Mems_allowed_list /proc/%s/status" % pid[0]
status, output = utils.exec_cmd(cmd, shell=True)
nodeval = output[0].split('\t')[1]
ret = utils.param_to_tuple(nodeval, node_num)
logger.info("Mems_allowed_list in domain pid status is: %s" % nodeval)
logger.debug("parse nodeset to tuple is:")
logger.debug(ret)
if not ret:
logger.error("fail to parse nodeset to tuple")
return 1
# TODO: add check for mode
if ret == node_tuple:
return 0
else:
return 1
def vcpupin_check(guestname, vcpu, cpulist):
"""check vcpu subprocess status of the running virtual machine
grep Cpus_allowed_list /proc/PID/task/*/status
"""
cmd_pid = "cat /var/run/libvirt/qemu/%s.pid" % guestname
status, pid = utils.exec_cmd(cmd_pid, shell=True)
if status:
logger.error("failed to get the pid of domain %s" % guestname)
return 1
cmd_vcpu_task_id = "virsh qemu-monitor-command %s --hmp info cpus|grep '#%s'|cut -d '=' -f3"\
% (guestname, vcpu)
status, vcpu_task_id = utils.exec_cmd(cmd_vcpu_task_id, shell=True)
if status:
logger.error("failed to get the threadid of domain %s" % guestname)
return 1
logger.debug("vcpu id %s:" % vcpu_task_id[0])
cmd_cpus_allowed_list = "grep Cpus_allowed_list /proc/%s/task/%s/status" % (
pid[0], vcpu_task_id[0])
status, output = utils.exec_cmd(cmd_cpus_allowed_list, shell=True)
if status:
logger.error("failed to get the cpu_allowed_list of vcpu %s")
return 1
logger.debug("the output of command 'grep Cpus_allowed_list \
/proc/%s/task/%s/status' is %s" %
(pid[0], vcpu_task_id[0], output))
if output[0].split('\t')[1] == cpulist:
logger.info("vcpu process cpus allowed list is expected")
return 0
else:
logger.error("vcpu process cpus allowed list is not expected")
return 1
def check_pinemulator(guestname, maxcpu, pininfo_after):
"""check emulator status of the running virtual machine
"""
cmd = "cat /var/run/libvirt/qemu/%s.pid" % guestname
status, pid = utils.exec_cmd(cmd, shell=True)
if status:
logger.error("failed to get the pid of domain %s" % guestname)
return 1
cmd = "grep Cpus_allowed_list /proc/%s/task/%s/status" % (pid[0], pid[0])
status, output = utils.exec_cmd(cmd, shell=True)
if status:
logger.error("failed to get Cpus_allowed_list")
return 1
cpu_allowed_list = output[0]
cpulistcheck = cpu_allowed_list.split('\t')[1]
pininfo_in_process = str(utils.param_to_tuple(cpulistcheck, maxcpu))
if cmp(pininfo_in_process, pininfo_after):
logger.error("domain emulator pin failed")
return 1
else:
logger.info("domain emulator pin successed")
return 0
def get_security_driver(logger):
"""get security driver from /etc/libvirt/qemu.conf"""
cmds = "grep \"^security_driver\" /etc/libvirt/qemu.conf"
(ret, conf) = utils.exec_cmd(cmds, shell=True)
if ret:
cmds = "getenforce"
(ret, policy) = utils.exec_cmd(cmds, shell=True)
if policy[0] == "Disabled":
return "none"
else:
return "selinux"
tmp = conf[0].split(' = ')
if len(tmp[1].split(', ')) > 1:
driver = tmp[1].split(', ')
return (filter(str.isalpha, driver[0]))
else:
cmds = "echo '%s' | awk -F '\"' '{print $2}'" % conf[0]
(ret, driver) = utils.exec_cmd(cmds, shell=True)
if driver[0] == "selinux":
return "selinux"
elif driver[0] == "none":
return "none"
elif driver[0] == "apparmor":
return "apparmor"
elif driver[0] == "stack":
return "stack"
else:
return ""
def check_numa_params(guestname, mode, node_tuple):
"""dump domain live xml description to check numa params and
check memory allowed list of domain pid
"""
cmd = "cat /var/run/libvirt/qemu/%s.pid" % guestname
status, pid = utils.exec_cmd(cmd, shell=True)
if status:
logger.error("failed to get the pid of domain %s" % guestname)
return 1
cmd = "grep Mems_allowed_list /proc/%s/status" % pid[0]
status, output = utils.exec_cmd(cmd, shell=True)
nodeval = output[0].split('\t')[1]
ret = utils.param_to_tuple(nodeset_val, node_num)
logger.info("Mems_allowed_list in domain pid status is: %s" % nodeval)
logger.debug("parse nodeset to tuple is:")
logger.debug(ret)
if not ret:
logger.error("fail to parse nodeset to tuple")
return 1
# TODO: add check for mode
if ret == node_tuple:
return 0
else:
return 1
def nfs_setup(root_squash, logger):
"""setup nfs on localhost
"""
logger.info("set nfs service")
if root_squash == "yes":
option = "root_squash"
elif root_squash == "no":
option = "no_root_squash"
else:
logger.error("wrong root_squash value")
return 1
cmd = "echo /tmp *\(rw,%s\) >> /etc/exports" % option
ret, out = utils.exec_cmd(cmd, shell=True)
if ret:
logger.error("failed to config nfs export")
return 1
logger.info("restart nfs service")
cmd = "service nfs restart"
ret, out = utils.exec_cmd(cmd, shell=True)
if ret:
logger.error("failed to restart nfs service")
return 1
else:
for i in range(len(out)):
logger.info(out[i])
return 0
def CA_setting_up(logger):
""" setting up a Certificate Authority """
# Create a private key for CA
logger.info("generate CA certificates")
cakey_fd = open(CAKEY, "w")
ret, out = utils.exec_cmd([CERTTOOL, "--generate-privkey"], outfile=cakey_fd)
cakey_fd.close()
if ret != 0:
logger.error("failed to create CA private key")
return 1
# ca.info file
cainfo = os.path.join(TEMP_TLS_FOLDER, "ca.info")
cainfo_fd = open(cainfo, "w")
cainfo_str = "cn = Libvirt_test_API\n" + "ca\n" + "cert_signing_key\n"
cainfo_fd.write(cainfo_str)
cainfo_fd.close()
# Generate cacert.pem
cacert_args = [CERTTOOL, "--generate-self-signed", "--load-privkey", CAKEY, "--template", cainfo]
cacert_fd = open(CACERT, "w")
ret, out = utils.exec_cmd(cacert_args, outfile=cacert_fd)
cacert_fd.close()
if ret != 0:
logger.error("failed to create cacert.pem")
return 1
logger.info("done the CA certificates job")
return 0
def nfs_setup(root_squash, logger):
"""setup nfs on localhost
"""
logger.info("set nfs service")
if root_squash == "yes":
option = "root_squash"
elif root_squash == "no":
option = "no_root_squash"
else:
logger.error("wrong root_squash value")
return 1
cmd = "echo /tmp *\(rw,%s\) >> /etc/exports" % option
ret, out = utils.exec_cmd(cmd, shell=True)
if ret:
logger.error("failed to config nfs export")
return 1
logger.info("restart nfs service")
cmd = "service nfs restart"
ret, out = utils.exec_cmd(cmd, shell=True)
if ret:
logger.error("failed to restart nfs service")
return 1
else:
for i in range(len(out)):
logger.info(out[i])
return 0
def vcpupin_check(guestname, vcpu, cpumap):
"""check vcpu subprocess status of the running virtual machine
grep Cpus_allowed_list /proc/PID/task/*/status
"""
tmp_str = ''
cmd = "cat /var/run/libvirt/qemu/%s.pid" % guestname
status, pid = utils.exec_cmd(cmd, shell=True)
if status:
logger.error("failed to get the pid of domain %s" % guestname)
return 1
cmd = "grep Cpus_allowed_list /proc/%s/task/*/status" % pid[0]
status, output = utils.exec_cmd(cmd, shell=True)
logger.debug("command '%s' output is:" % cmd)
for i in range(len(output)):
tmp_str += ''.join(output[i]) + '\n'
logger.debug(tmp_str)
task_list = output[1:]
vcpu_task = task_list[int(vcpu)]
cpulist = vcpu_task.split('\t')[1]
ret = utils.param_to_tuple(cpulist, maxcpu)
if ret == cpumap:
logger.info("vcpu process cpus allowed list is expected")
return 0
else:
logger.error("vcpu process cpus allowed list is not expected")
return 1
def vcpupin_check(guestname, vcpu, cpulist):
"""check vcpu subprocess status of the running virtual machine
grep Cpus_allowed_list /proc/PID/task/*/status
"""
cmd_pid = "cat /var/run/libvirt/qemu/%s.pid" % guestname
status, pid = utils.exec_cmd(cmd_pid, shell=True)
if status:
logger.error("failed to get the pid of domain %s" % guestname)
return 1
cmd_vcpu_task_id = "virsh qemu-monitor-command %s --hmp info cpus|grep '#%s'|cut -d '=' -f3"\
% (guestname, vcpu)
status, vcpu_task_id = utils.exec_cmd(cmd_vcpu_task_id, shell=True)
if status:
logger.error("failed to get the threadid of domain %s" % guestname)
return 1
logger.debug("vcpu id %s:" % vcpu_task_id[0])
cmd_cpus_allowed_list = "grep Cpus_allowed_list /proc/%s/task/%s/status" % (pid[
0], vcpu_task_id[0])
status, output = utils.exec_cmd(cmd_cpus_allowed_list, shell=True)
if status:
logger.error("failed to get the cpu_allowed_list of vcpu %s")
return 1
logger.debug("the output of command 'grep Cpus_allowed_list \
/proc/%s/task/%s/status' is %s" % (pid[0], vcpu_task_id[0], output))
if output[0].split('\t')[1] == cpulist:
logger.info("vcpu process cpus allowed list is expected")
return 0
else:
logger.error("vcpu process cpus allowed list is not expected")
return 1
def chown_file(filepath, logger):
"""touch a file and setting the chown
"""
if os.path.exists(filepath):
os.remove(filepath)
touch_cmd = "touch %s" % filepath
logger.info(touch_cmd)
ret, out = utils.exec_cmd(touch_cmd, shell=True)
if ret:
logger.error("failed to touch a new file")
logger.error(out[0])
return 1
logger.info("set chown of %s as 107:107" % filepath)
chown_cmd = "chown 107:107 %s" % filepath
ret, out = utils.exec_cmd(chown_cmd, shell=True)
if ret:
logger.error("failed to set the ownership of %s" % filepath)
return 1
logger.info("set %s mode as 664" % filepath)
cmd = "chmod 664 %s" % filepath
ret, out = utils.exec_cmd(cmd, shell=True)
if ret:
logger.error("failed to set the mode of %s" % filepath)
return 1
return 0
def check_pinemulator(guestname, maxcpu, pininfo_after):
"""check emulator status of the running virtual machine
"""
cmd = "cat /var/run/libvirt/qemu/%s.pid" % guestname
status, pid = utils.exec_cmd(cmd, shell=True)
if status:
logger.error("failed to get the pid of domain %s" % guestname)
return 1
cmd = "grep Cpus_allowed_list /proc/%s/task/%s/status" % (pid[0], pid[0])
status, output = utils.exec_cmd(cmd, shell=True)
if status:
logger.error("failed to get Cpus_allowed_list")
return 1
cpu_allowed_list = output[0]
cpulistcheck = cpu_allowed_list.split('\t')[1]
pininfo_in_process = str(utils.param_to_tuple(cpulistcheck, maxcpu))
if cmp(pininfo_in_process, pininfo_after):
logger.error("domain emulator pin failed")
return 1
else:
logger.info("domain emulator pin successed")
return 0
def chown_file(filepath, logger):
"""touch a file and setting the chown
"""
if os.path.exists(filepath):
os.remove(filepath)
touch_cmd = "touch %s" % filepath
logger.info(touch_cmd)
ret, out = utils.exec_cmd(touch_cmd, shell=True)
if ret:
logger.error("failed to touch a new file")
logger.error(out[0])
return 1
logger.info("set chown of %s as 107:107" % filepath)
chown_cmd = "chown 107:107 %s" % filepath
ret, out = utils.exec_cmd(chown_cmd, shell=True)
if ret:
logger.error("failed to set the ownership of %s" % filepath)
return 1
logger.info("set %s mode as 664" % filepath)
cmd = "chmod 664 %s" % filepath
ret, out = utils.exec_cmd(cmd, shell=True)
if ret:
logger.error("failed to set the mode of %s" % filepath)
return 1
return 0
def get_security_driver(logger):
"""get security driver from /etc/libvirt/qemu.conf"""
cmds = "grep \"^security_driver\" /etc/libvirt/qemu.conf"
(ret, conf) = utils.exec_cmd(cmds, shell=True)
if ret:
cmds = "getenforce"
(ret, policy) = utils.exec_cmd(cmds, shell=True)
if policy[0] == "Disabled":
return "none"
else:
return "selinux"
tmp = conf[0].split(' = ')
if len(tmp[1].split(', ')) > 1:
driver = tmp[1].split(', ')
return (filter(str.isalpha, driver[0]))
else:
cmds = "echo '%s' | awk -F '\"' '{print $2}'" % conf[0]
(ret, driver) = utils.exec_cmd(cmds, shell=True)
if driver[0] == "selinux":
return "selinux"
elif driver[0] == "none":
return "none"
elif driver[0] == "apparmor":
return "apparmor"
elif driver[0] == "stack":
return "stack"
else:
return ""
def deliver_cert(target_machine, username, password, pkipath, logger):
""" deliver CA, server and client certificates """
# transmit cacert.pem to remote host
logger.info("deliver CA, server and client certificates to both local and remote server")
ret = utils.scp_file(target_machine, username, password, CA_FOLDER, CACERT)
if ret:
logger.error("scp cacert.pem to %s error" % target_machine)
return 1
# copy cacert.pem to local CA folder
cacert_cp = [CP, "-f", CACERT, (pkipath and pkipath) or CA_FOLDER]
ret, out = utils.exec_cmd(cacert_cp)
if ret:
logger.error("copying cacert.pem to %s error" % CA_FOLDER)
return 1
# mkdir /etc/pki/libvirt/private on remote host
libvirt_priv_cmd = "mkdir -p %s" % PRIVATE_KEY_FOLDER
ret, output = utils.remote_exec_pexpect(target_machine, username, password, libvirt_priv_cmd)
if ret:
logger.error("failed to make /etc/pki/libvirt/private on %s" % target_machine)
return 1
# transmit serverkey.pem to remote host
ret = utils.scp_file(target_machine, username, password, PRIVATE_KEY_FOLDER, SERVERKEY)
if ret:
logger.error("failed to scp serverkey.pem to %s" % target_machine)
return 1
# transmit servercert.pem to remote host
ret = utils.scp_file(target_machine, username, password, CERTIFICATE_FOLDER, SERVERCERT)
if ret:
logger.error("failed to scp servercert.pem to %s" % target_machine)
return 1
libvirt_priv_cmd_local = [MKDIR, "-p", PRIVATE_KEY_FOLDER]
ret, out = utils.exec_cmd(libvirt_priv_cmd_local)
if ret:
logger.error("failed to make %s on local" % PRIVATE_KEY_FOLDER)
return 1
# copy clientkey.pem to local folder
clientkey_cp = [CP, "-f", CLIENTKEY, (pkipath and pkipath) or PRIVATE_KEY_FOLDER]
ret, out = utils.exec_cmd(clientkey_cp)
if ret:
logger.error("failed to copy clientkey.pem to %s" % PRIVATE_KEY_FOLDER)
return 1
# copy clientcert.pem to local folder
clientcert_cp = [CP, "-f", CLIENTCERT, (pkipath and pkipath) or CERTIFICATE_FOLDER]
ret, out = utils.exec_cmd(clientcert_cp)
if ret:
logger.error("failed to copy clientcert.pem to %s" % CERTIFICATE_FOLDER)
return 1
logger.info("done to delivery")
return 0
def tls_client_cert(local_machine, logger):
""" generating client certificates """
# Create tls client key
logger.info("generate client certificates")
clientkey_fd = open(CLIENTKEY, "w")
ret, out = utils.exec_cmd([CERTTOOL, "--generate-privkey"], outfile=clientkey_fd)
clientkey_fd.close()
if ret != 0:
logger.error("failed to create client key")
return 1
# client.info
clientinfo = os.path.join(TEMP_TLS_FOLDER, "client.info")
clientinfo_fd = open(clientinfo, "w")
clientinfo_str = (
"country = xxx\n"
+ "state = xxx\n"
+ "locality = xxx\n"
+ "organization = Libvirt_test_API\n"
+ "cn = %s\n" % local_machine
+ "tls_www_client\n"
+ "encryption_key\n"
+ "signing_key\n"
)
clientinfo_fd.write(clientinfo_str)
clientinfo_fd.close()
# Generate clientcert.pem
clientcert_args = [
CERTTOOL,
"--generate-certificate",
"--load-privkey",
CLIENTKEY,
"--load-ca-certificate",
CACERT,
"--load-ca-privkey",
CAKEY,
"--template",
clientinfo,
]
clientcert_fd = open(CLIENTCERT, "w")
ret, out = utils.exec_cmd(clientcert_args, outfile=clientcert_fd)
clientcert_fd.close()
if ret != 0:
logger.error("failed to create client certificates")
return 1
logger.info("done the client certificates job")
return 0
def tls_client_cert(local_machine, logger):
""" generating client certificates """
# Create tls client key
logger.info("generate client certificates")
clientkey_fd = open(CLIENTKEY, 'w')
ret, out = utils.exec_cmd([CERTTOOL, '--generate-privkey'],
outfile=clientkey_fd)
clientkey_fd.close()
if ret != 0:
logger.error("failed to create client key")
return 1
# client.info
clientinfo = os.path.join(TEMP_TLS_FOLDER, 'client.info')
clientinfo_fd = open(clientinfo, 'w')
clientinfo_str = "country = xxx\n" + \
"state = xxx\n" + \
"locality = xxx\n" + \
"organization = Libvirt_test_API\n" + \
"cn = %s\n" % local_machine + \
"tls_www_client\n" + \
"encryption_key\n" + \
"signing_key\n"
clientinfo_fd.write(clientinfo_str)
clientinfo_fd.close()
# Generate clientcert.pem
clientcert_args = [
CERTTOOL,
'--generate-certificate',
'--load-privkey',
CLIENTKEY,
'--load-ca-certificate',
CACERT,
'--load-ca-privkey',
CAKEY,
'--template',
clientinfo,
]
clientcert_fd = open(CLIENTCERT, 'w')
ret, out = utils.exec_cmd(clientcert_args, outfile=clientcert_fd)
clientcert_fd.close()
if ret != 0:
logger.error("failed to create client certificates")
return 1
logger.info("done the client certificates job")
return 0
def tls_server_cert(target_machine, logger):
""" generating server certificates """
# Create tls server key
logger.info("generate server certificates")
serverkey_fd = open(SERVERKEY, "w")
ret, out = utils.exec_cmd([CERTTOOL, "--generate-privkey"], outfile=serverkey_fd)
serverkey_fd.close()
if ret != 0:
logger.error("failed to create server key")
return 1
# server.info
serverinfo = os.path.join(TEMP_TLS_FOLDER, "server.info")
serverinfo_fd = open(serverinfo, "w")
serverinfo_str = (
"organization = Libvirt_test_API\n"
+ "cn = %s\n" % target_machine
+ "tls_www_server\n"
+ "encryption_key\n"
+ "signing_key\n"
)
serverinfo_fd.write(serverinfo_str)
serverinfo_fd.close()
# Generate servercert.pem
servercert_args = [
CERTTOOL,
"--generate-certificate",
"--load-privkey",
SERVERKEY,
"--load-ca-certificate",
CACERT,
"--load-ca-privkey",
CAKEY,
"--template",
serverinfo,
]
servercert_fd = open(SERVERCERT, "w")
ret, out = utils.exec_cmd(servercert_args, outfile=servercert_fd)
servercert_fd.close()
if ret != 0:
logger.error("failed to create servercert.pem")
return 1
logger.info("done the server certificates job")
return 0
def qemu_hang(params):
"""Hang qemu process, check libvirtd status"""
logger = params['logger']
guestname = params['guestname']
conn = sharedmod.libvirtobj['conn']
logger.info("check the domain state")
ret = check_domain_running(conn, guestname, logger)
if ret:
return 1
logger.info("check the libvirtd status:")
ret = libvirtd_check(logger)
if ret:
return 1
ret, pid = get_domain_pid(logger, guestname)
if ret:
return 1
cmd = "kill -STOP %s" % pid
logger.info(cmd)
ret, out = utils.exec_cmd(cmd, shell=True)
if ret:
logger.error("failed to stop qemu process of %s" % guestname)
return 1
logger.info("recheck libvirtd status:")
ret = libvirtd_check(logger)
if ret:
return 1
return 0
def check_pool_sources(host, xmlstr):
"""check the iscsi sources with command:
iscsiadm --mode discovery --type sendtargets --portal
"""
source_val = []
doc = minidom.parseString(xmlstr)
for diskTag in doc.getElementsByTagName("source"):
device_element = diskTag.getElementsByTagName("device")[0]
attr = device_element.getAttributeNode('path')
path_val = attr.nodeValue
source_val.append(path_val)
logger.debug("pool source info list is: %s" % source_val)
cmd = "iscsiadm --mode discovery --type sendtargets --portal %s:3260,1 |\
awk -F' ' '{print $2}'" % host
ret, path_list = utils.exec_cmd(cmd, shell=True)
logger.debug("iscsiadm command output list is: %s" % path_list)
if source_val == path_list:
logger.info("source list matched with iscsiadm command output")
return 0
else:
logger.error("source list did not match with iscsiadm command output")
return 1
def validate_caps_from_hv(emulatorbin, logger):
"""
Validate the relative caps between libvirt and qemu-kvm
"""
F1 = "%s -h| grep \"\-drive\""
F2 = "%s -h| grep \"format=\""
F3 = "%s -h| grep \"readonly=\""
F4 = "%s -h| grep \"^\\-device\""
l = [F1, F2, F3, F4]
flags = []
for item in l:
status, temp = utils.exec_cmd(item % emulatorbin, shell=True)
if not status:
flags.append(True)
logger.debug("Got: %s from vh" % temp)
else:
flags.append(False)
logger.debug("Got: %s from vh" % temp)
if get_hypervisor_ver(emulatorbin, logger) >= 11000:
flags.append(True)
else:
flags.append(False)
libvirt_f = [drive, drive_forma, drive_readonly, device, blk_sg_io]
if flags == libvirt_f:
return True
else:
return False
def check_pool_sources(host, xmlstr):
"""check the netfs sources with command:
showmount --no-headers -e HOSTNAME
"""
source_val = []
doc = minidom.parseString(xmlstr)
for diskTag in doc.getElementsByTagName("source"):
device_element = diskTag.getElementsByTagName("dir")[0]
attr = device_element.getAttributeNode('path')
path_val = attr.nodeValue
source_val.append(path_val)
logger.debug("pool source info list is: %s" % source_val)
cmd = "showmount --no-headers -e %s | awk -F' ' '{print $1}'" % host
ret, path_list = utils.exec_cmd(cmd, shell=True)
logger.debug("showmount command output list is: %s" % path_list)
if source_val == path_list:
logger.info("source list matched with showmount command output")
return 0
else:
logger.error("source list did not match with showmount command output")
return 1
def check_pool_sources(host, xmlstr):
"""check the iscsi sources with command:
iscsiadm --mode discovery --type sendtargets --portal
"""
source_val = []
doc = minidom.parseString(xmlstr)
for diskTag in doc.getElementsByTagName("source"):
device_element = diskTag.getElementsByTagName("device")[0]
attr = device_element.getAttributeNode('path')
path_val = attr.nodeValue
source_val.append(path_val)
logger.debug("pool source info list is: %s" % source_val)
cmd = "iscsiadm --mode discovery --type sendtargets --portal %s:3260,1 |\
awk -F' ' '{print $2}'" % host
ret, path_list = utils.exec_cmd(cmd, shell=True)
logger.debug("iscsiadm command output list is: %s" % path_list)
if source_val == path_list:
logger.info("source list matched with iscsiadm command output")
return 0
else:
logger.error("source list did not match with iscsiadm command output")
return 1
def qemu_hang(params):
"""Hang qemu process, check libvirtd status"""
logger = params['logger']
guestname = params['guestname']
conn = sharedmod.libvirtobj['conn']
logger.info("check the domain state")
ret = check_domain_running(conn, guestname, logger)
if ret:
return 1
logger.info("check the libvirtd status:")
ret = libvirtd_check(logger)
if ret:
return 1
ret, pid = get_domain_pid(logger, guestname)
if ret:
return 1
cmd = "kill -STOP %s" % pid
logger.info(cmd)
ret, out = utils.exec_cmd(cmd, shell=True)
if ret:
logger.error("failed to stop qemu process of %s" % guestname)
return 1
logger.info("recheck libvirtd status:")
ret = libvirtd_check(logger)
if ret:
return 1
return 0
def validate_caps_from_hv(emulatorbin, logger):
"""
Validate the relative caps between libvirt and qemu-kvm
"""
F1 = '%s -h| grep "\-drive"'
F2 = '%s -h| grep "format="'
F3 = '%s -h| grep "readonly="'
F4 = '%s -h| grep "^\\-device"'
l = [F1, F2, F3, F4]
flags = []
for item in l:
status, temp = utils.exec_cmd(item % emulatorbin, shell=True)
if not status:
flags.append(True)
logger.debug("Got: %s from vh" % temp)
else:
flags.append(False)
logger.debug("Got: %s from vh" % temp)
if get_hypervisor_ver(emulatorbin, logger) >= 11000:
flags.append(True)
else:
flags.append(False)
libvirt_f = [drive, drive_forma, drive_readonly, device, blk_sg_io]
if flags == libvirt_f:
return True
else:
return False
def get_cpu_list(state_type, logger):
""" get all cpu in the same type state
"""
ret = list()
if state_type == "online":
match = '1'
ret.append(0)
elif state_type == "offline":
match = '0'
else:
logger.error("Unidentified cpu state type %s" % state_type)
return ret
cpu_num = get_cpu_num(logger)
if cpu_num < 0:
return ret
for i in range(1, cpu_num):
cmd = CPUSTATE % i
status, out = utils.exec_cmd(cmd, shell=True)
if status != 0:
logger.error("Exec %s fails" % cmd)
return ret
logger.debug("Exec outputs %s" % out[0])
if out[0] == match:
ret.append(i)
return ret
def check_hypervisor_ver_num(conn, logger):
"""check hypervisor version number
"""
# TODO: modify utils.get_hypervisor, support lxc, openvz, and so on
conn_type = conn.getType()
logger.info("connection's type is %s" % conn_type)
if str.lower(conn_type) == 'qemu':
cmds = "rpm -q qemu-kvm"
ver_num_pos = 2
(status, output) = utils.exec_cmd(cmds, shell=True)
if status != 0:
cmds = "rpm -q qemu-kvm-rhev"
ver_num_pos = 3
(status, output) = utils.exec_cmd(cmds, shell=True)
if status != 0:
logger.error("Could not be aware of qemu")
return False
hyper_version = output[0]
ver = hyper_version.split('-')[ver_num_pos]
x = int(ver.split('.')[0])
y = int(ver.split('.')[1])
z = int(ver.split('.')[2])
elif str.lower(conn_type) == 'lxc':
cmds = "uname -r"
(status, output) = utils.exec_cmd(cmds, shell=True)
if status != 0:
logger.error("Exec_cmd failed: %s" % cmds)
return False
hyper_version = output[0]
ver = hyper_version.split('-')[0]
x = int(ver.split('.')[0])
y = int(ver.split('.')[1])
z = int(ver.split('.')[2])
else:
logger.error("This hypervisor %s is unsupported currently" % conn_type)
return False
hyper_ver_num = produce_ver_num(x, y, z)
conn_hyper_ver = conn.getVersion()
logger.info("get hypervisor version from connection: %s" % conn_hyper_ver)
if conn_hyper_ver != hyper_ver_num:
logger.error("libvirt version is wrong, should be %s" % hyper_ver_num)
return False
return True
def check_hypervisor_ver_num(conn, logger):
"""check hypervisor version number
"""
# TODO: modify utils.get_hypervisor, support lxc, openvz, and so on
conn_type = conn.getType()
logger.info("connection's type is %s" % conn_type)
if str.lower(conn_type) == 'qemu':
cmds = "rpm -q qemu-kvm"
ver_num_pos = 2
(status, output) = utils.exec_cmd(cmds, shell=True)
if status != 0:
cmds = "rpm -q qemu-kvm-rhev"
ver_num_pos = 3
(status, output) = utils.exec_cmd(cmds, shell=True)
if status != 0:
logger.error("Could not be aware of qemu")
return False
hyper_version = output[0]
ver = hyper_version.split('-')[ver_num_pos]
x = int(ver.split('.')[0])
y = int(ver.split('.')[1])
z = int(ver.split('.')[2])
elif str.lower(conn_type) == 'lxc':
cmds = "uname -r"
(status, output) = utils.exec_cmd(cmds, shell=True)
if status != 0:
logger.error("Exec_cmd failed: %s" % cmds)
return False
hyper_version = output[0]
ver = hyper_version.split('-')[0]
x = int(ver.split('.')[0])
y = int(ver.split('.')[1])
z = int(ver.split('.')[2])
else:
logger.error("This hypervisor %s is unsupported currently" % conn_type)
return False
hyper_ver_num = produce_ver_num(x, y, z)
conn_hyper_ver = conn.getVersion()
logger.info("get hypervisor version from connection: %s" % conn_hyper_ver)
if conn_hyper_ver != hyper_ver_num:
logger.error("libvirt version is wrong, should be %s" % hyper_ver_num)
return False
return True
def get_info_from_dnsmasq(network,macaddr,logger):
"""
generate dict for lease info from virtual network's lease file
"""
title = ['expirytime','mac','ipaddr','hostname','clientid']
output_list = []
lease_dnsmasq = []
temp = []
remove_list = []
GREP_MAC = "grep -w %s" + " " + LEASE_FILE_DNSMASQ
CAT_FILE = "cat" + " " + LEASE_FILE_DNSMASQ
status, output = utils.exec_cmd(CAT_FILE, shell=True)
if not status:
for i in range(0, len(output)):
output_list = []
output_str = output[i]
for item in output_str.split(" "):
output_list.append(item)
lease_dnsmasq.append(dict(zip(title,output_list)))
#due to no mac field in IPv6 line, so do nothing here temporarily.
if macaddr != None:
pass
#remove bridge duid line
for i in range(0, len(lease_dnsmasq)):
if lease_dnsmasq[i]['expirytime'] == 'duid':
remove_list.append(lease_dnsmasq[i])
for i in range(0, len(remove_list)):
lease_dnsmasq.remove(remove_list[i])
#remove expiry leases
for i in range(0, len(lease_dnsmasq)):
temp = int(lease_dnsmasq[i]['expirytime'])
lease_dnsmasq[i]['expirytime'] = temp
remove_list = []
for i in range(0, len(lease_dnsmasq)):
if time.time() >= int(lease_dnsmasq[i]['expirytime']):
remove_list.append(lease_dnsmasq[i])
for i in range(0, len(remove_list)):
lease_dnsmasq.remove(remove_list[i])
#replace * to None
for i in range(0, len(lease_dnsmasq)):
if lease_dnsmasq[i]['hostname'] == "*":
lease_dnsmasq[i]['hostname'] = None
if lease_dnsmasq[i]['clientid'] == "*":
lease_dnsmasq[i]['clientid'] = None
return lease_dnsmasq
else:
logger.error("\"" + CAT_FILE + "\"" + "error")
logger.error(output)
return False
def get_info_from_dnsmasq(network, macaddr, logger):
"""
generate dict for lease info from virtual network's lease file
"""
title = ['expirytime', 'mac', 'ipaddr', 'hostname', 'clientid']
output_list = []
lease_dnsmasq = []
temp = []
remove_list = []
GREP_MAC = "grep -w %s" + " " + LEASE_FILE_DNSMASQ
CAT_FILE = "cat" + " " + LEASE_FILE_DNSMASQ
status, output = utils.exec_cmd(CAT_FILE, shell=True)
if not status:
for i in range(0, len(output)):
output_list = []
output_str = output[i]
for item in output_str.split(" "):
output_list.append(item)
lease_dnsmasq.append(dict(zip(title, output_list)))
# due to no mac field in IPv6 line, so do nothing here temporarily.
if macaddr is not None:
pass
# remove bridge duid line
for i in range(0, len(lease_dnsmasq)):
if lease_dnsmasq[i]['expirytime'] == 'duid':
remove_list.append(lease_dnsmasq[i])
for i in range(0, len(remove_list)):
lease_dnsmasq.remove(remove_list[i])
# remove expiry leases
for i in range(0, len(lease_dnsmasq)):
temp = int(lease_dnsmasq[i]['expirytime'])
lease_dnsmasq[i]['expirytime'] = temp
remove_list = []
for i in range(0, len(lease_dnsmasq)):
if time.time() >= int(lease_dnsmasq[i]['expirytime']):
remove_list.append(lease_dnsmasq[i])
for i in range(0, len(remove_list)):
lease_dnsmasq.remove(remove_list[i])
# replace * to None
for i in range(0, len(lease_dnsmasq)):
if lease_dnsmasq[i]['hostname'] == "*":
lease_dnsmasq[i]['hostname'] = None
if lease_dnsmasq[i]['clientid'] == "*":
lease_dnsmasq[i]['clientid'] = None
return lease_dnsmasq
else:
logger.error("\"" + CAT_FILE + "\"" + "error")
logger.error(output)
return False
def ownership_test_clean(params):
"""clean testing environment"""
logger = params['logger']
use_nfs = params['use_nfs']
if use_nfs == 'enable':
if os.path.ismount("/mnt"):
umount_cmd = "umount /mnt"
ret, out = utils.exec_cmd(umount_cmd, shell=True)
if ret:
logger.error("Failed to unmount the nfs path")
for i in range(len(out)):
logger.error(out[i])
clean_nfs_conf = "sed -i '$d' /etc/exports"
utils.exec_cmd(clean_nfs_conf, shell=True)
filepath = TEMP_FILE
elif use_nfs == 'disable':
filepath = SAVE_FILE
if os.path.exists(filepath):
os.remove(filepath)
clean_qemu_conf = "sed -i '$d' %s" % QEMU_CONF
utils.exec_cmd(clean_qemu_conf, shell=True)
cmd = "service libvirtd restart"
utils.exec_cmd(cmd, shell=True)
return 0
def ownership_test_clean(params):
"""clean testing environment"""
logger = params['logger']
use_nfs = params['use_nfs']
if use_nfs == 'enable':
if os.path.ismount("/mnt"):
umount_cmd = "umount /mnt"
ret, out = utils.exec_cmd(umount_cmd, shell=True)
if ret:
logger.error("Failed to unmount the nfs path")
for i in range(len(out)):
logger.error(out[i])
clean_nfs_conf = "sed -i '$d' /etc/exports"
utils.exec_cmd(clean_nfs_conf, shell=True)
filepath = TEMP_FILE
elif use_nfs == 'disable':
filepath = SAVE_FILE
if os.path.exists(filepath):
os.remove(filepath)
clean_qemu_conf = "sed -i '$d' %s" % QEMU_CONF
utils.exec_cmd(clean_qemu_conf, shell=True)
cmd = "service libvirtd restart"
utils.exec_cmd(cmd, shell=True)
return 0
def clean_env(logger):
"""
clean testing environment
"""
status, output = utils.exec_cmd(CMD % API_FILE, shell=True)
if status != 0:
logger.error("Can not delete %s" % API_FILE)
else:
logger.debug("Deleted %s successfully" % API_FILE)
def get_ip_prefix(network, iptype, logger):
"""
get ip prefix according to IP type
"""
br = get_bridge_name(network, logger)
PREFIX = "ip -4 -o ad show %s | awk '{print $4}'|awk -F\"/\" '{print $2}'"
PREFIX_6 = "ip -6 -o ad show %s|awk '{print $4}'|awk -F\"/\" '{print $2}'"
if iptype == "ipv4":
status, output = utils.exec_cmd(PREFIX % br, shell=True)
elif iptype == "ipv6":
status, output = utils.exec_cmd(PREFIX_6 % br, shell=True)
if not status:
pass
else:
logger.error("\"" + GREP_BRIDGE + "\"" + "error")
logger.error(output)
return False
return output[0]
def clean_env(logger):
"""
clean testing environment
"""
status, output = utils.exec_cmd(CMD % API_FILE, shell=True)
if status != 0:
logger.error("Can not delete %s" % API_FILE)
else:
logger.debug("Deleted %s successfully" % API_FILE)
def get_ip_prefix(network, iptype, logger):
"""
get ip prefix according to IP type
"""
br = get_bridge_name(network, logger)
PREFIX = "ip -4 -o ad show %s | awk '{print $4}'|awk -F\"/\" '{print $2}'"
PREFIX_6 = "ip -6 -o ad show %s|awk '{print $4}'|awk -F\"/\" '{print $2}'"
if iptype == "ipv4":
status, output = utils.exec_cmd(PREFIX % br, shell=True)
elif iptype == "ipv6":
status, output = utils.exec_cmd(PREFIX_6 % br, shell=True)
if not status:
pass
else:
logger.error("\"" + "show bridge %s" % br + "error")
logger.error(output)
return False
return output[0]
def build_img(self, index_id):
index_id = int(index_id)
proj_uid = self.index[index_id]
proj_obj = self.projs[proj_uid]
proj_dir = os.path.join(PROJS_DIR, proj_uid)
build_conf_file = os.path.join(proj_dir, 'k8s/docker_build.json')
if not check_docker():
print('ERR: docker is needed on this host')
if not self._get_code(proj_uid):
print('ERR: fail to get proj code, build img failed!')
return False
if not os.path.isfile(build_conf_file):
print('ERR: lack of docker_build.json file, quit!')
return False
build_params = json.loads(open(build_conf_file).read())
imgs = build_params.keys()
tag = 'latest'
os.chdir(proj_dir)
if proj_obj['rep_type'] == 'git':
tag = os.popen("git log --pretty=oneline | sed -n '1p' | awk '{print $1}'").read()[:-1]
else:
tag = os.popen("svn info | grep -w 'Revision:' | awk '{print $2}'").read()[:-1]
for img_name in imgs:
img_dir = os.path.join(IMG_DIR, proj_uid)
if not os.path.exists(img_dir):
os.makedirs(img_dir)
dockerfile = os.path.join(proj_dir, build_params[img_name].get('dockerfile',
'k8s/dockerfile/Dockerfile'))
cmd = "docker build -t {}:{} -f {} {}".format(img_name, tag, dockerfile, proj_dir)
_, errs = exec_cmd(cmd)
if not errs:
os.chdir(img_dir)
cmd = 'docker save -o {}.tar {}:{}'.format(img_name, img_name, tag)
_, errs = exec_cmd(cmd)
if errs:
print('WARRING: save img {}:{} failed!'.format(img_name, tag))
print('OK: build img finished!')
return True
else:
print('ERR: build img {}:{} failed!'.format(img_name, tag))
return False
def get_sockets(logger):
"""get nodeinfo sockets
"""
cmds = "lscpu | grep 'Socket(s)' | awk {'print $2'}"
(status, output) = utils.exec_cmd(cmds, shell=True)
if status != 0:
logger.error("Exec_cmd failed: %s" % cmds)
return ""
logger.info("cpu sockets is %s" % output[0])
return int(output[0])
def get_sockets(logger):
"""get nodeinfo sockets
"""
cmds = "lscpu | grep 'Socket(s)' | awk {'print $2'}"
(status, output) = utils.exec_cmd(cmds, shell=True)
if status != 0:
logger.error("Exec_cmd failed: %s" % cmds)
return ""
logger.info("cpu sockets is %s" % output[0])
return int(output[0])
def get_security_model(logger, domname):
"""get security model from process"""
PID = "ps aux | grep -v grep | grep %s | awk '{print $2}'" % domname
ret, pid = utils.exec_cmd(PID, shell=True)
if ret:
logger.error("get domain pid failed.")
return ""
LABEL = "ls -nZd /proc/%s" % pid[0]
ret, label = utils.exec_cmd(LABEL, shell=True)
if ret:
logger.error("get domain process's label failed.")
return ""
if "system_u:system_r:svirt_t:s0" in label[0]:
return "selinux"
else:
return "none"
def get_security_model(logger, domname):
"""get security model from process"""
PID = "ps aux | grep -v grep | grep %s | awk '{print $2}'" % domname
ret, pid = utils.exec_cmd(PID, shell=True)
if ret:
logger.error("get domain pid failed.")
return ""
LABEL = "ls -nZd /proc/%s" % pid[0]
ret, label = utils.exec_cmd(LABEL, shell=True)
if ret:
logger.error("get domain process's label failed.")
return ""
if "system_u:system_r:svirt_t:s0" in label[0]:
return "selinux"
else:
return "none"
def get_threads(logger):
"""get nodeinfo threads
"""
cmds = "lscpu | grep 'Thread(s)' | awk {'print $4'}"
(status, output) = utils.exec_cmd(cmds, shell=True)
if status != 0:
logger.error("Exec_cmd failed: %s" % cmds)
return ""
logger.info("cpu threads is %s" % output[0])
return int(output[0])
def get_threads(logger):
"""get nodeinfo threads
"""
cmds = "lscpu | grep 'Thread(s)' | awk {'print $4'}"
(status, output) = utils.exec_cmd(cmds, shell=True)
if status != 0:
logger.error("Exec_cmd failed: %s" % cmds)
return ""
logger.info("cpu threads is %s" % output[0])
return int(output[0])
def tls_server_cert(target_machine, logger):
""" generating server certificates """
# Create tls server key
logger.info("generate server certificates")
serverkey_fd = open(SERVERKEY, 'w')
ret, out = utils.exec_cmd(
[CERTTOOL, '--generate-privkey'], outfile=serverkey_fd)
serverkey_fd.close()
if ret != 0:
logger.error("failed to create server key")
return 1
# server.info
serverinfo = os.path.join(TEMP_TLS_FOLDER, 'server.info')
serverinfo_fd = open(serverinfo, 'w')
serverinfo_str = "organization = Libvirt_test_API\n" + \
"cn = %s\n" % target_machine + \
"tls_www_server\n" + \
"encryption_key\n" + \
"signing_key\n"
serverinfo_fd.write(serverinfo_str)
serverinfo_fd.close()
# Generate servercert.pem
servercert_args = [CERTTOOL,
'--generate-certificate',
'--load-privkey', SERVERKEY,
'--load-ca-certificate', CACERT,
'--load-ca-privkey', CAKEY,
'--template', serverinfo
]
servercert_fd = open(SERVERCERT, 'w')
ret, out = utils.exec_cmd(servercert_args, outfile=servercert_fd)
servercert_fd.close()
if ret != 0:
logger.error("failed to create servercert.pem")
return 1
logger.info("done the server certificates job")
return 0
def check_crash_command(logger):
"""
check crash command on current OS
"""
CMD = "which crash"
status, output = utils.exec_cmd(CMD, shell=True)
if status != 0:
logger.info("Can not find crash command")
return False
else:
return True
def get_cpu_num(logger):
""" get cpu number
"""
cmd = "lscpu | grep 'CPU(s):' | head -1 | cut -d : -f 2 | tr -d ' '"
status, out = utils.exec_cmd(cmd, shell=True)
if status != 0:
logger.error("Exec %s fails" % cmd)
return -1
logger.debug("Exec outputs %s" % out[0])
return int(out[0])
def check_crash_command(logger):
"""
check crash command on current OS
"""
CMD = "which crash"
status, output = utils.exec_cmd(CMD, shell=True)
if status != 0:
logger.info("Can not find crash command")
return False
else:
return True
def get_domain_pid(logger, guestname):
"""get the pid of running domain"""
logger.info("get the pid of running domain %s" % guestname)
get_pid_cmd = "cat /var/run/libvirt/qemu/%s.pid" % guestname
ret, pid = utils.exec_cmd(get_pid_cmd, shell=True)
if ret:
logger.error("fail to get the pid of runnings domain %s" % guestname)
return 1, ""
else:
logger.info("the pid of domain %s is %s" % (guestname, pid[0]))
return 0, pid[0]
def coredump_with_format_clean(params):
"""clean testing environment"""
logger = params['logger']
topath = params['topath']
CMD = "rm -rf %s"
status, output = utils.exec_cmd(CMD % topath, shell=True)
if status != 0:
logger.info("Can not delete %s" % topath)
else:
logger.info("Deleted %s successfully" % topath)
def coredump_with_format_clean(params):
"""clean testing environment"""
logger = params['logger']
topath = params['topath']
CMD = "rm -rf %s"
status, output = utils.exec_cmd(CMD % topath, shell=True)
if status != 0:
logger.info("Can not delete %s" % topath)
else:
logger.info("Deleted %s successfully" % topath)
def migrate_database(request):
"""Triggers the execution of the database migration scripts."""
cmd = [
sys.exec_prefix + "/bin/python",
"manage.py",
"migrate",
]
result = exec_cmd(" ".join(cmd))
print(result) # TODO: log the result
messages.info(request, "Database up-to-date.")
return HttpResponseRedirect("/admin/")
def compile_translations(request):
"""Triggers the compilation of the translation files in a subprocess."""
cmd = [
sys.exec_prefix + "/bin/python",
"manage.py",
"compilemessages",
]
result = exec_cmd(" ".join(cmd))
print(result) # TODO: log the result
messages.info(request, "Translations files compiled.")
return HttpResponseRedirect("/admin/")
def get_interface_list(option, logger):
"""
return host interface list
"""
nic_names = []
status, nic_names = utils.exec_cmd(IFCONFIG_DRIVER % option, shell=True)
if not status:
return nic_names
else:
logger.error("\"" + IFCONFIG_DRIVER % option + "\"" + "error")
logger.error(nic_names)
return nic_names
def check_savefile_remove(*args):
"""Check guest managed save file"""
(guestname) = args
cmds = "ls /var/lib/libvirt/qemu/save/%s" % guestname + ".save -lh"
logger.info("Execute cmd %s" % cmds)
(status, output) = utils.exec_cmd(cmds, shell=True)
if status != 0:
logger.info("No managed save file")
return True
else :
logger.error("managed save file exists")
return False
def libvirtd_check(logger):
"""check libvirtd status
"""
cmd = "service libvirtd status"
ret, out = utils.exec_cmd(cmd, shell=True)
if ret != 0:
logger.error("failed to get libvirtd status")
return 1
else:
logger.info(out[0])
logger.info(VIRSH_LIST)
ret, out = utils.exec_cmd(VIRSH_LIST, shell=True)
if ret != 0:
logger.error("failed to get virsh list result")
return 1
else:
for i in range(len(out)):
logger.info(out[i])
return 0
def qemu_hang_clean(params):
""" clean testing environment """
logger = params['logger']
guestname = params['guestname']
ret = get_domain_pid(logger, guestname)
cmd = "kill -CONT %s" % ret[1]
ret = utils.exec_cmd(cmd, shell=True)
if ret[0]:
logger.error("failed to resume qemu process of %s" % guestname)
return 0
def check_savefile_remove(*args):
"""Check guest managed save file"""
(guestname) = args
cmds = "ls /var/lib/libvirt/qemu/save/%s" % guestname + ".save -lh"
logger.info("Execute cmd %s" % cmds)
(status, output) = utils.exec_cmd(cmds, shell=True)
if status != 0:
logger.info("No managed save file")
return True
else:
logger.error("managed save file exists")
return False
def qemu_hang_clean(params):
""" clean testing environment """
logger = params['logger']
guestname = params['guestname']
ret = get_domain_pid(logger, guestname)
cmd = "kill -CONT %s" % ret[1]
ret = utils.exec_cmd(cmd, shell=True)
if ret[0]:
logger.error("failed to resume qemu process of %s" % guestname)
return 0
def libvirtd_check(logger):
"""check libvirtd status
"""
cmd = "service libvirtd status"
ret, out = utils.exec_cmd(cmd, shell=True)
if ret != 0:
logger.error("failed to get libvirtd status")
return 1
else:
logger.info(out[0])
logger.info(VIRSH_LIST)
ret, out = utils.exec_cmd(VIRSH_LIST, shell=True)
if ret != 0:
logger.error("failed to get virsh list result")
return 1
else:
for i in range(len(out)):
logger.info(out[i])
return 0
