Merge autotest upstream from @5318 ~ @5336

client/tests/kvm/tests/virtio_console.py

 """
 virtio_console test
 
 @copyright: 2010 Red Hat, Inc.
 """
 import array, logging, os, random, re, select, shutil, socket, sys, tempfile
 import threading, time, traceback
 from collections import deque
 from threading import Thread
 
 from autotest_lib.client.common_lib import error
 from autotest_lib.client.bin import utils
-import kvm_subprocess, kvm_test_utils, kvm_utils
-import kvm_preprocessing, kvm_monitor
+from autotest_lib.client.virt import virt_utils, virt_test_utils, kvm_monitor
+from autotest_lib.client.virt import virt_env_process, aexpect
 
 
 def run_virtio_console(test, params, env):
     """
     KVM virtio_console test
 
     1) Starts VMs with the specified number of virtio console devices
     2) Start smoke test
     3) Start loopback test
     4) Start performance test
@@ skipping 271 matching lines @@
             self.quiet = quiet
 
 
         def run(self):
             logging.debug("ThSend %s: run", self.getName())
             try:
                 while not self.exitevent.isSet():
                     self.idx += self.port.send(self.data)
                 logging.debug("ThSend %s: exit(%d)", self.getName(),
                               self.idx)
-            except Exception as ints:
+            except Exception, ints:
                 if not self.quiet:
                     raise ints
                 logging.debug(ints)
 
 
     class ThSendCheck(Thread):
         """
         Random data sender thread.
         """
         def __init__(self, port, event, queues, blocklen=1024):
@@ skipping 92 matching lines @@
             logging.debug("ThRecv %s: run", self.getName())
             try:
                 while not self.exitevent.isSet():
                     # TODO: Workaround, it didn't work with select :-/
                     try:
                         self.idx += len(self.port.recv(self.blocklen))
                     except socket.timeout:
                         pass
                 self.port.settimeout(self._port_timeout)
                 logging.debug("ThRecv %s: exit(%d)", self.getName(), self.idx)
-            except Exception as ints:
+            except Exception, ints:
                 if not self.quiet:
                     raise ints
                 logging.debug(ints)
 
 
     class ThRecvCheck(Thread):
         """
         Random data receiver/checker thread.
         """
         def __init__(self, port, buffer, event, blocklen=1024, sendlen=0):
@@ skipping 197 matching lines @@
         @return: Tuple (match index, data, kernel_crash)
         """
         logging.debug("Executing '%s' on virtio_console_guest.py loop," +
                       " vm: %s, timeout: %s", command, vm[0].name, timeout)
         vm[1].sendline(command)
         try:
             (match, data) = vm[1].read_until_last_line_matches(["PASS:",
                                                                 "FAIL:"],
                                                                timeout)
 
-        except (kvm_subprocess.ExpectError), e:
+        except aexpect.ExpectError, e:
             match = None
             data = "Cmd process timeout. Data in console: " + e.output
 
         kcrash_data = _search_kernel_crashlog(vm[3])
         if kcrash_data is not None:
             logging.error(kcrash_data)
             vm[4] = True
 
         return (match, data)
 
@@ skipping 117 matching lines @@
         kcrash = False
 
         return [vm, session, tmp_dir, sserial, kcrash], [consoles, serialports]
 
 
     def _restore_vm():
         """
         Restore old virtual machine when VM is destroyed.
         """
         logging.debug("Booting guest %s", params.get("main_vm"))
