Create implicit concept of iterations in 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 50 matching lines @@
     by adding a new class and auto-selecting it in __init__.
 
     The WiFiTest class could be generalized to handle clients other than
     ChromeOS; this would useful for systems that use Network Manager or
     wpa_supplicant directly.
     """
 
     def __init__(self, name, steps, config):
         self.name = name
         self.steps = steps
-        self.keyvals = {}
+        self.perf_keyvals = {}
 
         router = config['router']
         self.router = hosts.create_host(router['addr'])
         # NB: truncate SSID to 32 characters
         self.defssid = self.__get_defssid(router['addr'])[0:32]
 
         defaults = config.get('defaults', {})
         self.deftimeout = defaults.get('timeout', 30)
         self.defpingcount = defaults.get('pingcount', 10)
         self.defwaittime = str(defaults.get('netperf_wait_time', 3))
@@ skipping 43 matching lines @@
             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_discover_commands(client)
-        self.netperf_iter = 0
         self.firewall_rules = []
 
+        # Find all repeated steps and create iterators for them
+        self.iterated_steps = {}
+        step_names = [step[0] for step in steps]
+        for step_name in list(set(step_names)):
+            if step_names.count(step_name) > 1:
+                self.iterated_steps[step_name] = 0
 
     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):
@@ skipping 33 matching lines @@
         in this class or the ancillary router class and invoked with
         the supplied parameter dictionary.
         """
         for s in self.steps:
             method = s[0]
             if len(s) > 1:
                 params = s[1]
             else:
                 params = {}
 
+            # What should perf data be prefixed with?
+            if 'perf_prefix' in params:
+                self.prefix = '%s_%s' % (method, params.pop('perf_prefix'))
+            elif method in self.iterated_steps:
+                self.prefix = '%s_%d' % (method, self.iterated_steps[method])
+                self.iterated_steps[method] += 1
+            else:
+                self.prefix = method
+
             logging.info("%s: step '%s' params %s", self.name, method, params)
 
             func = getattr(self, method, None)
             if func is None:
                 func = getattr(self.wifi, method, None)
             if func is not None:
                 try:
                     func(params)
                 except Exception, e:
                     logging.error("%s: Step '%s' failed: %s; abort test",
                         self.name, method, str(e))
                     self.cleanup(params)
                     raise e
                     break
             else:
                 logging.error("%s: Step '%s' unknown; abort test",
                     self.name, method)
                 self.cleanup(params)
                 break
 
         # Other cleanup steps might be optional, but this is mandatory
         self.client_netdump_stop({})
 
 
     def write_keyvals(self, job):
-        job.write_perf_keyval(self.keyvals)
+        job.write_perf_keyval(self.perf_keyvals)
 
+    def write_perf(self, data):
+        for key, value in data.iteritems():
+            self.perf_keyvals['%s_%s' % (self.prefix, key)] = value
 
     def __get_ipaddr(self, host, ifnet):
         # XXX gotta be a better way to do this
         result = host.run("%s %s" % (self.client_cmd_ifconfig, ifnet))
         m = re.search('inet addr:([^ ]*)', result.stdout)
         if m is None:
              raise error.TestFail("No inet address found")
         return m.group(1)
 
 
@@ skipping 15 matching lines @@
         result = self.client.run('python "%s" "%s" "%s" "%s" "%d" "%d"' %
             (script_client_file,
             params.get('ssid', self.wifi.get_ssid()),
             params.get('security', ''),
             params.get('psk', ''),
             params.get('assoc_timeout', self.deftimeout),
             params.get('config_timeout', self.deftimeout))).stdout.rstrip()
 
         result_times = re.match("OK ([0-9\.]*) ([0-9\.]*) .*", result)
 
-        self.keyvals['connect_config_s'] = result_times.group(1)
-        self.keyvals['connect_assoc_s'] = result_times.group(2)
-        for k in ('multiple_attempts', 'clear_error', 'fast_fail'):
+        self.write_perf({'config_s': result_times.group(1),
+                          'assoc_s': result_times.group(2)})
+        for k in ('already_connected', 'clear_error', 'fast_fail',
+                  'get_prop', 'in_progress', 'lost_dbus', 'multiple_attempts'):
             if re.search(k, result) is not None:
-                self.keyvals[k] = 'true'
+                self.write_perf({k:'true'})
 
         print "%s: %s" % (self.name, result)
 
         # fetch IP address of wireless device
         self.client_wifi_ip = self.__get_ipaddr(self.client, self.client_wlanif)
         logging.info("%s: client WiFi-IP is %s", self.name, self.client_wifi_ip)
         # TODO(sleffler) not right for non-mac80211 devices
         # TODO(sleffler) verify debugfs is mounted @ /sys/kernel/debug
         self.client_debugfs_path = "/sys/kernel/debug/ieee80211/%s/netdev:%s" \
             % ("phy0", self.client_wlanif)
@@ skipping 149 matching lines @@
             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[prefix + k] = v
+        self.write_perf(stats)
         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()
 
@@ skipping 11 matching lines @@
             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("%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.write_perf(stats)
         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
         ping_ip = params.get('ping_ip', self.client_wifi_ip)
         cmd = "ping %s %s" % (self.__ping_args(params), ping_ip)
@@ skipping 122 matching lines @@
         # 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
+        self.write_perf({'test':test, 'mode':mode, '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])
+            self.write_perf({'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])
+            self.write_perf({'Throughput':float(udp_tokens[5]),
+                             '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])
+            self.write_perf({'Trasnfer_Rate':float(lines[6].split()[5])})
         else:
             raise error.TestError('Unhandled test')
 
         return True
 
 
     def client_netperf(self, params):
         """ Run netperf on the client against the server """
         self.__run_netperf('client', params)
 
@@ skipping 111 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