# Copyright 2014 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 collections
import logging

from autotest_lib.client.bin import test
from autotest_lib.client.common_lib import error
from autotest_lib.client.common_lib.cros.tendo import peerd_config
from autotest_lib.client.cros import chrooted_avahi
from autotest_lib.client.cros.netprotos import interface_host
from autotest_lib.client.cros.netprotos import zeroconf
from autotest_lib.client.cros.tendo import peerd_dbus_helper


class peerd_DiscoverServices(test.test):
    """Test that peerd can correctly discover services over mDNS."""
    version = 1

    FakeService = collections.namedtuple('FakeService',
                                         'service_id service_info port')
    FAKE_HOST_HOSTNAME = 'test-host'
    TEST_TIMEOUT_SECONDS = 30
    PEER_ID = '123e4567-e89b-12d3-a456-426655440000'
    PEER_SERBUS_VERSION = '1.12'
    PEER_SERVICES = [FakeService('test-service-0',
                                 {'some_data': 'a value',
                                  'other_data': 'another value',
                                 },
                                 8080),
                     FakeService('test-service-1',
                                 {'again': 'so much data',
                                 },
                                 8081),
                    ]
    SERBUS_SERVICE_NAME = '_serbus'
    SERBUS_PROTOCOL = '_tcp'
    SERBUS_PORT = 0
    SERBUS_TXT_DICT = {'ver': PEER_SERBUS_VERSION,
                       'id': PEER_ID,
                       'services': '.'.join([service.service_id
                                             for service in PEER_SERVICES])
                      }
    UNIQUE_PREFIX = 'a_unique_mdns_prefix'



    def initialize(self):
        # Make sure these are initiallized to None in case we throw
        # during self.initialize().
        self._chrooted_avahi = None
        self._peerd = None
        self._host = None
        self._zc_listener = None
        self._chrooted_avahi = chrooted_avahi.ChrootedAvahi()
        self._chrooted_avahi.start()
        # Start up a fresh copy of peerd with really verbose logging.
        self._peerd = peerd_dbus_helper.make_helper(
                peerd_config.PeerdConfig(verbosity_level=3))
        # Listen on our half of the interface pair for mDNS advertisements.
        self._host = interface_host.InterfaceHost(
                self._chrooted_avahi.unchrooted_interface_name)
        self._zc_listener = zeroconf.ZeroconfDaemon(self._host,
                                                    self.FAKE_HOST_HOSTNAME)
        # The queries for hostname/dns_domain are IPCs and therefore relatively
        # expensive.  Do them just once.
        hostname = self._chrooted_avahi.hostname
        dns_domain = self._chrooted_avahi.dns_domain
        if not hostname or not dns_domain:
            raise error.TestFail('Failed to get hostname/domain from avahi.')
        self._dns_domain = dns_domain
        self._hostname = '%s.%s' % (hostname, dns_domain)


    def cleanup(self):
        for obj in (self._chrooted_avahi,
                    self._host,
                    self._peerd):
            if obj is not None:
                obj.close()


    def _has_expected_peer(self):
        peer = self._peerd.has_peer(self.PEER_ID)
        if peer is None:
            logging.debug('No peer found.')
            return False
        logging.debug('Found peer=%s', peer)
        if len(peer.services) != len(self.PEER_SERVICES):
            logging.debug('Found %d services, but expected %d.',
                          len(peer.services), len(self.PEER_SERVICES))
            return False
        for service_id, info, port in self.PEER_SERVICES:
            service = None
            for s in peer.services:
                if s.service_id == service_id:
                    service = s
                    break
            else:
                logging.debug('No service %s found.', service_id)
                return False
            if service.service_info != info:
                logging.debug('Invalid info found for service %s, '
                              'expected %r but got %r.', service_id,
                              info, service.service_info)
                return False
            if len(service.service_ips) != 1:
                logging.debug('Missing service IP for service %s.',
                              service_id)
                return False
            # We're publishing records from a "peer" outside the chroot.
            expected_addr = (self._chrooted_avahi.MONITOR_IF_IP.addr, port)
            if service.service_ips[0] != expected_addr:
                logging.debug('Expected service IP for service %s=%r '
                              'but got %r.',
                              service_id, expected_addr, service.service_ips[0])
                return False
        return True


    def run_once(self):
        # Expose serbus mDNS records through our fake peer.
        self._zc_listener.register_service(
                self.UNIQUE_PREFIX,
                self.SERBUS_SERVICE_NAME,
                self.SERBUS_PROTOCOL,
                self.SERBUS_PORT,
                ['='.join(pair) for pair in self.SERBUS_TXT_DICT.iteritems()])
        for service_id, info, port in self.PEER_SERVICES:
            self._zc_listener.register_service(
                    self.UNIQUE_PREFIX,
                    '_' + service_id,
                    self.SERBUS_PROTOCOL,
                    port,
                    ['='.join(pair) for pair in info.iteritems()])

            # Look for mDNS records through peerd
        self._peerd.start_monitoring([peerd_dbus_helper.TECHNOLOGY_MDNS])
        # Wait for advertisements of that service to appear from avahi.
        logging.info('Waiting for peerd to discover our services.')
        success, duration = self._host.run_until(self._has_expected_peer,
                                                 self.TEST_TIMEOUT_SECONDS)
        logging.debug('Took %f seconds to find our peer.', duration)
        if not success:
            raise error.TestFail('Peerd failed to publish suitable DBus '
                                 'proxies in time.')