Merge pull request #80 from FengYang/netperf

Netperf related script update.

qemu/tests/cfg/migrate.cfg

@@ -163,19 +163,22 @@
             type = migration_with_netperf
             client_num = 100
             netperf_timeout = 1000
-            mig_timeout = 1000
+            mig_timeout = 1500
             # netperf_download_link can be local file or a remote URL
             # when using remote URL, pkg_md5sum must be setted. for example:
             # when using local file, support both relative path and absolute path
             # when using the relative path, the base dir is "shared/deps/".
             #netperf_download_link = ftp://ftp.netperf.org/netperf/netperf-2.6.0.tar.bz2
             #pkg_md5sum = 9654ffdfd4c4f2c93ce3733cd9ed9236
-            netperf_download_link = netperf/netperf-2.6.0.tar.bz2
-            server_path = /tmp/netperf-2.6.0.tar.bz2
-            client_path = /tmp/netperf-2.6.0.tar.bz2
+            netperf_link = netperf-2.6.0.tar.bz2
+            server_path = /var/tmp
+            client_path = /var/tmp
             Windows:
                 # server_download_link config like netperf_download_link, only for win guest
                 #server_download_link = ftp://x.com/netserver-2.6.0.exe
                 #server_md5sum = 8f107e9df4f501d20cf46cccc426f4a9
-                server_download_link = "netserver-2.6.0.exe"
-                server_path = "c:\\netserver.exe"
+                netperf_server_link = "netserver-2.6.0.exe"
+                netperf_link_win = "netperf.exe"
+                server_path_win = "c:\"
+                client_path_win = "c:\"
+                shell_client = nc

qemu/tests/cfg/multi_vms_netperf_stress.cfg

+- multi_vms_netperf_stress:
+    virt_test_type = qemu
+    type = netperf_stress
+    image_snapshot = yes
+    hostpassword = redhat
+    vms += " vm2 vm3"
+    netperf_client = ${vms}
+    netperf_server = localhost
+    netperf_link = netperf-2.6.0.tar.bz2
+    server_path = /var/tmp/
+    client_path = /var/tmp/
+    netperf_test_duration = 600
+    netperf_para_sessions = 1
+    test_protocol = TCP_STREAM
+    Windows:
+        netperf_server_link_win = "netserver-2.6.0.exe"
+        netperf_client_link_win = "netperf.exe"
+        server_path_win = "c:\\"
+        client_path_win = "c:\\"

qemu/tests/cfg/netperf_stress.cfg → qemu/tests/cfg/netperf_stress_test.cfg

-- netperf_stress:
+- netperf_stress_test:
     virt_test_type = qemu
     type = netperf_stress
     image_snapshot = yes
-    hostpasswd = redhat
+    hostpassword = redhat
     #netperf server is main vm, the netperf client is the host or another vm
     #Set the netperf client via dsthost
-    dsthost = localhost
-    netperf_download_link = ftp://ftp.netperf.org/netperf/netperf-2.6.0.tar.bz2
-    server_path = /var/tmp/netperf-2.6.0.tar.bz2
-    client_path = /var/tmp/netperf-2.6.0.tar.bz2
-    pkg_md5sum = 9654ffdfd4c4f2c93ce3733cd9ed9236
-    netperf_test_duration = 60
-    netperf_test_timeout = 120
+    netperf_client = ${vms}
+    netperf_server = localhost
+    netperf_link = netperf-2.6.0.tar.bz2
+    server_path = /var/tmp/
+    client_path = /var/tmp/
+    netperf_test_duration = 120
     netperf_para_sessions = 1
     test_protocol = TCP_STREAM
     Windows:
-        server_download_link = "c:\\netserver-2.6.0.exe"
-        server_md5sum = 8f107e9df4f501d20cf46cccc426f4a9
-        server_path = "c:\\netserver.exe"
+        netperf_server_link_win = "netserver-2.6.0.exe"
+        netperf_client_link_win = "netperf.exe"
+        server_path_win = "c:\\"
+        client_path_win = "c:\\"

qemu/tests/migration_with_netperf.py

 import logging
 from autotest.client import utils
 from autotest.client.shared import error
-from virttest import utils_netperf, utils_misc, data_dir
+from virttest import utils_netperf, utils_misc, data_dir, utils_net
 
 
 @error.context_aware
