def run(test, params, env): """ Build and install packages from git on the client or guest VM Supported configurations: build_install_pkg: name of the package to get from git, build and install :param test: QEMU test object. :param params: Dictionary with the test parameters. :param env: Dictionary with test environment. """ # Collect test parameters pkgName = params.get("build_install_pkg") script = params.get("script") vm_name = params.get("vm_name") dst_dir = params.get("dst_dir") # Path of the script on the VM vm_script_path = os.path.join(dst_dir, script) # Get root session for the VM (vm, vm_root_session) = connect_to_vm(vm_name, env, params) # location of the script on the host host_script_path = os.path.join(data_dir.get_deps_dir(), "spice", script) logging.info( "Transferring the script to %s," "destination directory: %s, source script location: %s", vm_name, vm_script_path, host_script_path, ) vm.copy_files_to(host_script_path, vm_script_path, timeout=60) time.sleep(5) # All packages require spice-protocol build_install_spiceprotocol(vm_root_session, vm_script_path, params) # Run build_install.py script if pkgName == "xf86-video-qxl": build_install_qxl(vm_root_session, vm_script_path, params) elif pkgName == "spice-vd-agent": build_install_vdagent(vm_root_session, vm_script_path, params) elif pkgName == "spice-gtk": build_install_spicegtk(vm_root_session, vm_script_path, params) elif pkgName == "virt-viewer": build_install_virtviewer(vm_root_session, vm_script_path, params) else: logging.info("Not supported right now") raise error.TestFail("Incorrect Test_Setup") utils_spice.clear_interface(vm)
def run(test, params, env): """ Build and install packages from git on the client or guest VM Supported configurations: build_install_pkg: name of the package to get from git, build and install :param test: QEMU test object. :param params: Dictionary with the test parameters. :param env: Dictionary with test environment. """ # Collect test parameters pkgName = params.get("build_install_pkg") script = params.get("script") vm_name = params.get("vm_name") dst_dir = params.get("dst_dir") # Path of the script on the VM vm_script_path = os.path.join(dst_dir, script) # Get root session for the VM (vm, vm_root_session) = connect_to_vm(vm_name, env, params) # location of the script on the host host_script_path = os.path.join(data_dir.get_deps_dir(), "spice", script) logging.info( "Transferring the script to %s," "destination directory: %s, source script location: %s", vm_name, vm_script_path, host_script_path) vm.copy_files_to(host_script_path, vm_script_path, timeout=60) time.sleep(5) # All packages require spice-protocol build_install_spiceprotocol(vm_root_session, vm_script_path, params) # Run build_install.py script if pkgName == "xf86-video-qxl": build_install_qxl(vm_root_session, vm_script_path, params) elif pkgName == "spice-vd-agent": build_install_vdagent(vm_root_session, vm_script_path, params) elif pkgName == "spice-gtk": build_install_spicegtk(vm_root_session, vm_script_path, params) elif pkgName == "virt-viewer": build_install_virtviewer(vm_root_session, vm_script_path, params) else: logging.info("Not supported right now") raise error.TestFail("Incorrect Test_Setup") utils_spice.clear_interface(vm)
def run(test, params, env): """ Simple test for Remote Desktop connection Tests expectes that Remote Desktop client (spice/vnc) will be executed from within a second guest so we won't be limited to Linux only clients The plan is to support remote-viewer at first place :param test: QEMU test object. :param params: Dictionary with the test parameters. :param env: Dictionary with test environment. """ guest_vm = env.get_vm(params["guest_vm"]) guest_vm.verify_alive() guest_session = guest_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) client_vm = env.get_vm(params["client_vm"]) client_vm.verify_alive() client_session = client_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) if (client_vm.params.get("os_type") == "windows" and client_vm.params.get("rv_installer", None)): utils_spice.install_rv_win(client_vm, params.get("rv_installer")) return if params.get("clear_interface", "yes") == "yes": for vm in params.get("vms").split(): try: session = env.get_vm(vm).wait_for_login(timeout=360) output = session.cmd('cat /etc/redhat-release') logging.info(output) except ShellCmdError: test.cancel("Test is only currently supported on " "RHEL and Fedora operating systems") if "release 6." in output: waittime = 15 else: waittime = 60 utils_spice.clear_interface( env.get_vm(vm), int(params.get("login_timeout", "360"))) utils_spice.wait_timeout(waittime) launch_rv(test, client_vm, guest_vm, params) client_session.close() guest_session.close()
def run(test, params, env): """ Simple test for Remote Desktop connection Tests expectes that Remote Desktop client (spice/vnc) will be executed from within a second guest so we won't be limited to Linux only clients The plan is to support remote-viewer at first place :param test: QEMU test object. :param params: Dictionary with the test parameters. :param env: Dictionary with test environment. """ guest_vm = env.get_vm(params["guest_vm"]) guest_vm.verify_alive() guest_session = guest_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) client_vm = env.get_vm(params["client_vm"]) client_vm.verify_alive() client_session = client_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) if (client_vm.params.get("os_type") == "windows" and client_vm.params.get("rv_installer", None)): utils_spice.install_rv_win(client_vm, params.get("rv_installer")) return if params.get("clear_interface", "yes") == "yes": for vm in params.get("vms").split(): try: session = env.get_vm(vm).wait_for_login(timeout=360) output = session.cmd('cat /etc/redhat-release') logging.info(output) except ShellCmdError: raise error.TestNAError("Test is only currently supported on " "RHEL and Fedora operating systems") if "release 6." in output: waittime = 15 else: waittime = 60 utils_spice.clear_interface(env.get_vm(vm), int(params.get("login_timeout", "360"))) utils_spice.wait_timeout(waittime) launch_rv(client_vm, guest_vm, params) client_session.close() guest_session.close()
def run(test, params, env): """ Simple test for Remote Desktop connection Tests expectes that Remote Desktop client (spice/vnc) will be executed from within a second guest so we won't be limited to Linux only clients The plan is to support remote-viewer at first place :param test: QEMU test object. :param params: Dictionary with the test parameters. :param env: Dictionary with test environment. """ guest_vm = env.get_vm(params["guest_vm"]) guest_vm.verify_alive() guest_session = guest_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) client_vm = env.get_vm(params["client_vm"]) client_vm.verify_alive() client_session = client_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) if (client_vm.params.get("os_type") == "windows" and client_vm.params.get("rv_installer", None)): utils_spice.install_rv_win(client_vm, params.get("rv_installer")) return if params.get("clear_interface", "yes") == "yes": for vm in params.get("vms").split(): utils_spice.clear_interface( env.get_vm(vm), int(params.get("login_timeout", "360"))) utils_spice.wait_timeout(15) launch_rv(client_vm, guest_vm, params) client_session.close() guest_session.close()
def run_rv_connect(test, params, env): """ Simple test for Remote Desktop connection Tests expectes that Remote Desktop client (spice/vnc) will be executed from within a second guest so we won't be limited to Linux only clients The plan is to support remote-viewer at first place :param test: QEMU test object. :param params: Dictionary with the test parameters. :param env: Dictionary with test environment. """ guest_vm = env.get_vm(params["guest_vm"]) guest_vm.verify_alive() guest_session = guest_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) client_vm = env.get_vm(params["client_vm"]) client_vm.verify_alive() client_session = client_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) if (client_vm.params.get("os_type") == "windows" and client_vm.params.get("rv_installer", None)): utils_spice.install_rv_win(client_vm, params.get("rv_installer")) return if params.get("clear_interface", "yes") == "yes": for vm in params.get("vms").split(): utils_spice.clear_interface(env.get_vm(vm), int(params.get("login_timeout", "360"))) utils_spice.wait_timeout(15) launch_rv(client_vm, guest_vm, params) client_session.close() guest_session.close()
def run(test, params, env): """ Simple setup test to create certs on the client to be passed to VM's smartcard. :param test: QEMU test object. :param params: Dictionary with the test parameters. :param env: Dictionary with test environment. """ # Get necessary params cert_list = params.get("gencerts").split(",") cert_db = params.get("certdb") self_sign = params.get("self_sign") cert_trustargs = params.get("trustargs") logging.debug("Cert List:") for cert in cert_list: logging.debug(cert) logging.debug(cert_trustargs) logging.debug("CN=%s", cert) logging.debug(cert_db) client_vm = env.get_vm(params["client_vm"]) client_vm.verify_alive() client_session = client_vm.wait_for_login(timeout=int( params.get("login_timeout", 360)), username="******", password="******") for vm in params.get("vms").split(): utils_spice.clear_interface(env.get_vm(vm), int(params.get("login_timeout", "360"))) # generate a random string, used to create a random key for the certs randomstring = utils_misc.generate_random_string(2048) cmd = "echo '" + randomstring + "' > /tmp/randomtext.txt" output = client_session.cmd(cmd) #output2 = client_session.cmd("cat /tmp/randomtext.txt") utils_spice.wait_timeout(5) # for each cert listed by the test, create it on the client for cert in cert_list: cmd = "certutil " if self_sign: cmd += " -x " cmd += "-t '" + cert_trustargs + "' -S -s " + "'CN=" + cert cmd += "' -n '" + cert + "' -d " + cert_db cmd += " -z " + "/tmp/randomtext.txt" logging.debug(cmd) output = client_session.cmd(cmd) logging.debug("Cert Created: %s", output) cmd = "certutil -L -d " + cert_db output = client_session.cmd(cmd) logging.info("Listing all certs on the client: %s", output) # Verify that all the certs have been generated on the client for cert in cert_list: if not (cert in output): test.fail("Certificate %s not found" % cert) client_session.close()
def run(test, params, env): """ Simple test for Remote Desktop connection Tests expectes that Remote Desktop client (spice/vnc) will be executed from within a second guest so we won't be limited to Linux only clients The plan is to support remote-viewer at first place :param test: QEMU test object. :param params: Dictionary with the test parameters. :param env: Dictionary with test environment. """ # Get necessary params test_timeout = float(params.get("test_timeout", 600)) utils_spice.wait_timeout(20) for vm in params.get("vms").split(): utils_spice.clear_interface(env.get_vm(vm), int(params.get("login_timeout", "360"))) utils_spice.wait_timeout(20) guest_vm = env.get_vm(params["guest_vm"]) guest_vm.verify_alive() guest_session = guest_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) guest_root_session = guest_vm.wait_for_login(username="******", password="******") logging.debug("Exporting guest display") guest_session.cmd("export DISPLAY=:0.0") # Get the min, current, and max resolution on the guest output = guest_session.cmd("xrandr | grep Screen") outputlist = output.split() minimum = "640x480" current_index = outputlist.index("current") current = outputlist[current_index + 1] current += outputlist[current_index + 2] # Remove trailing comma current += outputlist[current_index + 3].replace(",", "") maximum = "2560x1600" logging.info("Minimum: " + minimum + " Current: " + current + " Maximum: " + maximum) if(current != minimum): resolution = minimum else: resolution = maximum # Changing the guest resolution guest_session.cmd("xrandr -s " + resolution) logging.info("The resolution on the guest has been changed from " + current + " to: " + resolution) # Start vdagent daemon utils_spice.start_vdagent(guest_root_session, test_timeout) client_vm = env.get_vm(params["client_vm"]) client_vm.verify_alive() client_session = client_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) client_session.close() guest_session.close()
def run(test, params, env): """ Simple setup test to create certs on the client to be passed to VM's smartcard. :param test: QEMU test object. :param params: Dictionary with the test parameters. :param env: Dictionary with test environment. """ # Get necessary params cert_list = params.get("gencerts").split(",") cert_db = params.get("certdb") self_sign = params.get("self_sign") cert_trustargs = params.get("trustargs") logging.debug("Cert List:") for cert in cert_list: logging.debug(cert) logging.debug(cert_trustargs) logging.debug("CN=" + cert) logging.debug(cert_db) client_vm = env.get_vm(params["client_vm"]) client_vm.verify_alive() client_session = client_vm.wait_for_login( timeout=int(params.get("login_timeout", 360)), username="******", password="******") for vm in params.get("vms").split(): utils_spice.clear_interface(env.get_vm(vm), int(params.get("login_timeout", "360"))) # generate a random string, used to create a random key for the certs randomstring = utils_misc.generate_random_string(2048) cmd = "echo '" + randomstring + "' > /tmp/randomtext.txt" output = client_session.cmd(cmd) #output2 = client_session.cmd("cat /tmp/randomtext.txt") utils_spice.wait_timeout(5) # for each cert listed by the test, create it on the client for cert in cert_list: cmd = "certutil " if self_sign: cmd += " -x " cmd += "-t '" + cert_trustargs + "' -S -s " + "'CN=" + cert cmd += "' -n '" + cert + "' -d " + cert_db cmd += " -z " + "/tmp/randomtext.txt" logging.debug(cmd) output = client_session.cmd(cmd) logging.debug("Cert Created: " + output) cmd = "certutil -L -d " + cert_db output = client_session.cmd(cmd) logging.info("Listing all certs on the client: " + output) # Verify that all the certs have been generated on the client for cert in cert_list: if not(cert in output): raise error.TestFail("Certificate %s not found" % cert) client_session.close()