| # 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.') |