@@ -18,17 +18,6 @@ def run(test, params, env):
     :param params: Dictionary with test parameters.
     :param env: Dictionary with the test environment.
     """
-    def dlink_preprcess(download_link):
-        """
-        Preprocess the download link
-        """
-        if not download_link:
-            raise error.TestNAError("Can not get the netperf download_link")
-        if not utils.is_url(download_link):
-            download_link = utils_misc.get_path(data_dir.get_deps_dir(),
-                                                download_link)
-        return download_link
-
     login_timeout = int(params.get("login_timeout", 360))
     mig_timeout = float(params.get("mig_timeout", "3600"))
     mig_protocol = params.get("migration_protocol", "tcp")
@@ -40,52 +29,109 @@ def run(test, params, env):
     vm.verify_alive()
     session = vm.wait_for_login(timeout=login_timeout)
     guest_address = vm.get_address()
-
-    download_link = dlink_preprcess(params.get("netperf_download_link"))
+    host_address = utils_net.get_host_ip_address(params)
+    remote_ip = params.get("remote_host", host_address)
+    netperf_link = utils_misc.get_path(data_dir.get_deps_dir("netperf"),
+                                       params.get("netperf_link"))
     md5sum = params.get("pkg_md5sum")
-    server_download_link = params.get("server_download_link", download_link)
+    netperf_link_win = params.get("netperf_link_win")
+    if netperf_link_win:
+        netperf_link_win = utils_misc.get_path(data_dir.get_deps_dir("netperf"),
+                                               netperf_link_win)
+    netperf_md5sum_win = params.get("netperf_md5sum_win")
+    netperf_server_link = params.get("netperf_server_link", netperf_link)
     server_md5sum = params.get("server_md5sum", md5sum)
-    server_download_link = dlink_preprcess(server_download_link)
-    server_path = params.get("server_path", "/tmp/server.tar.bz2")
-    client_path = params.get("client_path", "/tmp/client.tar.bz2")
+    netperf_server_link = utils_misc.get_path(data_dir.get_deps_dir("netperf"),
+                                              netperf_server_link)
+    server_path = params.get("server_path", "/var/tmp/")
+    client_path = params.get("client_path", "/var/tmp/")
+    server_path_win = params.get("server_path_win")
+    client_path_win = params.get("client_path_win")
 
     username = params.get("username", "root")
     password = params.get("password", "redhat")
     passwd = params.get("hostpasswd", "redhat")
     client = params.get("shell_client", "ssh")
     port = params.get("shell_port", "22")
-
-    netperf_client = utils_netperf.NetperfClient("localhost", client_path,
-                                                 md5sum, download_link,
-                                                 password=passwd)
-
-    netperf_server = utils_netperf.NetperfServer(guest_address,
-                                                 server_path,
-                                                 server_md5sum,
-                                                 server_download_link,
-                                                 client, port,
-                                                 username=username,
-                                                 password=password)
-
+    if params.get("os_type") == "linux":
+        session.cmd("iptables -F", ignore_all_errors=True)
+        g_client_link = netperf_link
+        g_server_path = server_path
+        g_client_path = client_path
+        g_client_install = False
+    elif params.get("os_type") == "windows":
+        g_client_link = netperf_link_win
+        g_server_path = server_path_win
+        g_client_path = client_path_win
+        md5sum = netperf_md5sum_win
+        g_client_install = True
+    netperf_client_g = None
+    netperf_client_h = None
+    netperf_server_g = None
+    netperf_server_h = None
     try:
-        if params.get("os_type") == "linux":
-            session.cmd("iptables -F", ignore_all_errors=True)
+        netperf_client_g = utils_netperf.NetperfClient(guest_address,
+                                                       g_client_path,
+                                                       md5sum,
+                                                       g_client_link,
+                                                       client=client,
+                                                       port=port,
+                                                       username=username,
+                                                       password=password,
+                                                       install=g_client_install)
+        netperf_server_h = utils_netperf.NetperfServer(remote_ip,
+                                                       server_path,
+                                                       server_md5sum,
+                                                       netperf_link,
+                                                       password=passwd,
+                                                       install=False)
+        netperf_client_h = utils_netperf.NetperfClient(remote_ip, client_path,
+                                                       md5sum, netperf_link,
+                                                       password=passwd)
+        netperf_server_g = utils_netperf.NetperfServer(guest_address,
+                                                       g_server_path,
+                                                       server_md5sum,
+                                                       netperf_server_link,
+                                                       client=client,
+                                                       port=port,
+                                                       username=username,
+                                                       password=password)
         error.base_context("Run netperf test between host and guest")
         error.context("Start netserver in guest.", logging.info)
-        netperf_server.start()
-        error.context("Start Netperf on host", logging.info)
+        netperf_server_g.start()
+        if netperf_server_h:
+            error.context("Start netserver in host.", logging.info)
+            netperf_server_h.start()
+
+        error.context("Start Netperf in host", logging.info)
         test_option = "-l %s" % netperf_timeout
-        netperf_client.bg_start(guest_address, test_option, client_num)
+        netperf_client_h.bg_start(guest_address, test_option, client_num)
+        if netperf_client_g:
+            error.context("Start Netperf in guest", logging.info)
+            netperf_client_g.bg_start(host_address, test_option, client_num)
 
         m_count = 0
-        while netperf_client.is_test_running():
+        while netperf_client_h.is_netperf_running():
             m_count += 1
             error.context("Start migration iterations: %s " % m_count,
                           logging.info)
             vm.migrate(mig_timeout, mig_protocol, mig_cancel_delay, env=env)
     finally:
-        netperf_server.stop()
-        netperf_server.env_cleanup(True)
-        netperf_client.env_cleanup(True)
+        if netperf_server_g:
+            if netperf_server_g.is_server_running():
+                netperf_server_g.stop()
+            netperf_server_g.package.env_cleanup(True)
+        if netperf_server_h:
+            if netperf_server_h.is_server_running():
+                netperf_server_h.stop()
+            netperf_server_h.package.env_cleanup(True)
+        if netperf_client_h:
+            if netperf_client_h.is_netperf_running():
+                netperf_client_h.stop()
+            netperf_client_h.package.env_cleanup(True)
+        if netperf_client_g:
+            if netperf_client_g.is_netperf_running():
+                netperf_client_g.stop()
+            netperf_client_g.package.env_cleanup(True)
         if session:
             session.close()

qemu/tests/netperf_stress.py

 import re
+import os
 import logging
 import time
 from autotest.client.shared import error
-from virttest import utils_net, utils_netperf, utils_misc
+from virttest import utils_net, utils_netperf, utils_misc, data_dir
 
 
 @error.context_aware
 def run(test, params, env):
     """
