[KVM-Autotest][PATCH 2/2][virtio-console] Adds many tests to virtio-console.

["Jiří Župka" <jzupka@redhat.com>]

1) Check if port /dev/vport0p0 was created.
2) Guest read/write big data from host when host is disconnected.
3) Host send data to guest port and guest not read any data from port.
4) Remove and again install modules of virtio_console.
5) Test maximim count of ports in guest machine.
    - Max serial ports.
    - Max console ports.
    - Max console and serial ports.
6) Try to gently shutdown the machine. Virtio_console shouldn't block this.
7) Let the machine migrate. Virtio_concoles should survive this.

Signed-off-by: Jiří Župka <jzupka@redhat.com>
Signed-off-by: Lukaš Doktor <ldoktor@redhat.com>
---
 client/tests/kvm/scripts/virtio_console_guest.py |   10 +
 client/tests/kvm/tests/virtio_console.py         |  273 +++++++++++++++++++++-
 2 files changed, 272 insertions(+), 11 deletions(-)

diff --git a/client/tests/kvm/scripts/virtio_console_guest.py b/client/tests/kvm/scripts/virtio_console_guest.py
index f11436c..db67fc9 100755
--- a/client/tests/kvm/scripts/virtio_console_guest.py
+++ b/client/tests/kvm/scripts/virtio_console_guest.py
@@ -138,6 +138,16 @@ class VirtioGuest:
         return ports
 
 
+    def check_zero_sym(self):
+        """
+        Check if port /dev/vport0p0 was created.
+        """
+        if os.path.exists("/dev/vport0p0"):
+            print "PASS: Port exist."
+        else:
+            print "FAIL: Device /dev/vport0p0 not exist."
+
+
     def init(self, in_files):
         """
         Init and check port properties.
diff --git a/client/tests/kvm/tests/virtio_console.py b/client/tests/kvm/tests/virtio_console.py
index 8ab6427..808d78d 100644
--- a/client/tests/kvm/tests/virtio_console.py
+++ b/client/tests/kvm/tests/virtio_console.py
@@ -712,6 +712,15 @@ def run_virtio_console(test, params, env):
         port.open()
 
 
+    def tcheck_zero_sym(vm):
+        """
+        Check if port /dev/vport0p0 was created.
+
+        @param vm: Target virtual machine [vm, session, tmp_dir, ser_session].
+        """
+        on_guest("virt.check_zero_sym()", vm, 10)
+
+
     def tmulti_open(vm, port):
         """
         Multiopen virtioconsole port.
@@ -873,6 +882,107 @@ def run_virtio_console(test, params, env):
         on_guest("print 'PASS: nothing'", vm, 10)
 
 
