def setup_remote_ssh_key(hostname1, user1, password1,
hostname2=None, user2=None, password2=None,
port=22, config_options=None, public_key="rsa"):
"""
Setup up remote to remote login in another server by using public key
If hostname2 is not supplied, setup to local.
:param hostname1: the server wants to login other host
:param hostname2: the server to be logged in
:type hostname: str
:param user: user to login
:type user: str
:param password: password
:type password: str
:param port: port number
:type port: int
:param config_options: list of options eg: ["StrictHostKeyChecking=no"]
:type config_options: list of str
"""
LOG.debug('Performing SSH key setup on %s:%d as %s.' %
(hostname1, port, user1))
try:
session1 = remote.remote_login(client='ssh', host=hostname1, port=port,
username=user1, password=password1,
prompt=r'[$#%]')
public_key = get_remote_public_key(session1, public_key=public_key)
if hostname2 is None:
# Simply create a session to local
session2 = aexpect.ShellSession("sh", linesep='\n', prompt='#')
# set config in local machine
if config_options:
for each_option in config_options:
session2.cmd_output("echo '%s' >> ~/.ssh/config" %
each_option)
else:
session2 = remote.remote_login(client='ssh', host=hostname2,
port=port, username=user2,
password=password2,
prompt=r'[$#%]')
# set config in remote machine
if config_options:
for each_option in config_options:
session1.cmd_output("echo '%s' >> ~/.ssh/config" %
each_option)
session2.cmd_output('mkdir -p ~/.ssh')
session2.cmd_output('chmod 700 ~/.ssh')
session2.cmd_output("echo '%s' >> ~/.ssh/authorized_keys; " %
public_key)
session2.cmd_output('chmod 600 ~/.ssh/authorized_keys')
LOG.debug('SSH key setup on %s complete.', session2)
except Exception as err:
LOG.debug('SSH key setup has failed: %s', err)
try:
session1.close()
session2.close()
except Exception:
pass
def start_ip_sniffing(self, params):
"""
Start ip sniffing.
:param params: Params object.
"""
self.data.setdefault("address_cache", ip_sniffing.AddrCache())
sniffers = ip_sniffing.Sniffers
if not self._sniffer:
remote_pp = params.get("remote_preprocess") == "yes"
remote_opts = None
session = None
if remote_pp:
client = params.get('remote_shell_client', 'ssh')
remote_opts = (params['remote_node_address'],
params.get('remote_shell_port',
'22'), params['remote_node_user'],
params['remote_node_password'],
params.get('remote_shell_prompt', '#'))
session = remote.remote_login(client, *remote_opts)
for s_cls in sniffers:
if s_cls.is_supported(session):
self._sniffer = s_cls(self.data["address_cache"],
"ip-sniffer.log", remote_opts)
break
if session:
session.close()
if not self._sniffer:
raise exceptions.TestError("Can't find any supported ip sniffer! "
"%s" % [s.command for s in sniffers])
self._sniffer.start()
def __init__(self, address, netperf_path, md5sum="", netperf_source="",
client="ssh", port="22", username="******", password="******",
prompt="^root@.*[\#\$]\s*$|", linesep="\n", status_test_command="echo $?",
compile_option="--enable-demo=yes", install=True):
"""
Init Netperf class.
:param address: Remote host or guest address
:param netperf_path: Remote netperf path
:param me5sum: Local netperf package me5sum
:param netperf_source: netperf source file (path or link) which will
transfer to remote
:param client: The client to use ('ssh', 'telnet' or 'nc')
:param port: Port to connect to
:param username: Username (if required)
:param password: Password (if required)
:param compile_option: Compile option for netperf
:param install: Whether need install netperf or not.
"""
self.client = client
self.package = NetperfPackage(address, netperf_path, md5sum,
netperf_source, client, port, username,
password, prompt, linesep, status_test_command)
self.netserver_path, self.netperf_path = self.package.install(install,
compile_option)
LOG.debug("Create remote session")
self.session = remote.remote_login(client, address, port, username,
password, prompt,
linesep, timeout=360,
status_test_command=status_test_command)
def setup_esx_ssh_key(hostname, username, password, port=22):
"""
Setup up remote login in esx server by using public key
:param hostname: hostname or IP address
:param username: username
:param password: password
:param port: ssh port number
"""
session = None
logging.debug('Performing SSH key setup on %s:%d as %s.' %
(hostname, port, username))
try:
session = remote.remote_login(
client='ssh',
host=hostname,
username=username,
port=port,
password=password,
prompt=r"[\#\$\[\]]",
verbose=True,
preferred_authenticaton='password,keyboard-interactive',
user_known_hosts_file='${HOME}/.ssh/known_hosts')
public_key = ssh_key.get_public_key()
session.cmd("echo '%s' >> /etc/ssh/keys-root/authorized_keys; " %
public_key)
logging.debug('SSH key setup complete.')
return public_key
except Exception as err:
raise exceptions.TestFail("SSH key setup failed: '%s'" % err)
finally:
if session:
session.close()
def __init__(self, address, netperf_path, md5sum="", netperf_source="",
client="ssh", port="22", username="******", password="******",
prompt="^root@.*[\#\$]\s*$|", linesep="\n", status_test_command="echo $?"):
"""
Class NetperfPackage just represent the netperf package
Init NetperfPackage class.
:param address: Remote host or guest address
:param netperf_path: Installed netperf path
:param me5sum: Local netperf package me5sum
:param netperf_source: source netperf (path or link) path
:param client: The client to use ('ssh', 'telnet' or 'nc')
:param port: Port to connect to
:param username: Username (if required)
:param password: Password (if required)
"""
super(NetperfPackage, self).__init__(address, client, username,
password, port, netperf_path)
self.netperf_source = netperf_source
self.pack_suffix = ""
self.netperf_dir = None
self.build_tool = False
self.md5sum = md5sum
self.netperf_base_dir = self.remote_path
self.netperf_file = os.path.basename(self.netperf_source)
if client == "ssh":
if self.netperf_source.endswith("tar.bz2"):
self.pack_suffix = ".tar.bz2"
self.decomp_cmd = "tar jxf"
elif self.netperf_source.endswith("tar.gz"):
self.pack_suffix = ".tar.gz"
self.decomp_cmd = "tar zxf"
self.netperf_dir = os.path.join(self.remote_path,
self.netperf_file.rstrip(self.pack_suffix))
if self.pack_suffix:
self.netserver_path = os.path.join(self.netperf_dir,
"src/netserver")
self.netperf_path = os.path.join(self.netperf_dir,
"src/netperf")
else:
self.netserver_path = os.path.join(self.netperf_base_dir,
self.netperf_file)
self.netperf_path = os.path.join(self.netperf_base_dir,
self.netperf_file)
LOG.debug("Create remote session")
self.session = remote.remote_login(self.client, self.address,
self.port, self.username,
self.password, prompt,
linesep, timeout=360,
status_test_command=status_test_command)
def get_log(server_info):
"""
Tail output appended data as the file /var/log/messages grows
:param server_info: dictionary with the server information
:returns: the appended data tailed from /var/log/messages
"""
tailed_log_file = os.path.join(data_dir.get_tmp_dir(), 'tail_log')
tail_session = remote.remote_login('ssh',
server_info['ip'],
'22',
server_info['user'],
server_info['pwd'],
r"[\#\$]\s*$",
log_function=utils_misc.log_line,
log_filename=tailed_log_file)
tail_session.sendline('tail -f /var/log/messages')
return tail_session
def setup_ssh_key(hostname, user, password, port=22, client_user=None):
"""
Setup up remote login in another server by using public key
:param hostname: the server to login
:type hostname: str
:param user: user to login
:type user: str
:param password: password
:type password: str
:param port: port number
:type port: int
:param client_user: genenrate the ssh_key for which client
user to login into the server
:type client_user: str
"""
logging.debug('Performing SSH key setup on %s:%d as %s.' %
(hostname, port, user))
try:
session = remote.remote_login(client='ssh',
host=hostname,
username=user,
port=port,
password=password,
prompt=r'[$#%]')
public_key = get_public_key(client_user)
session.cmd('mkdir -p ~/.ssh')
session.cmd('chmod 700 ~/.ssh')
session.cmd("echo '%s' >> ~/.ssh/authorized_keys; " % public_key)
session.cmd('chmod 600 ~/.ssh/authorized_keys')
logging.debug('SSH key setup complete.')
except Exception:
logging.debug('SSH key setup has failed.')
finally:
try:
session.close()
except Exception:
pass
def cleanup_authorized_keys_in_vmx(self):
"""
Clean up authorized_keys in vmx server
"""
session = None
if len(self.authorized_keys) == 0:
return
try:
session = remote.remote_login(
client='ssh',
host=self.esxi_host,
port=22,
username=self.username,
password=self.esxi_password,
prompt=r"[\#\$\[\]]",
preferred_authenticaton='password,keyboard-interactive')
for key in self.authorized_keys:
session.cmd(
"sed -i '/%s/d' /etc/ssh/keys-root/authorized_keys" %
key)
finally:
if session:
session.close()
def __init__(self,
params,
address,
source,
shell_client=None,
shell_port=None,
file_transfer_client=None,
file_transfer_port=None,
username=None,
password=None,
make_flags="",
build_dir=None,
build_dir_prefix=None,
shell_linesep=None,
shell_prompt=None):
"""
:param params: Dictionary with test parameters, used to get the default
values of all named parameters.
:param address: Remote host or guest address
:param source: Directory containing the source on the machine
where this script is running
:param shell_client: The client to use ('ssh', 'telnet' or 'nc')
:param shell_port: Port to connect to for the shell client
:param file_transfer_client: The file transfer client to use ('scp' or
'rss')
:param file_transfer_port: Port to connect to for the file transfer
client
:param username: Username (if required)
:param password: Password (if required)
:param make_flags: Flags to pass to the make process, default: ""
:param build_dir: Where to copy and build the files on target. If None,
use params['tmp_dir']
:param build_dir_prefix: What to name the build directory on target
If None, use the name of the source directory.
:param shell_linesep: Line separator in the shell
:param shell_prompt: Regexp that matches the prompt in the shell.
"""
def full_build_path(build_dir, directory_prefix, make_flags):
"""
Generates the full path for the build using the make flags and
supplied build location.
:return: The full path as a string
"""
extra_flags_hash = hashlib.sha1()
extra_flags_hash.update(make_flags)
directory_name = "%s-%s" % (directory_prefix,
(extra_flags_hash.hexdigest())[:8])
return os.path.join(build_dir, directory_name)
def def_helper(arg, param, default):
if arg is None:
return params.get(param, default)
else:
return arg
self.address = address
self.source = os.path.normpath(source)
self.client = def_helper(shell_client, "shell_client", "ssh")
self.port = def_helper(shell_port, "shell_port", "22")
self.file_transfer_client = def_helper(file_transfer_client,
"file_transfer_client", "scp")
self.file_transfer_port = def_helper(file_transfer_port,
"file_transfer_port", "22")
self.username = def_helper(username, "username", "root")
self.password = def_helper(password, "password", "redhat")
self.make_flags = make_flags
self.build_dir = def_helper(build_dir, "tmp_dir",
data_dir.get_tmp_dir())
if build_dir_prefix is None:
build_dir_prefix = os.path.basename(source)
self.full_build_path = full_build_path(self.build_dir,
build_dir_prefix, make_flags)
self.linesep = def_helper(shell_linesep, "shell_linesep", "\n")
self.prompt = def_helper(shell_prompt, "shell_prompt",
"^\[.*\][\#\$]\s*)$")
self.session = remote.remote_login(self.client,
self.address,
self.port,
self.username,
self.password,
self.prompt,
self.linesep,
timeout=360)
