def test_leds_and_esc_keys(client_vm, guest_session, params): """ Test LEDS and Escaped keys. Function sends various keys through qemu monitor to client VM. @param client_vm - vm object @param guest_session - ssh session to guest VM @param params """ # Run wxPython form catching KeyEvents on guest run_test_form(guest_session, params) utils_spice.wait_timeout(3) # Prepare lists with the keys to be sent to client machine leds = ["a", "caps_lock", "a", "caps_lock", "num_lock", "kp_1", "num_lock", "kp_1"] shortcuts = ["a", "shift-a", "shift_r-a", "ctrl-a", "ctrl-c", "ctrl-v", "alt-x"] escaped = ["insert", "delete", "home", "end", "pgup", "pgdn", "up", "down", "right", "left"] test_keys = leds + shortcuts + escaped # Send keys to client machine logging.info("Sending leds and escaped keys to client machine") for key in test_keys: client_vm.send_key(key) utils_spice.wait_timeout(0.3)
def test_leds_and_esc_keys(client_vm, guest_session, params): """ Test LEDS and Escaped keys. Function sends various keys through qemu monitor to client VM. @param client_vm - vm object @param guest_session - ssh session to guest VM @param params """ #Run wxPython form catching KeyEvents on guest run_test_form(guest_session, params) utils_spice.wait_timeout(3) #Prepare lists with the keys to be sent to client machine leds = ['a', 'caps_lock', 'a', 'caps_lock', 'num_lock', 'kp_1', 'num_lock', 'kp_1'] shortcuts = ['a', 'shift-a', 'shift_r-a', 'ctrl-a', 'ctrl-c', 'ctrl-v', 'alt-x'] escaped = ['insert', 'delete', 'home', 'end', 'pgup', 'pgdn', 'up', 'down', 'right', 'left'] test_keys = leds + shortcuts + escaped #Send keys to client machine logging.info("Sending leds and escaped keys to client machine") for key in test_keys: client_vm.send_key(key) utils_spice.wait_timeout(0.3)
def test_leds_migration(client_vm, guest_vm, guest_session, params): """ Check LEDS after migration. Function sets LEDS (caps, num) to ON and send scancodes of "a" and "1 (num)" and expected to get keycodes of "A" and "1" after migration. @param client_vm - vm object @param guest_vm - vm object @param guest_session - ssh session to guest VM @param params """ #Run wxPython form catching KeyEvents on guest run_test_form(guest_session, params) utils_spice.wait_timeout(3) #Tested keys before migration test_keys = ['a', 'kp_1', 'caps_lock', 'num_lock', 'a', 'kp_1'] logging.info("Sending leds keys to client machine before migration") for key in test_keys: client_vm.send_key(key) utils_spice.wait_timeout(0.3) guest_vm.migrate() utils_spice.wait_timeout(5) #Tested keys after migration test_keys = ['a', 'kp_1'] logging.info("Sending leds keys to client machine after migration") for key in test_keys: client_vm.send_key(key) utils_spice.wait_timeout(0.3) utils_spice.wait_timeout(30)
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))) utils_spice.wait_timeout(15) launch_rv(client_vm, guest_vm, params) client_session.close() guest_session.close()
def run_smartcard_setup(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="******") #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()
def run_fullscreen_setup(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)) 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))) utils_spice.wait_timeout(10) 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_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 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 test_leds_migration(client_vm, guest_vm, guest_session, params): """ Check LEDS after migration. Function sets LEDS (caps, num) to ON and send scancodes of "a" and "1 (num)" and expected to get keycodes of "A" and "1" after migration. :param client_vm - vm object :param guest_vm - vm object :param guest_session - ssh session to guest VM :param params """ # Turn numlock on RHEL6 on before the test begins: grep_ver_cmd = "grep -o 'release [[:digit:]]' /etc/redhat-release" rhel_ver = guest_session.cmd(grep_ver_cmd).strip() logging.info("RHEL version: #{0}#".format(rhel_ver)) if rhel_ver == "release 6": client_vm.send_key('num_lock') #Run PyGTK form catching KeyEvents on guest run_test_form(guest_session, params) utils_spice.wait_timeout(3) # Tested keys before migration test_keys = ['a', 'kp_1', 'caps_lock', 'num_lock', 'a', 'kp_1'] logging.info("Sending leds keys to client machine before migration") for key in test_keys: client_vm.send_key(key) utils_spice.wait_timeout(0.3) guest_vm.migrate() utils_spice.wait_timeout(8) #Tested keys after migration test_keys = ['a', 'kp_1', 'caps_lock', 'num_lock'] logging.info("Sending leds keys to client machine after migration") for key in test_keys: client_vm.send_key(key) utils_spice.wait_timeout(0.3) utils_spice.wait_timeout(30)
def test_type_and_func_keys(client_vm, guest_session, params): """ Test typewriter and functional keys. Function sends various keys through qemu monitor to client VM. @param client_vm - vm object @param guest_session - ssh session to guest VM @param params """ run_test_form(guest_session, params) utils_spice.wait_timeout(3) # Send typewriter and functional keys to client machine based on scancodes logging.info("Sending typewriter and functional keys to client machine") for i in range(1, 69): # Avoid Ctrl, RSH, LSH, PtScr, Alt, CpsLk if not (i in [29, 42, 54, 55, 56, 58]): client_vm.send_key(str(hex(i))) utils_spice.wait_timeout(0.3)
def test_type_and_func_keys(client_vm, guest_session, params): """ Test typewriter and functional keys. Function sends various keys through qemu monitor to client VM. :param client_vm - vm object :param guest_session - ssh session to guest VM :param params """ run_test_form(guest_session, params) utils_spice.wait_timeout(3) # Send typewriter and functional keys to client machine based on scancodes logging.info("Sending typewriter and functional keys to client machine") for i in range(1, 69): # Avoid Ctrl, RSH, LSH, PtScr, Alt, CpsLk if not (i in [29, 42, 54, 55, 56, 58]): client_vm.send_key(str(hex(i))) utils_spice.wait_timeout(0.3)
def test_nonus_layout(client_vm, guest_session, params): """ Test some keys of non-us keyboard layouts (de, cz). Function sends various keys through qemu monitor to client VM. @param client_vm - vm object @param guest_session - ssh session to guest VM @param params """ # Run wxPython form catching KeyEvents on guest run_test_form(guest_session, params) utils_spice.wait_timeout(3) # Czech layout - test some special keys cmd = "setxkbmap cz" guest_session.cmd(cmd) test_keys = ["7", "8", "9", "0", "alt_r-x", "alt_r-c", "alt_r-v"] logging.info("Sending czech keys to client machine") for key in test_keys: client_vm.send_key(key) utils_spice.wait_timeout(0.3) # German layout - test some special keys cmd = "setxkbmap de" guest_session.cmd(cmd) test_keys = ["minus", "0x1a", "alt_r-q", "alt_r-m"] logging.info("Sending german keys to client machine") for key in test_keys: client_vm.send_key(key) utils_spice.wait_timeout(0.3) cmd = "setxkbmap us" guest_session.cmd(cmd)
def test_nonus_layout(client_vm, guest_session, params): """ Test some keys of non-us keyboard layouts (de, cz). Function sends various keys through qemu monitor to client VM. :param client_vm - vm object :param guest_session - ssh session to guest VM :param params """ #Run PyGTK form catching KeyEvents on guest run_test_form(guest_session, params) utils_spice.wait_timeout(3) # Czech layout - test some special keys cmd = "setxkbmap cz" guest_session.cmd(cmd) test_keys = ['7', '8', '9', '0', 'alt_r-x', 'alt_r-c', 'alt_r-v'] logging.info("Sending czech keys to client machine") for key in test_keys: client_vm.send_key(key) utils_spice.wait_timeout(0.3) # German layout - test some special keys cmd = "setxkbmap de" guest_session.cmd(cmd) test_keys = ['minus', '0x1a', 'alt_r-q', 'alt_r-m'] logging.info("Sending german keys to client machine") for key in test_keys: client_vm.send_key(key) utils_spice.wait_timeout(0.3) cmd = "setxkbmap us" guest_session.cmd(cmd)
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 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()
# It's not that important to have printed versions in the log. logging.debug("Ignoring a Status Exception that occurs from calling " "print versions of remote-viewer or spice-gtk") logging.info("Launching %s on the client (virtual)", cmd) try: client_session.cmd(cmd) except ShellStatusError: logging.debug("Ignoring a status exception, will check connection of" "remote-viewer later") # client waits for user entry (authentication) if spice_password is set # use qemu monitor password if set, else check if the normal password is set if qemu_ticket: # Wait for remote-viewer to launch utils_spice.wait_timeout(5) send_ticket(client_vm, qemu_ticket) elif ticket: if ticket_send: ticket = ticket_send utils_spice.wait_timeout(5) # Wait for remote-viewer to launch send_ticket(client_vm, ticket) utils_spice.wait_timeout(5) # Wait for conncetion to establish try: utils_spice.verify_established(client_vm, host_ip, host_port, rv_binary) except utils_spice.RVConnectError: if test_type == "negative": logging.info("remote-viewer connection failed as expected") else: raise error.TestFail("remote-viewer connection failed")
def run_rv_gui(test, params, env): """ Tests GUI automation of remote-viewer @param test: QEMU test object. @param params: Dictionary with the test parameters. @param env: Dictionary with test environment. """ #Get required paramters host_ip = utils_net.get_host_ip_address(params) screenshot_dir = params.get("screenshot_dir") #screenshot_name = params.get("screenshot_name") screenshot_exp_name = params.get("screenshot_expected_name") expected_rv_corners_fs = "Corners: +0+0 -0+0 -0-0 +0-0" screenshot_exp_file = "" host_port = None guest_res = "" guest_res2 = "" rv_res = "" rv_res2 = "" rv_binary = params.get("rv_binary", "remote-viewer") changex = params.get("changex") changey = params.get("changey") accept_pct = params.get("accept_pct") tests = params.get("rv_gui_test_list").split() rv_version = params.get("rv_version") rv_version_el7 = params.get("rv_version_el7") ticket = params.get("spice_password", None) errors = 0 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( timeout=int(params.get("login_timeout", 360)), username="******", password="******") #update host_port host_port = guest_vm.get_spice_var("spice_port") 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))) output = client_session.cmd('cat /etc/redhat-release') isRHEL7 = "release 7." in output client_session.cmd("export DISPLAY=:0") guest_session.cmd("export DISPLAY=:0") #if isRHEL7: # pass # client_session.cmd('mkdir /home/test/.dbus/session-bus/ # client_session.cmd('. /home/test/.dbus/session-bus/`cat ' + \ # '/etc/machine-id`-0') #else: client_session.cmd('. /home/test/.dbus/session-bus/`cat ' + \ '/var/lib/dbus/machine-id`-0') client_session.cmd('export DBUS_SESSION_BUS_ADDRESS ' + \ 'DBUS_SESSION_BUS_PID DBUS_SESSION_BUS_WINDOWID') client_session.cmd("cd %s" % params.get("test_script_tgt")) rv_res_orig = getrvgeometry(client_session, host_port, host_ip) logging.info("Executing gui tests: " + str(tests)) #Make sure Accessibility is enabled before running the GUI tests if isRHEL7: logging.info("Enabling accessibility") client_session.cmd("export DISPLAY=:0.0") client_session.cmd("gsettings set org.gnome.desktop.interface" " toolkit-accessibility true") #Go through all tests to be run for i in tests: logging.info("Test: " + i) #Verification that needs to be done prior to running the gui test. if "zoom" in i or "autoresize" in i: #Get preliminary information needed for the zoom tests guest_res = getres(guest_session) rv_res = getrvgeometry(client_session, host_port, host_ip) # if i in ("screenshot"): if "screenshot" in i: screenshot_exp_file = os.path.join(screenshot_dir, \ screenshot_exp_name) try: client_session.cmd('[ -e ' + screenshot_exp_file +' ]') client_session.cmd('rm ' + screenshot_exp_file) logging.info("Deleted: " + screenshot_exp_file) except ShellCmdError: logging.info(screenshot_exp_name + " doesn't exist, continue") cmd = "./unittests/%s_rv.py" % i #Verification of the printscreen test prior to the test being run if "printscreen" in i: output = client_session.cmd('cat /etc/redhat-release') if "release 7." in output: output = guest_session.cmd('rm -vf /home/test/Pictures/Screen*') logging.info("Screenshots removed: " + output) #Adding parameters to the test if (i == "connect"): cmd += " 'spice://%s:%s'" % (host_ip, host_port) if ticket: cmd += " %s > /dev/null 2>&1" % ticket #Run the test client_session_dt = client_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) client_session_dt.cmd("export DISPLAY=:0.0") client_session_dt.cmd('. /home/test/.dbus/session-bus/`cat ' + \ '/var/lib/dbus/machine-id`-0') client_session_dt.cmd('export DBUS_SESSION_BUS_ADDRESS ' + \ 'DBUS_SESSION_BUS_PID DBUS_SESSION_BUS_WINDOWID') print "Running test: " + cmd try: logging.info(client_session_dt.cmd(cmd)) except: logging.error("Status: FAIL") errors += 1 else: logging.info("Status: PASS") client_session_dt.close() #Wait before doing any verification utils_spice.wait_timeout(5) #Verification Needed after the gui test was run if "zoom" in i: guest_res2 = getres(guest_session) rv_res2 = getrvgeometry(client_session, host_port, host_ip) #Check to see that the resolution doesn't change logstr = "Checking that the guest's resolution doesn't change" checkresequal(guest_res, guest_res2, logstr) if "zoomin" in i: #verify the rv window has increased errorstr = "Checking the rv window's size has increased" logging.info(errorstr) checkgeometryincrease(rv_res, rv_res2, errorstr) if "zoomout" in i: #verify the rv window has decreased errorstr = "Checking the rv window's size has decreased" logging.info(errorstr) checkgeometryincrease(rv_res2, rv_res, errorstr) if "zoomnorm" in i: errorstr = "Checking the rv window's size is the same as " + \ "it was originally when rv was started." checkresequal(rv_res2, rv_res_orig, errorstr) if "quit" in i or "close" in i: #Verify for quit tests that remote viewer is not running on client try: rvpid = str(client_session.cmd("pgrep remote-viewer")) raise error.TestFail("Remote-viewer is still running: " + rvpid) except ShellCmdError: logging.info("Remote-viewer process is no longer running.") if "screenshot" in i: #Verify the screenshot was created and clean up try: client_session.cmd('[ -e ' + screenshot_exp_file + ' ]') client_session.cmd('rm ' + screenshot_exp_file) print screenshot_exp_name + " was created as expected" except ShellCmdError: raise error.TestFail("Screenshot " + screenshot_exp_file + \ " was not created") if i == "fullscreen" or i == "fullscreen_shortcut": #Verify that client's res = guests's res guest_res = getres(guest_session) client_res = getres(client_session) rv_geometry = getrvgeometry(client_session, host_port, host_ip) rv_corners = getrvcorners(client_session, host_port, host_ip) if(client_res == guest_res): logging.info("PASS: Guest resolution is the same as the client") #Verification #2, client's res = rv's geometry if(client_res == rv_geometry): logging.info("PASS client's res = geometry of rv window") else: raise error.TestFail("Client resolution: " + client_res + \ " differs from the rv's geometry: " + rv_geometry) else: raise error.TestFail("Guest resolution: " + guest_res + \ "differs from the client: " + client_res) #Verification #3, verify the rv window is at the top corner if(rv_corners in expected_rv_corners_fs): logging.info("PASS: rv window is at the top corner: " + \ rv_corners) else: raise error.TestFail("rv window is not at the top corner " + \ "as expected, it is at: " + rv_corners) #Verify rv window < client's res if i == "leave_fullscreen" or i == "leave_fullscreen_shortcut": rv_corners = getrvcorners(client_session, host_port, host_ip) if(rv_corners not in expected_rv_corners_fs): logging.info("PASS: rv window is not at top corner: " + \ rv_corners) else: raise error.TestFail("rv window, leaving full screen failed.") if "printscreen" in i: output = client_session.cmd('cat /etc/redhat-release') if "release 7." in output: output = guest_session.cmd('ls -al /home/test/Pictures | grep Screen*') logging.info("Screenshot Taken Found: " + output) else: output = guest_root_session.cmd("ps aux | grep gnome-screenshot") index = 1 found = 0 plist = output.splitlines() for line in plist: print str(index) + " " + line index += 1 list2 = line.split() #get gnome-screenshot info gss_pid = str(list2[1]) gss_process_name = str(list2[10]) #Verify gnome-screenshot is running and kill it if gss_process_name == "gnome-screenshot": found = 1 guest_root_session.cmd("kill " + gss_pid) break else: continue if not (found): raise error.TestFail("gnome-screenshot is not running.") #Verify the shutdown dialog is present if "ctrl_alt_del" in i: #looking for a blank named dialog will not work for RHEL 7 #Will need to find a better solution to verify #the shutdown dialog has come up if isRHEL7: #wait 80 seconds for the VM to completely shutdown utils_spice.wait_timeout(90) try: guest_vm.verify_alive() raise error.TestFail("Guest VM is still alive, shutdown failed.") except VMDeadError: logging.info("Guest VM is verified to be shutdown") else: guest_session.cmd("xwininfo -name ''") #If autoresize_on is run, change window geometry if i == "autoresize_on" or i == "autoresize_off": logging.info("Attempting to change the window size of rv to:" + \ str(changex) + "x" + str(changey)) #wmctrl_cmd = "wmctrl -r 'spice://%s?port=%s (1) - Remote Viewer'" \ # % (host_ip, host_port) wmctrl_cmd = "wmctrl -r %s" % window_title wmctrl_cmd += " -e 0,0,0," + str(changex) + "," + str(changey) output = client_session.cmd(wmctrl_cmd) logging.info("Original res: " + guest_res) logging.info("Original geometry: " + rv_res) #Wait for the rv window to change and guest to adjust resolution utils_spice.wait_timeout(2) guest_res2 = getres(guest_session) rv_res2 = getrvgeometry(client_session, host_port, host_ip) logging.info("After test res: " + guest_res2) logging.info("After test geometry: " + rv_res2) #Get the required information width2 = int(guest_res2.split('x')[0]) rvwidth2 = int(rv_res2.split('x')[0]) #The second split of - is a workaround because the xwinfo sometimes #prints out dashes after the resolution for some reason. height2 = int(guest_res2.split('x')[1].split('-')[0]) rvheight2 = int(rv_res2.split('x')[1].split('-')[0]) #the width and height that was specified is changed w/alotted limit percentchange(accept_pct, changey, rvheight2, "Height parameter:") percentchange(accept_pct, changex, rvwidth2, "Width parameter:") if i == "autoresize_on": #resolution is changed, attempted to match the window logging.info("Checking resolution is changed, attempted" + \ " to match the window, when autoresize is on") percentchange(accept_pct, rvheight2, height2, "Height param:") percentchange(accept_pct, rvwidth2, width2, "Width param:") if i == "autoresize_off": #resolutions did not change logging.info("Checking the resolution does not change" + \ ", when autoresize is off") logstr = "Checking that the guest's resolution doesn't change" checkresequal(guest_res, guest_res2, logstr) #Verify a connection is established if i == "connect": try: utils_spice.verify_established(client_vm, host_ip, \ host_port, rv_binary) except utils_spice.RVConnectError: raise error.TestFail("remote-viewer connection failed") if errors: raise error.TestFail("%d GUI tests failed, see log for more details" \ % errors)
def launch_rv(test, client_vm, guest_vm, params): """ Launches rv_binary with args based on spice configuration inside client_session on background. remote-viewer will try to connect from vm1 from vm2 :param client_vm - vm object :param guest_vm - vm object :param params """ rv_binary = params.get("rv_binary", "remote-viewer") rv_ld_library_path = params.get("rv_ld_library_path") display = params.get("display") proxy = params.get("spice_proxy", None) if proxy: try: socket.inet_aton(params.get("proxy_ip", None)) except socket.error: test.cancel('Parameter proxy_ip not changed from default values') host_ip = utils_net.get_host_ip_address(params) host_port = None if guest_vm.get_spice_var("listening_addr") == "ipv6": host_ip = ("[" + utils_misc.convert_ipv4_to_ipv6(host_ip) + "]") host_tls_port = None disable_audio = params.get("disable_audio", "no") full_screen = params.get("full_screen") check_spice_info = params.get("spice_info") ssltype = params.get("ssltype") test_type = params.get("test_type") # cmd var keeps final remote-viewer command line # to be executed on client cmd = rv_binary if client_vm.params.get("os_type") != "windows": cmd = cmd + " --display=:0.0" # If qemu_ticket is set, set the password # of the VM using the qemu-monitor ticket = None ticket_send = params.get("spice_password_send") qemu_ticket = params.get("qemu_password") if qemu_ticket: guest_vm.monitor.cmd("set_password spice %s" % qemu_ticket) logging.info("Sending to qemu monitor: set_password spice %s", qemu_ticket) gencerts = params.get("gencerts") certdb = params.get("certdb") smartcard = params.get("smartcard") host_subj = None cacert = None rv_parameters_from = params.get("rv_parameters_from", "cmd") if rv_parameters_from == 'file': cmd += " ~/rv_file.vv" client_session = client_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) if display == "spice": ticket = guest_vm.get_spice_var("spice_password") if guest_vm.get_spice_var("spice_ssl") == "yes": # client needs cacert file cacert = "%s/%s" % ( guest_vm.get_spice_var("spice_x509_prefix"), guest_vm.get_spice_var("spice_x509_cacert_file")) client_session.cmd("rm -rf %s && mkdir -p %s" % (guest_vm.get_spice_var("spice_x509_prefix"), guest_vm.get_spice_var("spice_x509_prefix"))) remote.copy_files_to(client_vm.get_address(), 'scp', params.get("username"), params.get("password"), params.get("shell_port"), cacert, cacert) host_tls_port = guest_vm.get_spice_var("spice_tls_port") host_port = guest_vm.get_spice_var("spice_port") # cacert subj is in format for create certificate(with '/' delimiter) # remote-viewer needs ',' delimiter. And also is needed to remove # first character (it's '/') host_subj = guest_vm.get_spice_var("spice_x509_server_subj") host_subj = host_subj.replace('/', ',')[1:] if ssltype == "invalid_explicit_hs": host_subj = "Invalid Explicit HS" else: host_subj += host_ip # If it's invalid implicit, a remote-viewer connection # will be attempted with the hostname, since ssl certs were # generated with the ip address hostname = socket.gethostname() if ssltype == "invalid_implicit_hs": spice_url = r" spice://%s?tls-port=%s\&port=%s" % ( hostname, host_tls_port, host_port) else: spice_url = r" spice://%s?tls-port=%s\&port=%s" % ( host_ip, host_tls_port, host_port) if rv_parameters_from == "menu": line = spice_url elif rv_parameters_from == "file": pass else: cmd += spice_url if not rv_parameters_from == "file": cmd += " --spice-ca-file=%s" % cacert if (params.get("spice_client_host_subject") == "yes" and not rv_parameters_from == "file"): cmd += " --spice-host-subject=\"%s\"" % host_subj else: host_port = guest_vm.get_spice_var("spice_port") if rv_parameters_from == "menu": # line to be sent through monitor once r-v is started # without spice url line = "spice://%s?port=%s" % (host_ip, host_port) elif rv_parameters_from == "file": pass else: cmd += " spice://%s?port=%s" % (host_ip, host_port) elif display == "vnc": raise NotImplementedError("remote-viewer vnc") else: raise Exception("Unsupported display value") # Check to see if the test is using the full screen option. if full_screen == "yes" and not rv_parameters_from == "file": logging.info("Remote Viewer Set to use Full Screen") cmd += " --full-screen" if disable_audio == "yes": logging.info("Remote Viewer Set to disable audio") cmd += " --spice-disable-audio" # Check to see if the test is using a smartcard. if smartcard == "yes": logging.info("remote viewer Set to use a smartcard") if not rv_parameters_from == "file": cmd += " --spice-smartcard" if certdb is not None: logging.debug( "Remote Viewer set to use the following certificate" " database: %s", certdb) cmd += " --spice-smartcard-db " + certdb if gencerts is not None: logging.debug("Remote Viewer set to use the following certs: %s", gencerts) cmd += " --spice-smartcard-certificates " + gencerts if client_vm.params.get("os_type") == "linux": cmd = "nohup " + cmd + " &> /dev/null &" # Launch it on background if rv_ld_library_path: cmd = "export LD_LIBRARY_PATH=" + rv_ld_library_path + ";" + cmd if rv_parameters_from == "file": logging.info("Generating file") utils_spice.gen_rv_file(params, guest_vm, host_subj, cacert) logging.info("Uploading file to client") client_vm.copy_files_to("rv_file.vv", "~/rv_file.vv") # Launching the actual set of commands try: if rv_ld_library_path: print_rv_version(client_session, "LD_LIBRARY_PATH=/usr/local/lib " + rv_binary) else: print_rv_version(client_session, rv_binary) except (ShellStatusError, ShellProcessTerminatedError): # Sometimes It fails with Status error, ingore it and continue. # It's not that important to have printed versions in the log. logging.debug("Ignoring a Status Exception that occurs from calling " "print versions of remote-viewer or spice-gtk") logging.info("Launching %s on the client (virtual)", cmd) if proxy: if "http" in proxy: split = proxy.split('//')[1].split(':') else: split = proxy.split(':') host_ip = split[0] if len(split) > 1: host_port = split[1] else: host_port = "3128" if rv_parameters_from != "file": client_session.cmd("export SPICE_PROXY=%s" % proxy) if not params.get("rv_verify") == "only": try: client_session.cmd(cmd) except ShellStatusError: logging.debug("Ignoring a status exception, will check connection" "of remote-viewer later") # Send command line through monitor since url was not provided if rv_parameters_from == "menu": utils_spice.wait_timeout(1) str_input(client_vm, line) # client waits for user entry (authentication) if spice_password is set # use qemu monitor password if set, else, if set, try normal password. if qemu_ticket: # Wait for remote-viewer to launch utils_spice.wait_timeout(5) str_input(client_vm, qemu_ticket) elif ticket: if ticket_send: ticket = ticket_send utils_spice.wait_timeout(5) # Wait for remote-viewer to launch str_input(client_vm, ticket) utils_spice.wait_timeout(15) # Wait for conncetion to establish is_rv_connected = True try: utils_spice.verify_established( client_vm, host_ip, host_port, rv_binary, host_tls_port, params.get("spice_secure_channels", None)) except utils_spice.RVConnectError: if test_type == "negative": logging.info("remote-viewer connection failed as expected") if ssltype in ("invalid_implicit_hs", "invalid_explicit_hs"): # Check the qemu process output to verify what is expected qemulog = guest_vm.process.get_output() if "SSL_accept failed" in qemulog: return else: test.fail("SSL_accept failed not shown in qemu" "process as expected.") is_rv_connected = False else: test.fail("remote-viewer connection failed") if test_type == "negative" and is_rv_connected: test.fail("remote-viewer connection was established when" " it was supposed to be unsuccessful") # Get spice info output = guest_vm.monitor.cmd("info spice") logging.debug("INFO SPICE") logging.debug(output) # Check to see if ipv6 address is reported back from qemu monitor if (check_spice_info == "ipv6"): logging.info("Test to check if ipv6 address is reported" " back from the qemu monitor") # Remove brackets from ipv6 host ip if (host_ip[1:len(host_ip) - 1] in output): logging.info("Reported ipv6 address found in output from" " 'info spice'") else: test.fail("ipv6 address not found from qemu monitor" " command: 'info spice'") else: logging.info("Not checking the value of 'info spice'" " from the qemu monitor") # prevent from kill remote-viewer after test finish if client_vm.params.get("os_type") == "linux": cmd = "disown -ar" client_session.cmd_output(cmd)
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()
except ShellStatusError, ShellProcessTerminatedError: # Sometimes It fails with Status error, ingore it and continue. # It's not that important to have printed versions in the log. logging.debug("Ignoring a Status Exception that occurs from calling " "print versions of remote-viewer or spice-gtk") logging.info("Launching %s on the client (virtual)", cmd) try: client_session.cmd(cmd) except ShellStatusError: logging.debug("Ignoring a status exception, will check connection of" "remote-viewer later") # Send command line through monitor since r-v was started without spice url if menu == "yes": utils_spice.wait_timeout(1) str_input(client_vm, line) client_vm.send_key("tab") client_vm.send_key("tab") client_vm.send_key("tab") client_vm.send_key("kp_enter") # client waits for user entry (authentication) if spice_password is set # use qemu monitor password if set, else check if the normal password is # set if qemu_ticket: # Wait for remote-viewer to launch utils_spice.wait_timeout(5) str_input(client_vm, qemu_ticket) elif ticket: if ticket_send:
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="******") 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_root_session = client_vm.wait_for_login(username="******", password="******") logging.debug("Exporting client display") client_session.cmd("export DISPLAY=:0.0") # Get the min, current, and max resolution on the guest output = client_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): newClientResolution = minimum else: newClientResolution = maximum # Changing the guest resolution client_session.cmd("xrandr -s " + newClientResolution) logging.info("The resolution on the client has been changed from " + current + " to: " + newClientResolution) 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() current_index = outputlist.index("current") currentGuestRes = outputlist[current_index + 1] currentGuestRes += outputlist[current_index + 2] currentGuestRes += outputlist[current_index + 3].replace(",", "") logging.info("Current Resolution of Guest: " + currentGuestRes) if (newClientResolution == currentGuestRes): raise error.TestFail("Client resolution is same as guest resolution!") # Start vdagent daemon utils_spice.start_vdagent(guest_root_session, test_timeout) client_session.close() guest_session.close()
def launch_rv(client_vm, guest_vm, params): """ Launches rv_binary with args based on spice configuration inside client_session on background. remote-viewer will try to connect from vm1 from vm2 @param client_vm - vm object @param guest_vm - vm object @param params """ rv_binary = params.get("rv_binary", "remote-viewer") host_ip = utils_misc.get_host_ip_address(params) host_port = None full_screen = params.get("full_screen") display = params.get("display") cmd = rv_binary + " --display=:0.0" ticket = None client_session = client_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) if display == "spice": ticket = guest_vm.get_spice_var("spice_password") if guest_vm.get_spice_var("spice_ssl") == "yes": host_port = guest_vm.get_spice_var("spice_tls_port") cacert = "%s/%s" % (guest_vm.get_spice_var("spice_x509_prefix"), guest_vm.get_spice_var("spice_x509_cacert_file")) #cacert subj is in format for create certificate(with '/' delimiter) #remote-viewer needs ',' delimiter. And also is needed to remove #first character (it's '/') host_subj = guest_vm.get_spice_var("spice_x509_server_subj") host_subj = host_subj.replace('/', ',')[1:] cmd += " spice://%s?tls-port=%s" % (host_ip, host_port) cmd += " --spice-ca-file=%s" % cacert if params.get("spice_client_host_subject") == "yes": cmd += " --spice-host-subject=\"%s\"" % host_subj #client needs cacert file client_session.cmd("rm -rf %s && mkdir -p %s" % ( guest_vm.get_spice_var("spice_x509_prefix"), guest_vm.get_spice_var("spice_x509_prefix"))) remote.copy_files_to(client_vm.get_address(), 'scp', params.get("username"), params.get("password"), params.get("shell_port"), cacert, cacert) else: host_port = guest_vm.get_spice_var("spice_port") cmd += " spice://%s?port=%s" % (host_ip, host_port) elif display == "vnc": raise NotImplementedError("remote-viewer vnc") else: raise Exception("Unsupported display value") # Check to see if the test is using the full screen option. if full_screen == "yes": logging.info("Remote Viewer Set to use Full Screen") cmd += " --full-screen" cmd = "nohup " + cmd + " &> /dev/null &" # Launch it on background # Launching the actual set of commands try: client_session.cmd("startx &", timeout=15) except (ShellCmdError, ShellStatusError): logging.debug("Ignoring an Exception that Occurs from calling startx") utils_spice.wait_timeout(15) try: print_rv_version(client_session, rv_binary) except ShellStatusError: # Sometimes It fails with Status error, ingore it and continue. # It's not that important to have printed versions in the log. logging.debug("Ignoring a Status Exception that occurs from calling " \ + "print versions of remote-viewer or spice-gtk") logging.info("Launching %s on the client (virtual)", cmd) client_session.cmd(cmd) # client waits for user entry (authentication) if spice_password is set if ticket: utils_spice.wait_timeout(5) # Wait for remote-viewer to launch send_ticket(client_vm, ticket) utils_spice.wait_timeout(5) # Wait for conncetion to establish verify_established(client_session, host_ip, host_port, rv_binary) #prevent from kill remote-viewer after test finish cmd = "disown -ar" client_session.cmd(cmd)
def setup_vm_windows(test, params, env, vm): setup_type = vm.params.get("setup_type", None) logging.info("Setup type: %s" % setup_type) if vm.params.get("display", None) == "vnc": logging.info("Display of VM is VNC; assuming it is client") utils_spice.install_rv_win(vm, params.get("rv_installer"), env) utils_spice.install_usbclerk_win(vm, params.get("usb_installer"), env) return if setup_type == "guest_tools": logging.info("Installing Windows guest tools") session = vm.wait_for_login( timeout = int(params.get("login_timeout", 360))) winqxl = params.get("winqxl") winvdagent = params.get("winvdagent") vioserial = params.get("vioserial") pnputil = params.get("pnputil") winp7 = params.get("winp7zip") guest_script_req = params.get("guest_script_req") md5sumwin = params.get("md5sumwin") md5sumwin_dir = os.path.join("scripts", md5sumwin) guest_sr_dir = os.path.join("scripts", guest_script_req) guest_sr_path = utils_misc.get_path(test.virtdir, guest_sr_dir) md5sumwin_path = utils_misc.get_path(test.virtdir, md5sumwin_dir) winp7_path = os.path.join(test.virtdir, 'deps', winp7) winqxlzip = os.path.join(test.virtdir, 'deps', winqxl) winvdagentzip = os.path.join(test.virtdir, 'deps', winvdagent) vioserialzip = os.path.join(test.virtdir, 'deps', vioserial) #copy p7zip to windows and install it silently logging.info("Installing 7zip") vm.copy_files_to(winp7_path, "C:\\") session.cmd_status("start /wait msiexec /i C:\\7z920-x64.msi /qn") #copy over the winqxl, winvdagent, virtio serial vm.copy_files_to(winqxlzip, "C:\\") vm.copy_files_to(winvdagentzip, "C:\\") vm.copy_files_to(vioserialzip, "C:\\") vm.copy_files_to(guest_sr_path, "C:\\") vm.copy_files_to(md5sumwin_path, "C:\\") #extract winvdagent zip and start service if vdservice is not installed try: output = session.cmd('sc queryex type= service state= all' + ' | FIND "vdservice"') except aexpect.ShellCmdError: session.cmd_status('"C:\\Program Files\\7-Zip\\7z.exe" e C:\\wvdagent.zip -oC:\\') utils_spice.wait_timeout(2) session.cmd_status("C:\\vdservice.exe install") #wait for vdservice to come up utils_spice.wait_timeout(5) logging.info(session.cmd("net start vdservice")) logging.info(session.cmd("chdir")) #extract winqxl driver, place drivers in correct location & reboot #Note pnputil only works win 7+, need to find a way for win xp #Verify if virtio serial is already installed output = session.cmd(pnputil + " /e") if("System devices" in output): logging.info( "Virtio Serial already installed") else: session.cmd_status('"C:\\Program Files\\7-Zip\\7z.exe" e C:\\vioserial.zip -oC:\\') output = session.cmd(pnputil + " -i -a C:\\vioser.inf") logging.info("Virtio Serial status: " + output) #Make sure virtio install is complete utils_spice.wait_timeout(5) output = session.cmd(pnputil + " /e") if("Display adapters" in output): logging.info("QXL already installed") else: #winqxl session.cmd_status('"C:\\Program Files\\7-Zip\\7z.exe" e C:\\wqxl.zip -oC:\\') output = session.cmd(pnputil + " -i -a C:\\qxl.inf") logging.info( "Win QXL status: " + output ) #Make sure qxl install is complete utils_spice.wait_timeout(5) vm.reboot() logging.info("Installation of Windows guest tools completed") logging.info("Setup complete")
def launch_rv(client_vm, guest_vm, params): """ Launches rv_binary with args based on spice configuration inside client_session on background. remote-viewer will try to connect from vm1 from vm2 @param client_vm - vm object @param guest_vm - vm object @param params """ rv_binary = params.get("rv_binary", "remote-viewer") host_ip = utils_misc.get_host_ip_address(params) host_port = None full_screen = params.get("full_screen") display = params.get("display") cmd = rv_binary + " --display=:0.0" ticket = None client_session = client_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) if display == "spice": ticket = guest_vm.get_spice_var("spice_password") if guest_vm.get_spice_var("spice_ssl") == "yes": host_port = guest_vm.get_spice_var("spice_tls_port") cacert = "%s/%s" % ( guest_vm.get_spice_var("spice_x509_prefix"), guest_vm.get_spice_var("spice_x509_cacert_file")) #cacert subj is in format for create certificate(with '/' delimiter) #remote-viewer needs ',' delimiter. And also is needed to remove #first character (it's '/') host_subj = guest_vm.get_spice_var("spice_x509_server_subj") host_subj = host_subj.replace('/', ',')[1:] cmd += " spice://%s?tls-port=%s" % (host_ip, host_port) cmd += " --spice-ca-file=%s" % cacert if params.get("spice_client_host_subject") == "yes": cmd += " --spice-host-subject=\"%s\"" % host_subj #client needs cacert file client_session.cmd("rm -rf %s && mkdir -p %s" % (guest_vm.get_spice_var("spice_x509_prefix"), guest_vm.get_spice_var("spice_x509_prefix"))) remote.copy_files_to(client_vm.get_address(), 'scp', params.get("username"), params.get("password"), params.get("shell_port"), cacert, cacert) else: host_port = guest_vm.get_spice_var("spice_port") cmd += " spice://%s?port=%s" % (host_ip, host_port) elif display == "vnc": raise NotImplementedError("remote-viewer vnc") else: raise Exception("Unsupported display value") # Check to see if the test is using the full screen option. if full_screen == "yes": logging.info("Remote Viewer Set to use Full Screen") cmd += " --full-screen" cmd = "nohup " + cmd + " &> /dev/null &" # Launch it on background # Launching the actual set of commands try: client_session.cmd("startx &", timeout=15) except (ShellCmdError, ShellStatusError): logging.debug("Ignoring an Exception that Occurs from calling startx") utils_spice.wait_timeout(15) try: print_rv_version(client_session, rv_binary) except ShellStatusError: # Sometimes It fails with Status error, ingore it and continue. # It's not that important to have printed versions in the log. logging.debug("Ignoring a Status Exception that occurs from calling " \ + "print versions of remote-viewer or spice-gtk") logging.info("Launching %s on the client (virtual)", cmd) client_session.cmd(cmd) # client waits for user entry (authentication) if spice_password is set if ticket: utils_spice.wait_timeout(5) # Wait for remote-viewer to launch send_ticket(client_vm, ticket) utils_spice.wait_timeout(5) # Wait for conncetion to establish verify_established(client_session, host_ip, host_port, rv_binary) #prevent from kill remote-viewer after test finish cmd = "disown -ar" client_session.cmd(cmd)
def setup_vm_windows(test, params, env, vm): setup_type = vm.params.get("setup_type", None) logging.info("Setup type: %s" % setup_type) if vm.params.get("display", None) == "vnc": logging.info("Display of VM is VNC; assuming it is client") utils_spice.install_rv_win(vm, params.get("rv_installer"), env) utils_spice.install_usbclerk_win(vm, params.get("usb_installer"), env) return if setup_type == "guest_tools": logging.info("Installing Windows guest tools") session = vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) winqxl = params.get("winqxl") winvdagent = params.get("winvdagent") vioserial = params.get("vioserial") pnputil = params.get("pnputil") winp7 = params.get("winp7zip") guest_script_req = params.get("guest_script_req") md5sumwin = params.get("md5sumwin") md5sumwin_dir = os.path.join("scripts", md5sumwin) guest_sr_dir = os.path.join("scripts", guest_script_req) guest_sr_path = utils_misc.get_path(test.virtdir, guest_sr_dir) md5sumwin_path = utils_misc.get_path(test.virtdir, md5sumwin_dir) winp7_path = os.path.join(test.virtdir, 'deps', winp7) winqxlzip = os.path.join(test.virtdir, 'deps', winqxl) winvdagentzip = os.path.join(test.virtdir, 'deps', winvdagent) vioserialzip = os.path.join(test.virtdir, 'deps', vioserial) #copy p7zip to windows and install it silently logging.info("Installing 7zip") vm.copy_files_to(winp7_path, "C:\\") session.cmd_status("start /wait msiexec /i C:\\7z920-x64.msi /qn") #copy over the winqxl, winvdagent, virtio serial vm.copy_files_to(winqxlzip, "C:\\") vm.copy_files_to(winvdagentzip, "C:\\") vm.copy_files_to(vioserialzip, "C:\\") vm.copy_files_to(guest_sr_path, "C:\\") vm.copy_files_to(md5sumwin_path, "C:\\") #extract winvdagent zip and start service if vdservice is not installed try: output = session.cmd('sc queryex type= service state= all' + ' | FIND "vdservice"') except aexpect.ShellCmdError: session.cmd_status( '"C:\\Program Files\\7-Zip\\7z.exe" e C:\\wvdagent.zip -oC:\\') utils_spice.wait_timeout(2) session.cmd_status("C:\\vdservice.exe install") #wait for vdservice to come up utils_spice.wait_timeout(5) logging.info(session.cmd("net start vdservice")) logging.info(session.cmd("chdir")) #extract winqxl driver, place drivers in correct location & reboot #Note pnputil only works win 7+, need to find a way for win xp #Verify if virtio serial is already installed output = session.cmd(pnputil + " /e") if ("System devices" in output): logging.info("Virtio Serial already installed") else: session.cmd_status( '"C:\\Program Files\\7-Zip\\7z.exe" e C:\\vioserial.zip -oC:\\' ) output = session.cmd(pnputil + " -i -a C:\\vioser.inf") logging.info("Virtio Serial status: " + output) #Make sure virtio install is complete utils_spice.wait_timeout(5) output = session.cmd(pnputil + " /e") if ("Display adapters" in output): logging.info("QXL already installed") else: #winqxl session.cmd_status( '"C:\\Program Files\\7-Zip\\7z.exe" e C:\\wqxl.zip -oC:\\') output = session.cmd(pnputil + " -i -a C:\\qxl.inf") logging.info("Win QXL status: " + output) #Make sure qxl install is complete utils_spice.wait_timeout(5) vm.reboot() logging.info("Installation of Windows guest tools completed") logging.info("Setup complete")
def run_fullscreen_setup(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: KVM 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)) 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))) try: guest_session.cmd("startx &", timeout=15) except (aexpect.ShellCmdError, aexpect.ShellStatusError): logging.debug("Ignoring an Exception that Occurs from calling startx") # Sleep while X session starts utils_spice.wait_timeout(15) 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() MINindex = outputlist.index("minimum") minimum = outputlist[MINindex + 1] minimum += outputlist[MINindex + 2] # Remove trailing comma minimum += outputlist[MINindex + 3].replace(",", "") CURRENTindex = outputlist.index("current") current = outputlist[CURRENTindex + 1] current += outputlist[CURRENTindex + 2] # Remove trailing comma current += outputlist[CURRENTindex + 3].replace(",", "") MAXindex = outputlist.index("maximum") maximum = outputlist[MAXindex + 1] maximum += outputlist[MAXindex + 2] maximum += outputlist[MAXindex + 3] 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_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_rv_input(test, params, env): """ Test for testing keyboard inputs through spice. Test depends on rv_connect test. @param test: KVM 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() client_vm = env.get_vm(params["client_vm"]) client_vm.verify_alive() guest_session = guest_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) if guest_session.cmd("test -e /etc/redhat-release"): deploy_epel_repo(guest_session, params) try: guest_session.cmd("startx &", timeout=15) except (ShellCmdError, ShellStatusError): logging.debug("Ignoring an Exception that Occurs from calling startx") #Give some time to X utils_spice.wait_timeout(15) guest_session.cmd("export DISPLAY=:0.0") utils_spice.wait_timeout(3) # Verify that gnome is now running on the guest guest_session.cmd("ps aux | grep -v grep | grep gnome-session") install_wxpython(guest_session, params) deploy_test_form(test, guest_vm, params) #Get test type and perform proper test test_type = params.get("config_test") test_mapping = { 'type_and_func_keys': test_type_and_func_keys, 'leds_and_esc_keys': test_leds_and_esc_keys, 'nonus_layout': test_nonus_layout, 'leds_migration': test_leds_migration } test_parameters = { 'type_and_func_keys': (client_vm, guest_session, params), 'leds_and_esc_keys': (client_vm, guest_session, params), 'nonus_layout': (client_vm, guest_session, params), 'leds_migration': (client_vm, guest_vm, guest_session, params) } try: func = test_mapping[test_type] args = test_parameters[test_type] except: raise error.TestFail("Unknown type of test") func(*args) #Get file with caught keycodes from guest result_path = get_test_results(guest_vm) #Analyze results and raise fail exp. If sent scancodes #do not match with expected keycodes result = analyze_results(result_path, test_type) if result is not None: raise error.TestFail("Testing of sending keys failed:" " Expected keycode = %s" % result) 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_rv_input(test, params, env): """ Test for testing keyboard inputs through spice. Test depends on rv_connect test. @param test: KVM 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() client_vm = env.get_vm(params["client_vm"]) client_vm.verify_alive() guest_session = guest_vm.wait_for_login(timeout=int(params.get("login_timeout", 360))) if guest_session.cmd("test -e /etc/redhat-release"): deploy_epel_repo(guest_session, params) try: guest_session.cmd("startx &", timeout=15) except (ShellCmdError, ShellStatusError): logging.debug("Ignoring an Exception that Occurs from calling startx") # Give some time to X utils_spice.wait_timeout(15) guest_session.cmd("export DISPLAY=:0.0") utils_spice.wait_timeout(3) # Verify that gnome is now running on the guest guest_session.cmd("ps aux | grep -v grep | grep gnome-session") install_wxpython(guest_session, params) deploy_test_form(test, guest_vm, params) # Get test type and perform proper test test_type = params.get("config_test") test_mapping = { "type_and_func_keys": test_type_and_func_keys, "leds_and_esc_keys": test_leds_and_esc_keys, "nonus_layout": test_nonus_layout, "leds_migration": test_leds_migration, } test_parameters = { "type_and_func_keys": (client_vm, guest_session, params), "leds_and_esc_keys": (client_vm, guest_session, params), "nonus_layout": (client_vm, guest_session, params), "leds_migration": (client_vm, guest_vm, guest_session, params), } try: func = test_mapping[test_type] args = test_parameters[test_type] except: raise error.TestFail("Unknown type of test") func(*args) # Get file with caught keycodes from guest result_path = get_test_results(guest_vm) # Analyze results and raise fail exp. If sent scancodes # do not match with expected keycodes result = analyze_results(result_path, test_type) if result is not None: raise error.TestFail("Testing of sending keys failed:" " Expected keycode = %s" % result) guest_session.close()
def run_rv_gui(test, params, env): """ Tests GUI automation of remote-viewer @param test: QEMU test object. @param params: Dictionary with the test parameters. @param env: Dictionary with test environment. """ #Get required paramters host_ip = utils_net.get_host_ip_address(params) screenshot_dir = params.get("screenshot_dir") #screenshot_name = params.get("screenshot_name") screenshot_exp_name = params.get("screenshot_expected_name") expected_rv_corners_fs = "Corners: +0+0 -0+0 -0-0 +0-0" screenshot_exp_file = "" host_port = None guest_res = "" guest_res2 = "" rv_res = "" rv_res2 = "" rv_binary = params.get("rv_binary", "remote-viewer") changex = params.get("changex") changey = params.get("changey") accept_pct = params.get("accept_pct") tests = params.get("rv_gui_test_list").split() rv_version = params.get("rv_version") rv_version_el7 = params.get("rv_version_el7") ticket = params.get("spice_password", None) errors = 0 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(timeout=int( params.get("login_timeout", 360)), username="******", password="******") #update host_port host_port = guest_vm.get_spice_var("spice_port") 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))) output = client_session.cmd('cat /etc/redhat-release') isRHEL7 = "release 7." in output client_session.cmd("export DISPLAY=:0") guest_session.cmd("export DISPLAY=:0") #if isRHEL7: # pass # client_session.cmd('mkdir /home/test/.dbus/session-bus/ # client_session.cmd('. /home/test/.dbus/session-bus/`cat ' + \ # '/etc/machine-id`-0') #else: client_session.cmd('. /home/test/.dbus/session-bus/`cat ' + \ '/var/lib/dbus/machine-id`-0') client_session.cmd('export DBUS_SESSION_BUS_ADDRESS ' + \ 'DBUS_SESSION_BUS_PID DBUS_SESSION_BUS_WINDOWID') client_session.cmd("cd %s" % params.get("test_script_tgt")) rv_res_orig = getrvgeometry(client_session, host_port, host_ip) logging.info("Executing gui tests: " + str(tests)) #Make sure Accessibility is enabled before running the GUI tests if isRHEL7: logging.info("Enabling accessibility") client_session.cmd("export DISPLAY=:0.0") client_session.cmd("gsettings set org.gnome.desktop.interface" " toolkit-accessibility true") #Go through all tests to be run for i in tests: logging.info("Test: " + i) #Verification that needs to be done prior to running the gui test. if "zoom" in i or "autoresize" in i: #Get preliminary information needed for the zoom tests guest_res = getres(guest_session) rv_res = getrvgeometry(client_session, host_port, host_ip) # if i in ("screenshot"): if "screenshot" in i: screenshot_exp_file = os.path.join(screenshot_dir, \ screenshot_exp_name) try: client_session.cmd('[ -e ' + screenshot_exp_file + ' ]') client_session.cmd('rm ' + screenshot_exp_file) logging.info("Deleted: " + screenshot_exp_file) except ShellCmdError: logging.info(screenshot_exp_name + " doesn't exist, continue") cmd = "./unittests/%s_rv.py" % i #Verification of the printscreen test prior to the test being run if "printscreen" in i: output = client_session.cmd('cat /etc/redhat-release') if "release 7." in output: output = guest_session.cmd( 'rm -vf /home/test/Pictures/Screen*') logging.info("Screenshots removed: " + output) #Adding parameters to the test if (i == "connect"): cmd += " 'spice://%s:%s'" % (host_ip, host_port) if ticket: cmd += " %s > /dev/null 2>&1" % ticket #Run the test client_session_dt = client_vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) client_session_dt.cmd("export DISPLAY=:0.0") client_session_dt.cmd('. /home/test/.dbus/session-bus/`cat ' + \ '/var/lib/dbus/machine-id`-0') client_session_dt.cmd('export DBUS_SESSION_BUS_ADDRESS ' + \ 'DBUS_SESSION_BUS_PID DBUS_SESSION_BUS_WINDOWID') print "Running test: " + cmd try: logging.info(client_session_dt.cmd(cmd)) except: logging.error("Status: FAIL") errors += 1 else: logging.info("Status: PASS") client_session_dt.close() #Wait before doing any verification utils_spice.wait_timeout(5) #Verification Needed after the gui test was run if "zoom" in i: guest_res2 = getres(guest_session) rv_res2 = getrvgeometry(client_session, host_port, host_ip) #Check to see that the resolution doesn't change logstr = "Checking that the guest's resolution doesn't change" checkresequal(guest_res, guest_res2, logstr) if "zoomin" in i: #verify the rv window has increased errorstr = "Checking the rv window's size has increased" logging.info(errorstr) checkgeometryincrease(rv_res, rv_res2, errorstr) if "zoomout" in i: #verify the rv window has decreased errorstr = "Checking the rv window's size has decreased" logging.info(errorstr) checkgeometryincrease(rv_res2, rv_res, errorstr) if "zoomnorm" in i: errorstr = "Checking the rv window's size is the same as " + \ "it was originally when rv was started." checkresequal(rv_res2, rv_res_orig, errorstr) if "quit" in i or "close" in i: #Verify for quit tests that remote viewer is not running on client try: rvpid = str(client_session.cmd("pgrep remote-viewer")) raise error.TestFail("Remote-viewer is still running: " + rvpid) except ShellCmdError: logging.info("Remote-viewer process is no longer running.") if "screenshot" in i: #Verify the screenshot was created and clean up try: client_session.cmd('[ -e ' + screenshot_exp_file + ' ]') client_session.cmd('rm ' + screenshot_exp_file) print screenshot_exp_name + " was created as expected" except ShellCmdError: raise error.TestFail("Screenshot " + screenshot_exp_file + \ " was not created") if i == "fullscreen" or i == "fullscreen_shortcut": #Verify that client's res = guests's res guest_res = getres(guest_session) client_res = getres(client_session) rv_geometry = getrvgeometry(client_session, host_port, host_ip) rv_corners = getrvcorners(client_session, host_port, host_ip) if (client_res == guest_res): logging.info( "PASS: Guest resolution is the same as the client") #Verification #2, client's res = rv's geometry if (client_res == rv_geometry): logging.info("PASS client's res = geometry of rv window") else: raise error.TestFail("Client resolution: " + client_res + \ " differs from the rv's geometry: " + rv_geometry) else: raise error.TestFail("Guest resolution: " + guest_res + \ "differs from the client: " + client_res) #Verification #3, verify the rv window is at the top corner if (rv_corners in expected_rv_corners_fs): logging.info("PASS: rv window is at the top corner: " + \ rv_corners) else: raise error.TestFail("rv window is not at the top corner " + \ "as expected, it is at: " + rv_corners) #Verify rv window < client's res if i == "leave_fullscreen" or i == "leave_fullscreen_shortcut": rv_corners = getrvcorners(client_session, host_port, host_ip) if (rv_corners not in expected_rv_corners_fs): logging.info("PASS: rv window is not at top corner: " + \ rv_corners) else: raise error.TestFail("rv window, leaving full screen failed.") if "printscreen" in i: output = client_session.cmd('cat /etc/redhat-release') if "release 7." in output: output = guest_session.cmd( 'ls -al /home/test/Pictures | grep Screen*') logging.info("Screenshot Taken Found: " + output) else: output = guest_root_session.cmd( "ps aux | grep gnome-screenshot") index = 1 found = 0 plist = output.splitlines() for line in plist: print str(index) + " " + line index += 1 list2 = line.split() #get gnome-screenshot info gss_pid = str(list2[1]) gss_process_name = str(list2[10]) #Verify gnome-screenshot is running and kill it if gss_process_name == "gnome-screenshot": found = 1 guest_root_session.cmd("kill " + gss_pid) break else: continue if not (found): raise error.TestFail("gnome-screenshot is not running.") #Verify the shutdown dialog is present if "ctrl_alt_del" in i: #looking for a blank named dialog will not work for RHEL 7 #Will need to find a better solution to verify #the shutdown dialog has come up if isRHEL7: #wait 80 seconds for the VM to completely shutdown utils_spice.wait_timeout(90) try: guest_vm.verify_alive() raise error.TestFail( "Guest VM is still alive, shutdown failed.") except VMDeadError: logging.info("Guest VM is verified to be shutdown") else: guest_session.cmd("xwininfo -name ''") #If autoresize_on is run, change window geometry if i == "autoresize_on" or i == "autoresize_off": logging.info("Attempting to change the window size of rv to:" + \ str(changex) + "x" + str(changey)) #wmctrl_cmd = "wmctrl -r 'spice://%s?port=%s (1) - Remote Viewer'" \ # % (host_ip, host_port) wmctrl_cmd = "wmctrl -r %s" % window_title wmctrl_cmd += " -e 0,0,0," + str(changex) + "," + str(changey) output = client_session.cmd(wmctrl_cmd) logging.info("Original res: " + guest_res) logging.info("Original geometry: " + rv_res) #Wait for the rv window to change and guest to adjust resolution utils_spice.wait_timeout(2) guest_res2 = getres(guest_session) rv_res2 = getrvgeometry(client_session, host_port, host_ip) logging.info("After test res: " + guest_res2) logging.info("After test geometry: " + rv_res2) #Get the required information width2 = int(guest_res2.split('x')[0]) rvwidth2 = int(rv_res2.split('x')[0]) #The second split of - is a workaround because the xwinfo sometimes #prints out dashes after the resolution for some reason. height2 = int(guest_res2.split('x')[1].split('-')[0]) rvheight2 = int(rv_res2.split('x')[1].split('-')[0]) #the width and height that was specified is changed w/alotted limit percentchange(accept_pct, changey, rvheight2, "Height parameter:") percentchange(accept_pct, changex, rvwidth2, "Width parameter:") if i == "autoresize_on": #resolution is changed, attempted to match the window logging.info("Checking resolution is changed, attempted" + \ " to match the window, when autoresize is on") percentchange(accept_pct, rvheight2, height2, "Height param:") percentchange(accept_pct, rvwidth2, width2, "Width param:") if i == "autoresize_off": #resolutions did not change logging.info("Checking the resolution does not change" + \ ", when autoresize is off") logstr = "Checking that the guest's resolution doesn't change" checkresequal(guest_res, guest_res2, logstr) #Verify a connection is established if i == "connect": try: utils_spice.verify_established(client_vm, host_ip, \ host_port, rv_binary) except utils_spice.RVConnectError: raise error.TestFail("remote-viewer connection failed") if errors: raise error.TestFail("%d GUI tests failed, see log for more details" \ % errors)
def launch_rv(client_vm, guest_vm, params): """ Launches rv_binary with args based on spice configuration inside client_session on background. remote-viewer will try to connect from vm1 from vm2 :param client_vm - vm object :param guest_vm - vm object :param params """ rv_binary = params.get("rv_binary", "remote-viewer") rv_ld_library_path = params.get("rv_ld_library_path") display = params.get("display") proxy = params.get("spice_proxy", None) if proxy: try: socket.inet_aton(params.get("proxy_ip", None)) except socket.error: raise error.TestNAError("Parameter proxy_ip not changed from default values") host_ip = utils_net.get_host_ip_address(params) host_port = None if guest_vm.get_spice_var("listening_addr") == "ipv6": host_ip = "[" + utils_misc.convert_ipv4_to_ipv6(host_ip) + "]" host_tls_port = None disable_audio = params.get("disable_audio", "no") full_screen = params.get("full_screen") check_spice_info = params.get("spice_info") ssltype = params.get("ssltype") test_type = params.get("test_type") # cmd var keeps final remote-viewer command line # to be executed on client cmd = rv_binary if client_vm.params.get("os_type") != "windows": cmd = cmd + " --display=:0.0" # If qemu_ticket is set, set the password # of the VM using the qemu-monitor ticket = None ticket_send = params.get("spice_password_send") qemu_ticket = params.get("qemu_password") if qemu_ticket: guest_vm.monitor.cmd("set_password spice %s" % qemu_ticket) logging.info("Sending to qemu monitor: set_password spice %s" % qemu_ticket) gencerts = params.get("gencerts") certdb = params.get("certdb") smartcard = params.get("smartcard") host_subj = None cacert = None rv_parameters_from = params.get("rv_parameters_from", "cmd") if rv_parameters_from == "file": cmd += " ~/rv_file.vv" client_session = client_vm.wait_for_login(timeout=int(params.get("login_timeout", 360))) if display == "spice": ticket = guest_vm.get_spice_var("spice_password") if guest_vm.get_spice_var("spice_ssl") == "yes": # client needs cacert file cacert = "%s/%s" % ( guest_vm.get_spice_var("spice_x509_prefix"), guest_vm.get_spice_var("spice_x509_cacert_file"), ) client_session.cmd( "rm -rf %s && mkdir -p %s" % (guest_vm.get_spice_var("spice_x509_prefix"), guest_vm.get_spice_var("spice_x509_prefix")) ) remote.copy_files_to( client_vm.get_address(), "scp", params.get("username"), params.get("password"), params.get("shell_port"), cacert, cacert, ) host_tls_port = guest_vm.get_spice_var("spice_tls_port") host_port = guest_vm.get_spice_var("spice_port") # cacert subj is in format for create certificate(with '/' delimiter) # remote-viewer needs ',' delimiter. And also is needed to remove # first character (it's '/') host_subj = guest_vm.get_spice_var("spice_x509_server_subj") host_subj = host_subj.replace("/", ",")[1:] if ssltype == "invalid_explicit_hs": host_subj = "Invalid Explicit HS" else: host_subj += host_ip # If it's invalid implicit, a remote-viewer connection # will be attempted with the hostname, since ssl certs were # generated with the ip address hostname = socket.gethostname() if ssltype == "invalid_implicit_hs": spice_url = " spice://%s?tls-port=%s\&port=%s" % (hostname, host_tls_port, host_port) else: spice_url = " spice://%s?tls-port=%s\&port=%s" % (host_ip, host_tls_port, host_port) if rv_parameters_from == "menu": line = spice_url elif rv_parameters_from == "file": pass else: cmd += spice_url if not rv_parameters_from == "file": cmd += " --spice-ca-file=%s" % cacert if params.get("spice_client_host_subject") == "yes" and not rv_parameters_from == "file": cmd += ' --spice-host-subject="%s"' % host_subj else: host_port = guest_vm.get_spice_var("spice_port") if rv_parameters_from == "menu": # line to be sent through monitor once r-v is started # without spice url line = "spice://%s?port=%s" % (host_ip, host_port) elif rv_parameters_from == "file": pass else: cmd += " spice://%s?port=%s" % (host_ip, host_port) elif display == "vnc": raise NotImplementedError("remote-viewer vnc") else: raise Exception("Unsupported display value") # Check to see if the test is using the full screen option. if full_screen == "yes" and not rv_parameters_from == "file": logging.info("Remote Viewer Set to use Full Screen") cmd += " --full-screen" if disable_audio == "yes": logging.info("Remote Viewer Set to disable audio") cmd += " --spice-disable-audio" # Check to see if the test is using a smartcard. if smartcard == "yes": logging.info("remote viewer Set to use a smartcard") if not rv_parameters_from == file: cmd += " --spice-smartcard" if certdb is not None: logging.debug("Remote Viewer set to use the following certificate" " database: " + certdb) cmd += " --spice-smartcard-db " + certdb if gencerts is not None: logging.debug("Remote Viewer set to use the following certs: " + gencerts) cmd += " --spice-smartcard-certificates " + gencerts if client_vm.params.get("os_type") == "linux": cmd = "nohup " + cmd + " &> /dev/null &" # Launch it on background if rv_ld_library_path: cmd = "export LD_LIBRARY_PATH=" + rv_ld_library_path + ";" + cmd if rv_parameters_from == "file": print "Generating file" utils_spice.gen_rv_file(params, guest_vm, host_subj, cacert) print "Uploading file to client" client_vm.copy_files_to("rv_file.vv", "~/rv_file.vv") # Launching the actual set of commands try: if rv_ld_library_path: print_rv_version(client_session, "LD_LIBRARY_PATH=/usr/local/lib " + rv_binary) else: print_rv_version(client_session, rv_binary) except (ShellStatusError, ShellProcessTerminatedError): # Sometimes It fails with Status error, ingore it and continue. # It's not that important to have printed versions in the log. logging.debug( "Ignoring a Status Exception that occurs from calling " "print versions of remote-viewer or spice-gtk" ) logging.info("Launching %s on the client (virtual)", cmd) if proxy: if "http" in proxy: split = proxy.split("//")[1].split(":") else: split = proxy.split(":") host_ip = split[0] if len(split) > 1: host_port = split[1] else: host_port = "3128" if rv_parameters_from != "file": client_session.cmd("export SPICE_PROXY=%s" % proxy) if not params.get("rv_verify") == "only": try: client_session.cmd(cmd) except ShellStatusError: logging.debug("Ignoring a status exception, will check connection" "of remote-viewer later") # Send command line through monitor since url was not provided if rv_parameters_from == "menu": utils_spice.wait_timeout(1) str_input(client_vm, line) # client waits for user entry (authentication) if spice_password is set # use qemu monitor password if set, else, if set, try normal password. if qemu_ticket: # Wait for remote-viewer to launch utils_spice.wait_timeout(5) str_input(client_vm, qemu_ticket) elif ticket: if ticket_send: ticket = ticket_send utils_spice.wait_timeout(5) # Wait for remote-viewer to launch str_input(client_vm, ticket) utils_spice.wait_timeout(5) # Wait for conncetion to establish is_rv_connected = True try: utils_spice.verify_established( client_vm, host_ip, host_port, rv_binary, host_tls_port, params.get("spice_secure_channels", None) ) except utils_spice.RVConnectError: if test_type == "negative": logging.info("remote-viewer connection failed as expected") if ssltype in ("invalid_implicit_hs", "invalid_explicit_hs"): # Check the qemu process output to verify what is expected qemulog = guest_vm.process.get_output() if "SSL_accept failed" in qemulog: return else: raise error.TestFail("SSL_accept failed not shown in qemu" + "process as expected.") is_rv_connected = False else: raise error.TestFail("remote-viewer connection failed") if test_type == "negative" and is_rv_connected: raise error.TestFail("remote-viewer connection was established when" + " it was supposed to be unsuccessful") # Get spice info output = guest_vm.monitor.cmd("info spice") logging.debug("INFO SPICE") logging.debug(output) # Check to see if ipv6 address is reported back from qemu monitor if check_spice_info == "ipv6": logging.info("Test to check if ipv6 address is reported" " back from the qemu monitor") # Remove brackets from ipv6 host ip if host_ip[1 : len(host_ip) - 1] in output: logging.info("Reported ipv6 address found in output from" " 'info spice'") else: raise error.TestFail("ipv6 address not found from qemu monitor" " command: 'info spice'") else: logging.info("Not checking the value of 'info spice'" " from the qemu monitor") # prevent from kill remote-viewer after test finish if client_vm.params.get("os_type") == "linux": cmd = "disown -ar" client_session.cmd_output(cmd)
def run_fullscreen_setup(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: KVM 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)) 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))) try: guest_session.cmd("startx &", timeout=15) except (aexpect.ShellCmdError, aexpect.ShellStatusError): logging.debug("Ignoring an Exception that Occurs from calling startx") # Sleep while X session starts utils_spice.wait_timeout(15) 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() MINindex = outputlist.index("minimum") minimum = outputlist[MINindex + 1] minimum += outputlist[MINindex + 2] # Remove trailing comma minimum += outputlist[MINindex + 3].replace(",", "") CURRENTindex = outputlist.index("current") current = outputlist[CURRENTindex + 1] current += outputlist[CURRENTindex + 2] # Remove trailing comma current += outputlist[CURRENTindex + 3].replace(",", "") MAXindex = outputlist.index("maximum") maximum = outputlist[MAXindex + 1] maximum += outputlist[MAXindex + 2] maximum += outputlist[MAXindex + 3] 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_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()