Add standalone netperf code directly within site_wifitest

server/site_wifitest.py

 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import common, fnmatch, logging, os, re, string, threading, time
 
 from autotest_lib.server import autotest, hosts, subcommand
 from autotest_lib.server import site_bsd_router
 from autotest_lib.server import site_linux_router
 from autotest_lib.server import site_host_attributes
@@ skipping 101 matching lines @@
         # The server machine may be multi-homed or only on the wifi
         # network.  When only on the wifi net we suppress server_*
         # requests since we cannot initiate them from the control machine.
         #
         server = config['server']
         # NB: server may not be reachable on the control network
         if 'addr' in server:
             self.server = hosts.create_host(server['addr'])
             self.server_at = autotest.Autotest(self.server)
             # if not specified assume the same as the control address
-            self.server_wifi_ip = getattr(server, 'wifi_addr', self.server.ip)
+            self.server_wifi_ip = server.get('wifi_addr', self.server.ip)
+            self.__server_discover_commands(server)
         else:
             self.server = None;
             # NB: wifi address must be set if not reachable from control
             self.server_wifi_ip = server['wifi_addr']
 
         # potential bg thread for ping untilstop
         self.ping_thread = None
 
         # potential bg thread for client network monitoring
         self.client_netdump_thread = None
-        self.client_cmd_netdump = client.get('cmd_netdump', 'tshark')
-        self.client_cmd_ifconfig = client.get('cmd_ifconfig', 'ifconfig')
-        self.client_cmd_iw = client.get('cmd_iw', 'iw')
+        self.__client_discover_commands(client)
+        self.netperf_iter = 0
+        self.firewall_rules = []
 
 
     def cleanup(self, params):
         """ Cleanup state: disconnect client and destroy ap """
         self.disconnect({})
         self.wifi.destroy({})
         self.client_netdump_stop({})
+        self.firewall_cleanup({})
+
+
+    def __client_discover_commands(self, client):
+        self.client_cmd_netdump = client.get('cmd_netdump', 'tshark')
+        self.client_cmd_ifconfig = client.get('cmd_ifconfig', 'ifconfig')
+        self.client_cmd_iw = client.get('cmd_iw', 'iw')
+        self.client_cmd_netperf = client.get('cmd_netperf_client',
+                                             '/usr/local/bin/netperf')
+        self.client_cmd_netserv = client.get('cmd_netperf_server',
+                                             '/usr/local/sbin/netserver')
+        self.client_cmd_iptables = '/sbin/iptables'
+
+
+    def __server_discover_commands(self, server):
+        self.server_cmd_netperf = server.get('cmd_netperf_client',
+                                             '/usr/bin/netperf')
+        self.server_cmd_netserv = server.get('cmd_netperf_server',
+                                             '/usr/bin/netserver')
+        # /usr/bin/ping is preferred, as it is likely to be iputils
+        if self.__is_installed(self.server, '/usr/bin/ping'):
+            self.server_ping_cmd = '/usr/bin/ping'
+        else:
+            self.server_ping_cmd = 'ping'
 
 
     def __get_defssid(self, ipaddr):
         #
         # Calculate ssid based on test name; this lets us track progress
         # by watching beacon frames.
         #
         return re.sub('[^a-zA-Z0-9_]', '_', "%s_%s" % (self.name, ipaddr))
 
 
@@ skipping 224 matching lines @@
     def __get_pingstats(self, str):
         stats = {}
         for k in ('xmit', 'recv', 'loss', 'min', 'avg', 'max'):
             stats[k] = '???'
         m = re.search('([0-9]*) packets transmitted,[ ]*([0-9]*)[ ]'
             '(packets |)received, ([0-9]*)', str)
         if m is not None:
             stats['xmit'] = m.group(1)
             stats['recv'] = m.group(2)
             stats['loss'] = m.group(4)
