def _initialize(self,
hostname,
user="******",
port=_DEFAULT_SSH_PORT,
password="",
is_client_install_supported=True,
afe_host=None,
host_info_store=None,
connection_pool=None,
*args,
**dargs):
super(AbstractSSHHost, self)._initialize(hostname=hostname,
*args,
**dargs)
"""
@param hostname: The hostname of the host.
@param user: The username to use when ssh'ing into the host.
@param password: The password to use when ssh'ing into the host.
@param port: The port to use for ssh.
@param is_client_install_supported: Boolean to indicate if we can
install autotest on the host.
@param afe_host: The host object attained from the AFE (get_hosts).
@param host_info_store: Optional host_info.CachingHostInfoStore object
to obtain / update host information.
@param connection_pool: ssh_multiplex.ConnectionPool instance to share
the master ssh connection across control scripts.
"""
# IP address is retrieved only on demand. Otherwise the host
# initialization will fail for host is not online.
self._ip = None
self.user = user
self.port = port
self.password = password
self._is_client_install_supported = is_client_install_supported
self._use_rsync = None
self.known_hosts_file = tempfile.mkstemp()[1]
self._rpc_server_tracker = rpc_server_tracker.RpcServerTracker(self)
"""
Master SSH connection background job, socket temp directory and socket
control path option. If master-SSH is enabled, these fields will be
initialized by start_master_ssh when a new SSH connection is initiated.
"""
self._connection_pool = connection_pool
if connection_pool:
self._master_ssh = connection_pool.get(hostname, user, port)
else:
self._master_ssh = ssh_multiplex.MasterSsh(hostname, user, port)
self._afe_host = afe_host or utils.EmptyAFEHost()
self.host_info_store = (host_info_store
or host_info.InMemoryHostInfoStore())
# The cached status of whether the DUT responded to ping.
self._cached_up_status = None
# The timestamp when the value of _cached_up_status is set.
self._cached_up_status_updated = None
def create_host(hostname,
board,
model,
servo_hostname,
servo_port,
servo_serial=None,
logs_dir=None):
"""Yield a server.hosts.CrosHost object to use for DUT preparation.
This object contains just enough inventory data to be able to prepare the
DUT for lab deployment. It does not contain any reference to AFE / Skylab so
that DUT preparation is guaranteed to be isolated from the scheduling
infrastructure.
@param hostname: FQDN of the host to prepare.
@param board: The autotest board label for the DUT.
@param model: The autotest model label for the DUT.
@param servo_hostname: FQDN of the servo host controlling the DUT.
@param servo_port: Servo host port used for the controlling servo.
@param servo_serial: (Optional) Serial number of the controlling servo.
@param logs_dir: (Optional) Directory to save logs obtained from the
host.
@yield a server.hosts.Host object.
"""
labels = [
'board:%s' % board,
'model:%s' % model,
]
attributes = {
servo_host.SERVO_HOST_ATTR: servo_hostname,
servo_host.SERVO_PORT_ATTR: servo_port,
}
if servo_serial is not None:
attributes[servo_host.SERVO_SERIAL_ATTR] = servo_serial
store = host_info.InMemoryHostInfoStore(info=host_info.HostInfo(
labels=labels,
attributes=attributes,
))
machine_dict = {
'hostname': hostname,
'host_info_store': store,
'afe_host': server_utils.EmptyAFEHost(),
}
host = hosts.create_host(machine_dict)
servohost = servo_host.ServoHost(
**servo_host.get_servo_args_for_host(host))
_prepare_servo(servohost)
host.set_servo_host(servohost)
host.servo.uart_logs_dir = logs_dir
try:
yield host
finally:
host.close()
def _initialize(self,
hostname,
user="******",
port=22,
password="",
is_client_install_supported=True,
afe_host=None,
host_info_store=None,
*args,
**dargs):
super(AbstractSSHHost, self)._initialize(hostname=hostname,
*args,
**dargs)
"""
@param hostname: The hostname of the host.
@param user: The username to use when ssh'ing into the host.
@param password: The password to use when ssh'ing into the host.
@param port: The port to use for ssh.
@param is_client_install_supported: Boolean to indicate if we can
install autotest on the host.
@param afe_host: The host object attained from the AFE (get_hosts).
@param host_info_store: Optional host_info.CachingHostInfoStore object
to obtain / update host information.
"""
# IP address is retrieved only on demand. Otherwise the host
# initialization will fail for host is not online.
self._ip = None
self.user = user
self.port = port
self.password = password
self._is_client_install_supported = is_client_install_supported
self._use_rsync = None
self.known_hosts_file = tempfile.mkstemp()[1]
self._rpc_server_tracker = rpc_server_tracker.RpcServerTracker(self)
"""
Master SSH connection background job, socket temp directory and socket
control path option. If master-SSH is enabled, these fields will be
initialized by start_master_ssh when a new SSH connection is initiated.
"""
self.master_ssh_job = None
self.master_ssh_tempdir = None
self.master_ssh_option = ''
# Create a Lock to protect against race conditions.
self._lock = Lock()
self._afe_host = afe_host or utils.EmptyAFEHost()
self.host_info_store = (host_info_store
or host_info.InMemoryHostInfoStore())
def _gen_machine_dict(hostname='localhost', labels=[], attributes={}):
"""Generate a machine dictionary with the specified parameters.
@param hostname: hostname of machine
@param labels: list of host labels
@param attributes: dict of host attributes
@return: machine dict with mocked AFE Host object and fake AfeStore.
"""
afe_host = base_label_unittest.MockAFEHost(labels, attributes)
store = host_info.InMemoryHostInfoStore()
store.commit(host_info.HostInfo(labels, attributes))
return {'hostname': hostname,
'afe_host': afe_host,
'host_info_store': store}
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
def test_update_labels(self):
"""Check that we add/remove the expected labels in update_labels()."""
label_to_add = 'label_to_add'
label_to_remove = 'prefix:label_to_remove'
store = host_info.InMemoryHostInfoStore(info=host_info.HostInfo(
labels=[label_to_remove, TestBaseLabel._NAME], ), )
mockhost = MockHost(store=store)
retriever = base_label.LabelRetriever(
[TestStringPrefixLabel(label=label_to_add),
TestBaseLabel()])
retriever.update_labels(mockhost)
self.assertEqual(
set(store.get().labels),
{
'%s:%s' % (TestStringPrefixLabel._NAME, label_to_add),
TestBaseLabel._NAME
},
)
def __init__(self,
hostname='localhost',
afe_host=None,
adb_serials=None,
host_info_store=None,
**dargs):
"""Initialize a TestBed.
This will create the Test Station Host and connected hosts (ADBHost for
now) and allow the user to retrieve them.
@param hostname: Hostname of the test station connected to the duts.
@param adb_serials: List of adb device serials.
@param host_info_store: A CachingHostInfoStore object.
@param afe_host: The host object attained from the AFE (get_hosts).
"""
logging.info('Initializing TestBed centered on host: %s', hostname)
self.hostname = hostname
self._afe_host = afe_host or utils.EmptyAFEHost()
self.host_info_store = (host_info_store
or host_info.InMemoryHostInfoStore())
self.labels = base_label.LabelRetriever(testbed_label.TESTBED_LABELS)
self.teststation = teststation_host.create_teststationhost(
hostname=hostname, afe_host=self._afe_host, **dargs)
self.is_client_install_supported = False
serials_from_attributes = self._afe_host.attributes.get('serials')
if serials_from_attributes:
serials_from_attributes = serials_from_attributes.split(',')
self.adb_device_serials = (adb_serials or serials_from_attributes
or self.query_adb_device_serials())
self.adb_devices = {}
for adb_serial in self.adb_device_serials:
self.adb_devices[adb_serial] = adb_host.ADBHost(
hostname=hostname,
teststation=self.teststation,
adb_serial=adb_serial,
afe_host=self._afe_host,
host_info_store=self.host_info_store,
**dargs)
def setUp(self):
self.store = host_info.InMemoryHostInfoStore()
def __init__(self, labels, *args):
self._afe_host = MockAFEHost(labels)
self.mock_cmds = {c.cmd: c for c in args}
info = host_info.HostInfo(labels=labels)
self.host_info_store = host_info.InMemoryHostInfoStore(info)