-        kvm_preprocessing.preprocess_vm(test, params, env,
+        virt_env_process.preprocess_vm(test, params, env,
                                         params.get("main_vm"))
 
         vm = env.get_vm(params.get("main_vm"))
 
         kernel_bug = None
         try:
-            session = kvm_test_utils.wait_for_login(vm, 0,
+            session = virt_test_utils.wait_for_login(vm, 0,
                                     float(params.get("boot_timeout", 100)),
                                     0, 2)
         except (error.TestFail):
             kernel_bug = _search_kernel_crashlog(vm.serial_console, 10)
             if kernel_bug is not None:
                 logging.error(kernel_bug)
             raise
 
         kernel_bug = _search_kernel_crashlog(vm.serial_console, 10)
         if kernel_bug is not None:
             logging.error(kernel_bug)
 
-        sserial = kvm_test_utils.wait_for_login(vm, 0,
+        sserial = virt_test_utils.wait_for_login(vm, 0,
                                          float(params.get("boot_timeout", 20)),
                                          0, 2, serial=True)
         return [vm, session, sserial]
 
 
     def topen(vm, port):
         """
         Open virtioconsole port.
 
         @param vm: Target virtual machine [vm, session, tmp_dir, ser_session].
@@ skipping 383 matching lines @@
         Test maximum count of ports in guest machine.
 
         @param vm: Target virtual machine [vm, session, tmp_dir, ser_session].
         @param consoles: Consoles which should be close before rmmod.
         """
         logging.debug("Count of serial ports: 30")
         vm[0].destroy(gracefully = False)
         (vm, consoles) = _vm_create(0, 30, False)
         try:
             init_guest(vm, consoles)
-        except error.TestFail as ints:
+        except error.TestFail, ints:
             logging.info("Count of serial ports: 30")
             raise ints
         clean_reload_vm(vm, consoles, expected=True)
 
 
     def tmax_console_ports(vm, consoles):
         """
         Test maximum count of ports in guest machine.
 
         @param vm: Target virtual machine [vm, session, tmp_dir, ser_session].
         @param consoles: Consoles which should be close before rmmod.
         """
         logging.debug("Count of console ports: 30")
         vm[0].destroy(gracefully = False)
         (vm, consoles) = _vm_create(30, 0, False)
         try:
             init_guest(vm, consoles)
-        except error.TestFail as ints:
+        except error.TestFail, ints:
             logging.info("Count of console ports: 30")
             raise ints
         clean_reload_vm(vm, consoles, expected=True)
 
 
     def tmax_mix_serial_conosle_port(vm, consoles):
         """
         Test maximim count of ports in guest machine.
 
         @param vm: Target virtual machine [vm, session, tmp_dir, ser_session].
         @param consoles: Consoles which should be close before rmmod.
         """
         logging.debug("Count of ports (serial+console): 30")
         vm[0].destroy(gracefully = False)
         (vm, consoles) = _vm_create(15, 15, False)
         try:
             init_guest(vm, consoles)
-        except error.TestFail as ints:
+        except error.TestFail, ints:
             logging.info("Count of ports (serial+console): 30")
             raise ints
         clean_reload_vm(vm, consoles, expected=True)
 
 
     def tshutdown(vm, consoles):
         """
         Try to gently shutdown the machine. Virtio_console shouldn't block this.
 
         @param vm: Target virtual machine [vm, session, tmp_dir, ser_session].
@@ skipping 87 matching lines @@
             tmp = "%d data sent; " % threads[0].idx
             for thread in threads[1:]:
                 tmp += "%d, " % thread.idx
             logging.debug("test_loopback: %s data received and verified",
                          tmp[:-2])
             i+=1
             time.sleep(2)
 
 
         for j in range(parms[1]):
-            vm[0] = kvm_test_utils.migrate(vm[0], env, 3600, "exec", 0,
+            vm[0] = virt_test_utils.migrate(vm[0], env, 3600, "exec", 0,
                                              offline)
             if not vm[1]:
                 raise error.TestFail("Could not log into guest after migration")
-            vm[1] = kvm_test_utils.wait_for_login(vm[0], 0,
+            vm[1] = virt_test_utils.wait_for_login(vm[0], 0,
                                         float(params.get("boot_timeout", 100)),
                                         0, 2)
             # OS is sometime a bit dizzy. DL=30
             _init_guest(vm, 30)
 
             i=0
             while i < 6:
                 tmp = "%d data sent; " % threads[0].idx
                 for thread in threads[1:]:
                     tmp += "%d, " % thread.idx
@@ skipping 538 matching lines @@
                 kernel_bug = _search_kernel_crashlog(vm[0].serial_console, 10)
                 if kernel_bug is not None:
                     logging.error(kernel_bug)
                     raise error.TestFail("Kernel crash.")
 
                 if vm[4] == True:
                     raise error.TestFail("Kernel crash.")
                 match, tmp = _on_guest("guest_exit()", vm, 10)
                 if (match is None) or (match == 0):
                     vm[1].close()
-                    vm[1] = kvm_test_utils.wait_for_login(vm[0], 0,
+                    vm[1] = virt_test_utils.wait_for_login(vm[0], 0,
                                         float(params.get("boot_timeout", 5)),
                                         0, 10)
                 on_guest("killall -9 python "
                          "&& echo -n PASS: python killed"
                          "|| echo -n PASS: python was already dead",
                          vm, 10)
 
                 init_guest(vm, consoles)
                 _clean_ports(vm, consoles)
 
-            except (error.TestFail, kvm_subprocess.ExpectError,
+            except (error.TestFail, aexpect.ExpectError,
                     Exception), inst:
                 logging.error(inst)
                 logging.error("Virtio-console driver is irreparably"
                               " blocked. Every comd end with sig KILL."
                               "Trying to reboot vm to continue testing...")
                 try:
                     vm[0].destroy(gracefully = True)
                     (vm[0], vm[1], vm[3]) = _restore_vm()
                 except (kvm_monitor.MonitorProtocolError):
                     logging.error("Qemu is blocked. Monitor no longer "
@@ skipping 237 matching lines @@
 
     if subtest.is_failed():
         raise error.TestFail("%d out of %d virtio console tests failed" %
                              (subtest.failed, (subtest.passed+subtest.failed)))
 
 
     # CLEANUP
     vm[1].close()
     vm[0].destroy(gracefully=False)
     shutil.rmtree(vm[2])