-        m = re.search('(round-trip|rtt) min[^=]*= ([0-9.]*)/([0-9.]*)/([0-9.]*)', str)
+        m = re.search('(round-trip|rtt) min[^=]*= '
+                      '([0-9.]*)/([0-9.]*)/([0-9.]*)', str)
         if m is not None:
             stats['min'] = m.group(2)
             stats['avg'] = m.group(3)
             stats['max'] = m.group(4)
         return stats
 
 
     def __print_pingstats(self, label, stats):
         logging.info("%s: %s%s/%s, %s%% loss, rtt %s/%s/%s",
             self.name, label, stats['xmit'], stats['recv'], stats['loss'],
              stats['min'], stats['avg'], stats['max'])
 
 
+    def __ping_prefix(self, params):
+        if 'name' in params:
+            return params['name']
+
+        args = []
+        for k, v in params.items():
+            if k != 'count':
+                args.append('%s_%s' % (k, v))
+        return '/'.join(args)
+
+
     def client_ping(self, params):
         """ Ping the server from the client """
         ping_ip = params.get('ping_ip', self.server_wifi_ip)
         count = params.get('count', self.defpingcount)
         # set timeout for 3s / ping packet
         result = self.client.run("ping %s %s" % \
             (self.__ping_args(params), ping_ip), timeout=3*int(count))
 
         stats = self.__get_pingstats(result.stdout)
+        prefix = 'client_ping_%s_' % self.__ping_prefix(params)
         for k,v in stats.iteritems():
-            self.keyvals['client_ping_' + k] = v
+            self.keyvals[prefix + k] = v
         self.__print_pingstats("client_ping ", stats)
 
 
     def client_ping_bg(self, params):
         """ Ping the server from the client """
         ping_ip = params.get('ping_ip', self.server_wifi_ip)
         cmd = "ping %s %s" % (self.__ping_args(params), ping_ip)
         self.ping_thread = HelperThread(self.client, cmd)
         self.ping_thread.start()
 
 
     def client_ping_bg_stop(self, params):
         if self.ping_thread is not None:
             self.client.run("pkill ping")
             self.ping_thread.join()
             self.ping_thread = None
 
 
     def server_ping(self, params):
         """ Ping the client from the server """
         if self.server is None:
             self.__unreachable("server_ping")
             return
         ping_ip = params.get('ping_ip', self.client_wifi_ip)
         count = params.get('count', self.defpingcount)
         # set timeout for 3s / ping packet
-        result = self.server.run("ping %s %s" % \
-            (self.__ping_args(params), ping_ip), timeout=3*int(count))
+        result = self.server.run("%s %s %s" % \
+            (self.server_ping_cmd, self.__ping_args(params),
+             ping_ip), timeout=3*int(count))
 
         stats = self.__get_pingstats(result.stdout)
+        prefix = 'server_ping_' + self.__ping_prefix(params)
         for k,v in stats.iteritems():
             self.keyvals['server_ping_' + k] = v
         self.__print_pingstats("server_ping ", stats)
 
 
     def server_ping_bg(self, params):
         """ Ping the client from the server """
         if self.server is None:
             self.__unreachable("server_ping_bg")
             return
@@ skipping 61 matching lines @@
 
 
     def server_iperf(self, params):
         """ Run iperf on the server against the client """
         if self.server is None:
             self.__unreachable("server_iperf")
             return
         self.__run_iperf(self.server_wifi_ip, self.client_wifi_ip, params)
 
 
-    def __run_netperf(self, client_ip, server_ip, params):
-        template = "job.run_test('"
-        if self.server is None:
-            template += "network_netperf2"
+    def __is_installed(self, host, filename):
+        result = host.run("ls %s" % filename, ignore_status=True)
+        m = re.search(filename, result.stdout)
+        return m is not None
+
+
+    def __firewall_open(self, proto, src):
+        rule = 'INPUT -s %s/32 -p %s -m %s -j ACCEPT' % (src, proto, proto)
+        result = self.client.run('%s -S INPUT' % self.client_cmd_iptables)
+        if '-A %s ' % rule in result.stdout.splitlines():
+            return None
+        self.client.run('%s -A %s' % (self.client_cmd_iptables, rule))
+        self.firewall_rules.append(rule)
+        return rule
+
+
+    def __firewall_close(self, rule):
+        if rule in self.firewall_rules:
+            self.client.run('%s -D %s' % (self.client_cmd_iptables, rule))
+            self.firewall_rules.remove(rule)
+
+    def firewall_cleanup(self, params):
+        for rule in self.firewall_rules:
+            self.__firewall_close(rule)
+
+    def __run_netperf(self, mode, params):
+        np_rules = []
+        if mode == 'server':
+            server = { 'host': self.client, 'cmd': self.client_cmd_netserv }
+            client = { 'host': self.server, 'cmd': self.server_cmd_netperf,
+                       'target': self.client_wifi_ip }
+
+            # Open up access from the server into our DUT
+            np_rules.append(self.__firewall_open('tcp', self.server_wifi_ip))
+            np_rules.append(self.__firewall_open('udp', self.server_wifi_ip))
         else:
-            template += "netperf2"
-        template += "', server_ip='%s', client_ip='%s', role='%s'"
-        if 'test' in params:
-            template += ", test='%s'" % params['test']
-        if 'bidir' in params:
-            template += ", bidi=True"
-        if 'time' in params:
-            template += ", test_time=%s" % params['time']
-        template += ", wait_time=%s" % params.get('wait_time', self.defwaittime)
+            server = { 'host': self.server, 'cmd': self.server_cmd_netserv }
+            client = { 'host': self.client, 'cmd': self.client_cmd_netperf,
+                       'target': self.server_wifi_ip }
 
-        # add a tag to distinguish runs when multiple tests are run
-        if 'tag' in params:
-            template += ", tag='%s'" % params['tag']
-        elif 'test' in params:
-            template += ", tag='%s'" % params['test']
+        # If appropriate apps are not installed, raise an error
+        if not self.__is_installed(client['host'], client['cmd']) or \
+                not self.__is_installed(server['host'], server['cmd']):
+            raise error.TestFail('Unable to find netperf on client or server')
 
-        template += ")"
+        # There are legitimate ways this command can fail, eg. already running
+        server['host'].run(server['cmd'], ignore_status=True)
 
-        client_control_file = template % (server_ip, client_ip, 'client')
-        client_command = subcommand.subcommand(self.client_at.run,
-               [client_control_file, self.client.hostname])
-        cmds = [client_command]
+        # Assemble arguments for client command
+        test = params.get('test', 'TCP_STREAM')
+        netperf_args = '-H %s -t %s -l %d' % (client['target'], test,
+                                              params.get('test_time', 15))
 
