VPN: Test to set up & validate a Client connection to the Server

server/site_wifitest.py

-# Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
+
+# Copyright (c) 2010, 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_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
 
 
@@ skipping 27 matching lines @@
       client_monitor_stop     stop monitoring for wireless system events
       client_check_event_*    check the client's event log for an event;
                               should always be preceded by client_monitor_start
       sleep                   pause on the autotest server for a time
       client_ping             ping the server on the client machine
       server_ping             ping the client on the server machine
       client_iperf            run iperf on the client to the server
       server_iperf            run iperf on the server to the client
       client_netperf          run netperf on the client to the server
       server_netperf          run netperf on the server to the client
+      vpn_launch_client       launch a VPN client to connect with the
+                              VPN server
 
     Steps that are done on the client or server machine are implemented in
     this class.  Steps that are done on the wifi router are implemented in
     a separate class that knows how to control the router.  There are presently
     two classes: BSDRouter for routers based on FreeBSD and LinuxRouter for
     those based on Linux/mac80211.  Additional router support can be added
     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.perf_keyvals = {}
 
         self.cur_frequency = None;
         self.cur_phymode = None;
         self.cur_security = None;
 
         router = config['router']
+        #
+        # 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
+
         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 = defaults.get('netperf_wait_time', 3)
         self.defiperfport = str(defaults.get('iperf_port', 12866))
         self.defnetperfport = str(defaults.get('netperf_port', 12865))
@@ skipping 19 matching lines @@
         # The address on the wifi network is retrieved each time it
         # associates to the router.
         #
         client = config['client']
         self.client = hosts.create_host(client['addr'])
         self.client_at = autotest.Autotest(self.client)
         self.client_wifi_ip = None            # client's IP address on wifi net
         self.client_wifi_device_path = None   # client's flimflam wifi path
         self.client_installed_scripts = {}
 
-        #
-        # 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 = 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']
 
+        # hosting_server is a machine which hosts network services,
+        # such as VPN.
+        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 = []
 
         # interface name on client
@@ skipping 108 matching lines @@
                 logging.info("%s: step '%s' (expect failure)  params %s",
                     self.name, method, params)
             else:
                 logging.info("%s: step '%s' params %s", self.name, method,
                     params)
 
             self.error_message = ''
             func = getattr(self, method, None)
             if func is None:
                 func = getattr(self.wifi, method, None)
+            if func is None:
+                func = getattr(self.hosting_server, method, None)
             if func is not None:
                 try:
                     func(params)
                     if expect_failure is True:
                         expect_failure = False
                         raise error.TestFail("Expected failure")
                 except Exception, e:
                     if expect_failure is True:
                         if not failure_string:
                             continue
@@ skipping 77 matching lines @@
 
     def install_files(self, params):
         """ Install files on the client or router with the provided
         contents"""
 
         systemname = params.get('system', None)
         if systemname == 'router':
             system = self.router
         elif systemname == 'client':
             system = self.client
+        elif systemname == 'server':
+            system = self.server
         else:
-            raise error.TestFail('install_files: Must specify router or client')
+            raise error.TestFail('install_files: Must specify router, server or client')
 
         for name,contents in params.get('files', {}).iteritems():
             self.insert_file(system, name, contents)
 
 
     def connect(self, params):
         """ Connect client to AP/router """
 
         script_client_file = self.install_script('site_wlan_connect.py',
                                                  'site_wlan_wait_state.py')
@@ skipping 786 matching lines @@
             system = { 'client': self.client,
                        'server': self.server,
                        'router': self.router }.get(name)
             if not system:
                 raise error.TestFail('time_sync: Must specify '
                                      'router, client or server')
             datefmt = '%m%d%H%M%Y.%S' if name == 'client' else '%Y%m%d%H%M.%S'
             system.run('date -u %s' %
                        datetime.datetime.utcnow().strftime(datefmt))
 
+    def vpn_launch_client(self, params):

[Paul Stewart, 2011/03/03 23:18:42]

I suggest you call these "openvpn_*" instead of "vpn_*" since they are specific
to openvpn, and it's likely we'll have other vpn types.  Either that or you
should make a "TODO" to make these functions generic as more VPN types come
along.

+        result = self.client.run('modprobe tun');
+        # connect-vpn openvpn <name> <host> <domain> <cafile> <certfile>
+        result = self.client.run('%s/test/connect-vpn openvpn '
+                                 'vpn-name 192.168.2.254 vpn-domain '
+                                 '/tmp/ca.crt '
+                                 '/tmp/client.crt '
+                                 '/tmp/client.key ' %
+                                 self.client_cmd_flimflam_lib)
+
+    def vpn_kill_client(self, params):
+        """ Kill the VPN client. """
+        self.server.run("pkill openvpn")
 
 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
@@ skipping 115 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