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)