cros/networking/android_xmlrpc_server.py

#!/usr/bin/python2.7

# Copyright (c) 2015 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 argparse
import contextlib2
import errno
import logging
import Queue
import select
import shutil
import signal
import subprocess
import threading
import time

from SimpleXMLRPCServer import SimpleXMLRPCServer

from acts import logger
from acts import utils
from acts.controllers import android_device
from acts.controllers import attenuator
from acts.test_utils.wifi import wifi_test_utils as wutils


class Map(dict):
    """A convenience class that makes dictionary values accessible via dot
    operator.

    Example:
        >> m = Map({"SSID": "GoogleGuest"})
        >> m.SSID
        GoogleGuest
    """
    def __init__(self, *args, **kwargs):
        super(Map, self).__init__(*args, **kwargs)
        for arg in args:
            if isinstance(arg, dict):
                for k, v in arg.items():
                    self[k] = v
        if kwargs:
            for k, v in kwargs.items():
                self[k] = v


    def __getattr__(self, attr):
        return self.get(attr)


    def __setattr__(self, key, value):
        self.__setitem__(key, value)


# This is copied over from client/cros/xmlrpc_server.py so that this
# daemon has no autotest dependencies.
class XmlRpcServer(threading.Thread):
    """Simple XMLRPC server implementation.

    In theory, Python should provide a sane XMLRPC server implementation as
    part of its standard library.  In practice the provided implementation
    doesn't handle signals, not even EINTR.  As a result, we have this class.

    Usage:

    server = XmlRpcServer(('localhost', 43212))
    server.register_delegate(my_delegate_instance)
    server.run()

    """

    def __init__(self, host, port):
        """Construct an XmlRpcServer.

        @param host string hostname to bind to.
        @param port int port number to bind to.

        """
        super(XmlRpcServer, self).__init__()
        logging.info('Binding server to %s:%d', host, port)
        self._server = SimpleXMLRPCServer((host, port), allow_none=True)
        self._server.register_introspection_functions()
        self._keep_running = True
        self._delegates = []
        # Gracefully shut down on signals.  This is how we expect to be shut
        # down by autotest.
        signal.signal(signal.SIGTERM, self._handle_signal)
        signal.signal(signal.SIGINT, self._handle_signal)


    def register_delegate(self, delegate):
        """Register delegate objects with the server.

        The server will automagically look up all methods not prefixed with an
        underscore and treat them as potential RPC calls.  These methods may
        only take basic Python objects as parameters, as noted by the
        SimpleXMLRPCServer documentation.  The state of the delegate is
        persisted across calls.

        @param delegate object Python object to be exposed via RPC.

        """
        self._server.register_instance(delegate)
        self._delegates.append(delegate)


    def run(self):
        """Block and handle many XmlRpc requests."""
        logging.info('XmlRpcServer starting...')
        with contextlib2.ExitStack() as stack:
            for delegate in self._delegates:
                stack.enter_context(delegate)
            while self._keep_running:
                try:
                    self._server.handle_request()
                except select.error as v:
                    # In a cruel twist of fate, the python library doesn't
                    # handle this kind of error.
                    if v[0] != errno.EINTR:
                        raise
                except Exception as e:
                    logging.error("Error in handle request: %s", e)
        logging.info('XmlRpcServer exited.')


    def _handle_signal(self, _signum, _frame):
        """Handle a process signal by gracefully quitting.

        SimpleXMLRPCServer helpfully exposes a method called shutdown() which
        clears a flag similar to _keep_running, and then blocks until it sees
        the server shut down.  Unfortunately, if you call that function from
        a signal handler, the server will just hang, since the process is
        paused for the signal, causing a deadlock.  Thus we are reinventing the
        wheel with our own event loop.

        """
        self._server.server_close()
        self._keep_running = False


class XmlRpcServerError(Exception):
    """Raised when an error is encountered in the XmlRpcServer."""


