Rolled up change to wireless test suite for OpenWRT.

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
 
@@ skipping 48 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
+        router = config['router']
 
-        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]
 
         if 'type' not in router:
             # auto-detect router type
             if site_linux_router.isLinuxRouter(self.router):
                 router['type'] = 'linux'
-            if site_bsd_router.isBSDRouter(self.router):
+            elif site_bsd_router.isBSDRouter(self.router):
                 router['type'] = 'bsd'
             else:
                 raise Exception('Unable to autodetect router type')
         if router['type'] == 'linux':
             self.wifi = site_linux_router.LinuxRouter(self.router, router,
                 self.defssid)
         elif router['type'] == 'bsd':
             self.wifi = site_bsd_router.BSDRouter(self.router, router,
                 self.defssid)
         else:
@@ skipping 73 matching lines @@
                     self.cleanup(params)
                     break
             else:
                 logging.error("%s: Step '%s' unknown; abort test",
                     self.name, method)
                 self.cleanup(params)
                 break
 
 
     def __get_connect_script(self, params):
+        # Something is off in our current setup so we'll set the assoc_timeout
+        # to 60. When all is fixed, it should go back to 15.
         return '''
 import dbus, dbus.mainloop.glib, gobject, logging, re, sys, time
 
 ssid = "''' + params['ssid'] + '''"
 security = "''' + params['security'] + '''"
 psk = "''' + params.get('psk', "") + '''"
-assoc_timeout = ''' + params.get('assoc_timeout', "15") + '''
+assoc_timeout = ''' + params.get('assoc_timeout', "60") + '''
 config_timeout = ''' + params.get('config_timeout', "15") + '''
 
 bus_loop = dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
 bus = dbus.SystemBus(mainloop=bus_loop)
 manager = dbus.Interface(bus.get_object("org.moblin.connman", "/"),
     "org.moblin.connman.Manager")
 
 try:
     path = manager.GetService(({
         "Type": "wifi",
@@ skipping 242 matching lines @@
     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 client_ping(self, params):
         """ Ping the server from the client """
         ping_ip = params.get('ping_ip', self.server_wifi_ip)
         count = params.get('count', 10)
-        # set timeout for 3s / ping packet
+        # set timeout for 5s / ping packet
         result = self.client.run("ping %s %s" % \
-            (self.__ping_args(params), ping_ip), timeout=3*int(count))
+            (self.__ping_args(params), ping_ip), timeout=5*int(count))
 
         self.__print_pingstats("client_ping ",
             self.__get_pingstats(result.stdout))
 
 
     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', 10)
-        # set timeout for 3s / ping packet
+        # set timeout for 5s / ping packet
         result = self.server.run("ping %s %s" % \
-            (self.__ping_args(params), ping_ip), timeout=3*int(count))
+            (self.__ping_args(params), ping_ip), timeout=5*int(count))
 
         self.__print_pingstats("server_ping ",
             self.__get_pingstats(result.stdout))
 
 
     def server_ping_bg(self, params):
         """ Ping the client from the server """
         if self.server is None:
             self.__unreachable("server_ping_bg")
             return
@@ skipping 182 matching lines @@
 
     server = config['server']
     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