# 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 dpkt
import logging
import time
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_HandlesNameConflicts(test.test):
"""Test that peerd can handle mDNS name conflicts."""
version = 1
CACHE_REFRESH_PERIOD_SECONDS = 5
FAKE_HOST_HOSTNAME = 'a-test-host'
TEST_TIMEOUT_SECONDS = 30
TEST_SERVICE_ID = 'test-service-0'
TEST_SERVICE_INFO = {'some_data': 'a value',
'other_data': 'another value'}
INITIAL_MDNS_PREFIX = 'initial_mdns_prefix'
SERBUS_SERVICE_ID = 'serbus'
SERBUS_SERVICE_NAME = '_serbus'
SERBUS_PROTOCOL = '_tcp'
SERBUS_PORT = 0
def reset_peerd(self):
"""Start up a peerd instance.
This instance will have really verbose logging and will attempt
to use a known MDNS prefix to start out.
"""
self._peerd = peerd_dbus_helper.make_helper(
peerd_config.PeerdConfig(verbosity_level=3,
mdns_prefix=self.INITIAL_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()
self.reset_peerd()
# 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 therefor 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)
self._last_cache_refresh_seconds = 0
def cleanup(self):
for obj in (self._chrooted_avahi,
self._host,
self._peerd):
if obj is not None:
obj.close()
def _get_PTR_prefix(self, service_id):
ptr_name = '_%s._tcp.%s' % (service_id, self._dns_domain)
found_records = self._zc_listener.cached_results(
ptr_name, dpkt.dns.DNS_PTR)
if len(found_records) == 0:
logging.debug('Found no PTR records for %s', ptr_name)
return None
if len(found_records) > 1:
logging.debug('Found multiple PTR records for %s', ptr_name)
return None
unique_name = found_records[0].data
expected_suffix = '.' + ptr_name
if not unique_name.endswith(expected_suffix):
logging.error('PTR record for "%s" points to odd name: "%s"',
ptr_name, unique_name)
return None
ptr_prefix = unique_name[0:-len(expected_suffix)]
logging.debug('PTR record for "%s" points to service with name "%s"',
ptr_name, ptr_prefix)
return ptr_prefix
def _found_expected_PTR_records(self, forbidden_record_prefix):
for service_id in (self.SERBUS_SERVICE_ID, self.TEST_SERVICE_ID):
prefix = self._get_PTR_prefix(service_id)
if prefix is None:
break
if prefix == forbidden_record_prefix:
logging.debug('Ignoring service with conflicting prefix')
break
else:
return True
delta_seconds = time.time() - self._last_cache_refresh_seconds
if delta_seconds > self.CACHE_REFRESH_PERIOD_SECONDS:
self._zc_listener.clear_cache()
self._last_cache_refresh_seconds = time.time()
return False
def run_once(self):
# Tell peerd about this exciting new service we have.
self._peerd.expose_service(self.TEST_SERVICE_ID, self.TEST_SERVICE_INFO)
# Wait for advertisements of that service to appear from avahi.
# They should be prefixed with our special name, since there are no
# conflicts.
logging.info('Waiting to receive mDNS advertisements of '
'peerd services.')
success, duration = self._host.run_until(
lambda: self._found_expected_PTR_records(None),
self.TEST_TIMEOUT_SECONDS)
if not success:
raise error.TestFail('Did not receive mDNS advertisements in time.')
actual_prefix = self._get_PTR_prefix(self.SERBUS_SERVICE_ID)
if actual_prefix != self.INITIAL_MDNS_PREFIX:
raise error.TestFail('Expected initial mDNS advertisements to have '
'a prefix=%s' % self.INITIAL_MDNS_PREFIX)
logging.info('Found initial records advertised by peerd.')
# Now register services with the same name, and restart peerd.
# 1) The old instance of peerd should withdraw its services from Avahi
# 2) The new instance of peerd should re-register services with Avahi
# 3) Avahi should notice that the name.service_type.domain tuple
# conflicts with existing records, and signal this to peerd.
# 4) Peerd should pick a new prefix and try again.
self.reset_peerd()
self._zc_listener.register_service(
self.INITIAL_MDNS_PREFIX,
self.SERBUS_SERVICE_NAME,
self.SERBUS_PROTOCOL,
self.SERBUS_PORT,
['invalid=record'])
self._peerd.expose_service(self.TEST_SERVICE_ID, self.TEST_SERVICE_INFO)
run_until_predicate = lambda: self._found_expected_PTR_records(
self.INITIAL_MDNS_PREFIX)
success, duration = self._host.run_until(run_until_predicate,
self.TEST_TIMEOUT_SECONDS)
if not success:
raise error.TestFail('Timed out waiting for peerd to change the '
'record prefix.')