class AndroidXmlRpcDelegate(object):
    """Exposes methods called remotely during WiFi autotests.

    All instance methods of this object without a preceding '_' are exposed via
    an XMLRPC server.
    """

    WEP40_HEX_KEY_LEN = 10
    WEP104_HEX_KEY_LEN = 26
    SHILL_DISCONNECTED_STATES = ['idle']
    SHILL_CONNECTED_STATES =  ['portal', 'online', 'ready']
    DISCONNECTED_SSID = '0x'
    DISCOVERY_POLLING_INTERVAL = 1
    NUM_ATTEN = 4


    def __init__(self, serial_number, log_dir, test_station):
        """Initializes the ACTS library components.

        @test_station string represting teststation's hostname.
        @param serial_number Serial number of the android device to be tested,
               None if there is only one device connected to the host.
        @param log_dir Path to store output logs of this run.

        """
        # Cleanup all existing logs for this device when starting.
        shutil.rmtree(log_dir, ignore_errors=True)
        logger.setup_test_logger(log_path=log_dir, prefix="ANDROID_XMLRPC")
        if not serial_number:
            ads = android_device.get_all_instances()
            if not ads:
                msg = "No android device found, abort!"
                logging.error(msg)
                raise XmlRpcServerError(msg)
            self.ad = ads[0]
        elif serial_number in android_device.list_adb_devices():
            self.ad = android_device.AndroidDevice(serial_number)
        else:
            msg = ("Specified Android device %s can't be found, abort!"
                   ) % serial_number
            logging.error(msg)
            raise XmlRpcServerError(msg)
        # Even if we find one attenuator assume the rig has attenuators for now.
        # With the single IP attenuator, this will be a easy check.
        rig_has_attenuator = False
        count = 0
        for i in range(1, self.NUM_ATTEN + 1):
            atten_addr = test_station+'-attenuator-'+'%d' %i
            if subprocess.Popen(['ping', '-c', '2', atten_addr],
                                 stdout=subprocess.PIPE).communicate()[0]:
                rig_has_attenuator = True
                count = count + 1
        if rig_has_attenuator and count == self.NUM_ATTEN:
            atten = attenuator.create([{"Address":test_station+'-attenuator-1',
                                        "Port":23,
                                        "Model":"minicircuits",
                                        "InstrumentCount": 1,
                                        "Paths":["Attenuator-1"]},
                                        {"Address":test_station+'-attenuator-2',
                                        "Port":23,
                                        "Model":"minicircuits",
                                        "InstrumentCount": 1,
                                        "Paths":["Attenuator-2"]},
                                        {"Address":test_station+'-attenuator-3',
                                        "Port":23,
                                        "Model":"minicircuits",
                                        "InstrumentCount": 1,
                                        "Paths":["Attenuator-3"]},
                                        {"Address":test_station+'-attenuator-4',
                                        "Port":23,
                                        "Model":"minicircuits",
                                        "InstrumentCount": 1,
                                        "Paths":["Attenuator-4"]}])
            device = 0
            # Set attenuation on all attenuators to 0.
            for device in range(len(atten)):
               atten[device].set_atten(0)
            attenuator.destroy(atten)
        elif rig_has_attenuator and count < self.NUM_ATTEN:
            msg = 'One or more attenuators are down.'
            logging.error(msg)
            raise XmlRpcServerError(msg)


    def __enter__(self):
        logging.debug('Bringing up AndroidXmlRpcDelegate.')
        self.ad.get_droid()
        self.ad.ed.start()
        self.ad.start_adb_logcat()
        return self


    def __exit__(self, exception, value, traceback):
        logging.debug('Tearing down AndroidXmlRpcDelegate.')
        self.ad.terminate_all_sessions()
        self.ad.stop_adb_logcat()


    # Commands start.
    def ready(self):
        """Confirm that the XMLRPC server is up and ready to serve.

        @return True (always).

        """
        logging.debug('ready()')
        return True


    def collect_debug_info(self, test_name):
        """Collects appropriate debug information on DUT.

        @param test_name: string name of the test to collect debug information
                          for.
        """
        self.ad.cat_adb_log(test_name, self.test_begin_time)
        self.ad.take_bug_report(test_name, self.test_begin_time)


    def list_controlled_wifi_interfaces(self):
        """List all controlled wifi interfaces (just wlan0 for Android). """
        return ['wlan0']


    def set_device_enabled(self, wifi_interface, enabled):
        """Enable or disable the WiFi device.

        @param wifi_interface: string name of interface being modified.
        @param enabled: boolean; true if this device should be enabled,
                false if this device should be disabled.
        @return True if it worked; false, otherwise

        """
        return wutils.wifi_toggle_state(self.ad, enabled)


    def sync_time_to(self, epoch_seconds):
        """Sync time on the DUT to |epoch_seconds| from the epoch.

        @param epoch_seconds: float number of seconds from the epoch.

        """
        # The adb_host is already doing this; just return True.
        return True


    def clean_profiles(self):
        """ Not applicable for Android.
        @param profile_name: Ignored.
        """
        return True


    def create_profile(self, profile_name):
        """ Not applicable for Android.
        @param profile_name: Ignored.
        """
        return True


    def push_profile(self, profile_name):
        """ Not applicable for Android.
        @param profile_name: Ignored.
        """
        return True


    def remove_profile(self, profile_name):
        """ Not applicable for Android.
        @param profile_name: Ignored.
        """
        return True


    def pop_profile(self, profile_name):
        """ Not applicable for Android.
        @param profile_name: Ignored.
        """
        return True


    def disconnect(self, ssid):
        """Attempt to disconnect from the given ssid.

        Blocks until disconnected or operation has timed out.  Returns True iff
        disconnect was successful.

        @param ssid string network to disconnect from.
        @return bool True on success, False otherwise.

        """
        # Android had no explicit disconnect, so let's just forget the network.
        return self.delete_entries_for_ssid(ssid)


    def get_active_wifi_SSIDs(self):
        """Get the list of all SSIDs in the current scan results.

        @return list of string SSIDs with at least one BSS we've scanned.

        """
        ssids = []
        try:
            self.ad.droid.wifiStartScan()
            self.ad.ed.pop_event('WifiManagerScanResultsAvailable')
            scan_results = self.ad.droid.wifiGetScanResults()
            for result in scan_results:
                if wutils.WifiEnums.SSID_KEY in result:
                    ssids.append(result[wutils.WifiEnums.SSID_KEY])
        except Queue.Empty:
            logging.error("Scan results available event timed out!")
        except Exception as e:
            logging.error("Scan results error: %s", e)
        finally:
            logging.debug("Scan Results: %r", ssids)
            return ssids


    def wait_for_service_states(self, ssid, states, timeout_seconds):
        """Wait for SSID to reach one state out of a list of states.

        @param ssid string the network to connect to (e.g. 'GoogleGuest').
        @param states tuple the states for which to wait
        @param timeout_seconds int seconds to wait for a state

        @return (result, final_state, wait_time) tuple of the result for the
                wait.
        """
        current_con = self.ad.droid.wifiGetConnectionInfo()
        # Check the current state to see if we're connected/disconnected.
        if set(states).intersection(set(self.SHILL_CONNECTED_STATES)):
            if current_con[wutils.WifiEnums.SSID_KEY] == ssid:
                return True, '', 0
            wait_event = 'WifiNetworkConnected'
        elif set(states).intersection(set(self.SHILL_DISCONNECTED_STATES)):
            if current_con[wutils.WifiEnums.SSID_KEY] == self.DISCONNECTED_SSID:
                return True, '', 0
            wait_event = 'WifiNetworkDisconnected'
        else:
            assert 0, "Unhandled wait states received: %r" % states
        final_state = ""
        wait_time = -1
        result = False
        logging.debug(current_con)
        try:
            self.ad.droid.wifiStartTrackingStateChange()
            start_time = utils.get_current_epoch_time()
            wait_result = self.ad.ed.pop_event(wait_event, timeout_seconds)
            end_time = utils.get_current_epoch_time()
            wait_time = (end_time - start_time) / 1000
            if wait_event == 'WifiNetworkConnected':
                actual_ssid = wait_result['data'][wutils.WifiEnums.SSID_KEY]
                assert actual_ssid == ssid, ("Expected to connect to %s, but "
                        "connected to %s") % (ssid, actual_ssid)
            result = True
        except Queue.Empty:
            logging.error("No state change available yet!")
        except Exception as e:
            logging.error("State change error: %s", e)
        finally:
            logging.debug((result, final_state, wait_time))
            self.ad.droid.wifiStopTrackingStateChange()
            return result, final_state, wait_time


    def delete_entries_for_ssid(self, ssid):
        """Delete all saved entries for an SSID.

        @param ssid string of SSID for which to delete entries.
        @return True on success, False otherwise.

        """
        try:
            wutils.wifi_forget_network(self.ad, ssid)
        except Exception as e:
            logging.error(e)
            return False
        return True


    def connect_wifi(self, raw_params):
        """Block and attempt to connect to wifi network.

        @param raw_params serialized AssociationParameters.
        @return serialized AssociationResult

        """
        # Prepare data objects.
        params = Map(raw_params)
        params.security_config = Map(raw_params['security_config'])
        params.bgscan_config = Map(raw_params['bgscan_config'])
        logging.debug('connect_wifi(). Params: %r', params)
        network_config = {
            "SSID": params.ssid,
            "hiddenSSID":  True if params.is_hidden else False
        }
        assoc_result = {
            "discovery_time" : 0,
            "association_time" : 0,
            "configuration_time" : 0,
            "failure_reason" : "None",
            "xmlrpc_struct_type_key" : "AssociationResult"
        }
        duration = lambda: (utils.get_current_epoch_time() - start_time) / 1000
        try:
            # Verify that the network was found, if the SSID is not hidden.
            if not params.is_hidden:
                start_time = utils.get_current_epoch_time()
                found = False
                while duration() < params.discovery_timeout and not found:
                    active_ssids = self.get_active_wifi_SSIDs()
                    found = params.ssid in active_ssids
                    if not found:
                        time.sleep(self.DISCOVERY_POLLING_INTERVAL)
                assoc_result["discovery_time"] = duration()
                assert found, ("Could not find %s in scan results: %r") % (
                        params.ssid, active_ssids)
            result = False
            if params.security_config.security == "psk":
                network_config["password"] = params.security_config.psk
            elif params.security_config.security == "wep":
                network_config["wepTxKeyIndex"] = params.security_config.wep_default_key
                # Convert all ASCII keys to Hex
                wep_hex_keys = []
                for key in params.security_config.wep_keys:
                    if len(key) == self.WEP40_HEX_KEY_LEN or \
                       len(key) == self.WEP104_HEX_KEY_LEN:
                        wep_hex_keys.append(key)
                    else:
                        hex_key = ""
                        for byte in bytearray(key, 'utf-8'):
                            hex_key += '%x' % byte
                        wep_hex_keys.append(hex_key)
                network_config["wepKeys"] = wep_hex_keys
            # Associate to the network.
            self.ad.droid.wifiStartTrackingStateChange()
            start_time = utils.get_current_epoch_time()
            result = self.ad.droid.wifiConnect(network_config)
            assert result, "wifiConnect call failed."
            # Verify connection successful and correct.
            logging.debug('wifiConnect result: %s. Waiting for connection', result);
            timeout = params.association_timeout + params.configuration_timeout
            connect_result = self.ad.ed.pop_event(
                wutils.WifiEventNames.WIFI_CONNECTED, timeout)
            assoc_result["association_time"] = duration()
            actual_ssid = connect_result['data'][wutils.WifiEnums.SSID_KEY]
            logging.debug('Connected to SSID: %s', actual_ssid);
            assert actual_ssid == params.ssid, ("Expected to connect to %s, "
                "connected to %s") % (params.ssid, actual_ssid)
            result = True
        except Queue.Empty:
            msg = "Failed to connect to %s with %s" % (params.ssid,
                params.security_config.security)
            logging.error(msg)
            assoc_result["failure_reason"] = msg
            result = False
        except Exception as e:
            msg = e
            logging.error(msg)
            assoc_result["failure_reason"] = msg
            result = False
        finally:
            assoc_result["success"] = result
            logging.debug(assoc_result)
            self.ad.droid.wifiStopTrackingStateChange()
            return assoc_result


    def init_test_network_state(self):
        """Create a clean slate for tests with respect to remembered networks.

        @return True iff operation succeeded, False otherwise.
        """
        self.test_begin_time = logger.get_log_line_timestamp()
        try:
            wutils.wifi_test_device_init(self.ad)
            self.ad.ed.clear_all_events()
        except AssertionError as e:
            logging.error(e)
            return False
        return True


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Cros Wifi Xml RPC server.')
    parser.add_argument('-s', '--serial-number', action='store', default=None,
                         help='Serial Number of the device to test.')
    parser.add_argument('-l', '--log-dir', action='store', default=None,
                         help='Path to store output logs.')
    parser.add_argument('-t', '--test-station', action='store', default=None,
                         help='The accompaning teststion hostname.')
    parser.add_argument('-p', '--port', action='store', default=9989,
                        type=int, help='The port number to listen on.')
    args = parser.parse_args()
    listen_port = args.port
    logging.basicConfig(level=logging.DEBUG)
    logging.debug("android_xmlrpc_server main...")
    logging.debug('xmlrpc instance on port %d' % listen_port)
    server = XmlRpcServer('localhost', listen_port)
    server.register_delegate(
            AndroidXmlRpcDelegate(args.serial_number, args.log_dir,
                                  args.test_station))
    server.run()