def sshOpen(self, timeout=5): "Opens a SSH connection to the mgmt LXC." if self._ssh_interact is not None: return self._ssh_interact self.log(WARN, 'Acquiring LXC SSH session') self._ssh_client = paramiko.SSHClient() paramiko.hostkeys.HostKeys(filename=os.devnull) # client.load_system_host_keys() self._ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # the below might update self._lxc_host if the env var is set during # the execution of getLXCPort(). port = self.getLXCPort() try: self._ssh_client.connect(hostname=self._lxc_host, username=self._username, pkey=None, look_for_keys=False, allow_agent=False, password=self._password, port=port) except (paramiko.AuthenticationException, paramiko.SSHException) as e: self.log(CRITICAL, 'SSH connect failed: %s' % e) return None self._ssh_interact = SSHClientInteraction(self._ssh_client, timeout=timeout, display=self.isLogDebug()) return self._ssh_interact
def __init__(self, appliance): SSHClientInteraction.__init__( self, appliance.ssh_client, timeout=10, display=True, output_callback=logging_callback(appliance))
def remote_tail(self, host, port, user, passwd, logfile, webuser, filter_text=None): # 创建一个可跨文件的全局变量,控制停止 try: self.client = paramiko.SSHClient() self.client.load_system_host_keys() self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) self.client.connect(hostname=host, port=port, username=user, password=passwd) interact = SSHClientInteraction(self.client, timeout=10, display=False) interact.expect('.*#.*') logfile = logfile.strip().replace('&&', '').replace('||', '').replace('|', '') self.send_message(webuser, '[INFO][%s@%s]开始监控日志' % (user, host)) redis = RedisObj() redis.set('remote_tail_' + str(webuser), self.client) if filter_text: filter_text_re = filter_text.strip().replace('&&', '').replace('||', '').replace('|', '') interact.send('tail -f %s|grep --color=never %s' % (logfile, filter_text_re)) else: interact.send('tail -f %s' % (logfile)) interact.tail(output_callback=lambda m: self.send_message(webuser, m), stop_callback=lambda x: self.get_is_stop(webuser)) except Exception as e: self.send_message(webuser, e) finally: redis = RedisObj() redis.set('remote_tail_' + str(webuser), '1') try: self.client.close() except Exception as e: self.send_message(webuser, e)
def ConnectToSsh(UserID, Password): global objInteract global objSsh # Instantiate the SSH Object objSsh = paramiko.SSHClient() objSsh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # Begin SSH Connection try: objSsh.connect(strPhoneIP, username=UserID, password=Password) strFail = "SSH Object Connected Successfully" except: objSsh.close() strFail = "CTG Phone Control\n\nFailed SSH Connection\n" ErrorWindow(strFail) # Nowthat the SSH session is started, send the secondary login to the Phone # to enter debug mode. # Use Expect because the UC CLI takes to long to start and commands # vary in duration of run time. Expect ensures we enter the # command at the appropriate time. objInteract = SSHClientInteraction(objSsh, timeout=120, display=False) objInteract.expect('.*log.*', default_match_prefix='') objInteract.send('debug') objInteract.expect('.*Password.*') objInteract.send('debug')
def start_session(self): self.client.connect(hostname=self._hostname, username=self._username, password=self._password) interact = SSHClientInteraction(self.client, timeout=10, display=True) interact.expect(PROMPT) self._session = interact
def expect(self, re_string, *args, **kwargs): try: SSHClientInteraction.expect(self, re_string, *args, **kwargs) except socket.timeout: current_output = '""' if not self.current_output else self.current_output raise SSHExpectTimeoutError( f"Timeouted when waiting for '{re_string}'. Current output:\n" + textwrap.indent(current_output, '> '))
def test_channel(): client = ParamikoClient('config.ini', 'PPM101') client.connect() interact = SSHClientInteraction(client.client, timeout=10, display=False) interact.expect(re_strings='.*#.*') interact.send('echo ""') interact.send( 'tail -f /opt/ppm/ppm/QX_DEV_OPS_962/server/kintana/log/serverLog.txt') interact.tail(output_callback=lambda m: output_callback(m, interact), stop_callback=lambda x: get_is_stop(x), timeout=100)
def run_conn_log(): user = load_user_info() host = user.host name = user.name password = user.password prompt = '.+' try: client = paramiko.SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect(hostname=host, username=name, password=password) interact = SSHClientInteraction(client, timeout=10, display=False) interact.expect(prompt) interact.send(user.cmd) interact.tail(line_prefix=host + ': ', timeout=65535) except KeyboardInterrupt: print('Ctrl+C interruption detected, stopping tail') except Exception: traceback.print_exc() finally: try: client.close() except: pass
def commands(): """ssh write commands""" interact = SSHClientInteraction(ssh, timeout=10, display=True) interact.send('lock database override') interact.expect('\n.*> ') interact.send('fw tab -t connections -s') print('sended IF, expecting >') interact.expect('\n.*> ') print('ok!') cmd_output_uname = interact.current_output_clean print(cmd_output_uname)
def GetInteractiveSSh(self): """ Get an interactive object for running commands. """ try: self.interact = SSHClientInteraction(self.sshClient, timeout=10, encoding='utf-8', display=True, buffer_size=100000) except Exception as error: self.logger.error( "Couldnt get a SSHClientInteraction session to server") raise error
def upgrade3228Fpga(self): try: client = paramiko.SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy) client.connect(self.ip, username=self.username, password=self.password) with SSHClientInteraction(client, timeout=10, display=True) as exp: exp.expect([".*#\s+", ".*\$\s+"]) exp.send("wget -c -O /tmp/bcm3228.bin ftp://%s/%s"%( self.ftpdip, self.fpga_file )) # exp.send("tftp -g -l /tmp/bcm3228.bin -r %s %s"%( self.fpga_file , self.ftpdip )) exp.expect([".*#\s+", ".*\$\s+"]) exp.send("proxy_stdio_client docsiscore\n") exp.send("cd /\n") exp.expect("CMTS>\s+") exp.send("/hal/download_3228_fpga /tmp/bcm3228.bin\n") exp.expect(".*Success.*",timeout=180) return True except socket.timeout: self.logger.error("upgrade 3228 fpga error") return False finally: try: client.close() except: pass
def dump(host, commands, date, save_dir): # 1: Cisco enable mode, 2: Linux prompt, you may need to add prompt expression PROMPT = ['.*>\s*', '.*#\s*', '.*$\s*'] print('Taking {} backup configuration file'.format(host[0])) hostname, ipaddress, username, password = host[0], host[1], host[2], host[3] try: client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect(hostname=ipaddress, username=username, password=password, timeout=10, look_for_keys=False) with SSHClientInteraction(client, timeout=10, display=True) as interact: interact.send('') index = interact.expect(PROMPT) interact.expect('.*#\s') for command in commands: interact.send('') interact.expect('.*#\s') interact.send('n') interact.expect('.*#\s') output = interact.current_output_clean filename = hostname + '_' + date + '.txt' path = os.path.join(save_dir, filename) with open(path, 'a') as config_file: config_file.write(str(output) + '\n') interact.send('exit') index = interact.expect(PROMPT) except Exception as e: print('Exception throws: {}'.format(e.args))
def test_05_context(): client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect(hostname="localhost", username="******", port=2222, key_filename='./test/id_rsa') with SSHClientInteraction(client, timeout=10, display=True) as interact: interact.send('ls -all /') interact.expect(prompt, timeout=120)
def interact_with_ssh_connection(client, prompt_line = '.*@.*:.*', TIMEOUT=60*30): with SSHClientInteraction(client, timeout=TIMEOUT, display=True) as interact: need_to_exit=False interact.expect(prompt_line) while not need_to_exit: data = input(">") if "exit" in data: need_to_exit = True interact.send(data) interact.expect(prompt_line)
def ChangeUsername(ip, username, password, command, Username): sshsession = paramiko.SSHClient() sshsession.set_missing_host_key_policy(paramiko.AutoAddPolicy()) sshsession.connect(ip, username=username, password=password) # "display=True" is just to show you what script does in real time. While in production you can set it to False interact = SSHClientInteraction(sshsession, timeout=600, display=True) # program will wait till session is established and CUCM returns admin prompt interact.expect('admin:') output = interact.current_output_clean # program saves output of show status command to the "output" variable interact.send(command) interact.last_match == '.*administrator.*' interact.send(Username) interact.expect('admin:') output = interact.current_output_clean # program saves output of show status command to the "output" variable with open("Logs/ChangeAdminName.txt", 'a') as outfile: outfile.write( f"{output} {username} -- Administrator Name Changed to {Username} {datetime.now()}" ) outfile.close() sshsession.close()
def install_k8s_plugin(pn_ssh_conn, plugin): try: panorama_op_prompt = '.*> ' with SSHClientInteraction(pn_ssh_conn, timeout=10, display=False) as interact: interact.send("request plugins install {}".format(plugin)) interact.expect(panorama_op_prompt) interact.send('exit') info("Plugin {} installation triggered".format(plugin)) except: error("I couldn't install the kubernetes plugin. Try to install it manually.") sys.exit()
def download_plugin(pn_ssh_conn, plugin): try: panorama_op_prompt = '.*> ' with SSHClientInteraction(pn_ssh_conn, timeout=10, display=False) as interact: interact.send("request plugins download file {}".format(plugin)) interact.expect(panorama_op_prompt) interact.send('exit') info("Plugin {} downloading.".format(plugin)) except: error("I couldn't download the kubernetes plugin. Try to download it manually.") sys.exit()
def cucm_connect(ip, username, password): # # Create and return the connection to a CUCM node # ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect(ip, username=username, password=password) # # Set display=False for production # connection = SSHClientInteraction(ssh, timeout=60, display=True) return connection
def main(): # Set login credentials and the server prompt HOSTNAME = '192.168.1.177' USERNAME = '******' PASSWORD = '******' PROMPT = '~#' # Use SSH client to login try: # Create a new SSH client object client = paramiko.SSHClient() # Set SSH key parameters to auto accept unknown hosts client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # Connect to the host client.connect(hostname=HOSTNAME, username=USERNAME, password=PASSWORD) # Create a client interaction class which will interact with the host with SSHClientInteraction(client, timeout=10, display=True) as interact: interact.expect(PROMPT) # Run the first command and capture the cleaned output, if you want # the output without cleaning, simply grab current_output instead. interact.send('uname -a') interact.expect(PROMPT) cmd_output_uname = interact.current_output_clean interact.send("amixer -c1 sget OutputMode") interact.expect("Item0:") interact.send("amixer -c1 sset OutputMode EQ") interact.expect("EQ:") # Send the exit command and expect EOF (a closed session) interact.send('exit') interact.expect() # Print the output of each command print('-' * 79) print('Cleaned Command Output') print('-' * 79) print('uname -a output:') print(cmd_output_uname) except Exception: traceback.print_exc() finally: try: client.close() except Exception: pass
def configure_collector_group(pn_ssh_conn, cg): try: panorama_config_prompt = '.*# ' with SSHClientInteraction(pn_ssh_conn, timeout=10, display=False) as interact: interact.send('configure') interact.expect(panorama_config_prompt) interact.send('set log-collector-group {}'.format(cg)) interact.expect(panorama_config_prompt) interact.send('exit') except: error("I can not create a device group") sys.exit()
def session(): try: sshconnect = paramiko.SSHClient() sshconnect.set_missing_host_key_policy(paramiko.AutoAddPolicy()) for ipaddr in hostname: filename = 'MSHealthCheck_' + ipaddr.replace('.', '_') + '_' + timestr outputfile = '{}.txt'.format(filename) sshconnect.connect(hostname=ipaddr, username=username, password=password) interact = SSHClientInteraction(sshconnect, timeout=60, display=True) for command in commands: interact.expect('admin:') interact.send(command) devoutput = interact.current_output_clean with open(os.path.join(path, outputfile), 'a') as filewrite: filewrite.write('#' * 5 + command + '#' * 5) filewrite.write(devoutput) sshconnect.close() except paramiko.ssh_exception.AuthenticationException as a: print(a) except paramiko.ssh_exception.SSHException as c: print(c) except Exception as e: print(e)
def change_pwd(self, verbose): try: # Create a new SSH client object client = paramiko.SSHClient() # Set SSH key parameters to auto accept unknown hosts client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # Connect to the host proxy = None if self.proxy is not None: proxy = paramiko.ProxyCommand(self.proxy) client.connect(hostname=self.hostname, timeout=20, sock=proxy, username=self.username, password=self.oldpwd) with SSHClientInteraction( client, timeout=10, display=False, output_callback=lambda m: self.log_msg(m)) \ as interact: found_index = interact.expect( [Host.CONST_PROMPT, Host.CONST_OLDPWPROMPT]) if found_index == 0: interact.send("passwd") interact.expect(Host.CONST_OLDPWPROMPT) interact.send(self.oldpwd) interact.expect(Host.CONST_NEWPWPROMPT) interact.send(self.newpwd) interact.expect(Host.CONST_NEWPWPROMPT2) interact.send(self.newpwd) if found_index == 0: interact.expect(Host.CONST_SUCCESSMSG) interact.send('exit') interact.expect() self.changed = True client.close() except Exception: self.log_msg(traceback.format_exc()) finally: try: client.close() except Exception: pass status = HostStatus(self.hostname, self.changed) Host.updated.append(status) if verbose: status.print_status() if not self.changed: print(self.log)
def config(self, config_cmds, verbose=True): try: config_cmds.insert(0, 'system-view') with SSHClientInteraction(self.client, timeout=20, display=verbose) as interact: interact.expect('<[\S\s]+>') for cmd in config_cmds: interact.send(cmd) interact.expect('\[[\S\s]+\]') except Exception as e: print(e) finally: self.client.close()
def get_device_prompt(self, host, username, password): ssh_client = self.get_ssh_client(host, username, password) interact = SSHClientInteraction(ssh_client, timeout=10, display=True) interact.send("\n") interact.expect(".*") prompt = (str(interact.current_output)).strip() prompt_char = re.sub('[a-zA-Z0-9]*', '', prompt) return prompt_char
def ShowCommands(ip, username, password, command): sshsession = paramiko.SSHClient() sshsession.set_missing_host_key_policy(paramiko.AutoAddPolicy()) sshsession.connect(ip, username=username, password=password) # "display=True" is just to show you what script does in real time. While in production you can set it to False interact = SSHClientInteraction(sshsession, timeout=600, display=True) # program will wait till session is established and CUCM returns admin prompt interact.expect('admin:') interact.send(command) interact.expect('admin:') output = interact.current_output # program saves output of show status command to the "output" variable with open("Logs/ShowCommand.txt", 'a') as outfile: outfile.write(output) outfile.close() sshsession.close()
def stalkLog(self, log, dir, timeToStop): cmd = "cd " + dir + ";tail -f " + log interact = SSHClientInteraction(self.ssh, timeout=10, display=False) interact.send(cmd) #def tail(self, line_prefix=None, callback=None, # output_callback=None, stop_callback=lambda x: False, # timeout=None): interact.tail(None, self.process_tail, None, self.timer)
def configure_template(pn_ssh_conn, template): try: panorama_config_prompt = '.*# ' with SSHClientInteraction(pn_ssh_conn, timeout=10, display=False) as interact: interact.send('configure') interact.expect(panorama_config_prompt) interact.send('set template {} config vsys vsys1'.format(template)) interact.expect(panorama_config_prompt) interact.send('set template {} settings default-vsys vsys1'.format(template)) interact.expect(panorama_config_prompt) interact.send('exit') info("Template {} Created".format(template)) except: error("I can not create a template") sys.exit()
def configure_template_stack(pn_ssh_conn, template_stack): try: panorama_config_prompt = '.*# ' with SSHClientInteraction(pn_ssh_conn, timeout=10, display=False) as interact: interact.send('configure') interact.expect(panorama_config_prompt) interact.send('set template-stack {} settings'.format(template_stack)) interact.expect(panorama_config_prompt) interact.send('set template-stack {} templates {}'.format(template_stack,template_stack + '-tmp')) interact.expect(panorama_config_prompt) interact.send('exit') info("Template Stack {} Created".format(template_stack)) except: error("I can not create a template stack") sys.exit()
def test_08_issue_25_skip_newline(): client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect(hostname="localhost", username="******", port=2222, key_filename='./test/id_rsa') with SSHClientInteraction(client, timeout=10, display=True) as interact: interact.send('ls -all') interact.expect(prompt, timeout=5) # Do not actually sleep, send a ctrl-c at the end interact.send('sleep 1', newline=chr(3)) interact.expect(prompt, timeout=5) interact.send('sleep 1' + chr(3), newline='') interact.expect(prompt, timeout=5) interact.send('ls -all') interact.expect(prompt, timeout=5)
def create_auth_key(pn_ssh_conn): try: duration = 48 panorama_op_prompt = '.*> ' with SSHClientInteraction(pn_ssh_conn, timeout=10, display=False) as interact: interact.send("request bootstrap vm-auth-key generate lifetime {}".format(duration)) interact.expect(panorama_op_prompt) interact.send('exit') auth_key_output = interact.current_output_clean for l in auth_key_output.split('\n'): if 'generated' in l: auth_key = re.findall(r"\d{15,}", l)[0] return auth_key.strip() except: error("I couldn't create bootstrapping auth key") sys.exit()
def activate_license(pn_ssh_conn, auth_code, tokens=1): # Add CN-Series auth code try: info("Applying CN-Series Authcode {} and activating {} token(s)".format(auth_code, tokens)) panorama_op_prompt = '.*> ' with SSHClientInteraction(pn_ssh_conn, timeout=10, display=False) as interact: interact.send("request plugins kubernetes set-license-tokens authcode {} token-count {}".format(auth_code, tokens)) interact.expect(panorama_op_prompt) authcode_output = interact.current_output_clean if 'Error' in authcode_output: error(authcode_output.split('\n')[-3]) error("Auth code can not be added. CN-Series can run for 4 hours. without license.") else: info("CN-Series license auth code {} added and {} tokens activated".format(auth_code,tokens)) except: error("Auth code can not be added. CN-Series can run for 4 hours. without license.")
def main(): # Set login credentials and the server prompt hostname = "localhost" username = "******" password = "******" prompt = "fots@fotsies-ubuntu-testlab:~\$ " # Use SSH client to login try: # Create a new SSH client object client = paramiko.SSHClient() # Set SSH key parameters to auto accept unknown hosts client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # Connect to the host client.connect(hostname=hostname, username=username, password=password) # Create a client interaction class which will interact with the host interact = SSHClientInteraction(client, timeout=10, display=False) interact.expect(prompt) # Send the tail command interact.send("tail -f /var/log/auth.log") # Now let the class tail the file for us interact.tail(line_prefix=hostname + ": ") except KeyboardInterrupt: print "Ctrl+C interruption detected, stopping tail" except Exception: traceback.print_exc() finally: try: client.close() except: pass
def main(): # Set login credentials and the server prompt hostname = 'localhost' username = '******' password = '******' prompt = r'vagrant@paramiko-expect-dev:~\$\s+' # Use SSH client to login try: # Create a new SSH client object client = paramiko.SSHClient() # Set SSH key parameters to auto accept unknown hosts client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # Connect to the host client.connect(hostname=hostname, username=username, password=password) # Create a client interaction class which will interact with the host interact = SSHClientInteraction(client, timeout=10, display=False) interact.expect(prompt) # Send the tail command interact.send('tail -f /var/log/syslog') # Now let the class tail the file for us interact.tail(line_prefix=hostname+': ') except KeyboardInterrupt: print('Ctrl+C interruption detected, stopping tail') except Exception: traceback.print_exc() finally: try: client.close() except Exception: pass
def main(): # Set login credentials and the server prompt hostname = '10.10.0.254' username = '******' password = '******' prompt = 'test-checkpoint-for-scripts> ' # Use SSH client to login try: # Create a new SSH client object client = paramiko.SSHClient() # Set SSH key parameters to auto accept unknown hosts client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # Connect to the host client.connect(hostname=hostname, username=username, password=password) # Create a client interaction class which will interact with the host interact = SSHClientInteraction(client, timeout=10, display=True) interact.expect(prompt) # Run the first command and capture the cleaned output, if you want # the output without cleaning, simply grab current_output instead. interact.send('netstat -rnv') interact.expect(prompt) cmd_output_uname = interact.current_output_clean # Now let's do the same for the ls command but also set a timeout for # this specific expect (overriding the default timeout) interact.send('show interface Lan2') interact.expect(prompt, timeout=5) cmd_output_ls = interact.current_output_clean # To expect multiple expressions, just use a list. You can also # selectively take action based on what was matched. # Method 1: You may use the last_match property to find out what was # matched #interact.send('~/paramiko_expect-demo-helper.py') #interact.expect([prompt, 'Please enter your name: ']) #if interact.last_match == 'Please enter your name: ': # interact.send('Fotis Gimian') # interact.expect(prompt) # Method 2: You may use the matched index to determine the last match # (like pexpect) #interact.send('~/paramiko_expect-demo-helper.py') #found_index = interact.expect([prompt, 'Please enter your name: ']) #if found_index == 1: # interact.send('Fotis Gimian') # interact.expect(prompt) # Send the exit command and expect EOF (a closed session) interact.send('exit') interact.expect() # Print the output of each command #print '-'*79 print('Cleaned Command Output') #print '-'*79 print('uname -a output:') print(cmd_output_uname) print('ls -l / output:') print(cmd_output_ls) except Exception: traceback.print_exc() finally: try: client.close() except: pass
def commands(): """ssh write commands""" try: ssh.connect(hostname=host, username=user, password=passwd) except TimeoutError: print('surprise m**********r, host is down') interact = SSHClientInteraction(ssh, timeout=10, display=True)\ print('connected') interact.send(item) found_index = interact.expect([not_found, prompt]) if found_index == 0: print('command not found, trying expert mode') interact.send('expert') entering_expert_index = interact.expect([no_expert_pass, enter_expert_pass]) if entering_expert_index == 0: print('no expert password, need to set it') no_expert_output = interact.current_output_clean # something here to write to file elif entering_expert_index == 1: print('cp asked for expert password, entering it') interact.send(expert_passwd) expert_mode_index([wrong_expert_pass, expert_prompt]) if expert_mode_index == 0: print('wrong expert pass') #something here to write to file elif expert_mode_index == 1: print('password ok, continuing') interact.send(i) interact.expect(expert_prompt) interact.send('exit') interact.expect(prompt)
interact.send('lock database override') interact.expect('\n.*> ') interact.send('fw tab -t connections -s') print('sended IF, expecting >') interact.expect('\n.*> ') print('ok!') cmd_output_uname = interact.current_output_clean print(cmd_output_uname) # time.sleep(25) # output = stdout.readlines() # print('current output', output) # # return output ssh.connect(hostname=host, username=user, password=passwd) prompt = 'trevor@test-deb-morgan:~$' interact = SSHClientInteraction(ssh, timeout=10, display=True) #interact.expect('>') interact.send('show interface External') #interact.send('>') print('sended IF, expecting >') interact.expect('\n.*> ') interact.send('fw tab -t connections -s') interact.expect('.*> ') cmd_output_uname = interact.current_output print(cmd_output_uname) print('ok!') #print(cmd_output_uname) #ssh_connection() #commands()
def main(i): # Use SSH client to login try: # Create a new SSH client object ssh = paramiko.SSHClient() # Set SSH key parameters to auto accept unknown hosts ssh.load_system_host_keys() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) file = open('c:/python/checkpoint/{0}.txt'.format(host),"a") # Connect to the host ssh.connect(hostname=host, username=user, password=passwd) # Create a client interaction class which will interact with the host interact = SSHClientInteraction(ssh, timeout=5, display=True) interact.expect(prompt) # Run the first command and capture the cleaned output, if you want # the output without cleaning, simply grab current_output instead. interact.send('netstat -rnv') interact.expect(prompt) route_list = 'netstat -rnv \n' + interact.current_output_clean # Now let's do the same for the ls command but also set a timeout for # this specific expect (overriding the default timeout) #interact.send('ls -l /') #interact.expect(prompt, timeout=5) #cmd_output_ls = interact.current_output_clean interact.send('expert') entering_expert_index = interact.expect([no_expert_pass, enter_expert_pass]) if entering_expert_index == 0: print('no expert password, need to set it') no_expert_password = interact.current_output_clean set_expert_pass = no_expert_password file.write(set_expert_pass) file.close() ws.write(i, 1, 'No Expert Password. Need to set up.') i += 1 elif entering_expert_index == 1: print('cp asked for expert password, entering it') interact.send(expert_passwd) expert_mode_index = interact.expect([wrong_expert_pass, expert_prompt]) if expert_mode_index == 0: print('wrong expert pass') wrong_expert_pass_output = interact.current_output_clean file.write(wrong_expert_pass_output) file.close() ws.write(i, 1, 'Wrong Expert Password') i += 1 elif expert_mode_index == 1: print('password ok, continuing') interact.send('cat /etc/sysconfig/netconf.C') interact.expect(expert_prompt) netconf = 'cat /etc/sysconfig/netconf.C \n' + interact.current_output_clean interact.send('cat /etc/hosts.allow') interact.expect(expert_prompt) hosts = 'cat /etc/hosts.allow \n' + interact.current_output_clean interact.send('cat /etc/hosts') interact.expect(expert_prompt) hosts1 = 'cat /etc/hosts \n' + interact.current_output_clean interact.send('cat /etc/passwd') interact.expect(expert_prompt) passwords = 'cat /etc/passwd \n' + interact.current_output_clean\ interact.send('cat /etc/resolv.conf') interact.expect(expert_prompt) resolv = 'cat /etc/resolv.conf \n' + interact.current_output_clean interact.send('cat /etc/sysconfig/ntp') interact.expect(expert_prompt) ntp = 'cat /etc/sysconfig/ntp \n' + interact.current_output_clean output = sk1+route_list+sk1+netconf+sk1+hosts+sk1+hosts1+sk1+passwords+sk1+resolv+sk1+ntp file.write(output) file.close() ws.write(i, 1, 'OK') i += 1 except TimeoutError: file = open('c:/python/checkpoint/{0}.txt'.format(host),"a") file.write('Connection Failed') file.close ws.write(i, 1, 'Connection Failed') i += 1 except Exception: traceback.print_exc() errorstatus = 'connection failed' file = open('c:/python/checkpoint/{0}.txt'.format(host),"a") file.write('Connection Failed(exception)') file.close() ws.write(i, 1, 'UnknownError') i += 1 finally: try: ssh.close() except: pass return i
def main(): # Use SSH client to login try: # Create a new SSH client object ssh = paramiko.SSHClient() # Set SSH key parameters to auto accept unknown hosts ssh.load_system_host_keys() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # Connect to the host ssh.connect(hostname=host, username=user, password=passwd) # Create a client interaction class which will interact with the host interact = SSHClientInteraction(ssh, timeout=5, display=True) interact.expect(prompt) # Run the first command and capture the cleaned output, if you want # the output without cleaning, simply grab current_output instead. interact.send('netstat -rnv') interact.expect(prompt) route_list = interact.current_output_clean expert_mode() exp_cmd_output = interact.current_output_clean # To expect multiple expressions, just use a list. You can also # selectively take action based on what was matched. # Method 1: You may use the last_match property to find out what was # matched #interact.send('~/paramiko_expect-demo-helper.py') #interact.expect([prompt, 'Please enter your name: ']) #if interact.last_match == 'Please enter your name: ': # interact.send('Fotis Gimian') # interact.expect(prompt) # Method 2: You may use the matched index to determine the last match # (like pexpect) #interact.send('~/paramiko_expect-demo-helper.py') #found_index = interact.expect([prompt, 'Please enter your name: ']) #if found_index == 1: # interact.send('Fotis Gimian') # interact.expect(prompt) # Send the exit command and expect EOF (a closed session) #interact.send('exit') #interact.expect() ## Print the output of each command #print '-'*79 #print 'Cleaned Command Output' #print '-'*79 #print 'uname -a output:' #print cmd_output_uname #print 'ls -l / output:' #print cmd_output_ls except Exception: traceback.print_exc() finally: try: client.close() except: pass