+    def trw_host_offline_big_data(vm, port):
+        """
+        Guest read/write from host when host is disconnected.
+
+        @param vm: Target virtual machine [vm, session, tmp_dir, ser_session].
+        @param port: Port used in test.
+        """
+        if port.is_open:
+            port.close()
+
+        port.clean_port()
+        port.close()
+        on_guest("virt.clean_port('%s'),1024" % port.name, vm, 10)
+        match, tmp = _on_guest("virt.send('%s', (1024**3)*3, True, "
+                               "is_static=True)" % port.name, vm, 30)
+        if match != None:
+            raise error.TestFail("Write on guest while host disconnected "
+                                 "didn't timed out.\nOutput:\n%s"
+                                 % tmp)
+
+        time.sleep(20)
+
+        port.open()
+
+        rlen = 0
+        while rlen < (1024**3*3):
+            ret = select.select([port.sock], [], [], 10.0)
+            if (ret[0] != []):
+                rlen += len(port.sock.recv(((4096))))
+            elif rlen != (1024**3*3):
+                raise error.TestFail("Not all data are received."
+                                     "Only %d from %d" % (rlen, 1024**3*3))
+        on_guest("print 'PASS: nothing'", vm, 10)
+
+
+    def trw_notconnect_guest(vm, port, consoles):
+        """
+        Host send data to guest port and guest not read any data from port.
+
+        @param vm: Target virtual machine [vm, session, tmp_dir, ser_session].
+        @param port: Port used in test.
+        """
+        vm[0].destroy(gracefully = False)
+        (vm[0], vm[1], vm[3]) = _restore_vm()
+        if not port.is_open:
+            port.open()
+        else:
+            port.close()
+            port.open()
+
+        port.sock.settimeout(20.0)
+
+        loads = utils.SystemLoad([(os.getpid(), 'autotest'),
+                                  (vm[0].get_pid(), 'VM'), 0])
+        loads.start()
+
+        try:
+            sended1 = 0
+            for i in range(1000000):
+                sended1 += port.sock.send("a")
+        except (socket.timeout):
+            logging.info("Send data to closed port timeouted.")
+
+        logging.info("Sendes bytes to client: %d" % (sended1))
+        logging.info("\n" + loads.get_cpu_status_string()[:-1])
+
+        on_guest('echo -n "PASS:"', vm, 10)
+
+
+        logging.info("Open and then close port %s." % (port.name))
+        init_guest(vm, consoles)
+        #Test of live and open and close port again.
+        _clean_ports(vm, consoles)
+        on_guest("virt.close('%s')" % (port.name), vm, 10)
+
+        #With serialport it makes another behavior
+        on_guest("guest_exit()", vm, 10)
+        port.sock.settimeout(20.0)
+
+        loads.start()
+        try:
+            sended2 = 0
+            for i in range(40000):
+                sended2 = port.sock.send("a")
+        except (socket.timeout):
+            logging.info("Send data to closed port timeouted.")
+
+        logging.info("Sendes bytes to client: %d" % (sended2))
+        logging.info("\n" + loads.get_cpu_status_string()[:-1])
+        loads.stop()
+        if (sended1 != sended2):
+            logging.warning("Inconsis behavior first send %d and sec send %d" %
+                            (sended1, sended2))
+
+        port.sock.settimeout(None)
+        (vm[0], vm[1], vm[3]) = _restore_vm()
+
+        init_guest(vm, consoles)
+        _clean_ports(vm, consoles)
+
+
     def trw_blocking_mode(vm, port):
         """
         Guest read\write data in blocking mode.
@@ -954,6 +1064,134 @@ def run_virtio_console(test, params, env):
         _guest_exit_threads(vm, [send_port], [recv_port])
 
 
+    def trmmod(vm, consoles):
+        """
+        Remove and again install modules of virtio_console.
+
+        @param vm: Target virtual machine [vm, session, tmp_dir, ser_session].
+        @param consoles: Consoles which should be close before rmmod.
+        """
+        on_guest("guest_exit()", vm, 5)
+
+        on_guest("rmmod -f virtio_console && echo -n PASS: rmmod "
+                 "|| echo -n FAIL: rmmod", vm, 10)
+        on_guest("modprobe virtio_console "
+                 "&& echo -n PASS: modprobe || echo -n FAIL: modprobe",
+                 vm, 10)
+
+        init_guest(vm, consoles)
+        try:
+            cname = consoles[0][0].name
+        except (IndexError):
+            cname = consoles[1][0].name
+        on_guest("virt.clean_port('%s'),1024" % cname, vm, 2)
+
+
+    def tmax_serail_ports(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 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:
+            logging.info("Count of serial ports: 30")
+            raise ints
+        clean_reload_vm(vm, consoles, expected=True)
+
+
+    def tmax_console_ports(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 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:
+            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:
+            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].
+        @param consoles: Consoles which should be close before rmmod.
+        """
+        ports = []
+        for console in consoles[0]:
+            ports.append(console)
+        for console in consoles[1]:
+            ports.append(console)
+        for port in ports:
+            port.open()
+        # If more than one, send data on the other ports
+        for port in ports[1:]:
+            on_guest("virt.close('%s')" % (port.name), vm, 2)
+            on_guest("virt.open('%s')" % (port.name), vm, 2)
+            try:
+                os.system("dd if=/dev/random of='%s' bs=4096 &>/dev/null &"
+                          % port.path)
+            except:
+                pass
+        # Just start sending, it won't finish anyway...
+        _on_guest("virt.send('%s', 1024**3, True, is_static=True)"
+                  % ports[0].name, vm, 1)
+
+        # Let the computer transfer some bytes :-)
+        time.sleep(2)
+
+        # Power off the computer
+        vm[0].destroy(gracefully=True)
+        clean_reload_vm(vm, consoles, expected=True)
+
+
+    def tmigrate_offline(vm, consoles):
+        """
+        Let the machine migrate. Virtio_concoles should survive this.
+
+        @param vm: Target virtual machine [vm, session, tmp_dir, ser_session].
+        @param consoles: Consoles which should be close before rmmod.
+        """
+        # Migrate
+        vm[1].close()
+        dest_vm = kvm_test_utils.migrate(vm[0], env, 3600, "exec", 0, 0)
+        vm[1] = kvm_utils.wait_for(dest_vm.remote_login, 30, 0, 2)
+        if not vm[1]:
+            raise error.TestFail("Could not log into guest after migration")
+        logging.info("Logged in after migration")
+
+
     def tloopback(vm, consoles, params):
         """
         Virtio console loopback subtest.
@@ -1302,17 +1540,23 @@ def run_virtio_console(test, params, env):
             param = (param[0] == 'serialport')
             send_pt = consoles[param][0]
             recv_pt = consoles[param][1]
-            test.headline(headline)
-            test.do_test(topen, [vm, send_pt], True)
-            test.do_test(tclose, [vm, send_pt], True)
-            test.do_test(tmulti_open, [vm, send_pt])
-            test.do_test(tpooling, [vm, send_pt])
-            test.do_test(tsigio, [vm, send_pt])
-            test.do_test(tlseek, [vm, send_pt])
-            test.do_test(trw_host_offline, [vm, send_pt])
-            test.do_test(trw_nonblocking_mode, [vm, send_pt])
-            test.do_test(trw_blocking_mode, [vm, send_pt])
-            test.do_test(tbasic_loopback, [vm, send_pt, recv_pt, data], True)
+            subtest.headline(headline)
+            subtest.do_test(tcheck_zero_sym, [vm], cleanup=False)
+            subtest.do_test(topen, [vm, send_pt], True)
+            subtest.do_test(tclose, [vm, send_pt], True)
+            subtest.do_test(tmulti_open, [vm, send_pt])
+            subtest.do_test(tpooling, [vm, send_pt])
+            subtest.do_test(tsigio, [vm, send_pt])
+            subtest.do_test(tlseek, [vm, send_pt])
+            subtest.do_test(trw_host_offline, [vm, send_pt])
+            subtest.do_test(trw_host_offline_big_data, [vm, send_pt],
+                            cleanup=False)
+            subtest.do_test(trw_notconnect_guest,
+                            [vm, send_pt, consoles])
+            subtest.do_test(trw_nonblocking_mode, [vm, send_pt])
+            subtest.do_test(trw_blocking_mode, [vm, send_pt])
+            subtest.do_test(tbasic_loopback, [vm, send_pt, recv_pt, data],
+                            True)
 
 
     def test_multiport(test, vm, consoles, params):
@@ -1342,6 +1586,13 @@ def run_virtio_console(test, params, env):
         @param consoles: Field of virtio ports with the minimum of 2 items.
         """
         subtest.headline("test_destructive:")
+        #Test rmmod
+        subtest.do_test(trmmod,[vm, consoles])
+        subtest.do_test(tmax_serail_ports, [vm, consoles])
+        subtest.do_test(tmax_console_ports, [vm, consoles])
+        subtest.do_test(tmax_mix_serial_conosle_port, [vm, consoles])
+        subtest.do_test(tshutdown, [vm, consoles])
+        subtest.do_test(tmigrate_offline, [vm, consoles])
 
 
     # INITIALIZE
-- 
1.7.3.5