def test(self):
# This is virtual cpu flags which are supported by
# qemu but no with host cpu.
cpu_model, extra_flags = parse_cpu_model()
flags = HgFlags(cpu_model, extra_flags)
logging.debug("Unsupported flags %s.", str(flags.host_all_unsupported_flags))
cpuf_model = cpu_model + ",check"
# Add unsupported flags.
for fadd in flags.host_all_unsupported_flags:
cpuf_model += ",+" + str(fadd)
vnc_port = utils_misc.find_free_port(5900, 6100) - 5900
cmd = "%s -cpu %s -vnc :%d -enable-kvm" % (qemu_binary, cpuf_model, vnc_port)
out = None
try:
try:
out = utils.run(cmd, timeout=5, ignore_status=True).stderr
raise error.TestFail("Guest not boot with unsupported " "flags.")
except error.CmdError, e:
out = e.result_obj.stderr
finally:
uns_re = re.compile(r"^warning:.*flag '(.+)'", re.MULTILINE)
nf_re = re.compile(r"^CPU feature (.+) not found", re.MULTILINE)
warn_flags = set([utils_misc.Flag(x) for x in uns_re.findall(out)])
not_found = set([utils_misc.Flag(x) for x in nf_re.findall(out)])
fwarn_flags = flags.host_all_unsupported_flags - warn_flags
fwarn_flags -= not_found
if fwarn_flags:
raise error.TestFail("Qemu did not warn the use of " "flags %s" % str(fwarn_flags))
def test(self):
# This is virtual cpu flags which are supported by
# qemu but no with host cpu.
cpu_model, extra_flags = parse_cpu_model()
flags = HgFlags(cpu_model, extra_flags)
cpuf_model = cpu_model + ",enforce"
logging.debug("Unsupported flags %s.", str(flags.host_all_unsupported_flags))
# Add unsupported flags.
for fadd in flags.host_all_unsupported_flags:
cpuf_model += ",+" + str(fadd)
vnc_port = utils_misc.find_free_port(5900, 6100) - 5900
cmd = "%s -cpu %s -vnc :%d -enable-kvm" % (qemu_binary, cpuf_model, vnc_port)
out = None
try:
try:
out = utils.run(cmd, timeout=5, ignore_status=True).stderr
except error.CmdError:
logging.error("Host boot with unsupported flag")
finally:
uns_re = re.compile(r"^warning:.*flag '(.+)'", re.MULTILINE)
warn_flags = set(map(utils_misc.Flag, uns_re.findall(out)))
fwarn_flags = flags.host_all_unsupported_flags - warn_flags
if fwarn_flags:
raise error.TestFail("Qemu did not warn the use of " "flags %s" % str(fwarn_flags))
def setup_unattended_http_server(self):
'''
Setup a builtin http server for serving the kickstart file
Does nothing if unattended file is not a kickstart file
'''
if self.unattended_file.endswith('.ks'):
# Red Hat kickstart install
dest_fname = 'ks.cfg'
answer_path = os.path.join(self.tmpdir, dest_fname)
self.answer_kickstart(answer_path)
if self.unattended_server_port is None:
self.unattended_server_port = utils_misc.find_free_port(
8000, 8099, self.url_auto_content_ip)
start_unattended_server_thread(self.unattended_server_port,
self.tmpdir)
# Point installation to this kickstart url
ks_param = 'ks=http://%s:%s/%s' % (
self.url_auto_content_ip, self.unattended_server_port, dest_fname)
if 'ks=' in self.kernel_params:
kernel_params = re.sub('ks\=[\w\d\:\.\/]+', ks_param,
self.kernel_params)
else:
kernel_params = '%s %s' % (self.kernel_params, ks_param)
# reflect change on params
self.kernel_params = kernel_params
def setup_unattended_http_server(self):
"""
Setup a builtin http server for serving the kickstart file
Does nothing if unattended file is not a kickstart file
"""
if self.unattended_file.endswith(".ks"):
# Red Hat kickstart install
dest_fname = "ks.cfg"
answer_path = os.path.join(self.tmpdir, dest_fname)
self.answer_kickstart(answer_path)
if self.unattended_server_port is None:
self.unattended_server_port = utils_misc.find_free_port(8000, 8099, self.url_auto_content_ip)
start_unattended_server_thread(self.unattended_server_port, self.tmpdir)
# Point installation to this kickstart url
ks_param = "ks=http://%s:%s/%s" % (self.url_auto_content_ip, self.unattended_server_port, dest_fname)
self.kernel_params = getattr(self, "kernel_params")
if "ks=" in self.kernel_params:
kernel_params = re.sub("ks\=[\w\d\:\.\/]+", ks_param, self.kernel_params)
else:
kernel_params = "%s %s" % (self.kernel_params, ks_param)
# reflect change on params
self.kernel_params = kernel_params
self.params["kernel_params"] = self.kernel_params
def setup_unattended_http_server(self):
'''
Setup a builtin http server for serving the kickstart file
Does nothing if unattended file is not a kickstart file
'''
if self.unattended_file.endswith('.ks'):
# Red Hat kickstart install
dest_fname = 'ks.cfg'
answer_path = os.path.join(self.tmpdir, dest_fname)
self.answer_kickstart(answer_path)
if self.unattended_server_port is None:
self.unattended_server_port = utils_misc.find_free_port(
8000,
8099,
self.url_auto_content_ip)
start_unattended_server_thread(self.unattended_server_port,
self.tmpdir)
# Point installation to this kickstart url
ks_param = 'ks=http://%s:%s/%s' % (self.url_auto_content_ip,
self.unattended_server_port,
dest_fname)
if 'ks=' in self.kernel_params:
kernel_params = re.sub('ks\=[\w\d\:\.\/]+',
ks_param,
self.kernel_params)
else:
kernel_params = '%s %s' % (self.kernel_params, ks_param)
# reflect change on params
self.kernel_params = kernel_params
def nc_transfer(src, dst):
nc_port = utils_misc.find_free_port(1025, 5334, vm_ip[dst])
listen_cmd = params.get("listen_cmd")
send_cmd = params.get("send_cmd")
#listen in dst
listen_cmd = listen_cmd % (nc_port, "receive")
session[dst].sendline(listen_cmd)
time.sleep(2)
#send file from src to dst
send_cmd = send_cmd % (vlan_ip[dst], str(nc_port), "file")
session[src].cmd(send_cmd, timeout=60)
try:
session[dst].read_up_to_prompt(timeout=60)
except aexpect.ExpectError:
raise error.TestFail ("Fail to receive file"
" from vm%s to vm%s" % (src+1, dst+1))
#check MD5 message digest of receive file in dst
output = session[dst].cmd_output("md5sum receive").strip()
digest_receive = re.findall(r'(\w+)', output)[0]
if digest_receive == digest_origin[src]:
logging.info("file succeed received in vm %s", vlan_ip[dst])
else:
logging.info("digest_origin is %s", digest_origin[src])
logging.info("digest_receive is %s", digest_receive)
raise error.TestFail("File transfered differ from origin")
session[dst].cmd("rm -f receive")
def test(self):
#This is virtual cpu flags which are supported by
#qemu but no with host cpu.
cpu_model, extra_flags = parse_cpu_model()
flags = HgFlags(cpu_model, extra_flags)
cpuf_model = cpu_model + ",enforce"
logging.debug("Unsupported flags %s.",
str(flags.host_all_unsupported_flags))
# Add unsupported flags.
for fadd in flags.host_all_unsupported_flags:
cpuf_model += ",+" + str(fadd)
vnc_port = utils_misc.find_free_port(5900, 6100) - 5900
cmd = "%s -cpu %s -vnc :%d -enable-kvm" % (qemu_binary, cpuf_model,
vnc_port)
out = None
try:
try:
out = utils.run(cmd, timeout=5, ignore_status=True).stderr
except error.CmdError:
logging.error("Host boot with unsupported flag")
finally:
uns_re = re.compile(r"^warning:.*flag '(.+)'", re.MULTILINE)
warn_flags = set(map(utils_misc.Flag, uns_re.findall(out)))
fwarn_flags = flags.host_all_unsupported_flags - warn_flags
if fwarn_flags:
raise error.TestFail("Qemu did not warn the use of "
"flags %s" % str(fwarn_flags))
def nc_transfer(src, dst):
nc_port = utils_misc.find_free_port(1025, 5334, vm_ip[dst])
listen_cmd = params.get("listen_cmd")
send_cmd = params.get("send_cmd")
#listen in dst
listen_cmd = listen_cmd % (nc_port, "receive")
session[dst].sendline(listen_cmd)
time.sleep(2)
#send file from src to dst
send_cmd = send_cmd % (vlan_ip[dst], str(nc_port), "file")
session[src].cmd(send_cmd, timeout=60)
try:
session[dst].read_up_to_prompt(timeout=60)
except aexpect.ExpectError:
raise error.TestFail("Fail to receive file"
" from vm%s to vm%s" % (src + 1, dst + 1))
#check MD5 message digest of receive file in dst
output = session[dst].cmd_output("md5sum receive").strip()
digest_receive = re.findall(r'(\w+)', output)[0]
if digest_receive == digest_origin[src]:
logging.info("file succeed received in vm %s", vlan_ip[dst])
else:
logging.info("digest_origin is %s", digest_origin[src])
logging.info("digest_receive is %s", digest_receive)
raise error.TestFail("File transfered differ from origin")
session[dst].cmd_output("rm -f receive")
def migration_scenario(self):
sync = SyncData(self.master_id(), self.hostid, self.hosts,
self.id, self.sync_server)
srchost = self.params.get("hosts")[0]
dsthost = self.params.get("hosts")[1]
vms = [params.get("vms").split()[0]]
def worker(mig_data):
vm = mig_data.vms[0]
session = vm.wait_for_login(timeout=self.login_timeout)
cpuflags.install_cpuflags_util_on_vm(test, vm, install_path,
extra_flags="-msse3 -msse2")
cmd = ("%s/cpuflags-test --stressmem %d,%d" %
(os.path.join(install_path, "cpu_flags"),
vm_mem * 4, vm_mem / 2))
logging.debug("Sending command: %s" % (cmd))
session.sendline(cmd)
if self.master_id() == self.hostid:
server_port = utils_misc.find_free_port(5200, 6000)
server = listen_server(port=server_port)
data_len = 0
sync.sync(server_port, timeout=120)
client = server.socket.accept()[0]
endtime = time.time() + 30
while endtime > time.time():
data_len += len(client.recv(2048))
client.close()
server.close()
self.link_speed = data_len / (30 * 1024 * 1024)
logging.info("Link speed %d MB/s" % (self.link_speed))
ms = utils.convert_data_size(mig_speed, 'M')
if (ms > data_len / 30):
logging.warn("Migration speed %s MB/s is set faster than "
"real link speed %d MB/s" % (mig_speed,
self.link_speed))
else:
self.link_speed = ms / (1024 * 1024)
else:
data = ""
for _ in range(10000):
data += "i"
server_port = sync.sync(timeout=120)[self.master_id()]
sock = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
sock.connect((self.master_id(), server_port))
try:
endtime = time.time() + 10
while endtime > time.time():
sock.sendall(data)
sock.close()
except:
pass
self.migrate_wait(vms, srchost, dsthost, worker)
def setup_cdrom(self):
"""
Mount cdrom and copy vmlinuz and initrd.img.
"""
error.context("Copying vmlinuz and initrd.img from install cdrom %s" % self.cdrom_cd1)
if not os.path.isdir(self.image_path):
os.makedirs(self.image_path)
if self.params.get("unattended_delivery_method") in ["integrated", "url"]:
i = iso9660.Iso9660Mount(self.cdrom_cd1)
self.cdrom_cd1_mount = i.mnt_dir
else:
i = iso9660.iso9660(self.cdrom_cd1)
if i is None:
raise error.TestFail("Could not instantiate an iso9660 class")
i.copy(os.path.join(self.boot_path, os.path.basename(self.kernel)), self.kernel)
assert os.path.getsize(self.kernel) > 0
i.copy(os.path.join(self.boot_path, os.path.basename(self.initrd)), self.initrd)
assert os.path.getsize(self.initrd) > 0
if self.unattended_file.endswith(".preseed"):
self.preseed_initrd()
if self.params.get("vm_type") == "libvirt":
if self.vm.driver_type == "qemu":
# Virtinstall command needs files "vmlinuz" and "initrd.img"
os.chdir(self.image_path)
base_kernel = os.path.basename(self.kernel)
base_initrd = os.path.basename(self.initrd)
if base_kernel != "vmlinuz":
utils.run("mv %s vmlinuz" % base_kernel, verbose=DEBUG)
if base_initrd != "initrd.img":
utils.run("mv %s initrd.img" % base_initrd, verbose=DEBUG)
if self.params.get("unattended_delivery_method") != "integrated":
i.close()
utils_disk.cleanup(self.cdrom_cd1_mount)
elif (self.vm.driver_type == "xen") and (self.params.get("hvm_or_pv") == "pv"):
logging.debug("starting unattended content web server")
self.url_auto_content_port = utils_misc.find_free_port(8100, 8199, self.url_auto_content_ip)
start_auto_content_server_thread(self.url_auto_content_port, self.cdrom_cd1_mount)
self.medium = "url"
self.url = "http://%s:%s" % (self.url_auto_content_ip, self.url_auto_content_port)
pxe_path = os.path.join(os.path.dirname(self.image_path), "xen")
if not os.path.isdir(pxe_path):
os.makedirs(pxe_path)
pxe_kernel = os.path.join(pxe_path, os.path.basename(self.kernel))
pxe_initrd = os.path.join(pxe_path, os.path.basename(self.initrd))
utils.run("cp %s %s" % (self.kernel, pxe_kernel))
utils.run("cp %s %s" % (self.initrd, pxe_initrd))
def migration_scenario(self):
sync = SyncData(self.master_id(), self.hostid, self.hosts,
self.id, self.sync_server)
srchost = self.params.get("hosts")[0]
dsthost = self.params.get("hosts")[1]
vms = [params.get("vms").split()[0]]
def worker(mig_data):
vm = mig_data.vms[0]
session = vm.wait_for_login(timeout=self.login_timeout)
cpuflags.install_cpuflags_util_on_vm(test, vm, install_path,
extra_flags="-msse3 -msse2")
cmd = ("%s/cpuflags-test --stressmem %d,%d" %
(os.path.join(install_path, "cpu_flags"),
vm_mem * 4, vm_mem / 2))
logging.debug("Sending command: %s" % (cmd))
session.sendline(cmd)
if self.master_id() == self.hostid:
server_port = utils_misc.find_free_port(5200, 6000)
server = listen_server(port=server_port)
data_len = 0
sync.sync(server_port, timeout=120)
client = server.socket.accept()[0]
endtime = time.time() + 30
while endtime > time.time():
data_len += len(client.recv(2048))
client.close()
server.close()
self.link_speed = data_len / (30 * 1024 * 1024)
logging.info("Link speed %d MB/s" % (self.link_speed))
ms = utils.convert_data_size(mig_speed, 'M')
if (ms > data_len / 30):
logging.warn("Migration speed %s MB/s is set faster than "
"real link speed %d MB/s" % (mig_speed,
self.link_speed))
else:
self.link_speed = ms / (1024 * 1024)
else:
data = ""
for _ in range(10000):
data += "i"
server_port = sync.sync(timeout=120)[self.master_id()]
sock = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
sock.connect((self.master_id(), server_port))
try:
endtime = time.time() + 10
while endtime > time.time():
sock.sendall(data)
sock.close()
except:
pass
self.migrate_wait(vms, srchost, dsthost, worker)
def migration_scenario(self):
srchost = self.params.get("hosts")[0]
dsthost = self.params.get("hosts")[1]
mig_port = None
if params.get("hostid") == self.master_id():
mig_port = utils_misc.find_free_port(5200, 6000)
sync = SyncData(self.master_id(), self.hostid,
self.params.get("hosts"), {
'src': srchost,
'dst': dsthost,
'port': "ports"
}, self.sync_server)
mig_port = sync.sync(mig_port, timeout=120)
mig_port = mig_port[srchost]
logging.debug("Migration port %d" % (mig_port))
if params.get("hostid") != self.master_id():
s = self._connect_to_server(srchost, mig_port)
try:
fd = s.fileno()
logging.debug("File descrtiptor %d used for"
" migration." % (fd))
self.migrate_wait(["vm1"],
srchost,
dsthost,
mig_mode="fd",
params_append={"migration_fd": fd})
finally:
s.close()
else:
s = self._create_server(mig_port)
try:
conn, _ = s.accept()
fd = s.fileno()
logging.debug("File descrtiptor %d used for"
" migration." % (fd))
#Prohibits descriptor inheritance.
flags = fcntl.fcntl(fd, fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(fd, fcntl.F_SETFD, flags)
self.migrate_wait(["vm1"],
srchost,
dsthost,
mig_mode="fd",
params_append={"migration_fd": fd})
conn.close()
finally:
s.close()
def migration_scenario(self):
srchost = self.params.get("hosts")[0]
dsthost = self.params.get("hosts")[1]
mig_port = None
if params.get("hostid") == self.master_id():
mig_port = utils_misc.find_free_port(5200, 6000)
sync = SyncData(self.master_id(), self.hostid,
self.params.get("hosts"),
{'src': srchost, 'dst': dsthost,
'port': "ports"}, self.sync_server)
mig_port = sync.sync(mig_port, timeout=120)
mig_port = mig_port[srchost]
logging.debug("Migration port %d" % (mig_port))
if params.get("hostid") != self.master_id():
s = self._connect_to_server(srchost, mig_port)
try:
fd = s.fileno()
logging.debug("File descrtiptor %d used for"
" migration." % (fd))
self.migrate_wait(["vm1"], srchost, dsthost, mig_mode="fd",
params_append={"migration_fd": fd})
finally:
s.close()
else:
s = self._create_server(mig_port)
try:
conn, _ = s.accept()
fd = conn.fileno()
logging.debug("File descrtiptor %d used for"
" migration." % (fd))
#Prohibits descriptor inheritance.
flags = fcntl.fcntl(fd, fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(fd, fcntl.F_SETFD, flags)
self.migrate_wait(["vm1"], srchost, dsthost, mig_mode="fd",
params_append={"migration_fd": fd})
conn.close()
finally:
s.close()
def test(self):
# This is virtual cpu flags which are supported by
# qemu but no with host cpu.
cpu_model, extra_flags = parse_cpu_model()
flags = HgFlags(cpu_model, extra_flags)
logging.debug("Unsupported flags %s.",
str(flags.host_all_unsupported_flags))
cpuf_model = cpu_model + ",check"
# Add unsupported flags.
for fadd in flags.host_all_unsupported_flags:
cpuf_model += ",+" + str(fadd)
vnc_port = utils_misc.find_free_port(5900, 6100) - 5900
cmd = "%s -cpu %s -vnc :%d -enable-kvm" % (qemu_binary,
cpuf_model,
vnc_port)
out = None
try:
try:
out = utils.run(cmd, timeout=5, ignore_status=True).stderr
raise error.TestFail("Guest not boot with unsupported "
"flags.")
except error.CmdError, e:
out = e.result_obj.stderr
finally:
uns_re = re.compile(r"^warning:.*flag '(.+)'", re.MULTILINE)
nf_re = re.compile(
r"^CPU feature (.+) not found", re.MULTILINE)
warn_flags = set([utils_misc.Flag(x)
for x in uns_re.findall(out)])
not_found = set([utils_misc.Flag(x)
for x in nf_re.findall(out)])
fwarn_flags = flags.host_all_unsupported_flags - warn_flags
fwarn_flags -= not_found
if fwarn_flags:
raise error.TestFail("Qemu did not warn the use of "
"flags %s" % str(fwarn_flags))
def setup_boot_disk(self):
if self.unattended_file.endswith('.sif'):
dest_fname = 'winnt.sif'
setup_file = 'winnt.bat'
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir, self.vfd_size)
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_windows_ini(answer_path)
setup_file_path = os.path.join(self.unattended_dir, setup_file)
boot_disk.copy_to(setup_file_path)
if self.install_virtio == "yes":
boot_disk.setup_virtio_win2003(self.virtio_floppy,
self.virtio_oemsetup_id)
boot_disk.copy_to(self.finish_program)
elif self.unattended_file.endswith('.ks'):
# Red Hat kickstart install
dest_fname = 'ks.cfg'
if self.params.get('unattended_delivery_method') == 'integrated':
ks_param = 'ks=cdrom:/dev/sr0:/isolinux/%s' % dest_fname
kernel_params = getattr(self, 'kernel_params')
if 'ks=' in kernel_params:
kernel_params = re.sub('ks\=[\w\d\:\.\/]+',
ks_param,
kernel_params)
else:
kernel_params = '%s %s' % (kernel_params, ks_param)
# Standard setting is kickstart disk in /dev/sr0 and
# install cdrom in /dev/sr1. As we merge them together,
# we need to change repo configuration to /dev/sr0
if 'repo=cdrom' in kernel_params:
kernel_params = re.sub('repo\=cdrom[\:\w\d\/]*',
'repo=cdrom:/dev/sr0',
kernel_params)
self.params['kernel_params'] = ''
boot_disk = utils_disk.CdromInstallDisk(
self.cdrom_unattended,
self.tmpdir,
self.cdrom_cd1_mount,
kernel_params)
elif self.params.get('unattended_delivery_method') == 'url':
if self.unattended_server_port is None:
self.unattended_server_port = utils_misc.find_free_port(
8000,
8099,
self.url_auto_content_ip)
path = os.path.join(os.path.dirname(self.cdrom_unattended),
'ks')
boot_disk = RemoteInstall(path, self.url_auto_content_ip,
self.unattended_server_port,
dest_fname)
ks_param = 'ks=%s' % boot_disk.get_url()
kernel_params = getattr(self, 'kernel_params')
if 'ks=' in kernel_params:
kernel_params = re.sub('ks\=[\w\d\:\.\/]+',
ks_param,
kernel_params)
else:
kernel_params = '%s %s' % (kernel_params, ks_param)
# Standard setting is kickstart disk in /dev/sr0 and
# install cdrom in /dev/sr1. When we get ks via http,
# we need to change repo configuration to /dev/sr0
if 'repo=cdrom' in kernel_params:
if ((self.vm.driver_type == 'xen') and
(self.params.get('hvm_or_pv') == 'pv')):
kernel_params = re.sub('repo\=[\:\w\d\/]*',
'repo=http://%s:%s' %
(self.url_auto_content_ip,
self.url_auto_content_port),
kernel_params)
else:
kernel_params = re.sub('repo\=cdrom[\:\w\d\/]*',
'repo=cdrom:/dev/sr0',
kernel_params)
self.params['kernel_params'] = kernel_params
elif self.params.get('unattended_delivery_method') == 'cdrom':
boot_disk = utils_disk.CdromDisk(self.cdrom_unattended,
self.tmpdir)
elif self.params.get('unattended_delivery_method') == 'floppy':
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir, self.vfd_size)
else:
raise ValueError("Neither cdrom_unattended nor floppy set "
"on the config file, please verify")
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_kickstart(answer_path)
elif self.unattended_file.endswith('.xml'):
if "autoyast" in self.kernel_params:
# SUSE autoyast install
dest_fname = "autoinst.xml"
if self.cdrom_unattended:
boot_disk = utils_disk.CdromDisk(self.cdrom_unattended,
self.tmpdir)
elif self.floppy:
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir, self.vfd_size)
else:
raise ValueError("Neither cdrom_unattended nor floppy set "
"on the config file, please verify")
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_suse_xml(answer_path)
else:
# Windows unattended install
dest_fname = "autounattend.xml"
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir, self.vfd_size)
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_windows_xml(answer_path)
if self.install_virtio == "yes":
boot_disk.setup_virtio_win2008(self.virtio_floppy)
boot_disk.copy_to(self.finish_program)
else:
raise ValueError('Unknown answer file type: %s' %
self.unattended_file)
boot_disk.close()
def migrate_wait(self, vms_name, srchost, dsthost, start_work=None,
check_work=None, mig_mode="fd", params_append=None):
vms_count = len(vms_name)
mig_ports = []
if self.params.get("hostid") == srchost:
last_port = 5199
for _ in range(vms_count):
last_port = utils_misc.find_free_port(last_port + 1, 6000)
mig_ports.append(last_port)
sync = SyncData(self.master_id(), self.hostid,
self.params.get("hosts"),
{'src': srchost, 'dst': dsthost,
'port': "ports"}, self.sync_server)
mig_ports = sync.sync(mig_ports, timeout=120)
mig_ports = mig_ports[srchost]
logging.debug("Migration port %s" % (mig_ports))
if self.params.get("hostid") != srchost:
sockets = []
for mig_port in mig_ports:
sockets.append(self._connect_to_server(srchost, mig_port))
try:
fds = {}
for s, vm_name in zip(sockets, vms_name):
fds["migration_fd_%s" % vm_name] = s.fileno()
logging.debug("File descrtiptors %s used for"
" migration." % (fds))
super_cls = super(MultihostMigrationFd, self)
super_cls.migrate_wait(vms_name, srchost, dsthost,
start_work=start_work, mig_mode="fd",
params_append=fds)
finally:
for s in sockets:
s.close()
else:
sockets = []
for mig_port in mig_ports:
sockets.append(self._create_server(mig_port))
try:
conns = []
for s in sockets:
conns.append(s.accept()[0])
fds = {}
for conn, vm_name in zip(conns, vms_name):
fds["migration_fd_%s" % vm_name] = conn.fileno()
logging.debug("File descrtiptors %s used for"
" migration." % (fds))
# Prohibits descriptor inheritance.
for fd in fds.values():
flags = fcntl.fcntl(fd, fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(fd, fcntl.F_SETFD, flags)
super_cls = super(MultihostMigrationFd, self)
super_cls.migrate_wait(vms_name, srchost, dsthost,
start_work=start_work, mig_mode="fd",
params_append=fds)
for conn in conns:
conn.close()
finally:
for s in sockets:
s.close()
def migrate_wait(self, vms_name, srchost, dsthost, start_work=None,
check_work=None, mig_mode="exec", params_append=None):
vms_count = len(vms_name)
mig_ports = []
host_offline_migration = self.params.get("host_mig_offline")
sync = SyncData(self.master_id(), self.hostid,
self.params.get("hosts"),
{'src': srchost, 'dst': dsthost,
'port': "ports"}, self.sync_server)
mig_params = {}
if host_offline_migration != "yes":
if self.params.get("hostid") == dsthost:
last_port = 5199
for _ in range(vms_count):
last_port = utils_misc.find_free_port(last_port + 1, 6000)
mig_ports.append(last_port)
mig_ports = sync.sync(mig_ports, timeout=120)
mig_ports = mig_ports[dsthost]
logging.debug("Migration port %s" % (mig_ports))
mig_cmds = {}
for mig_port, vm_name in zip(mig_ports, vms_name):
mig_dst_cmd = "nc -l %s %s" % (dsthost, mig_port)
mig_src_cmd = "nc %s %s" % (dsthost, mig_port)
mig_params["migration_exec_cmd_src_%s" %
(vm_name)] = mig_src_cmd
mig_params["migration_exec_cmd_dst_%s" %
(vm_name)] = mig_dst_cmd
else:
# Generate filenames for migration.
mig_fnam = {}
for vm_name in vms_name:
while True:
fnam = ("mig_" + utils.generate_random_string(6) +
"." + vm_name)
fpath = os.path.join(self.test.tmpdir, fnam)
if (not fnam in mig_fnam.values() and
not os.path.exists(fnam)):
mig_fnam[vm_name] = fpath
break
mig_fs = sync.sync(mig_fnam, timeout=120)
mig_cmds = {}
# Prepare cmd and files.
if self.params.get("hostid") == srchost:
mig_src_cmd = "gzip -c > %s"
for vm_name in vms_name:
mig_params["migration_sfiles_path_%s" % (vm_name)] = (
mig_fs[srchost][vm_name])
mig_params["migration_dfiles_path_%s" % (vm_name)] = (
mig_fs[dsthost][vm_name])
mig_params["migration_exec_cmd_src_%s" % (vm_name)] = (
mig_src_cmd % mig_fs[srchost][vm_name])
if self.params.get("hostid") == dsthost:
mig_dst_cmd = "gzip -c -d %s"
for vm_name in vms_name:
mig_params["migration_exec_cmd_dst_%s" % (vm_name)] = (
mig_dst_cmd % mig_fs[dsthost][vm_name])
logging.debug("Exec commands %s", mig_cmds)
super_cls = super(MultihostMigrationExec, self)
super_cls.migrate_wait(vms_name, srchost, dsthost,
start_work=start_work, mig_mode=mig_mode,
params_append=mig_params)
def migrate_wait(self, vms_name, srchost, dsthost, start_work=None,
check_work=None, mig_mode="fd", params_append=None):
vms_count = len(vms_name)
mig_ports = []
if self.params.get("hostid") == srchost:
last_port = 5199
for _ in range(vms_count):
last_port = utils_misc.find_free_port(last_port + 1, 6000)
mig_ports.append(last_port)
sync = SyncData(self.master_id(), self.hostid,
self.params.get("hosts"),
{'src': srchost, 'dst': dsthost,
'port': "ports"}, self.sync_server)
mig_ports = sync.sync(mig_ports, timeout=120)
mig_ports = mig_ports[srchost]
logging.debug("Migration port %s" % (mig_ports))
if self.params.get("hostid") != srchost:
sockets = []
for mig_port in mig_ports:
sockets.append(self._connect_to_server(srchost, mig_port))
try:
fds = {}
for s, vm_name in zip(sockets, vms_name):
fds["migration_fd_%s" % vm_name] = s.fileno()
logging.debug("File descriptors %s used for"
" migration." % (fds))
super_cls = super(MultihostMigrationFd, self)
super_cls.migrate_wait(vms_name, srchost, dsthost,
start_work=start_work, mig_mode="fd",
params_append=fds)
finally:
for s in sockets:
s.close()
else:
sockets = []
for mig_port in mig_ports:
sockets.append(self._create_server(mig_port))
try:
conns = []
for s in sockets:
conns.append(s.accept()[0])
fds = {}
for conn, vm_name in zip(conns, vms_name):
fds["migration_fd_%s" % vm_name] = conn.fileno()
logging.debug("File descriptors %s used for"
" migration." % (fds))
# Prohibits descriptor inheritance.
for fd in fds.values():
flags = fcntl.fcntl(fd, fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(fd, fcntl.F_SETFD, flags)
super_cls = super(MultihostMigrationFd, self)
super_cls.migrate_wait(vms_name, srchost, dsthost,
start_work=start_work, mig_mode="fd",
params_append=fds)
for conn in conns:
conn.close()
finally:
for s in sockets:
s.close()
def migrate_wait(self, vms_name, srchost, dsthost, start_work=None,
check_work=None, mig_mode="exec", params_append=None):
vms_count = len(vms_name)
mig_ports = []
host_offline_migration = self.params.get("host_mig_offline")
sync = SyncData(self.master_id(), self.hostid,
self.params.get("hosts"),
{'src': srchost, 'dst': dsthost,
'port': "ports"}, self.sync_server)
mig_params = {}
if host_offline_migration != "yes":
if self.params.get("hostid") == dsthost:
last_port = 5199
for _ in range(vms_count):
last_port = utils_misc.find_free_port(last_port + 1, 6000)
mig_ports.append(last_port)
mig_ports = sync.sync(mig_ports, timeout=120)
mig_ports = mig_ports[dsthost]
logging.debug("Migration port %s" % (mig_ports))
mig_cmds = {}
for mig_port, vm_name in zip(mig_ports, vms_name):
mig_dst_cmd = "nc -l %s %s" % (dsthost, mig_port)
mig_src_cmd = "nc %s %s" % (dsthost, mig_port)
mig_params["migration_exec_cmd_src_%s" %
(vm_name)] = mig_src_cmd
mig_params["migration_exec_cmd_dst_%s" %
(vm_name)] = mig_dst_cmd
else:
# Generate filenames for migration.
mig_fnam = {}
for vm_name in vms_name:
while True:
fnam = ("mig_" + utils.generate_random_string(6) +
"." + vm_name)
fpath = os.path.join(self.test.tmpdir, fnam)
if (fnam not in mig_fnam.values() and
not os.path.exists(fnam)):
mig_fnam[vm_name] = fpath
break
mig_fs = sync.sync(mig_fnam, timeout=120)
mig_cmds = {}
# Prepare cmd and files.
if self.params.get("hostid") == srchost:
mig_src_cmd = "gzip -c > %s"
for vm_name in vms_name:
mig_params["migration_sfiles_path_%s" % (vm_name)] = (
mig_fs[srchost][vm_name])
mig_params["migration_dfiles_path_%s" % (vm_name)] = (
mig_fs[dsthost][vm_name])
mig_params["migration_exec_cmd_src_%s" % (vm_name)] = (
mig_src_cmd % mig_fs[srchost][vm_name])
if self.params.get("hostid") == dsthost:
mig_dst_cmd = "gzip -c -d %s"
for vm_name in vms_name:
mig_params["migration_exec_cmd_dst_%s" % (vm_name)] = (
mig_dst_cmd % mig_fs[dsthost][vm_name])
logging.debug("Exec commands %s", mig_cmds)
super_cls = super(MultihostMigrationExec, self)
super_cls.migrate_wait(vms_name, srchost, dsthost,
start_work=start_work, mig_mode=mig_mode,
params_append=mig_params)
def setup_cdrom(self):
"""
Mount cdrom and copy vmlinuz and initrd.img.
"""
error.context("Copying vmlinuz and initrd.img from install cdrom %s" %
self.cdrom_cd1)
if not os.path.isdir(self.image_path):
os.makedirs(self.image_path)
if (self.params.get('unattended_delivery_method') in
['integrated', 'url']):
i = iso9660.Iso9660Mount(self.cdrom_cd1)
self.cdrom_cd1_mount = i.mnt_dir
else:
i = iso9660.iso9660(self.cdrom_cd1)
if i is None:
raise error.TestFail("Could not instantiate an iso9660 class")
i.copy(os.path.join(self.boot_path, os.path.basename(self.kernel)),
self.kernel)
assert(os.path.getsize(self.kernel) > 0)
i.copy(os.path.join(self.boot_path, os.path.basename(self.initrd)),
self.initrd)
assert(os.path.getsize(self.initrd) > 0)
if self.unattended_file.endswith('.preseed'):
self.preseed_initrd()
if self.params.get("vm_type") == "libvirt":
if self.vm.driver_type == 'qemu':
# Virtinstall command needs files "vmlinuz" and "initrd.img"
os.chdir(self.image_path)
base_kernel = os.path.basename(self.kernel)
base_initrd = os.path.basename(self.initrd)
if base_kernel != 'vmlinuz':
utils.run("mv %s vmlinuz" % base_kernel, verbose=DEBUG)
if base_initrd != 'initrd.img':
utils.run("mv %s initrd.img" % base_initrd, verbose=DEBUG)
if (self.params.get('unattended_delivery_method') !=
'integrated'):
i.close()
utils_disk.cleanup(self.cdrom_cd1_mount)
elif ((self.vm.driver_type == 'xen') and
(self.params.get('hvm_or_pv') == 'pv')):
logging.debug("starting unattended content web server")
self.url_auto_content_port = utils_misc.find_free_port(8100,
8199,
self.url_auto_content_ip)
start_auto_content_server_thread(self.url_auto_content_port,
self.cdrom_cd1_mount)
self.medium = 'url'
self.url = ('http://%s:%s' % (self.url_auto_content_ip,
self.url_auto_content_port))
pxe_path = os.path.join(
os.path.dirname(self.image_path), 'xen')
if not os.path.isdir(pxe_path):
os.makedirs(pxe_path)
pxe_kernel = os.path.join(pxe_path,
os.path.basename(self.kernel))
pxe_initrd = os.path.join(pxe_path,
os.path.basename(self.initrd))
utils.run("cp %s %s" % (self.kernel, pxe_kernel))
utils.run("cp %s %s" % (self.initrd, pxe_initrd))
if 'repo=cdrom' in self.kernel_params:
# Red Hat
self.kernel_params = re.sub('repo\=[\:\w\d\/]*',
'repo=http://%s:%s' %
(self.url_auto_content_ip,
self.url_auto_content_port),
self.kernel_params)
def setup_boot_disk(self):
if self.unattended_file.endswith('.sif'):
dest_fname = 'winnt.sif'
setup_file = 'winnt.bat'
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir, self.vfd_size)
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_windows_ini(answer_path)
setup_file_path = os.path.join(self.unattended_dir, setup_file)
boot_disk.copy_to(setup_file_path)
if self.install_virtio == "yes":
boot_disk.setup_virtio_win2003(self.virtio_floppy,
self.virtio_oemsetup_id)
boot_disk.copy_to(self.finish_program)
elif self.unattended_file.endswith('.ks'):
# Red Hat kickstart install
dest_fname = 'ks.cfg'
if self.params.get('unattended_delivery_method') == 'integrated':
ks_param = 'ks=cdrom:/dev/sr0:/isolinux/%s' % dest_fname
kernel_params = self.kernel_params
if 'ks=' in kernel_params:
kernel_params = re.sub('ks\=[\w\d\:\.\/]+',
ks_param,
kernel_params)
else:
kernel_params = '%s %s' % (kernel_params, ks_param)
# Standard setting is kickstart disk in /dev/sr0 and
# install cdrom in /dev/sr1. As we merge them together,
# we need to change repo configuration to /dev/sr0
if 'repo=cdrom' in kernel_params:
kernel_params = re.sub('repo\=cdrom[\:\w\d\/]*',
'repo=cdrom:/dev/sr0',
kernel_params)
self.kernel_params = None
boot_disk = utils_disk.CdromInstallDisk(
self.cdrom_unattended,
self.tmpdir,
self.cdrom_cd1_mount,
kernel_params)
elif self.params.get('unattended_delivery_method') == 'url':
if self.unattended_server_port is None:
self.unattended_server_port = utils_misc.find_free_port(
8000,
8099,
self.url_auto_content_ip)
path = os.path.join(os.path.dirname(self.cdrom_unattended),
'ks')
boot_disk = RemoteInstall(path, self.url_auto_content_ip,
self.unattended_server_port,
dest_fname)
ks_param = 'ks=%s' % boot_disk.get_url()
kernel_params = self.kernel_params
if 'ks=' in kernel_params:
kernel_params = re.sub('ks\=[\w\d\:\.\/]+',
ks_param,
kernel_params)
else:
kernel_params = '%s %s' % (kernel_params, ks_param)
# Standard setting is kickstart disk in /dev/sr0 and
# install cdrom in /dev/sr1. When we get ks via http,
# we need to change repo configuration to /dev/sr0
kernel_params = re.sub('repo\=cdrom[\:\w\d\/]*',
'repo=cdrom:/dev/sr0',
kernel_params)
self.kernel_params = kernel_params
elif self.params.get('unattended_delivery_method') == 'cdrom':
boot_disk = utils_disk.CdromDisk(self.cdrom_unattended,
self.tmpdir)
elif self.params.get('unattended_delivery_method') == 'floppy':
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir, self.vfd_size)
ks_param = 'ks=floppy'
kernel_params = self.kernel_params
if 'ks=' in kernel_params:
# Reading ks from floppy directly doesn't work in some OS,
# options 'ks=hd:/dev/fd0' can reading ks from mounted
# floppy, so skip repace it;
if not re.search("fd\d+", kernel_params):
kernel_params = re.sub('ks\=[\w\d\:\.\/]+',
ks_param,
kernel_params)
else:
kernel_params = '%s %s' % (kernel_params, ks_param)
kernel_params = re.sub('repo\=cdrom[\:\w\d\/]*',
'repo=cdrom:/dev/sr0',
kernel_params)
self.kernel_params = kernel_params
else:
raise ValueError("Neither cdrom_unattended nor floppy set "
"on the config file, please verify")
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_kickstart(answer_path)
elif self.unattended_file.endswith('.xml'):
if "autoyast" in self.kernel_params:
# SUSE autoyast install
dest_fname = "autoinst.xml"
if (self.cdrom_unattended and
self.params.get('unattended_delivery_method') == 'cdrom'):
boot_disk = utils_disk.CdromDisk(self.cdrom_unattended,
self.tmpdir)
elif self.floppy:
autoyast_param = 'autoyast=device://fd0/autoinst.xml'
kernel_params = self.kernel_params
if 'autoyast=' in kernel_params:
kernel_params = re.sub('autoyast\=[\w\d\:\.\/]+',
autoyast_param,
kernel_params)
else:
kernel_params = '%s %s' % (
kernel_params, autoyast_param)
self.kernel_params = kernel_params
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir,
self.vfd_size)
else:
raise ValueError("Neither cdrom_unattended nor floppy set "
"on the config file, please verify")
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_suse_xml(answer_path)
else:
# Windows unattended install
dest_fname = "autounattend.xml"
if self.params.get('unattended_delivery_method') == 'cdrom':
boot_disk = utils_disk.CdromDisk(self.cdrom_unattended,
self.tmpdir)
if self.install_virtio == "yes":
boot_disk.setup_virtio_win2008(self.virtio_floppy,
self.cdrom_virtio)
self.cdrom_virtio = None
else:
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir,
self.vfd_size)
if self.install_virtio == "yes":
boot_disk.setup_virtio_win2008(self.virtio_floppy)
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_windows_xml(answer_path)
boot_disk.copy_to(self.finish_program)
else:
raise ValueError('Unknown answer file type: %s' %
self.unattended_file)
boot_disk.close()
def setup_cdrom(self):
"""
Mount cdrom and copy vmlinuz and initrd.img.
"""
error.context("Copying vmlinuz and initrd.img from install cdrom %s" %
self.cdrom_cd1)
if not os.path.isdir(self.image_path):
os.makedirs(self.image_path)
if (self.params.get('unattended_delivery_method')
in ['integrated', 'url']):
i = iso9660.Iso9660Mount(self.cdrom_cd1)
self.cdrom_cd1_mount = i.mnt_dir
else:
i = iso9660.iso9660(self.cdrom_cd1)
if i is None:
raise error.TestFail("Could not instantiate an iso9660 class")
i.copy(os.path.join(self.boot_path, os.path.basename(self.kernel)),
self.kernel)
assert (os.path.getsize(self.kernel) > 0)
i.copy(os.path.join(self.boot_path, os.path.basename(self.initrd)),
self.initrd)
assert (os.path.getsize(self.initrd) > 0)
if self.unattended_file.endswith('.preseed'):
self.preseed_initrd()
if self.params.get("vm_type") == "libvirt":
if self.vm.driver_type == 'qemu':
# Virtinstall command needs files "vmlinuz" and "initrd.img"
os.chdir(self.image_path)
base_kernel = os.path.basename(self.kernel)
base_initrd = os.path.basename(self.initrd)
if base_kernel != 'vmlinuz':
utils.run("mv %s vmlinuz" % base_kernel, verbose=DEBUG)
if base_initrd != 'initrd.img':
utils.run("mv %s initrd.img" % base_initrd, verbose=DEBUG)
if (self.params.get('unattended_delivery_method') !=
'integrated'):
i.close()
utils_disk.cleanup(self.cdrom_cd1_mount)
elif ((self.vm.driver_type == 'xen')
and (self.params.get('hvm_or_pv') == 'pv')):
logging.debug("starting unattended content web server")
self.url_auto_content_port = utils_misc.find_free_port(
8100, 8199, self.url_auto_content_ip)
start_auto_content_server_thread(self.url_auto_content_port,
self.cdrom_cd1_mount)
self.medium = 'url'
self.url = (
'http://%s:%s' %
(self.url_auto_content_ip, self.url_auto_content_port))
pxe_path = os.path.join(os.path.dirname(self.image_path),
'xen')
if not os.path.isdir(pxe_path):
os.makedirs(pxe_path)
pxe_kernel = os.path.join(pxe_path,
os.path.basename(self.kernel))
pxe_initrd = os.path.join(pxe_path,
os.path.basename(self.initrd))
utils.run("cp %s %s" % (self.kernel, pxe_kernel))
utils.run("cp %s %s" % (self.initrd, pxe_initrd))
if 'repo=cdrom' in self.kernel_params:
# Red Hat
self.kernel_params = re.sub(
'repo\=[\:\w\d\/]*', 'repo=http://%s:%s' %
(self.url_auto_content_ip, self.url_auto_content_port),
self.kernel_params)
def setup_boot_disk(self):
if self.unattended_file.endswith('.sif'):
dest_fname = 'winnt.sif'
setup_file = 'winnt.bat'
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir, self.vfd_size)
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_windows_ini(answer_path)
setup_file_path = os.path.join(self.unattended_dir, setup_file)
boot_disk.copy_to(setup_file_path)
if self.install_virtio == "yes":
boot_disk.setup_virtio_win2003(self.virtio_floppy,
self.virtio_oemsetup_id)
boot_disk.copy_to(self.finish_program)
elif self.unattended_file.endswith('.ks'):
# Red Hat kickstart install
dest_fname = 'ks.cfg'
if self.params.get('unattended_delivery_method') == 'integrated':
ks_param = 'ks=cdrom:/dev/sr0:/isolinux/%s' % dest_fname
kernel_params = self.kernel_params
if 'ks=' in kernel_params:
kernel_params = re.sub('ks\=[\w\d\:\.\/]+', ks_param,
kernel_params)
else:
kernel_params = '%s %s' % (kernel_params, ks_param)
# Standard setting is kickstart disk in /dev/sr0 and
# install cdrom in /dev/sr1. As we merge them together,
# we need to change repo configuration to /dev/sr0
if 'repo=cdrom' in kernel_params:
kernel_params = re.sub('repo\=cdrom[\:\w\d\/]*',
'repo=cdrom:/dev/sr0',
kernel_params)
self.kernel_params = None
boot_disk = utils_disk.CdromInstallDisk(
self.cdrom_unattended, self.tmpdir, self.cdrom_cd1_mount,
kernel_params)
elif self.params.get('unattended_delivery_method') == 'url':
if self.unattended_server_port is None:
self.unattended_server_port = utils_misc.find_free_port(
8000, 8099, self.url_auto_content_ip)
path = os.path.join(os.path.dirname(self.cdrom_unattended),
'ks')
boot_disk = RemoteInstall(path, self.url_auto_content_ip,
self.unattended_server_port,
dest_fname)
ks_param = 'ks=%s' % boot_disk.get_url()
kernel_params = self.kernel_params
if 'ks=' in kernel_params:
kernel_params = re.sub('ks\=[\w\d\:\.\/]+', ks_param,
kernel_params)
else:
kernel_params = '%s %s' % (kernel_params, ks_param)
# Standard setting is kickstart disk in /dev/sr0 and
# install cdrom in /dev/sr1. When we get ks via http,
# we need to change repo configuration to /dev/sr0
kernel_params = re.sub('repo\=cdrom[\:\w\d\/]*',
'repo=cdrom:/dev/sr0', kernel_params)
self.kernel_params = kernel_params
elif self.params.get('unattended_delivery_method') == 'cdrom':
boot_disk = utils_disk.CdromDisk(self.cdrom_unattended,
self.tmpdir)
elif self.params.get('unattended_delivery_method') == 'floppy':
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir, self.vfd_size)
ks_param = 'ks=floppy'
kernel_params = self.kernel_params
if 'ks=' in kernel_params:
# Reading ks from floppy directly doesn't work in some OS,
# options 'ks=hd:/dev/fd0' can reading ks from mounted
# floppy, so skip repace it;
if not re.search("fd\d+", kernel_params):
kernel_params = re.sub('ks\=[\w\d\:\.\/]+', ks_param,
kernel_params)
else:
kernel_params = '%s %s' % (kernel_params, ks_param)
kernel_params = re.sub('repo\=cdrom[\:\w\d\/]*',
'repo=cdrom:/dev/sr0', kernel_params)
self.kernel_params = kernel_params
else:
raise ValueError("Neither cdrom_unattended nor floppy set "
"on the config file, please verify")
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_kickstart(answer_path)
elif self.unattended_file.endswith('.xml'):
if "autoyast" in self.kernel_params:
# SUSE autoyast install
dest_fname = "autoinst.xml"
if (self.cdrom_unattended
and self.params.get('unattended_delivery_method')
== 'cdrom'):
boot_disk = utils_disk.CdromDisk(self.cdrom_unattended,
self.tmpdir)
elif self.floppy:
autoyast_param = 'autoyast=device://fd0/autoinst.xml'
kernel_params = self.kernel_params
if 'autoyast=' in kernel_params:
kernel_params = re.sub('autoyast\=[\w\d\:\.\/]+',
autoyast_param, kernel_params)
else:
kernel_params = '%s %s' % (kernel_params,
autoyast_param)
self.kernel_params = kernel_params
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir,
self.vfd_size)
else:
raise ValueError("Neither cdrom_unattended nor floppy set "
"on the config file, please verify")
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_suse_xml(answer_path)
else:
# Windows unattended install
dest_fname = "autounattend.xml"
if self.params.get('unattended_delivery_method') == 'cdrom':
boot_disk = utils_disk.CdromDisk(self.cdrom_unattended,
self.tmpdir)
if self.install_virtio == "yes":
boot_disk.setup_virtio_win2008(self.virtio_floppy,
self.cdrom_virtio)
else:
self.cdrom_virtio = None
else:
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir,
self.vfd_size)
if self.install_virtio == "yes":
boot_disk.setup_virtio_win2008(self.virtio_floppy)
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_windows_xml(answer_path)
boot_disk.copy_to(self.finish_program)
else:
raise ValueError('Unknown answer file type: %s' %
self.unattended_file)
boot_disk.close()
def setup_boot_disk(self):
if self.unattended_file.endswith(".sif"):
dest_fname = "winnt.sif"
setup_file = "winnt.bat"
boot_disk = utils_disk.FloppyDisk(self.floppy, self.qemu_img_binary, self.tmpdir, self.vfd_size)
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_windows_ini(answer_path)
setup_file_path = os.path.join(self.unattended_dir, setup_file)
boot_disk.copy_to(setup_file_path)
if self.install_virtio == "yes":
boot_disk.setup_virtio_win2003(self.virtio_floppy, self.virtio_oemsetup_id)
boot_disk.copy_to(self.finish_program)
elif self.unattended_file.endswith(".ks"):
# Red Hat kickstart install
dest_fname = "ks.cfg"
if self.params.get("unattended_delivery_method") == "integrated":
ks_param = "ks=cdrom:/dev/sr0:/isolinux/%s" % dest_fname
kernel_params = self.kernel_params
if "ks=" in kernel_params:
kernel_params = re.sub("ks\=[\w\d\:\.\/]+", ks_param, kernel_params)
else:
kernel_params = "%s %s" % (kernel_params, ks_param)
# Standard setting is kickstart disk in /dev/sr0 and
# install cdrom in /dev/sr1. As we merge them together,
# we need to change repo configuration to /dev/sr0
if "repo=cdrom" in kernel_params:
kernel_params = re.sub("repo\=cdrom[\:\w\d\/]*", "repo=cdrom:/dev/sr0", kernel_params)
self.kernel_params = None
boot_disk = utils_disk.CdromInstallDisk(
self.cdrom_unattended, self.tmpdir, self.cdrom_cd1_mount, kernel_params
)
elif self.params.get("unattended_delivery_method") == "url":
if self.unattended_server_port is None:
self.unattended_server_port = utils_misc.find_free_port(8000, 8099, self.url_auto_content_ip)
path = os.path.join(os.path.dirname(self.cdrom_unattended), "ks")
boot_disk = RemoteInstall(path, self.url_auto_content_ip, self.unattended_server_port, dest_fname)
ks_param = "ks=%s" % boot_disk.get_url()
kernel_params = self.kernel_params
if "ks=" in kernel_params:
kernel_params = re.sub("ks\=[\w\d\:\.\/]+", ks_param, kernel_params)
else:
kernel_params = "%s %s" % (kernel_params, ks_param)
# Standard setting is kickstart disk in /dev/sr0 and
# install cdrom in /dev/sr1. When we get ks via http,
# we need to change repo configuration to /dev/sr0
kernel_params = re.sub("repo\=cdrom[\:\w\d\/]*", "repo=cdrom:/dev/sr0", kernel_params)
self.kernel_params = kernel_params
elif self.params.get("unattended_delivery_method") == "cdrom":
boot_disk = utils_disk.CdromDisk(self.cdrom_unattended, self.tmpdir)
elif self.params.get("unattended_delivery_method") == "floppy":
boot_disk = utils_disk.FloppyDisk(self.floppy, self.qemu_img_binary, self.tmpdir, self.vfd_size)
ks_param = "ks=floppy"
kernel_params = self.kernel_params
if "ks=" in kernel_params:
kernel_params = re.sub("ks\=[\w\d\:\.\/]+", ks_param, kernel_params)
else:
kernel_params = "%s %s" % (kernel_params, ks_param)
kernel_params = re.sub("repo\=cdrom[\:\w\d\/]*", "repo=cdrom:/dev/sr0", kernel_params)
self.kernel_params = kernel_params
else:
raise ValueError("Neither cdrom_unattended nor floppy set " "on the config file, please verify")
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_kickstart(answer_path)
elif self.unattended_file.endswith(".xml"):
if "autoyast" in self.kernel_params:
# SUSE autoyast install
dest_fname = "autoinst.xml"
if self.cdrom_unattended:
boot_disk = utils_disk.CdromDisk(self.cdrom_unattended, self.tmpdir)
elif self.floppy:
autoyast_param = "autoyast=floppy"
kernel_params = self.kernel_params
if "autoyast=" in kernel_params:
kernel_params = re.sub("autoyast\=[\w\d\:\.\/]+", autoyast_param, kernel_params)
else:
kernel_params = "%s %s" % (kernel_params, autoyast_param)
self.kernel_params = kernel_params
boot_disk = utils_disk.FloppyDisk(self.floppy, self.qemu_img_binary, self.tmpdir, self.vfd_size)
else:
raise ValueError("Neither cdrom_unattended nor floppy set " "on the config file, please verify")
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_suse_xml(answer_path)
else:
# Windows unattended install
dest_fname = "autounattend.xml"
boot_disk = utils_disk.FloppyDisk(self.floppy, self.qemu_img_binary, self.tmpdir, self.vfd_size)
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_windows_xml(answer_path)
if self.install_virtio == "yes":
boot_disk.setup_virtio_win2008(self.virtio_floppy)
boot_disk.copy_to(self.finish_program)
else:
raise ValueError("Unknown answer file type: %s" % self.unattended_file)
boot_disk.close()
def setup_boot_disk(self):
if self.unattended_file.endswith('.sif'):
dest_fname = 'winnt.sif'
setup_file = 'winnt.bat'
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir, self.vfd_size)
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_windows_ini(answer_path)
setup_file_path = os.path.join(self.unattended_dir, setup_file)
boot_disk.copy_to(setup_file_path)
if self.install_virtio == "yes":
boot_disk.setup_virtio_win2003(self.virtio_floppy,
self.virtio_oemsetup_id)
boot_disk.copy_to(self.finish_program)
elif self.unattended_file.endswith('.ks'):
# Red Hat kickstart install
dest_fname = 'ks.cfg'
if self.params.get('unattended_delivery_method') == 'integrated':
ks_param = 'ks=cdrom:/dev/sr0:/isolinux/%s' % dest_fname
kernel_params = getattr(self, 'kernel_params')
if 'ks=' in kernel_params:
kernel_params = re.sub('ks\=[\w\d\:\.\/]+', ks_param,
kernel_params)
else:
kernel_params = '%s %s' % (kernel_params, ks_param)
# Standard setting is kickstart disk in /dev/sr0 and
# install cdrom in /dev/sr1. As we merge them together,
# we need to change repo configuration to /dev/sr0
if 'repo=cdrom' in kernel_params:
kernel_params = re.sub('repo\=cdrom[\:\w\d\/]*',
'repo=cdrom:/dev/sr0',
kernel_params)
self.params['kernel_params'] = ''
boot_disk = utils_disk.CdromInstallDisk(
self.cdrom_unattended, self.tmpdir, self.cdrom_cd1_mount,
kernel_params)
elif self.params.get('unattended_delivery_method') == 'url':
if self.unattended_server_port is None:
self.unattended_server_port = utils_misc.find_free_port(
8000, 8099, self.url_auto_content_ip)
path = os.path.join(os.path.dirname(self.cdrom_unattended),
'ks')
boot_disk = RemoteInstall(path, self.url_auto_content_ip,
self.unattended_server_port,
dest_fname)
ks_param = 'ks=%s' % boot_disk.get_url()
kernel_params = getattr(self, 'kernel_params')
if 'ks=' in kernel_params:
kernel_params = re.sub('ks\=[\w\d\:\.\/]+', ks_param,
kernel_params)
else:
kernel_params = '%s %s' % (kernel_params, ks_param)
# Standard setting is kickstart disk in /dev/sr0 and
# install cdrom in /dev/sr1. When we get ks via http,
# we need to change repo configuration to /dev/sr0
if 'repo=cdrom' in kernel_params:
if ((self.vm.driver_type == 'xen')
and (self.params.get('hvm_or_pv') == 'pv')):
kernel_params = re.sub(
'repo\=[\:\w\d\/]*',
'repo=http://%s:%s' % (self.url_auto_content_ip,
self.url_auto_content_port),
kernel_params)
else:
kernel_params = re.sub('repo\=cdrom[\:\w\d\/]*',
'repo=cdrom:/dev/sr0',
kernel_params)
self.params['kernel_params'] = kernel_params
elif self.params.get('unattended_delivery_method') == 'cdrom':
boot_disk = utils_disk.CdromDisk(self.cdrom_unattended,
self.tmpdir)
elif self.params.get('unattended_delivery_method') == 'floppy':
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir, self.vfd_size)
else:
raise ValueError("Neither cdrom_unattended nor floppy set "
"on the config file, please verify")
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_kickstart(answer_path)
elif self.unattended_file.endswith('.xml'):
if "autoyast" in self.kernel_params:
# SUSE autoyast install
dest_fname = "autoinst.xml"
if self.cdrom_unattended:
boot_disk = utils_disk.CdromDisk(self.cdrom_unattended,
self.tmpdir)
elif self.floppy:
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir,
self.vfd_size)
else:
raise ValueError("Neither cdrom_unattended nor floppy set "
"on the config file, please verify")
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_suse_xml(answer_path)
else:
# Windows unattended install
dest_fname = "autounattend.xml"
boot_disk = utils_disk.FloppyDisk(self.floppy,
self.qemu_img_binary,
self.tmpdir, self.vfd_size)
answer_path = boot_disk.get_answer_file_path(dest_fname)
self.answer_windows_xml(answer_path)
if self.install_virtio == "yes":
boot_disk.setup_virtio_win2008(self.virtio_floppy)
boot_disk.copy_to(self.finish_program)
else:
raise ValueError('Unknown answer file type: %s' %
self.unattended_file)
boot_disk.close()
def run(test, params, env):
"""
Test usb redirection
1) Check host configurations
2) Start usbredirserver on host (optional)
3) Preprocess VM
4) Start USB redirection via spice (optional)
5) Check the boot menu list (optional)
6) Check the redirected USB device in guest
:param test: QEMU test object
:param params: Dictionary with test parameters
:param env: Dictionary with test environment.
"""
def _start_usbredir_server():
process.getoutput("killall usbredirserver")
usbredir_server = utils_misc.get_binary('usbredirserver', params)
usbredirserver_args = usbredir_server + " -p %s " % free_port
usbredirserver_args += " %s:%s" % (vendorid, productid)
usbredirserver_args += " > /dev/null 2>&1"
rv_thread = utils_misc.InterruptedThread(os.system,
(usbredirserver_args, ))
rv_thread.start()
def create_repo():
logging.info("Create temp repository")
version_cmd = 'grep "^VERSION_ID=" /etc/os-release | cut -d = -f2'
version_id = process.getoutput(version_cmd).strip('"')
major, minor = version_id.split('.')
baseurl = params["temprepo_url"]
baseurl = baseurl.replace("MAJOR", major)
content = "[temp]\nname=temp\nbaseurl=%s\nenable=1\n" % baseurl
content += "gpgcheck=0\nskip_if_unavailable=1"
create_cmd = r'echo -e "%s" > /etc/yum.repos.d/temp.repo' % content
process.system(create_cmd, shell=True)
def _host_config_check():
status = True
err_msg = ''
if option == "with_negative_config":
out = process.getoutput("dmesg")
pattern = r"usb (\d-\d(?:.\d)?):.*idVendor=%s, idProduct=%s"
pattern = pattern % (vendorid, productid)
obj = re.search(pattern, out, re.ASCII)
if not obj:
status = False
err_msg = "Fail to get the USB device info in host dmesg"
return (status, err_msg)
error_context.context("Make USB device unconfigured", logging.info)
unconfig_value = params["usbredir_unconfigured_value"]
cmd = "echo %s > /sys/bus/usb/devices/%s/bConfigurationValue"
cmd = cmd % (unconfig_value, obj.group(1))
logging.info(cmd)
s, o = process.getstatusoutput(cmd)
if s:
status = False
err_msg = "Fail to unconfig the USB device, output: %s" % o
return (status, err_msg)
if backend == 'spicevmc':
gui_group = "Server with GUI"
out = process.getoutput('yum group list --installed',
allow_output_check='stdout',
shell=True)
obj = re.search(r"(Installed Environment Groups:.*?)^\S", out,
re.S | re.M)
if not obj or gui_group not in obj.group(1):
gui_groupinstall_cmd = "yum groupinstall -y '%s'" % gui_group
s, o = process.getstatusoutput(gui_groupinstall_cmd,
shell=True)
if s:
status = False
err_msg = "Fail to install '%s' on host, " % gui_group
err_msg += "output: %s" % o
return (status, err_msg)
virt_viewer_cmd = "rpm -q virt-viewer || yum install -y virt-viewer"
s, o = process.getstatusoutput(virt_viewer_cmd, shell=True)
if s:
status = False
err_msg = "Fail to install 'virt-viewer' on host, "
err_msg += "output: %s" % o
return (status, err_msg)
elif backend == 'tcp_socket':
create_repo()
if not utils_package.package_install("usbredir-server"):
status = False
err_msg = "Fail to install 'usbredir-server' on host"
return (status, err_msg)
return (status, err_msg)
def _usbredir_preprocess():
def _generate_usb_redir_cmdline():
extra_params = ''
_backend = 'socket' if 'socket' in backend else backend
chardev_id = usbredir_params.get("chardev_id",
"chardev_%s" % usbredirdev_name)
chardev_params = Params({'backend': _backend, 'id': chardev_id})
if backend == 'spicevmc':
chardev_params['debug'] = usbredir_params.get('chardev_debug')
chardev_params['name'] = usbredir_params.get('chardev_name')
else:
chardev_params['host'] = usbredir_params['chardev_host']
chardev_params['port'] = free_port
chardev_params['server'] = usbredir_params.get(
'chardev_server')
chardev_params['wait'] = usbredir_params.get('chardev_wait')
chardev = qdevices.CharDevice(chardev_params, chardev_id)
usbredir_dev = qdevices.QDevice('usb-redir',
aobject=usbredirdev_name)
usbredir_filter = usbredir_params.get("usbdev_option_filter")
usbredir_bootindex = usbredir_params.get("usbdev_option_bootindex")
usbredir_bus = usbredir_params.get("usb_bus")
usbredir_dev.set_param('id', 'usb-%s' % usbredirdev_name)
usbredir_dev.set_param('chardev', chardev_id)
usbredir_dev.set_param('filter', usbredir_filter)
usbredir_dev.set_param('bootindex', usbredir_bootindex)
usbredir_dev.set_param('bus', usbredir_bus)
extra_params += ' '.join(
[chardev.cmdline(), usbredir_dev.cmdline()])
return extra_params
extra_params = _generate_usb_redir_cmdline()
params["extra_params"] = extra_params
if backend == 'spicevmc':
params["paused_after_start_vm"] = "yes"
del params["spice_password"]
del params["spice_addr"]
del params["spice_image_compression"]
del params["spice_zlib_glz_wan_compression"]
del params["spice_streaming_video"]
del params["spice_agent_mouse"]
del params["spice_playback_compression"]
del params["spice_ipv4"]
params["start_vm"] = "yes"
env_process.preprocess_vm(test, params, env, params["main_vm"])
def _start_spice_redirection():
def _rv_connection_check():
rv_pid = process.getoutput("pidof %s" % rv_binary)
spice_port = vm.get_spice_var('spice_port')
cmd = 'netstat -ptn | grep "^tcp.*127.0.0.1:%s.*ESTABLISHED %s.*"'
cmd = cmd % (spice_port, rv_pid)
s, o = process.getstatusoutput(cmd)
if s:
return False
logging.info("netstat output:\n%s", o)
return True
status = True
err_msg = ''
rv_binary_path = utils_misc.get_binary(rv_binary, params)
spice_port = vm.get_spice_var('spice_port')
rv_args = rv_binary_path + " spice://localhost:%s " % spice_port
rv_args += "--spice-usbredir-redirect-on-connect="
rv_args += "'-1,0x%s,0x%s,-1,1'" % (vendorid, productid)
rv_args += " > /dev/null 2>&1"
rv_thread = utils_misc.InterruptedThread(os.system, (rv_args, ))
rv_thread.start()
if not utils_misc.wait_for(_rv_connection_check, timeout, 60):
status = False
err_msg = "Fail to establish %s connection" % rv_binary
return (status, err_msg)
def boot_check(info):
"""
boot info check
"""
return re.search(info, vm.serial_console.get_stripped_output())
def _usb_dev_verify():
error_context.context("Check USB device in guest", logging.info)
if session.cmd_status(lsusb_cmd):
return False
return True
def _kill_rv_proc():
s, o = process.getstatusoutput("pidof %s" % rv_binary)
if not s:
process.getoutput("killall %s" % rv_binary)
def _get_usb_mount_point():
""" Get redirected USB stick mount point """
dmesg_cmd = "dmesg | grep 'Attached SCSI removable disk'"
s, o = session.cmd_status_output(dmesg_cmd)
if s:
test.error("Fail to get redirected USB stick in guest.")
dev = re.findall(r'\[(sd\w+)\]', o)[0]
mounts_cmd = "cat /proc/mounts | grep /dev/%s" % dev
s, o = session.cmd_status_output(mounts_cmd)
if s:
s, o = session.cmd_status_output('mount /dev/%s /mnt' % dev)
if s:
test.error("Fail to mount /dev/%s, output: %s" % (dev, o))
mp = "/mnt"
else:
mp = re.findall(r'/dev/%s\d*\s+(\S+)\s+' % dev, o)[0]
return mp
def _usb_stick_io(mount_point):
"""
Do I/O operations on passthrough USB stick
"""
error_context.context("Read and write on USB stick ", logging.info)
testfile = os.path.join(mount_point, 'testfile')
iozone_cmd = params.get("iozone_cmd",
" -a -I -r 64k -s 1m -i 0 -i 1 -f %s")
iozone_test.run(iozone_cmd % testfile)
usbredirdev_name = params["usbredirdev_name"]
usbredir_params = params.object_params(usbredirdev_name)
backend = usbredir_params.get('chardev_backend', 'spicevmc')
if backend not in ('spicevmc', 'tcp_socket'):
test.error("Unsupported char device backend type: %s" % backend)
if backend == 'spicevmc' and params.get('display') != 'spice':
test.cancel("Only support spice connection")
option = params.get("option")
vendorid = params["usbredir_vendorid"]
productid = params["usbredir_productid"]
timeout = params.get("wait_timeout", 600)
lsusb_cmd = "lsusb -v -d %s:%s" % (vendorid, productid)
usb_stick = "Mass Storage" in process.getoutput(lsusb_cmd)
rv_binary = params.get('rv_binary', 'remote-viewer')
error_context.context("Check host configurations", logging.info)
s, o = _host_config_check()
if not s:
test.error(o)
if backend == 'tcp_socket':
free_port = utils_misc.find_free_port()
_start_usbredir_server()
error_context.context("Preprocess VM", logging.info)
_usbredir_preprocess()
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
if backend == 'spicevmc':
error_context.context("Start USB redirection via spice", logging.info)
s, o = _start_spice_redirection()
if not s:
test.error(o)
vm.resume()
if option == "with_bootindex":
error_context.context("Check 'bootindex' option", logging.info)
boot_menu_hint = params["boot_menu_hint"]
boot_menu_key = params["boot_menu_key"]
if not utils_misc.wait_for(lambda: boot_check(boot_menu_hint), timeout,
1):
test.fail("Could not get boot menu message")
# Send boot menu key in monitor.
vm.send_key(boot_menu_key)
output = vm.serial_console.get_stripped_output()
boot_list = re.findall(r"^\d+\. (.*)\s", output, re.M)
if not boot_list:
test.fail("Could not get boot entries list")
logging.info("Got boot menu entries: '%s'", boot_list)
bootindex = int(params["usbdev_option_bootindex_%s" %
usbredirdev_name])
if "USB" not in boot_list[bootindex]:
test.fail("'bootindex' option of usb-redir doesn't take effect")
if usb_stick:
error_context.context("Boot from redirected USB stick",
logging.info)
boot_entry_info = params["boot_entry_info"]
vm.send_key(str(bootindex + 1))
if not utils_misc.wait_for(lambda: boot_check(boot_entry_info),
timeout, 1):
test.fail("Could not boot from redirected USB stick")
return
error_context.context("Login to guest", logging.info)
session = vm.wait_for_login()
if params.get("policy") == "deny":
if _usb_dev_verify():
error_msg = "Redirected USB device can be found in guest"
error_msg += " while policy is deny"
test.fail(error_msg)
if backend == 'spicevmc':
_kill_rv_proc()
return
if not _usb_dev_verify():
if backend == 'tcp_socket':
process.system("killall usbredirserver", ignore_status=True)
test.fail("Can not find the redirected USB device in guest")
if usb_stick:
iozone_test = None
try:
mount_point = _get_usb_mount_point()
iozone_test = generate_instance(params, vm, 'iozone')
_usb_stick_io(mount_point)
finally:
if iozone_test:
iozone_test.clean()
if backend == 'tcp_socket':
process.system("killall usbredirserver", ignore_status=True)
session.close()