# Copyright 2014 The ChromiumOS Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import logging
import six.moves
import socket

from autotest_lib.client.bin import utils
from autotest_lib.client.common_lib.cros import retry
from autotest_lib.client.cros import constants
from autotest_lib.server import autotest

POWER_DIR = '/var/lib/power_manager'
TMP_POWER_DIR = '/tmp/power_manager'
POWER_DEFAULTS = '/usr/share/power_manager/board_specific'

RESUME_CTRL_RETRIES = 3
RESUME_GRACE_PERIOD = 10
XMLRPC_BRINGUP_TIMEOUT_SECONDS = 60
DARK_SUSPEND_MAX_DELAY_TIMEOUT_MILLISECONDS = 60000


class DarkResumeUtils(object):
    """Class containing common functionality for tests which exercise dark
    resume pathways. We set up powerd to allow dark resume and also configure
    the suspended devices so that the backchannel can stay up. We can also
    check for the number of dark resumes that have happened in a particular
    suspend request.
    """


    def __init__(self, host, duration=0):
        """Set up powerd preferences so we will properly go into dark resume,
        and still be able to communicate with the DUT.

        @param host: the DUT to set up dark resume for

        """
        self._host = host
        logging.info('Setting up dark resume preferences')

        # Make temporary directory, which will be used to hold
        # temporary preferences. We want to avoid writing into
        # /var/lib so we don't have to save any state.
        logging.debug('Creating temporary powerd prefs at %s', TMP_POWER_DIR)
        host.run('mkdir -p %s' % TMP_POWER_DIR)

        logging.debug('Enabling dark resume')
        host.run('echo 0 > %s/disable_dark_resume' % TMP_POWER_DIR)
        logging.debug('setting max dark suspend delay timeout to %d msecs',
                  DARK_SUSPEND_MAX_DELAY_TIMEOUT_MILLISECONDS)
        host.run('echo %d > %s/max_dark_suspend_delay_timeout_ms' %
                 (DARK_SUSPEND_MAX_DELAY_TIMEOUT_MILLISECONDS, TMP_POWER_DIR))

        # bind the tmp directory to the power preference directory
        host.run('mount --bind %s %s' % (TMP_POWER_DIR, POWER_DIR))

        logging.debug('Restarting powerd with new settings')
        host.run('stop powerd; start powerd')

        logging.debug('Starting XMLRPC session to watch for dark resumes')
        self._client_proxy = self._get_xmlrpc_proxy()


    def teardown(self):
        """Clean up changes made by DarkResumeUtils."""

        logging.info('Tearing down dark resume preferences')

        logging.debug('Cleaning up temporary powerd bind mounts')
        self._host.run('umount %s' % POWER_DIR)

        logging.debug('Restarting powerd to revert to old settings')
        self._host.run('stop powerd; start powerd')


    def suspend(self, suspend_secs):
        """ Suspends the device for |suspend_secs| without blocking for resume.

        @param suspend_secs : Sleep for seconds. Sets a RTC alarm to wake the
                              system.
        """
        logging.info('Suspending DUT (in background)...')
        try:
            self._client_proxy.suspend_bg(suspend_secs)
        except (socket.error, six.moves.xmlrpc_client.ProtocolError,
                six.moves.http_client.BadStatusLine):
            self._rebuild_xmlrpc_proxy()
            self._client_proxy.suspend_bg(suspend_secs)


    def stop_resuspend_on_dark_resume(self, stop_resuspend=True):
        """
        If |stop_resuspend| is True, stops re-suspend on seeing a dark resume.
        """
        try:
            self._client_proxy.set_stop_resuspend(stop_resuspend)
        except (socket.error, six.moves.xmlrpc_client.ProtocolError,
                six.moves.http_client.BadStatusLine):
            self._rebuild_xmlrpc_proxy()
            self._client_proxy.set_stop_resuspend(stop_resuspend)


    def count_dark_resumes(self):
        """Return the number of dark resumes since the beginning of the test.

        This method will raise an error if the DUT is not reachable.

        @return the number of dark resumes counted by this DarkResumeUtils

        """
        try:
            return self._client_proxy.get_dark_resume_count()
        except (socket.error, six.moves.xmlrpc_client.ProtocolError,
                six.moves.http_client.BadStatusLine):
            self._rebuild_xmlrpc_proxy()
            return self._client_proxy.get_dark_resume_count()


    def host_has_lid(self):
        """Returns True if the DUT has a lid."""
        try:
            return self._client_proxy.has_lid()
        except (socket.error, six.moves.xmlrpc_client.ProtocolError,
                six.moves.http_client.BadStatusLine):
            self._rebuild_xmlrpc_proxy()
            return self._client_proxy.has_lid()

    def pause_ethernet_check_on_host(self):
        """Pause check_ethernet.hook on host."""
        try:
            self._client_proxy.pause_ethernet_hook()
        except (socket.error, six.moves.xmlrpc_client.ProtocolError,
                six.moves.http_client.BadStatusLine):
            self._rebuild_xmlrpc_proxy()
            self._client_proxy.pause_ethernet_hook()

    def resume_ethernet_check_on_host(self):
        """Resume check_ethernet.hook on host."""
        try:
            self._client_proxy.resume_ethernet_hook()
        except (socket.error, six.moves.xmlrpc_client.ProtocolError,
                six.moves.http_client.BadStatusLine):
            self._rebuild_xmlrpc_proxy()
            self._client_proxy.resume_ethernet_hook()

    def _get_xmlrpc_proxy(self):
        """Get a dark resume XMLRPC proxy for the host this DarkResumeUtils is
        attached to.

        The returned object has no particular type.  Instead, when you call
        a method on the object, it marshalls the objects passed as arguments
        and uses them to make RPCs on the remote server.  Thus, you should
        read dark_resume_xmlrpc_server.py to find out what methods are supported.

        @return proxy object for remote XMLRPC server.

        """
        # Make sure the client library is on the device so that the proxy
        # code is there when we try to call it.
        client_at = autotest.Autotest(self._host)
        client_at.install()
        # Start up the XMLRPC proxy on the client
        proxy = self._host.rpc_server_tracker.xmlrpc_connect(
                constants.DARK_RESUME_XMLRPC_SERVER_COMMAND,
                constants.DARK_RESUME_XMLRPC_SERVER_PORT,
                command_name=
                    constants.DARK_RESUME_XMLRPC_SERVER_CLEANUP_PATTERN,
                ready_test_name=
                    constants.DARK_RESUME_XMLRPC_SERVER_READY_METHOD,
                timeout_seconds=XMLRPC_BRINGUP_TIMEOUT_SECONDS)
        return proxy

    def _rebuild_xmlrpc_proxy(self):
        """SSH tunnel between RPC server and client might be broken while the
        server is still alive.

        Rebuild the ssh tunnel between them and the xmlrpc proxy. Return when
        the proxy is ready.
        """
        logging.info("Dark resume xmlrpc proxy connection lost. Rebuilding...")
        # Disconnect the old tunnel, even though it is likely to be already
        # terminated.
        remote_name, tunnel_proc, remote_pid = self._host.rpc_server_tracker._rpc_proxy_map[
                constants.DARK_RESUME_XMLRPC_SERVER_PORT]
        self._host.disconnect_ssh_tunnel(tunnel_proc)

        # Rebuild ssh tunnel and update xmlrpc proxy map.
        local_port = utils.get_unused_port()
        new_tunnel_proc = self._host.create_ssh_tunnel(
                constants.DARK_RESUME_XMLRPC_SERVER_PORT, local_port)
        self._host.rpc_server_tracker._rpc_proxy_map[
                constants.DARK_RESUME_XMLRPC_SERVER_PORT] = (remote_name,
                                                             new_tunnel_proc,
                                                             remote_pid)

        newurl = "http://localhost:%d" % local_port
        proxy = six.moves.xmlrpc_client.ServerProxy(newurl, allow_none=True)

        # Make sure the rebuilt proxy is ready.
        @retry.retry((socket.error, six.moves.xmlrpc_client.ProtocolError,
                      six.moves.http_client.BadStatusLine),
                     timeout_min=XMLRPC_BRINGUP_TIMEOUT_SECONDS / 60)
        def ready_test():
            getattr(proxy, constants.DARK_RESUME_XMLRPC_SERVER_READY_METHOD)()

        ready_test()
        del self._client_proxy
        self._client_proxy = proxy