| # Copyright (c) 2013 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. |
| |
| """A collection of context managers for working with shill objects.""" |
| |
| import errno |
| import logging |
| import os |
| |
| from contextlib import contextmanager |
| |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.common_lib import utils |
| from autotest_lib.client.cros.networking import shill_proxy |
| |
| SHILL_START_LOCK_PATH = '/run/lock/shill-start.lock' |
| |
| class ContextError(Exception): |
| """An error raised by a context managers dealing with shill objects.""" |
| pass |
| |
| |
| class AllowedTechnologiesContext(object): |
| """A context manager for allowing only specified technologies in shill. |
| |
| Usage: |
| # Suppose both 'wifi' and 'cellular' technology are originally enabled. |
| allowed = [shill_proxy.ShillProxy.TECHNOLOGY_CELLULAR] |
| with AllowedTechnologiesContext(allowed): |
| # Within this context, only the 'cellular' technology is allowed to |
| # be enabled. The 'wifi' technology is temporarily prohibited and |
| # disabled until after the context ends. |
| |
| """ |
| |
| def __init__(self, allowed): |
| self._allowed = set(allowed) |
| |
| |
| def __enter__(self): |
| shill = shill_proxy.ShillProxy.get_proxy() |
| |
| # The EnabledTechologies property is an array of strings of technology |
| # identifiers. |
| enabled = shill.get_dbus_property( |
| shill.manager, |
| shill_proxy.ShillProxy.MANAGER_PROPERTY_ENABLED_TECHNOLOGIES) |
| self._originally_enabled = set(enabled) |
| |
| # The ProhibitedTechnologies property is a comma-separated string of |
| # technology identifiers. |
| prohibited_csv = shill.get_dbus_property( |
| shill.manager, |
| shill_proxy.ShillProxy.MANAGER_PROPERTY_PROHIBITED_TECHNOLOGIES) |
| prohibited = prohibited_csv.split(',') if prohibited_csv else [] |
| self._originally_prohibited = set(prohibited) |
| |
| prohibited = ((self._originally_prohibited | self._originally_enabled) |
| - self._allowed) |
| prohibited_csv = ','.join(prohibited) |
| |
| logging.debug('Allowed technologies = [%s]', ','.join(self._allowed)) |
| logging.debug('Originally enabled technologies = [%s]', |
| ','.join(self._originally_enabled)) |
| logging.debug('Originally prohibited technologies = [%s]', |
| ','.join(self._originally_prohibited)) |
| logging.debug('To be prohibited technologies = [%s]', |
| ','.join(prohibited)) |
| |
| # Setting the ProhibitedTechnologies property will disable those |
| # prohibited technologies. |
| shill.set_dbus_property( |
| shill.manager, |
| shill_proxy.ShillProxy.MANAGER_PROPERTY_PROHIBITED_TECHNOLOGIES, |
| prohibited_csv) |
| |
| return self |
| |
| |
| def __exit__(self, exc_type, exc_value, traceback): |
| shill = shill_proxy.ShillProxy.get_proxy() |
| |
| prohibited_csv = ','.join(self._originally_prohibited) |
| shill.set_dbus_property( |
| shill.manager, |
| shill_proxy.ShillProxy.MANAGER_PROPERTY_PROHIBITED_TECHNOLOGIES, |
| prohibited_csv) |
| |
| # Re-enable originally enabled technologies as they may have been |
| # disabled. |
| for technology in self._originally_enabled: |
| shill.manager.EnableTechnology(technology) |
| |
| return False |
| |
| |
| class ServiceAutoConnectContext(object): |
| """A context manager for overriding a service's 'AutoConnect' property. |
| |
| As the service object of the same service may change during the lifetime |
| of the context, this context manager does not take a service object at |
| construction. Instead, it takes a |get_service| function at construction, |
| which it invokes to obtain a service object when entering and exiting the |
| context. It is assumed that |get_service| always returns a service object |
| that refers to the same service. |
| |
| Usage: |
| def get_service(): |
| # Some function that returns a service object. |
| |
| with ServiceAutoConnectContext(get_service, False): |
| # Within this context, the 'AutoConnect' property of the service |
| # returned by |get_service| is temporarily set to False if it's |
| # initially set to True. The property is restored to its initial |
| # value after the context ends. |
| |
| """ |
| def __init__(self, get_service, autoconnect): |
| self._get_service = get_service |
| self._autoconnect = autoconnect |
| self._initial_autoconnect = None |
| |
| |
| def __enter__(self): |
| service = self._get_service() |
| if service is None: |
| raise ContextError('Could not obtain a service object.') |
| |
| # Always set the AutoConnect property even if the requested value |
| # is the same so that shill will retain the AutoConnect property, else |
| # shill may override it. |
| service_properties = service.GetProperties() |
| self._initial_autoconnect = shill_proxy.ShillProxy.dbus2primitive( |
| service_properties[ |
| shill_proxy.ShillProxy.SERVICE_PROPERTY_AUTOCONNECT]) |
| logging.info('ServiceAutoConnectContext: change autoconnect to %s', |
| self._autoconnect) |
| service.SetProperty( |
| shill_proxy.ShillProxy.SERVICE_PROPERTY_AUTOCONNECT, |
| self._autoconnect) |
| |
| # Make sure the cellular service gets persisted by taking it out of |
| # the ephemeral profile. |
| if not service_properties[ |
| shill_proxy.ShillProxy.SERVICE_PROPERTY_PROFILE]: |
| shill = shill_proxy.ShillProxy.get_proxy() |
| manager_properties = shill.manager.GetProperties(utf8_strings=True) |
| active_profile = manager_properties[ |
| shill_proxy.ShillProxy.MANAGER_PROPERTY_ACTIVE_PROFILE] |
| logging.info('ServiceAutoConnectContext: change cellular service ' |
| 'profile to %s', active_profile) |
| service.SetProperty( |
| shill_proxy.ShillProxy.SERVICE_PROPERTY_PROFILE, |
| active_profile) |
| |
| return self |
| |
| |
| def __exit__(self, exc_type, exc_value, traceback): |
| if self._initial_autoconnect != self._autoconnect: |
| service = self._get_service() |
| if service is None: |
| raise ContextError('Could not obtain a service object.') |
| |
| logging.info('ServiceAutoConnectContext: restore autoconnect to %s', |
| self._initial_autoconnect) |
| service.SetProperty( |
| shill_proxy.ShillProxy.SERVICE_PROPERTY_AUTOCONNECT, |
| self._initial_autoconnect) |
| return False |
| |
| |
| @property |
| def autoconnect(self): |
| """AutoConnect property value within this context.""" |
| return self._autoconnect |
| |
| |
| @property |
| def initial_autoconnect(self): |
| """Initial AutoConnect property value when entering this context.""" |
| return self._initial_autoconnect |
| |
| |
| @contextmanager |
| def stopped_shill(): |
| """A context for executing code which requires shill to be stopped. |
| |
| This context stops shill on entry to the context, and starts shill |
| before exit from the context. This context further guarantees that |
| shill will be not restarted by recover_duts, while this context is |
| active. |
| |
| Note that the no-restart guarantee applies only if the user of |
| this context completes with a 'reasonable' amount of time. In |
| particular: if networking is unavailable for 15 minutes or more, |
| recover_duts will reboot the DUT. |
| |
| """ |
| def get_lock_holder(lock_path): |
| lock_holder = os.readlink(lock_path) |
| try: |
| os.stat(lock_holder) |
| return lock_holder # stat() success -> valid link -> locker alive |
| except OSError as e: |
| if e.errno == errno.ENOENT: # dangling link -> locker is gone |
| return None |
| else: |
| raise |
| |
| our_proc_dir = '/proc/%d/' % os.getpid() |
| try: |
| os.symlink(our_proc_dir, SHILL_START_LOCK_PATH) |
| except OSError as e: |
| if e.errno != errno.EEXIST: |
| raise |
| lock_holder = get_lock_holder(SHILL_START_LOCK_PATH) |
| if lock_holder is not None: |
| raise error.TestError('Shill start lock held by %s' % lock_holder) |
| os.remove(SHILL_START_LOCK_PATH) |
| os.symlink(our_proc_dir, SHILL_START_LOCK_PATH) |
| |
| utils.stop_service('shill') |
| yield |
| utils.start_service('shill') |
| os.remove(SHILL_START_LOCK_PATH) |