blob: bb51e21af6bbc44bd711d77ff3d56cfb5c16f14e [file] [log] [blame]
# Copyright 2007 Google Inc. Released under the GPL v2
This module defines the SSHHost class.
Implementation details:
You should import the "hosts" package instead of importing each type of host.
SSHHost: a remote machine with a ssh access
import re, logging
from autotest_lib.client.common_lib import error, pxssh
from autotest_lib.server import utils
from autotest_lib.server.hosts import abstract_ssh
class SSHHost(abstract_ssh.AbstractSSHHost):
This class represents a remote machine controlled through an ssh
session on which you can run programs.
It is not the machine autoserv is running on. The machine must be
configured for password-less login, for example through public key
It includes support for controlling the machine through a serial
console on which you can run programs. If such a serial console is
set up on the machine then capabilities such as hard reset and
boot strap monitoring are available. If the machine does not have a
serial console available then ordinary SSH-based commands will
still be available, but attempts to use extensions such as
console logging or hard reset will fail silently.
Implementation details:
This is a leaf class in an abstract class hierarchy, it must
implement the unimplemented methods in parent classes.
def _initialize(self, hostname, *args, **dargs):
Construct a SSHHost object
hostname: network hostname or address of remote machine
super(SSHHost, self)._initialize(hostname=hostname, *args, **dargs)
def ssh_command(self, connect_timeout=30, options='', alive_interval=300):
Construct an ssh command with proper args for this host.
@param connect_timeout: connection timeout (in seconds)
@param options: SSH options
@param alive_interval: SSH Alive interval.
options = "%s %s" % (options, self.master_ssh_option)
base_cmd = self.make_ssh_command(user=self.user, port=self.port,
return "%s %s" % (base_cmd, self.hostname)
def _run(self, command, timeout, ignore_status,
stdout, stderr, connect_timeout, env, options, stdin, args,
"""Helper function for run()."""
ssh_cmd = self.ssh_command(connect_timeout, options)
if not env.strip():
env = ""
env = "export %s;" % env
for arg in args:
command += ' "%s"' % utils.sh_escape(arg)
full_cmd = '%s "%s %s"' % (ssh_cmd, env, utils.sh_escape(command))
result =, timeout, True, stdout, stderr,
verbose=False, stdin=stdin,
if ignore_timeout and not result:
return None
# The error messages will show up in band (indistinguishable
# from stuff sent through the SSH connection), so we have the
# remote computer echo the message "Connected." before running
# any command. Since the following 2 errors have to do with
# connecting, it's safe to do these checks.
if result.exit_status == 255:
if'^ssh: connect to host .* port .*: '
r'Connection timed out\r$', result.stderr):
raise error.AutoservSSHTimeout("ssh timed out", result)
if "Permission denied." in result.stderr:
msg = "ssh permission denied"
raise error.AutoservSshPermissionDeniedError(msg, result)
if not ignore_status and result.exit_status > 0:
raise error.AutoservRunError("command execution error", result)
return result
def run(self, command, timeout=3600, ignore_status=False,
stdout_tee=utils.TEE_TO_LOGS, stderr_tee=utils.TEE_TO_LOGS,
connect_timeout=30, options='', stdin=None, verbose=True, args=(),
Run a command on the remote host.
@param connect_timeout: connection timeout (in seconds)
@param options: string with additional ssh command options
@param verbose: log the commands
@param ignore_timeout: bool True if SSH command timeouts should be
ignored. Will return None on command timeout.
@raises AutoservRunError: if the command failed
@raises AutoservSSHTimeout: ssh connection has timed out
if verbose:
logging.debug("Running (ssh) '%s'", command)
# Start a master SSH connection if necessary.
env = " ".join("=".join(pair) for pair in self.env.iteritems())
return self._run(command, timeout, ignore_status,
stdout_tee, stderr_tee, connect_timeout, env,
options, stdin, args, ignore_timeout)
except error.CmdError, cmderr:
# We get a CmdError here only if there is timeout of that command.
# Catch that and stuff it into AutoservRunError and raise it.
timeout_message = str('Timeout encountered: %s' % cmderr.args[0])
raise error.AutoservRunError(timeout_message, cmderr.args[1])
def run_short(self, command, **kwargs):
Calls the run() command with a short default timeout.
Takes the same arguments as does run(),
with the exception of the timeout argument which
here is fixed at 60 seconds.
It returns the result of run.
@param command: the command line string
return, timeout=60, **kwargs)
def run_grep(self, command, timeout=30, ignore_status=False,
stdout_ok_regexp=None, stdout_err_regexp=None,
stderr_ok_regexp=None, stderr_err_regexp=None,
Run a command on the remote host and look for regexp
in stdout or stderr to determine if the command was
successul or not.
@param command: the command line string
@param timeout: time limit in seconds before attempting to
kill the running process. The run() function
will take a few seconds longer than 'timeout'
to complete if it has to kill the process.
@param ignore_status: do not raise an exception, no matter
what the exit code of the command is.
@param stdout_ok_regexp: regexp that should be in stdout
if the command was successul.
@param stdout_err_regexp: regexp that should be in stdout
if the command failed.
@param stderr_ok_regexp: regexp that should be in stderr
if the command was successul.
@param stderr_err_regexp: regexp that should be in stderr
if the command failed.
@param connect_timeout: connection timeout (in seconds)
if the command was successul, raises an exception
- the exit code of the command execution was not 0.
- If stderr_err_regexp is found in stderr,
- If stdout_err_regexp is found in stdout,
- If stderr_ok_regexp is not found in stderr.
- If stdout_ok_regexp is not found in stdout,
# We ignore the status, because we will handle it at the end.
result =, timeout, ignore_status=True,
# Look for the patterns, in order
for (regexp, stream) in ((stderr_err_regexp, result.stderr),
(stdout_err_regexp, result.stdout)):
if regexp and stream:
err_re = re.compile (regexp)
raise error.AutoservRunError(
'%s failed, found error pattern: "%s"' % (command,
regexp), result)
for (regexp, stream) in ((stderr_ok_regexp, result.stderr),
(stdout_ok_regexp, result.stdout)):
if regexp and stream:
ok_re = re.compile (regexp)
if not ignore_status and result.exit_status > 0:
raise error.AutoservRunError("command execution error", result)
def setup_ssh_key(self):
"""Setup SSH Key"""
logging.debug('Performing SSH key setup on %s:%d as %s.',
self.hostname, self.port, self.user)
host = pxssh.pxssh()
host.login(self.hostname, self.user, self.password,
public_key = utils.get_public_key()
host.sendline('mkdir -p ~/.ssh')
host.sendline('chmod 700 ~/.ssh')
host.sendline("echo '%s' >> ~/.ssh/authorized_keys; " %
host.sendline('chmod 600 ~/.ssh/authorized_keys')
logging.debug('SSH key setup complete.')
logging.debug('SSH key setup has failed.')
def setup_ssh(self):
"""Setup SSH"""
if self.password:
except error.AutoservSshPingHostError: