# Copyright 2012 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.

"""Connect to factory server to find software updates and upload logs.

Description
-----------
This test will create connections from DUT to Chrome OS factory server and
invoke remote procedure calls for syncing data and programs.

This test will sync following items:

1. If ``sync_time`` is enabled (default True), sync system time from server.
2. If ``sync_event_logs`` is enabled (default True), sync the ``event_log`` YAML
   event logs to factory server.
3. If ``flush_testlog`` is enabled (default False), flush TestLog to factory
   server (which should have Instalog node running).
4. If ``upload_report`` is enabled (default False), upload a ``Gooftool`` style
   report collecting system information and manufacturing logs to server.
5. If ``update_toolkit`` is enabled (default True), compare the factory software
   (toolkit) installed on DUT with the active version on server, and update
   if needed.
6. If ``upload_reg_codes`` is enabled (default False), upload the registration
   codes to server using ``UploadCSVEntry`` API, and have the data stored in
   ``registration_code_log.csv`` file on server. If the reg codes must be sent
   back to partner's shopfloor backend, please use shopfloor_service pytest
   and ActivateRegCode API instead.

Additionally, if argument ``server_url`` is specified, this test will update the
stored 'default factory server URL' so all following tests connecting to factory
server via ``server_proxy.GetServerProxy()`` will use the new URL.

``server_url`` supports few different input:

- If a string is given, that is interpreted as simple URL. For example,
  ``"http://10.3.0.11:8080/"``.
- If a mapping (dict) is given, take key as network IP/CIDR and value as URL.
  For example, ``{"10.3.0.0/24": "http://10.3.0.11:8080"}``

Test Procedure
--------------
Basically no user interaction required unless a toolkit update is found.

- Make sure network is connected.
- Start the test and it will try to reach factory server and sync time and logs.
- If `update_toolkit` is True, compare installed toolkit with server's active
  version.
- If a new version is found, a message like 'A software update is available.'
  will be displayed on screen. Operator can follow the instruction (usually
  just press space) to start downloading and installing new software.

Dependency
----------
Nothing special.
This test uses only server components in Chrome OS Factory Software.

Examples
--------
To connect to default server and sync time, event logs, and update software,
add this in test list::

  {
    "pytest_name": "sync_factory_server"
  }

To only sync time and logs, and never update software (useful for stations)::

  {
    "pytest_name": "sync_factory_server",
    "args": {
      "update_toolkit": false
    }
  }

To sync time and logs, and then upload a report::

  {
    "pytest_name": "sync_factory_server",
    "args": {
      "upload_report": true
    }
  }

To override default factory server URL for all tests, change the
``default_factory_server_url`` in test list constants::

  {
    "constants": {
      "default_factory_server_url": "http://192.168.3.11:8080"
    }
  }

It is also possible to override and create one test item using different factory
server URL, and all tests after that::

  {
    "pytest_name": "sync_factory_server",
    "args": {
      "server_url": "http://192.168.3.11:8080"
    }
  }

To implement "station specific factory server" in JSON test lists, extend
``SyncFactoryServer`` from ``generic_common.test_list.json`` as::

  { "inherit": "SyncFactoryServer",
    "args": {
      "server_url": "eval! locals.factory_server_url"
    }
  }

And then in each station (or stage), override URL in locals::

  {"SMT": {"locals": {"factory_server_url": "http://192.168.3.11:8080" }}},
  {"FAT": {"locals": {"factory_server_url": "http://10.3.0.11:8080" }}},
  {"RunIn": {"locals": {"factory_server_url": "http://10.1.2.10:7000" }}},
  {"FFT": {"locals": {"factory_server_url": "http://10.3.0.11:8080" }}},
  {"GRT": {"locals": {"factory_server_url": "http://172.30.1.2:8081" }}},

To implement "auto-detect factory server by received DHCP IP address", specify a
mapping object with key set to "IP/CIDR" and value set to server URL::

  {
    "constants": {
      "default_factory_server_url": {
        "192.168.3.0/24": "http://192.168.3.11:8080",
        "10.3.0.0/24": "http://10.3.0.11:8080",
        "10.1.0.0/16": "http://10.1.2.10:8080"
      }
    }
  }
"""

import logging
import threading
import time

import factory_common  # pylint: disable=unused-import
from cros.factory.device import device_utils
from cros.factory.gooftool import commands
from cros.factory.goofy import updater
from cros.factory.test import device_data
from cros.factory.test.i18n import _
from cros.factory.test.rules import registration_codes
from cros.factory.test import server_proxy
from cros.factory.test import session
from cros.factory.test import state
from cros.factory.test import test_case
from cros.factory.test import test_ui
from cros.factory.test.utils import time_utils
from cros.factory.utils.arg_utils import Arg
from cros.factory.utils import debug_utils
from cros.factory.utils import log_utils
from cros.factory.utils import sync_utils


ID_TEXT_INPUT_URL = 'text_input_url'
ID_BUTTON_EDIT_URL = 'button_edit_url'

EVENT_SET_URL = 'event_set_url'
EVENT_CANCEL_SET_URL = 'event_cancel_set_url'
EVENT_DO_SET_URL = 'event_do_set_url'


class Report(object):
  """A structure for reports uploaded to factory server."""

  def __init__(self, serial_number, blob, station):
    self.serial_number = serial_number
    self.blob = blob
    self.station = station


class SyncFactoryServer(test_case.TestCase):
  ARGS = [
      Arg('first_retry_secs', int,
          'Time to wait after the first attempt; this will increase '
          'exponentially up to retry_secs.  This is useful because '
          'sometimes the network may not be available by the time the '
          'tests starts, but a full 10-second wait is unnecessary.',
          1),
      Arg('retry_secs', int, 'Maximum time to wait between retries.', 10),
      Arg('timeout_secs', int, 'Timeout for XML/RPC operations.', 10),
      Arg('update_toolkit', bool, 'Whether to check factory update.',
          default=True),
      Arg('update_without_prompt', bool, 'Update without prompting when an '
          'update is available.', default=False),
      Arg('sync_time', bool, 'Sync system time from factory server.',
          default=True),
      Arg('sync_event_logs', bool, 'Sync event logs to factory server.',
          default=True),
      Arg('flush_testlog', bool, 'Flush test logs to factory server.',
          # TODO(hungte) Change flush_testlog to default True when Umpire is
          # officially deployed.
          default=False),
      Arg('upload_reg_codes', bool, 'Upload registration codes to server.',
          default=False),
      Arg('upload_report', bool, 'Upload a factory report to factory server.',
          default=False),
      Arg('report_stage', str, 'Stage of report to upload.', default=None),
      Arg('report_serial_number_name', str,
          'Name of serial number to use for report file name to use.',
          default=None),
      Arg('server_url', (basestring, dict),
          'Set and keep new factory server URL.',
          default=None),
  ]

  def setUp(self):
    self.server = None
    self.do_setup_url = threading.Event()
    self.allow_edit_url = True
    self.event_url_set = threading.Event()
    self.goofy = state.GetInstance()
    self.report = Report(None, None, self.args.report_stage)
    self.dut = device_utils.CreateDUTInterface()
    self.station = device_utils.CreateStationInterface()

  @staticmethod
  def CreateButton(node_id, message, on_click):
    return [
        '<button type="button" id="%s" onclick=%r>' % (node_id, on_click),
        message, '</button>'
    ]

  def CreateChangeURLButton(self):
    return self.CreateButton(
        ID_BUTTON_EDIT_URL,
        _('Change URL'),
        'this.disabled = true; window.test.sendTestEvent("%s");' %
        EVENT_DO_SET_URL)

  def OnButtonSetClicked(self, event):
    self.ChangeServerURL(event.data)
    self.do_setup_url.clear()
    self.event_url_set.set()

  def OnButtonCancelClicked(self, event):
    del event  # Unused.
    self.do_setup_url.clear()
    self.event_url_set.set()

  def OnButtonEditClicked(self, event):
    del event  # Unused.
    self.do_setup_url.set()
    self.ui.SetHTML(
        _('Please wait few seconds to edit...'), id=ID_BUTTON_EDIT_URL)

  def EditServerURL(self):
    current_url = server_proxy.GetServerURL() or ''

    if current_url:
      prompt = []
    else:
      prompt = [
          '<span class="warning_label">',
          _('No factor server URL configured.'),
          '</span><span class="warning_message">',
          # TODO(hungte) Add message when we can't connect to factory server.
          _('For debugging or development, '
            'enter engineering mode to start individual tests.'),
          '</span>'
      ]

    self.ui.SetState([
        prompt,
        _('Change server URL: '),
        '<input type="text" id="%s" value="%s"/>' % (ID_TEXT_INPUT_URL,
                                                     current_url), '<span>',
        self.CreateButton('btnSet',
                          _('Set'), 'window.test.sendTestEvent("%s", '
                          'document.getElementById("%s").value)' %
                          (EVENT_SET_URL, ID_TEXT_INPUT_URL)),
        self.CreateButton(
            'btnCancel',
            _('Cancel'),
            'window.test.sendTestEvent("%s")' % EVENT_CANCEL_SET_URL), '</span>'
    ])

  def DetectServerURL(self):
    expected_networks = self.args.server_url.keys()
    label_connect = _('Please connect to network...')
    label_status = _('Expected network: {networks}', networks=expected_networks)

    while True:
      new_url = self.FindServerURL(self.args.server_url)
      if new_url:
        break
      # Collect current networks. The output format is DEV STATUS NETWORK.
      output = self.station.CallOutput(['ip', '-f', 'inet', '-br', 'addr'])
      networks = [entry.split()[2] for entry in output.splitlines()
                  if ' UP ' in entry]
      self.ui.SetState([
          label_connect, label_status,
          _('Current networks: {networks}', networks=networks)
      ])
      self.Sleep(0.5)

    self.ChangeServerURL(new_url)
    self.do_setup_url.clear()

  def Ping(self):
    if self.do_setup_url.is_set():
      self.event_url_set.clear()
      self.EditServerURL()
      sync_utils.EventWait(self.event_url_set)

    self.ui.SetState(
        [_('Trying to reach server...'),
         self.CreateChangeURLButton()])
    self.server = server_proxy.GetServerProxy(timeout=self.args.timeout_secs)

    if self.do_setup_url.is_set():
      raise Exception('Edit URL clicked.')

    self.ui.SetState(
        [_('Trying to check server protocol...'),
         self.CreateChangeURLButton()])
    self.server.Ping()
    self.allow_edit_url = False

  def ChangeServerURL(self, new_server_url):
    server_url = server_proxy.GetServerURL() or ''

    if new_server_url and new_server_url != server_url:
      server_proxy.SetServerURL(new_server_url.rstrip('/'))
      # Read again because server_proxy module may normalize it.
      new_server_url = server_proxy.GetServerURL()
      session.console.info(
          'Factory server URL has been changed from [%s] to [%s].',
          server_url, new_server_url)
      server_url = new_server_url

    self.ui.SetInstruction(_('Server URL: {server_url}', server_url=server_url))
    if not server_url:
      self.do_setup_url.set()

  def FlushTestlog(self):
    # TODO(hungte) goofy.FlushTestlog should reload factory_server_url.
    result = False
    while not result:
      result, progress = self.goofy.FlushTestlog(timeout=2)
      self.ui.SetState(
          _('Flush Test Log: Progress = <br>{progress}', progress=progress))

  def CreateReport(self):
    self.ui.SetState(_('Collecting report data...'))
    self.report.blob = commands.CreateReportArchiveBlob()
    self.ui.SetState(_('Getting serial number...'))
    self.report.serial_number = device_data.GetSerialNumber(
        self.args.report_serial_number_name or
        device_data.NAME_SERIAL_NUMBER)

  def UploadReport(self):
    self.server.UploadReport(
        self.report.serial_number, self.report.blob, None, self.report.station)

  def UploadRegCodes(self):
    """Uploads registration codes to factory server.

    The registration codes should be sent in format from http://goto/nkjyr.
    """
    hwid = device_data.GetDeviceData(
        device_data.KEY_HWID, self.dut.CallOutput('crossystem hwid'))
    if not hwid:
      raise Exception('Need HWID before uploading registration codes.')

    board = hwid.partition(' ')[0]
    ubind = device_data.GetDeviceData(device_data.KEY_VPD_USER_REGCODE)
    gbind = device_data.GetDeviceData(device_data.KEY_VPD_GROUP_REGCODE)
    for label, value in ('user', ubind), ('group', gbind):
      if not value:
        raise Exception('Missing %s registration codes in device data (%r).' %
                        (label, value))

    registration_codes.CheckRegistrationCode(ubind)
    registration_codes.CheckRegistrationCode(gbind)
    timestamp = time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime())
    entry = [board, ubind, gbind, timestamp, hwid]
    self.server.UploadCSVEntry('registration_code_log', entry)

  def UpdateToolkit(self):
    unused_toolkit_version, has_update = updater.CheckForUpdate(
        self.args.timeout_secs)
    if not has_update:
      return

    # Update necessary. Note that updateFactory() will kill this test.
    if not self.args.update_without_prompt:
      # Display message and require update.
      self.ui.SetState(
          _('A software update is available. Press SPACE to update.'))
      self.ui.WaitKeysOnce(test_ui.SPACE_KEY)

    self.ui.CallJSFunction('window.test.updateFactory')

    # Let this test sleep forever, and wait for either the SPACE event, or the
    # factory update to complete. Note that we want the test to neither pass or
    # fail, so we won't be accidentally running other tests when the
    # updateFactory is running.
    self.WaitTaskEnd()

  @staticmethod
  def IsDynamicServer(url_spec):
    """Returns if the url_spec is something to be dynamically configured."""
    return isinstance(url_spec, dict) and url_spec

  def FindServerURL(self, url_spec):
    """Try to return a single normalized URL from given specification.

    It is very often that partner may want to deploy multiple servers with
    different IP, and expect DUT to connect right server according to the DHCP
    IP it has received.

    This function tries to parse argument url_spec and find a "best match
    URL" for it.

    Args:
      url_spec: a simple string as URL or a mapping from IP/CIDR to URL.

    Returns:
      A single URL string that best matches given spec.
    """
    if not self.IsDynamicServer(url_spec):
      return url_spec

    # Sort by CIDR so smaller network matches first.
    networks = sorted(
        url_spec, reverse=True, key=lambda k: int(k.partition('/')[-1] or 0))
    for ip_cidr in networks:
      # The command returned zero even if no interfaces match.
      if self.station.CallOutput(['ip', 'addr', 'show', 'to', ip_cidr]):
        return url_spec[ip_cidr]

    return url_spec.get('default', '')

  def runTest(self):
    self.ui.SetInstruction(_('Preparing...'))
    retry_secs = self.args.first_retry_secs

    self.event_loop.AddEventHandler(EVENT_SET_URL, self.OnButtonSetClicked)
    self.event_loop.AddEventHandler(EVENT_CANCEL_SET_URL,
                                    self.OnButtonCancelClicked)
    self.event_loop.AddEventHandler(EVENT_DO_SET_URL, self.OnButtonEditClicked)

    # Setup tasks to perform.
    tasks = [(_('Ping'), self.Ping)]

    if self.IsDynamicServer(self.args.server_url):
      # Server URL must be confirmed before Ping.
      tasks = [(_('Detect Server URL'), self.DetectServerURL)] + tasks

    if self.args.sync_time:
      def SyncTime():
        if not time_utils.SyncTimeWithFactoryServer():
          raise Exception('Failed to sync time with factory server')
      tasks += [(_('Sync time'), SyncTime)]

    if self.args.sync_event_logs:
      tasks += [(_('Flush Event Logs'), self.goofy.FlushEventLogs)]

    if self.args.flush_testlog:
      tasks += [(_('Flush Test Log'), self.FlushTestlog)]

    if self.args.upload_report:
      tasks += [(_('Create Report'), self.CreateReport)]
      tasks += [(_('Upload report'), self.UploadReport)]

    if self.args.upload_reg_codes:
      tasks += [(_('Upload Reg Codes'), self.UploadRegCodes)]

    if self.args.update_toolkit:
      tasks += [(_('Update Toolkit'), self.UpdateToolkit)]
    else:
      session.console.info('Toolkit update is disabled.')

    # Setup new server URL
    server_proxy.ValidateServerConfig()
    self.ChangeServerURL(self.FindServerURL(self.args.server_url))

    # It's very often that a DUT under FA is left without network connected for
    # hours to days, so we should not log (which will increase TestLog events)
    # if the exception string is not changed.
    logger = log_utils.NoisyLogger(
        lambda fault, prompt: logging.exception(prompt, fault))

    self.ui.DrawProgressBar(len(tasks))

    for label, task in tasks:
      while True:
        try:
          self.ui.SetState(_('Running task: {label}', label=label))
          task()
          self.ui.SetState([
              '<span style="color: green">',
              _('Server Task Finished: {label}', label=label), '</span>'
          ])
          self.Sleep(0.5)
          break
        except server_proxy.Fault as f:
          message = f.faultString
          logger.Log(message, 'Server fault with message: %s')
        except Exception:
          message = debug_utils.FormatExceptionOnly()
          logger.Log(message, 'Unable to sync with server: %s')

        msg = lambda time_left, label_: _(
            'Task <b>{label}</b> failed, retry in {time_left} seconds...',
            time_left=time_left,
            label=label_)
        edit_url_button = (['<p>', self.CreateChangeURLButton(), '</p>']
                           if self.allow_edit_url else '')
        self.ui.SetState([
            '<span id="retry">',
            msg(retry_secs, label), '</span>', edit_url_button,
            '<p><textarea rows=25 cols=90 readonly class="sync-detail">',
            test_ui.Escape(message, False), '</textarea>'
        ])

        try:
          # sync_utils.EventWait() may log timeout message every second, so we
          # disable logging.INFO temporarily.
          logging.disable(logging.INFO)
          for sec in xrange(retry_secs):
            if sync_utils.EventWait(self.do_setup_url, timeout=1):
              break
            self.ui.SetHTML(msg(retry_secs - sec - 1, label), id='retry')
        finally:
          logging.disable(logging.NOTSET)
        retry_secs = min(2 * retry_secs, self.args.retry_secs)

      self.ui.AdvanceProgress()