Add a route backwards from the DUT to the test host

server/site_wifitest.py

 # Copyright (c) 2011 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, datetime, 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_linux_server
 from autotest_lib.server import site_host_attributes
+from autotest_lib.server import site_host_route
 from autotest_lib.server import site_eap_certs
 from autotest_lib.server import test
 from autotest_lib.client.common_lib import error
 
 class NotImplemented(Exception):
     def __init__(self, what):
         self.what = what
 
 
     def __str__(self):
@@ skipping 125 matching lines @@
         self.hosting_server = site_linux_server.LinuxServer(self.server, server)
 
         # 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.profile_save({})
         self.firewall_rules = []
+        self.host_route_args = {}
 
         # interface name on client
         self.client_wlanif = client.get('wlandev',
                                         self.__get_wlan_devs(self.client)[0])
 
         # Synchronize time on all devices
         self.time_sync([])
 
         # 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 """
         if params.get('force_disconnect'):
             self.disconnect({})
             self.wifi.destroy({})
         self.profile_cleanup({})
         self.client_netdump_stop({})
         self.firewall_cleanup({})
+        self.host_route_cleanup({})
 
 
     def __must_be_installed(self, host, cmd):
         if not self.__is_installed(host, cmd):
             # TODO(sleffler): temporary debugging
             host.run("ls -a /usr/bin /usr/local/bin" % cmd, ignore_status=True)
             raise error.TestFail('Unable to find %s on %s' % (cmd, host.ip))
         return cmd
 
 
@@ skipping 1033 matching lines @@
                     If not specified, the default is 'none'.
                     The value provided is passed directly to 'connect-vpn'.
         """
         self.vpn_client_kill({}) # Must be first.  Relies on self.vpn_kind.
         self.vpn_kind = params.get('kind', None)
         vpn_host_ip   = params.get('vpn-host-ip', self.server_wifi_ip)
 
         # Must get 'ca_certificate', 'client-certificate' and 'client-key'.
         cert_pathnames = params.get('files', {})
 
+        # Starting up the VPN client may cause the DUT's routing table (esp.
+        # the default route) to change.  Set up a host route backwards so

[thutt, 2011/04/01 22:01:56]

Thanks, that looks great.

+        # we don't lose our control connection in htat event.
+        __add_host_route(self.client)
+
         if self.vpn_kind is None:
             raise error.TestFail('No VPN kind specified for this test.')
         elif self.vpn_kind == 'openvpn':
             remote_cert_tls_option = ""
             remote_cert_tls        = params.get('remote-cert-tls', None)
 
             if remote_cert_tls is not None:
                 remote_cert_tls_option = "--remote-cert-tls " + remote_cert_tls
 
             # connect-vpn openvpn [options] <name> <host-ip> <domain> \
@@ skipping 18 matching lines @@
     def vpn_client_kill(self, params):
         """ Kill the VPN client if it's running. """
         if self.vpn_kind is not None:
             if self.vpn_kind == 'openvpn':
                 self.client.run("pkill openvpn")
             else:
                 raise error.TestFail('(internal error): No kill case '
                                      'for VPN kind (%s)' % self.vpn_kind)
             self.vpn_kind = None
 
+        __del_host_route(self.client)
+
+    def __add_host_route(self, host):
+        # What is the local address we use to get to the test host?
+        local_ip = site_host_route.LocalHostRoute(host.ip).route_info["src"]
+
+        # How does the test host currently get to this local address?
+        host_route = site_host_route.RemoteHostRoute(host, local_ip).route_info
+
+        # Flatten the returned dict into a single string
+        route_args = " ".join(" ".join(x) for x in host_route.iteritems())
+
+        self.host_route_args[host.ip] = "%s %s" % (local_ip, route_args)
+        host.run("ip route add %s" % self.host_route_args[host.ip])
+
+    def __del_host_route(self, host):
+        if host.ip not in self.host_route_args:
+            return
+
+        host.run("ip route del %s" % self.host_route_args.pop(host.ip))
+
+    def host_route_cleanup(self, params):
+        for host in (self.client, self.server, self.router):
+            self.__del_host_route(host)
+
+
 class HelperThread(threading.Thread):
     # Class that wraps a ping command in a thread so it can run in the bg.
     def __init__(self, client, cmd):
         threading.Thread.__init__(self)
         self.client = client
         self.cmd = cmd
 
     def run(self):
         # NB: set ignore_status as we're always terminated w/ pkill
         self.result = self.client.run(self.cmd, ignore_status=True)
@@ skipping 114 matching lines @@
     except error.TestFail:
       if 'expect_failure' in testcase:
         self.expect_failure(name, testcase['expect_failure'])
       else:
         raise
     except Exception, e:
       if 'expect_failure' in testcase:
         self.expect_failure(name, testcase['expect_failure'])
       else:
         raise