def _disable_internet(self, ping_server='google.com'):
"""Disable the internet connection"""
self._internet_was_disabled = True
try:
logging.debug('Before disconnect: %s', utils.run('ifconfig'))
# DUTs in the lab have a service called recover_duts that is used to
# check that the DUT is online and if it is not it will bring it
# back online. We will need to stop this service for the length
# of this test.
utils.stop_service('recover_duts', ignore_status=True)
for eth in self._NETWORK_INTERFACES:
result = utils.run('ifconfig %s down' % eth,
ignore_status=True)
logging.debug(result)
# Print ifconfig to help debug DUTs that stay online.
logging.debug('After disconnect: %s', utils.run('ifconfig'))
# Make sure we are offline
utils.poll_for_condition(
lambda: utils.ping(ping_server, deadline=5, timeout=5) != 0,
timeout=60,
sleep_interval=1,
desc='Ping failure while offline.')
except (error.CmdError, utils.TimeoutError):
logging.exception('Failed to disconnect one or more interfaces.')
logging.debug(utils.run('ifconfig', ignore_status=True))
raise error.TestFail('Disabling the internet connection failed.')
def _enable_internet(self, ping_server='google.com'):
"""
Re-enables the internet connection.
@param ping_server: The server to ping to check we are online.
"""
if not self._internet_was_disabled:
return
self._internet_was_disabled = False
logging.debug('Before reconnect: %s', utils.run('ifconfig'))
for eth in self._NETWORK_INTERFACES:
utils.run('ifconfig %s up' % eth, ignore_status=True)
utils.start_service('recover_duts', ignore_status=True)
# Print ifconfig to help debug DUTs that stay offline.
logging.debug('After reconnect: %s', utils.run('ifconfig'))
# We can't return right after reconnecting the network or the server
# test may not receive the message. So we wait a bit longer for the
# DUT to be reconnected.
utils.poll_for_condition(
lambda: utils.ping(ping_server, tries=3, timeout=10) == 0,
timeout=120,
sleep_interval=1,
exception=error.TestFail('Ping failed after reconnecting network'))
def execute(self):
# Check to see if the platform or any other labels can be grabbed from
# the hosts.
self.host_info_map = {}
for host in self.hosts:
try:
if utils.ping(host, tries=1, deadline=1) == 0:
if self.serials and len(self.serials) > 1:
host_dut = hosts.create_testbed(
host, adb_serials=self.serials)
else:
adb_serial = None
if self.serials:
adb_serial = self.serials[0]
host_dut = hosts.create_host(host,
adb_serial=adb_serial)
host_info = host_information(host, host_dut.get_platform(),
host_dut.get_labels())
else:
# Can't ping the host, use default information.
host_info = host_information(host, None, [])
except (socket.gaierror, error.AutoservRunError,
error.AutoservSSHTimeout):
# We may be adding a host that does not exist yet or we can't
# reach due to hostname/address issues or if the host is down.
host_info = host_information(host, None, [])
self.host_info_map[host] = host_info
# We need to check if these labels & ACLs exist,
# and create them if not.
if self.platform:
self.check_and_create_items('get_labels',
'add_label', [self.platform],
platform=True)
else:
# No platform was provided so check and create the platform label
# for each host.
platforms = []
for host_info in self.host_info_map.values():
if host_info.platform and host_info.platform not in platforms:
platforms.append(host_info.platform)
if platforms:
self.check_and_create_items('get_labels',
'add_label',
platforms,
platform=True)
labels_to_check_and_create = self.labels[:]
for host_info in self.host_info_map.values():
labels_to_check_and_create = (host_info.labels +
labels_to_check_and_create)
if labels_to_check_and_create:
self.check_and_create_items('get_labels',
'add_label',
labels_to_check_and_create,
platform=False)
if self.acls:
self.check_and_create_items('get_acl_groups', 'add_acl_group',
self.acls)
return self._execute_add_hosts()
def network_is_up(reachable=None, dev=None):
if not reachable:
reachable = get_pingable_address(dev=dev)
if not reachable:
return False
if utils.ping(reachable, tries=1) == 0:
return True
return False
def create_chameleon_host(dut, chameleon_args):
"""Create a ChameleonHost object.
There three possible cases:
1) If the DUT is in Cros Lab and has a chameleon board, then create
a ChameleonHost object pointing to the board. chameleon_args
is ignored.
2) If not case 1) and chameleon_args is neither None nor empty, then
create a ChameleonHost object using chameleon_args.
3) If neither case 1) or 2) applies, return None.
@param dut: host name of the host that chameleon connects. It can be used
to lookup the chameleon in test lab using naming convention.
If dut is an IP address, it can not be used to lookup the
chameleon in test lab.
@param chameleon_args: A dictionary that contains args for creating
a ChameleonHost object,
e.g. {'chameleon_host': '172.11.11.112',
'chameleon_port': 9992}.
@returns: A ChameleonHost object or None.
"""
if not utils.is_in_container():
is_moblab = utils.is_moblab()
else:
is_moblab = _CONFIG.get_config_value('SSP',
'is_moblab',
type=bool,
default=False)
if not is_moblab:
dut_is_hostname = not dnsname_mangler.is_ip_address(dut)
if dut_is_hostname:
chameleon_hostname = chameleon.make_chameleon_hostname(dut)
if utils.host_is_in_lab_zone(chameleon_hostname):
# Be more tolerant on chameleon in the lab because
# we don't want dead chameleon blocks non-chameleon tests.
if utils.ping(chameleon_hostname, deadline=3):
logging.warning(
'Chameleon %s is not accessible. Please file a bug'
' to test lab', chameleon_hostname)
return None
return ChameleonHost(chameleon_host=chameleon_hostname)
if chameleon_args:
return ChameleonHost(**chameleon_args)
else:
return None
else:
afe = frontend_wrappers.RetryingAFE(timeout_min=5, delay_sec=10)
hosts = afe.get_hosts(hostname=dut)
if hosts and CHAMELEON_HOST_ATTR in hosts[0].attributes:
return ChameleonHost(
chameleon_host=hosts[0].attributes[CHAMELEON_HOST_ATTR],
chameleon_port=hosts[0].attributes.get(CHAMELEON_PORT_ATTR,
9992))
else:
return None
def _detect_host_info(self, host):
"""Detect platform and labels from the host.
@param host: hostname
@return: HostInfo object
"""
# Mock an afe_host object so that the host is constructed as if the
# data was already in afe
data = {'attributes': self.attributes, 'labels': self.labels}
afe_host = frontend.Host(None, data)
store = host_info.InMemoryHostInfoStore(
host_info.HostInfo(labels=self.labels, attributes=self.attributes))
machine = {
'hostname': host,
'afe_host': afe_host,
'host_info_store': store
}
try:
if bin_utils.ping(host, tries=1, deadline=1) == 0:
serials = self.attributes.get('serials', '').split(',')
if serials and len(serials) > 1:
host_dut = hosts.create_testbed(machine,
adb_serials=serials)
else:
adb_serial = self.attributes.get('serials')
host_dut = hosts.create_host(machine,
adb_serial=adb_serial)
info = HostInfo(host, host_dut.get_platform(),
host_dut.get_labels())
# Clean host to make sure nothing left after calling it,
# e.g. tunnels.
if hasattr(host_dut, 'close'):
host_dut.close()
else:
# Can't ping the host, use default information.
info = HostInfo(host, None, [])
except (socket.gaierror, error.AutoservRunError,
error.AutoservSSHTimeout):
# We may be adding a host that does not exist yet or we can't
# reach due to hostname/address issues or if the host is down.
info = HostInfo(host, None, [])
return info