-        if self.server is None:
-            logging.info("%s: netperf %s => (%s)",
-                self.name, client_ip, server_ip)
+        # Run netperf command and receive command results
+        t0 = time.time()
+        results = client['host'].run("%s %s" % (client['cmd'], netperf_args))
+        actual_time = time.time() - t0
+        logging.info('actual_time: %f', actual_time)
+
+        # Close up whatever firewall rules we created for netperf
+        for rule in np_rules:
+            self.__firewall_close(rule)
+
+        # Results are prefixed with the iteration or a caller-defined name
+        prefix = 'Netperf_%s_' % params.get('name', str(self.netperf_iter))
+        self.netperf_iter += 1
+
+        self.keyvals[prefix + 'test'] = test
+        self.keyvals[prefix + 'mode'] = mode
+        self.keyvals[prefix + 'actual_time'] = actual_time
+
+        logging.info(results)
+
+        lines = results.stdout.splitlines()
+
+        # Each test type has a different form of output
+        if test in ['TCP_STREAM', 'TCP_MAERTS', 'TCP_SENDFILE']:
+            """Parses the following (works for both TCP_STREAM, TCP_MAERTS and
+            TCP_SENDFILE) and returns a singleton containing throughput.
+
+            TCP STREAM TEST from 0.0.0.0 (0.0.0.0) port 0 AF_INET to \
+            foo.bar.com (10.10.10.3) port 0 AF_INET
+            Recv   Send    Send
+            Socket Socket  Message  Elapsed
+            Size   Size    Size     Time     Throughput
+            bytes  bytes   bytes    secs.    10^6bits/sec
+
+            87380  16384  16384    2.00      941.28
+            """
+            self.keyvals[prefix + 'Throughput'] = float(lines[6].split()[4])
+        elif test == 'UDP_STREAM':
+            """Parses the following and returns a touple containing throughput
+            and the number of errors.
+
+            UDP UNIDIRECTIONAL SEND TEST from 0.0.0.0 (0.0.0.0) port 0 AF_INET \
+            to foo.bar.com (10.10.10.3) port 0 AF_INET
+            Socket  Message  Elapsed      Messages
+            Size    Size     Time         Okay Errors   Throughput
+            bytes   bytes    secs            #      #   10^6bits/sec
+
+            129024   65507   2.00         3673      0     961.87
+            131072           2.00         3673            961.87
+            """
+            udp_tokens = lines[5].split()
+            self.keyvals[prefix + 'Throughput'] = float(udp_tokens[5])
+            self.keyvals[prefix + 'Errors'] = float(udp_tokens[4])
+        elif test in ['TCP_RR', 'TCP_CRR', 'UDP_RR']:
+            """Parses the following which works for both rr (TCP and UDP)
+            and crr tests and returns a singleton containing transfer rate.
+
+            TCP REQUEST/RESPONSE TEST from 0.0.0.0 (0.0.0.0) port 0 AF_INET \
+            to foo.bar.com (10.10.10.3) port 0 AF_INET
+            Local /Remote
+            Socket Size   Request  Resp.   Elapsed  Trans.
+            Send   Recv   Size     Size    Time     Rate
+            bytes  Bytes  bytes    bytes   secs.    per sec
+
+            16384  87380  1        1       2.00     14118.53
+            16384  87380
+            """
+            self.kevals[prefix + 'Trasnfer_Rate'] = float(lines[6].split()[5])
         else:
-            server_control_file = template % (server_ip, client_ip, 'server')
-            server_command = subcommand.subcommand(self.server_at.run,
-                   [server_control_file, self.server.hostname])
-            cmds.append(server_command)
+            raise error.TestError('Unhandled test')
 
-            logging.info("%s: netperf %s => %s",
-                self.name, client_ip, server_ip)
-
-        subcommand.parallel(cmds)
+        return True
 
 
     def client_netperf(self, params):
         """ Run netperf on the client against the server """
-        self.__run_netperf(self.client_wifi_ip, self.server_wifi_ip, params)
+        self.__run_netperf('client', params)
+
 
     def server_netperf(self, params):
         """ Run netperf on the server against the client """
         if self.server is None:
             self.__unreachable("server_netperf")
             return
-        self.__run_netperf(self.server_wifi_ip, self.client_wifi_ip, params)
+        self.__run_netperf('server', params)
 
 
     def __create_netdump_dev(self, devname='mon0'):
         self.client.run("%s dev %s del || /bin/true" % (self.client_cmd_iw,
                                                         devname))
         self.client.run("%s dev %s interface add %s type monitor" %
                         (self.client_cmd_iw, self.client_wlanif, devname))
         self.client.run("%s %s up" % (self.client_cmd_ifconfig, devname))
         return devname
 
@@ skipping 39 matching lines @@
 
 
 def __byfile(a, b):
     if a['file'] < b['file']:
         return -1
     elif a['file'] > b['file']:
         return 1
     else:
         return 0
 
+
 def read_tests(dir, *args):
     """
     Collect WiFi test tuples from files.  File names are used to
     sort the test objects so the convention is to name them NNN<test>
     where NNN is a decimal number used to sort and <test> is an
     identifying name for the test; e.g. 000Check11b
     """
     tests = []
     for file in os.listdir(dir):
         if any(fnmatch.fnmatch(file, pat) for pat in args):
@@ skipping 34 matching lines @@
     if server_addr is None and hasattr(client_attributes, 'server_addr'):
         server_addr = client_attributes.server_addr
     if server_addr is not None:
         server['addr'] = server_addr;
     # TODO(sleffler) check for wifi_addr when no control address
 
     # tag jobs w/ the router's address on the control network
     config['tagname'] = router['addr']
 
     return config