-    Run netperf on server and client side, we need run this case on two
-    machines. if dsthost is not set will start netperf server on local
-    host.
-    Netperf stress test will keep running, until stress timeout or
-    env["netperf_run"] is False
+    Run netperf stress on server and client side.
 
-    1) Start one vm guest os as server.
-    2) Start a reference machine (dsthost) as client.
+    1) Start multi vm(s) guest.
+    2) Select multi vm(s) or host to setup netperf server/client.
     3) Run netperf stress test.
-    4) Finish test until timeout or env["netperf_run"] is False.
+    4) Finish test until timeout env["netperf_run"] is False.
 
     :param test: QEMU test object
     :param params: Dictionary with the test parameters
     :param env: Dictionary with test environment.
     """
     login_timeout = float(params.get("login_timeout", 360))
-    dsthost = params.get("dsthost", "localhost")
 
-    vm = env.get_vm(params["main_vm"])
-    vm.verify_alive()
-    session = vm.wait_for_login(timeout=int(params.get("login_timeout", 360)))
-    session.cmd("service iptables stop; iptables -F", ignore_all_errors=True)
+    netperf_server = params.get("netperf_server").split()
+    netperf_client = params.get("netperf_client").split()
+    guest_username = params.get("username", "")
+    guest_password = params.get("password", "")
+    host_password = params.get("hostpassword", "redhat")
+    shell_client = params.get("shell_client")
+    shell_port = params.get("shell_port")
+    os_type = params.get("os_type")
+    host_ip = utils_net.get_host_ip_address(params)
 
-    if dsthost in params.get("vms", "vm1 vm2"):
-        server_vm = env.get_vm(dsthost)
-        server_vm.verify_alive()
-        server_vm.wait_for_login(timeout=login_timeout)
-        dsthost_ip = server_vm.get_address()
-    elif re.match(r"((\d){1,3}\.){3}(\d){1,3}", dsthost):
-        dsthost_ip = dsthost
-    else:
-        server_interface = params.get("netdst", "switch")
-        host_nic = utils_net.Interface(server_interface)
-        dsthost_ip = host_nic.get_ip()
+    vms = params.get("vms")
+    server_infos = []
+    client_infos = []
+    for server in netperf_server:
+        s_info = {}
+        if server in vms:
+            server_vm = env.get_vm(server)
+            server_vm.verify_alive()
+            session = server_vm.wait_for_login(timeout=login_timeout)
+            session.cmd("service iptables stop; iptables -F",
+                        ignore_all_errors=True)
+            server_ip = server_vm.get_address()
+            s_info["ip"] = server_ip
+            s_info["os_type"] = params.get("os_type_%s" % server, os_type)
+            s_info["username"] = params.get("username_%s" % server,
+                                            guest_username)
+            s_info["password"] = params.get("password_%s" % server,
+                                            guest_password)
+            s_info["shell_client"] = params.get("shell_client_%s" % server,
+                                                shell_client)
+            s_info["shell_port"] = params.get("shell_port_%s" % server,
+                                              shell_port)
+        else:
+            if server == "localhost":
+                s_info["ip"] = host_ip
+                s_info["password"] = params.get("password_%s" % server,
+                                                host_password)
+            else:
+                s_info["ip"] = server
+                s_info["password"] = params.get("password_%s" % server,
+                                                "redhat")
+            s_info["os_type"] = params.get("os_type_%s" % server, "linux")
+            s_info["username"] = params.get("username_%s" % server,
+                                            "root")
+            s_info["shell_client"] = params.get("shell_client_%s" % server,
+                                                "ssh")
+            s_info["shell_port"] = params.get("shell_port_%s" % server,
+                                              "22")
+        server_infos.append(s_info)
 
-    download_link = params.get("netperf_download_link")
-    md5sum = params.get("pkg_md5sum")
-    server_download_link = params.get("server_download_link", download_link)
-    server_md5sum = params.get("server_md5sum", md5sum)
-    server_path = params.get("server_path", "/var/tmp")
-    client_path = params.get("client_path", "/var/tmp")
+    for client in netperf_client:
+        c_info = {}
+        if client in vms:
+            client_vm = env.get_vm(client)
+            client_vm.verify_alive()
+            session = client_vm.wait_for_login(timeout=login_timeout)
+            session.cmd("service iptables stop; iptables -F",
+                        ignore_all_errors=True)
+            client_ip = client_vm.get_address()
+            c_info["ip"] = client_ip
+            c_info["os_type"] = params.get("os_type_%s" % server, os_type)
+            c_info["username"] = params.get("username_%s" % server,
+                                            guest_username)
+            c_info["password"] = params.get("password_%s" % server,
+                                            guest_password)
+            c_info["shell_client"] = params.get("shell_client_%s" % server,
+                                                shell_client)
+            c_info["shell_port"] = params.get("shell_port_%s" % server,
+                                              shell_port)
+        else:
+            if client == "localhost":
+                c_info["ip"] = host_ip
+                c_info["password"] = params.get("password_%s" % server,
+                                                host_password)
+            else:
+                c_info["ip"] = client
+                c_info["password"] = params.get("password_%s" % server,
+                                                "redhat")
+            c_info["os_type"] = params.get("os_type_%s" % server, "linux")
+            c_info["username"] = params.get("username_%s" % server,
+                                            "root")
+            c_info["shell_client"] = params.get("shell_client_%s" % server,
+                                                "ssh")
+            c_info["shell_port"] = params.get("shell_port_%s" % server,
+                                              "23")
+        client_infos.append(c_info)
 
-    guest_usrname = params.get("username", "")
-    guest_passwd = params.get("password", "")
-    host_passwd = params.get("hostpasswd")
-    client = params.get("shell_client")
-    port = params.get("shell_port")
+    netperf_link = params.get("netperf_link")
+    netperf_link = os.path.join(data_dir.get_deps_dir("netperf"), netperf_link)
+    md5sum = params.get("pkg_md5sum")
+    netperf_server_link = params.get("netperf_server_link_win", netperf_link)
+    netperf_server_link = os.path.join(data_dir.get_deps_dir("netperf"),
+                                       netperf_server_link)
+    server_md5sum = params.get("server_md5sum")
+    netperf_client_link = params.get("netperf_client_link_win", netperf_link)
+    netperf_client_link = os.path.join(data_dir.get_deps_dir("netperf"),
+                                       netperf_client_link)
+    client_md5sum = params.get("client_md5sum")
 
-    # main vm run as server when vm_as_server is 'yes'.
-    if params.get("vm_as_server", "yes") == "yes":
-        netserver_ip = vm.get_address()
-        netperf_client_ip = dsthost_ip
-    else:
-        netserver_ip = dsthost_ip
-        netperf_client_ip = vm.get_address()
+    server_path_linux = params.get("server_path", "/var/tmp")
+    client_path_linux = params.get("client_path", "/var/tmp")
+    server_path_win = params.get("server_path_win", "c:\\")
+    client_path_win = params.get("client_path_win", "c:\\")
 
-    netperf_client = utils_netperf.NetperfClient(netperf_client_ip,
-                                                 client_path,
-                                                 md5sum, download_link,
-                                                 password=host_passwd)
+    netperf_clients = []
+    netperf_servers = []
+    for c_info in client_infos:
+        if c_info["os_type"] == "windows":
+            netperf_link_c = netperf_client_link
+            client_path = client_path_win
+        else:
+            netperf_link_c = netperf_link
+            client_path = client_path_linux
+        n_client = utils_netperf.NetperfClient(c_info["ip"],
+                                               client_path,
+                                               md5sum, netperf_link_c,
+                                               client=c_info["shell_client"],
+                                               port=c_info["shell_port"],
+                                               username=c_info["username"],
+                                               password=c_info["password"])
+        netperf_clients.append(n_client)
 
-    netperf_server = utils_netperf.NetperfServer(netserver_ip,
-                                                 server_path,
-                                                 server_md5sum,
-                                                 server_download_link,
-                                                 client, port,
-                                                 username=guest_usrname,
-                                                 password=guest_passwd)
+    for s_info in server_infos:
+        if s_info["os_type"] == "windows":
+            netperf_link_s = netperf_server_link
+            server_path = server_path_win
+        else:
+            netperf_link_s = netperf_link
+            server_path = server_path_linux
+        n_server = utils_netperf.NetperfServer(s_info["ip"],
+                                               server_path,
+                                               md5sum, netperf_link_s,
+                                               client=s_info["shell_client"],
+                                               port=s_info["shell_port"],
+                                               username=s_info["username"],
+                                               password=s_info["password"])
+        netperf_servers.append(n_server)
 
     # Get range of message size.
     try:
-        netperf_server.start()
+        for n_server in netperf_servers:
+            n_server.start()
         # Run netperf with message size defined in range.
-        stress_timeout = float(params.get("netperf_test_timeout", 1200))
-        netperf_test_duration = float(params.get("netperf_test_duration", 60))
+        netperf_test_duration = int(params.get("netperf_test_duration", 60))
         netperf_para_sess = params.get("netperf_para_sessions", "1")
         test_protocol = params.get("test_protocol", "TCP_STREAM")
         netperf_cmd_prefix = params.get("netperf_cmd_prefix", "")
         test_option = "-t %s -l %s" % (test_protocol, netperf_test_duration)
         start_time = time.time()
-        stop_time = start_time + stress_timeout
-
-        netperf_client.bg_start(netserver_ip, test_option,
-                                netperf_para_sess, netperf_cmd_prefix)
-        if utils_misc.wait_for(netperf_client.is_test_running, 10, 0, 1,
-                               "Wait netperf test start"):
-            logging.debug("Netperf test start successfully.")
-            # here when set a run flag, when other case call this case as a
-            # subprocess backgroundly, can set this run flag to False to stop
-            # the stress test.
-            env["netperf_run"] = True
-        else:
-            raise error.TestNAError("Can not start netperf test")
-
-        while (env["netperf_run"] and time.time() < stop_time):
-            run_left_time = stop_time - time.time()
-            if netperf_client.is_test_running():
-                if not utils_misc.wait_for(lambda: not
-                                           netperf_client.is_test_running(),
-                                           run_left_time, 0, 5,
-                                           "Wait netperf test finish"):
-                    logging.debug("Stress test timeout, finish it")
-                    break
-            netperf_client.bg_start(vm.get_address(), test_option,
-                                    netperf_para_sess)
+        stop_time = start_time + netperf_test_duration
+        num = 0
+        s_len = len(server_infos)
+        for n_client in netperf_clients:
+            index = num % s_len
+            server_ip = server_infos[index]["ip"]
+            n_client.bg_start(server_ip, test_option,
+                              netperf_para_sess, netperf_cmd_prefix)
+            if utils_misc.wait_for(n_client.is_netperf_running, 10, 0, 1,
+                                   "Wait netperf test start"):
+                logging.info("Netperf test start successfully.")
+            else:
+                raise error.TestError("Can not start netperf client.")
+            num += 1
+        # here when set a run flag, when other case call this case as a
+        # subprocess backgroundly, can set this run flag to False to stop
+        # the stress test.
+        env["netperf_run"] = True
 
+        for n_client in netperf_clients:
+            if n_client.is_netperf_running():
+                left_time = stop_time - time.time()
+                utils_misc.wait_for(lambda: not
+                                    n_client.is_netperf_running(),
+                                    left_time, 0, 5,
+                                    "Wait netperf test finish %ss" % left_time)
     finally:
-        netperf_server.stop()
-        netperf_server.env_cleanup(True)
-        netperf_client.env_cleanup(True)
+        for n_server in netperf_servers:
+            if n_server:
+                n_server.stop()
+            n_server.package.env_cleanup(True)
+        for n_client in netperf_clients:
+            if n_client:
+                n_client.package.env_cleanup(True)
         env["netperf_run"] = False
         if session:
             session.close()