def Hardware_Monitoring(): if DeviceType == 'f5_ltm' or DeviceType == 'f5': redispatch(net_connect, device_type='f5_ltm') output1 = net_connect.read_channel() if '(tmos)' in output1: clock = net_connect.send_command("show sys clock ", delay_factor=5, max_loops=100) Fan_Status = net_connect.send_command("show /sys hardware | grep 'Chassis Fan Status' -A 5", delay_factor=5, max_loops=10) Power_Status = net_connect.send_command("show /sys hardware | grep 'Chassis Power' -A 4", delay_factor=5, max_loops=10) new_output = str(Fan_Status) + '\n\n' + str(Power_Status) else: net_connect.send_command("tmsh", delay_factor=5, max_loops=10) clock = net_connect.send_command("show sys clock ", delay_factor=5, max_loops=100) Fan_Status = net_connect.send_command("show /sys hardware | grep 'Chassis Fan Status' -A 5", delay_factor=5, max_loops=10) Power_Status = net_connect.send_command("show /sys hardware | grep 'Chassis Power' -A 4", delay_factor=5, max_loops=10) new_output = str(Fan_Status) + '\n\n' + str(Power_Status) if 'down' in new_output or 'Down' in new_output or 'error' in new_output or 'Error' in new_output or 'bad' in new_output or 'Bad' in str( new_output) or 'FAULTY' in str(new_output) or 'Fail' in str(new_output) or 'fail' in str( new_output) or 'Invalid' in str(new_output) or 'invalid' in str(new_output): print('Issue in Device end') Status = 'Issue in Device end, Manual action required' decision = 2 else: Status = 'No issue found' decision = 1 Details = new_output.encode('ascii', 'ignore') # response_content = 'Utilization Summary: ' + Status + '\n Utilization Details: +' + Details + '%' response_content = 'Device Clock: ' + str(clock) + '\n Hardware Status: ' + str( Status) + '\n Hardware Summary:' + str(new_output) return response_content
def main(): dev = { 'device_type': 'vyos', 'ip': '172.17.143.1', 'username': '******', 'password': '******', 'port': 22 } saos = {"ip": "172.17.143.3", "user": "******", "passwd": "pass"} # logger for dbg # logging.basicConfig(filename="test.log", level=logging.DEBUG) # logger = logging.getLogger("netmiko") # connect to vrouter net_connect = ConnectHandler(**dev) print(net_connect.find_prompt()) # jump to saos from vrouter ... MGMT vrf is device specific config cmd = f"ssh {saos['user']}@{saos['ip']} routing-instance MGMT" try: output = net_connect.send_command_expect(cmd, expect_string="Password") print(output) except: try: net_connect.send_command_expect(cmd, expect_string="(yes/no)?") output = net_connect.send_command_expect('yes', expect_string="Password") print(output) except: print("Error connecting to SAOS") net_connect.disconnect() return output = net_connect.send_command_timing(saos['passwd']) print(output) print("Doing redispatch to dev type ciena_saos") try: redispatch(net_connect, device_type='ciena_saos') except: print( "ERROR redispatching, SAOS prompt not found ... verify login credentials" ) net_connect.disconnect() return net_connect.set_base_prompt(pri_prompt_terminator=">", alt_prompt_terminator="*>") cmd = "port show status" print("sending command") # import ipdb; ipdb.set_trace() # dbg res = net_connect.send_command(cmd, auto_find_prompt=False) print(res) net_connect.disconnect() return
def Interface_down(Interface): if DeviceType == 'f5_ltm' or DeviceType == 'f5': redispatch(net_connect, device_type='f5_ltm') output1 = net_connect.read_channel() if '(tmos)' in output1: new_output = net_connect.send_command("show net interface " + Interface + ' ', delay_factor=5, max_loops=10) decision = 1 else: net_connect.send_command("tmsh", delay_factor=5, max_loops=10) new_output = net_connect.send_command("show net interface " + Interface + ' ', delay_factor=5, max_loops=10) decision = 2 # Details = new_output.encode('ascii','ignore') if 'up' in new_output: # print('Processor_percentage is high which is ' + str(Processor_percentage) + ' ') Load_percentage_Status = 'Interface status Up -- Details are ' + new_output decision = 1 elif 'down' in new_output: Load_percentage_Status = 'Interface status Down -- Detaills are ' + new_output decision = 2 else: Load_percentage_Status = 'Interface status unknown -- Please check the device' decision = 2 Details = new_output.encode('ascii', 'ignore') response_content = Load_percentage_Status return response_content, decision
def proxied(self): """ Connects to the proxy server via netmiko library, then logs into the router via \ standard SSH """ proxy_name = self.device["proxy"] device_proxy = configuration.proxy(proxy_name) nm_proxy = { "host": device_proxy["address"], "username": device_proxy["username"], "password": device_proxy["password"], "device_type": device_proxy["type"], "global_delay_factor": 0.5, } nm_connect_proxied = ConnectHandler(**nm_proxy) nm_ssh_command = device_proxy["ssh_command"].format( **self.nm_host) + "\n" # Debug logger.debug(f"Netmiko proxy {proxy_name}:\n{nm_proxy}") logger.debug(f"Proxy SSH command: {nm_ssh_command}") # End Debug nm_connect_proxied.write_channel(nm_ssh_command) time.sleep(1) proxy_output = nm_connect_proxied.read_channel() logger.debug(f"Proxy output:\n{proxy_output}") try: # Accept SSH key warnings if "Are you sure you want to continue connecting" in proxy_output: logger.debug(f"Received OpenSSH key warning") nm_connect_proxied.write_channel("yes" + "\n") nm_connect_proxied.write_channel(self.nm_host["password"] + "\n") # Send password on prompt elif "assword" in proxy_output: logger.debug(f"Received password prompt") nm_connect_proxied.write_channel(self.nm_host["password"] + "\n") proxy_output += nm_connect_proxied.read_channel() # Reclassify netmiko connection as configured device type logger.debug( f'Redispatching netmiko with device class {self.nm_host["device_type"]}' ) redispatch(nm_connect_proxied, self.nm_host["device_type"]) response = nm_connect_proxied.send_command(self.command) status = codes["success"] logger.debug(f"Netmiko proxied response:\n{response}") except ( NetMikoAuthenticationException, NetMikoTimeoutException, NetmikoAuthError, NetmikoTimeoutError, ) as netmiko_exception: response = config["messages"]["general"] status = codes["danger"] logger.error( f'{netmiko_exception}, {status},Proxy: {self.nm_host["proxy"]}' ) nm_connect_proxied.disconnect() return response, status
def close_cross_connection(nc): time.sleep(1) main_logger.info(nc.write_channel("exit\n")) time.sleep(1) main_logger.info(nc.write_channel("exit\n")) time.sleep(1) redispatch(nc, device_type='versa') main_logger.info(nc.find_prompt())
def __set_config(self, net_connect=None, device_type='cisco') -> str: if device_type != consts.MF_AUTODETECT: netmiko.redispatch(net_connect, device_type=device_type) # Now just do your normal Netmiko operations output = net_connect.send_config_set( enter_config_mode=True, exit_config_mode=True, config_commands=self.cos.command_list, ) return output
def on(jumpserver, ip_addr, rsa_pwd): # Connect to jump box net_connect = ConnectHandler(**jumpserver) # Connect to the target device ssh_command = "ssh " + ip_addr # for TACACS account # ssh_command = "ssh " + local_user + "@" + ip_addr # for local account net_connect.write_channel(ssh_command) print(net_connect.find_prompt()) sleep(10) net_connect.write_channel(rsa_pwd + "\n") net_connect.read_channel() redispatch(net_connect, device_type='cisco_ios') return net_connect
def Interface_Utilization(Interface): if DeviceType == 'f5' or DeviceType == 'f5_ltm': redispatch(net_connect, device_type='f5_ltm') output1 = net_connect.read_channel() if '(tmos)' in output1: clock = net_connect.send_command("show sys clock ", delay_factor=5, max_loops=100) TMM = net_connect.send_command("show net interface " + Interface, delay_factor=5, max_loops=100) decision = 1 else: net_connect.send_command("tmsh", delay_factor=5, max_loops=10) clock = net_connect.send_command("show sys clock ", delay_factor=5, max_loops=100) TMM = net_connect.send_command("show net interface " + Interface, delay_factor=5, max_loops=100) decision = 1 # Details = new_output.encode('ascii','ignore') response_content = 'Device Clock :' + clock + '\nUtilization Summary: \n ' + str(TMM) return response_content, decision
def reset_cfg(self, task): task.host.open_connection("netmiko", None) conn = task.host.connections["netmiko"].connection conn.find_prompt() print("Connected to terminal server or KVM host...") conn.write_channel(f"telnet localhost {task.host['console_port']}") time.sleep(0.5) conn.write_channel("\r\n") time.sleep(0.5) for k, v in task.host["end_host_args"].items(): if k != "device_type": setattr(conn, k, v) conn.telnet_login() redispatch(conn, task.host["end_host_args"]["device_type"]) conn.find_prompt() conn.enable() print(f"Redispatched to {task.host}") cfg_check = conn.send_command( f"dir {task.host['filesystem']}:/{task.host['default_cfg']}", strip_prompt=False, strip_command=False, ) if "No such file" in cfg_check: print(f"{task.host['default_cfg']} is not in {task.host['filesystem']}") raise ValueError(f"Default config file not found") cfg_replace = conn.send_command( f"{task.host['default_cfg_cmd']} {task.host['filesystem']}:/{task.host['default_cfg']}", strip_prompt=False, strip_command=False, ) if "Rollback failed." in cfg_replace: failed = True print(f"{task.host} configuration replace failed. Output: {cfg_replace}") else: failed = False conn.save_config() print(f"{task.host} configuration replaced and config saved") return Result(host=task.host, result=cfg_replace, changed=True, failed=failed)
def cleanBoot(): moxa = netmiko.ConnectHandler(**moxaTermServer) redispatch(moxa, device_type='cisco_ios' ) #redispatch connection to use Cisco commands using Netmiko output = moxa.find_prompt() print(output) moxa.enable() print("[Status]: Checking Version...") version = moxa.send_command('show version', use_textfsm=True) #uses textfsm for parsing version = version[0] if version[ 'running_image'] == CURRENT_VERSION: #current version termination print("[TASK]: Current CISCO IOS found - " + version['running_image']) print('[Success]: CISCO IOS PreCheck - Complete!') moxa.disconnect() else: #Cisco version out of date print("[TASK]: CISCO IOS found: " + version['running_image']) print("[Status]: CISCO IOS Upgrade Required") moxa.config_mode() moxa.send_config_set(mgmt_cmd) moxa.enable() if moxa.check_enable_mode() == True: moxa.send_command_timing('del /f /r *') print('[Status]: Cisco IOS Updating.') output = moxa.send_command(copy_cmd, delay_factor=20) print(output) if output[-1] != ')': print('File Transfer Failed.') moxa.disconnect() cleanBoot() print('[Task]: CISCO IOS Updated.') output = moxa.send_command('wr erase') if 'Continue?' in output: moxa.send_command_timing('\n') output = moxa.send_command_timing('reload') if 'yes/no' in output: output = moxa.send_command_timing(no_cmd) if 'confirm' in output: moxa.send_command_timing('\n') print('[Status]: Reboot Initiated') moxa.disconnect() initialCheck()
def After_Intermediate_Server_Login(ais_id, ais_ip, ais_name, ais_cfile): net_connect.write_channel('shebin') net_connect.write_channel('\n') redispatch(net_connect, device_type='cisco_ios') console.print( '[bold][blue] Connecting to device with Sol_Id-> [/bold][/blue]' + ais_id, style='bold purple') console.print('[bold][blue] Branch-> [/bold][/blue]' + ais_name, style='bold purple') console.print('[bold][blue] IP-> [/bold][/blue]' + ais_ip, style='bold purple') console.print(Panel('Connected ! :smiley: '), style='bold green') console.print(Panel('[yellow][bold]Pushing configuration to the device')) net_connect.send_config_from_file(config_file=ais_cfile, enter_config_mode=True) console.print( Panel('Configuration Push Successfully !!!', style='bold green')) table.add_row(ais_id, ais_ip, config_success)
def do_cross_connection(vd_ssh_dict, dev_dict): global cpe_logger netconnect = make_connection(vd_ssh_dict) netconnect.write_channel("ssh " + dev_dict["username"] + "@" + dev_dict["ip"] + "\n") time.sleep(5) output = netconnect.read_channel() main_logger.debug(output) if 'assword:' in output: netconnect.write_channel(dev_dict["password"] + "\n") time.sleep(5) output = netconnect.read_channel() main_logger.debug(output) elif 'yes' in output: print "am in yes condition" netconnect.write_channel("yes\n") time.sleep(5) output = netconnect.read_channel() main_logger.debug(output) time.sleep(1) netconnect.write_channel(dev_dict["password"] + "\n") time.sleep(5) output = netconnect.read_channel() main_logger.debug(output) else: # cpe_logger.info(output) return "VD to CPE " + dev_dict["ip"] + "ssh Failed." # netconnect.write_channel("cli\n") # time.sleep(2) # output1 = netconnect.read_channel() # main_logger.info(output1) # time.sleep(2) try: main_logger.debug("doing redispatch") redispatch(netconnect, device_type='versa') except ValueError as Va: main_logger.info(Va) main_logger.info("Not able to get router prompt from CPE" + dev_dict["ip"] + " CLI. please check") return "Redispatch not Success" time.sleep(2) return netconnect
def Memory_Utilization(): if DeviceType == 'f5_ltm' or DeviceType == 'f5': redispatch(net_connect, device_type='f5_ltm') output1 = net_connect.read_channel() if '(tmos)' in output1: clock = net_connect.send_command("show sys clock ", delay_factor=5, max_loops=100) TMM = net_connect.send_command("show sys memory | grep 'TMM Memory Used'", delay_factor=5, max_loops=10) Other = net_connect.send_command("show sys memory | grep 'Other Memory Used'", delay_factor=5, max_loops=10) Swap = net_connect.send_command("show sys memory | grep 'Swap Used '", delay_factor=5, max_loops=10) # decision = 1 else: net_connect.send_command("tmsh", delay_factor=5, max_loops=10) clock = net_connect.send_command("show sys clock ", delay_factor=5, max_loops=100) TMM = net_connect.send_command("show sys memory | grep 'TMM Memory Used'", delay_factor=5, max_loops=10) Other = net_connect.send_command("show sys memory | grep 'Other Memory Used'", delay_factor=5, max_loops=10) Swap = net_connect.send_command("show sys memory | grep 'Swap Used '", delay_factor=5, max_loops=10) # decision = 1 # Details = new_output.encode('ascii','ignore') TMM_Load = re.findall('[0-9]+ +([0-9]+)', str(TMM)) Other_Load = re.findall('[0-9]+ +([0-9]+)', str(Other)) Swap_Load = re.findall('[0-9]+ +([0-9]+)', str(Swap)) TMM_Vaue = int(TMM_Load[0]) Other_Vaue = int(Other_Load[0]) Swap_Vaue = int(Swap_Load[0]) if TMM_Vaue >= 70 or Other_Vaue >= 70 or Swap_Vaue >= 70: print('Utilization is high') Status = 'Utilization is high' decision = 2 else: Status = 'Utilization is Low' decision = 1 # Details = new_output.encode('ascii','ignore') response_content = 'Device Clock :' + clock + '\nUtilization Summary: \n ' + str( Status) + '\nUtilization Details:\n TMM Value ' + str( TMM_Vaue) + '%\n Other Value :' + str(Other_Vaue) + '% \n Swap Value: ' + str(Swap_Vaue) # response_content ='Device clock : '+clock+'\nUtilization Summary: \n '+str(Status)+'\n Input load is '+str(Input_Load_percent)+'%\n Output Load is'+str(Output_Load_percent)+'\nUtilization Details:\n +'+str(validate)+'%' # print(response_content)) return response_content, decision
class main: """ This shows the set of commands to connect to a Terminal Server and perform SSH to a Huawei NE device. """ #THIS METHOD WILL CONNECT TO A TERMINAL SERVER SERVER_IP = '10.103.23.133' USERNAME = '******' username = '******' router_ip = '10.112.116.1' jumpserver = { 'device_type': 'terminal_server', 'ip': SERVER_IP, 'username': USERNAME, 'password': getpass(), "global_delay_factor": 1 } net_connect = ConnectHandler(**jumpserver) print(net_connect.find_prompt()) time.sleep(3) net_connect.write_channel('ssh {}@{}'.format(username, router_ip)) print(net_connect.find_prompt()) net_connect.write_channel(getpass()) redispatch(net_connect, device_type='huawei') net_connect.username(username) net_connect.ip(router_ip) net_connect.password(getpass()) net_connect.global_delay_factor(1) net_connect.find_prompt() output = net_connect.send_command("display version") print(output) net_connect.disconnect()
net_connect = ConnectHandler(**device) print(net_connect.find_prompt()) # Update the password as the terminal server uses different credentials net_connect.password = term_serv_pass net_connect.secret = term_serv_pass # Telnet to the terminal server command = f"telnet {terminal_server_ip}\n" net_connect.write_channel(command) # Use the telnet_login() method to handle the login process net_connect.telnet_login() print(net_connect.find_prompt()) # Made it to the terminal server (this terminal server is "cisco_ios") # Use redispatch to re-initialize the right class. redispatch(net_connect, device_type="cisco_ios") net_connect.enable() print(net_connect.find_prompt()) # Now connect to the end-device via the terminal server (Juniper SRX2) net_connect.write_channel("srx2\n") # Update the credentials for SRX2 as these are different. net_connect.username = "******" net_connect.password = srx2_pass # Use the telnet_login() method to connect to the SRX net_connect.telnet_login() redispatch(net_connect, device_type="juniper_junos") print(net_connect.find_prompt()) # Now we could do something on the SRX output = net_connect.send_command("show version")
c.write_channel(f'open /{our_lab.id}/{xr_node.id}/0\r') c.write_channel('\r\n') sleep(1) c.write_channel('\r\n') sleep(1) # router login # this makes an assumption that it's required to login #c.write_channel(LAB_USERNAME + '\r') #c.write_channel(LAB_PASSWORD + '\r') logging.info("Sending a few carriage returns") #c.write_channel('\r\n\r\n\r\n') # switch to Cisco XR mode netmiko.redispatch(c, device_type='cisco_ios') c.find_prompt() # get the list of interfaces c.enable() result = c.send_command('show run') print(result) # # create the keys # result = c.send_command('crypto key generate rsa', # expect_string='How many bits in the modul us \[2048\]\: ') # print(result) # # send the key length # c.write_channel('2048\n')
# Manually handle the Username and Password max_loops = 10 i = 1 while i <= max_loops: output = net_connect.read_channel() if "Username" in output: net_connect.write_channel(net_connect.username + "\r\n") time.sleep(1) output = net_connect.read_channel() # Search for password pattern / send password if "Password" in output: net_connect.write_channel(net_connect.password + "\r\n") time.sleep(0.5) output = net_connect.read_channel() # Did we successfully login if ">" in output or "#" in output: break net_connect.write_channel("\r\n") time.sleep(0.5) i += 1 # We are now logged into the end device # Dynamically reset the class back to the proper Netmiko class redispatch(net_connect, device_type="cisco_ios") # Now just do your normal Netmiko operations new_output = net_connect.send_command("show ip int brief")
import time from netmiko import ConnectHandler, redispatch zpe_username = "******" zpe_password = "******" zpe_hostname = "server_ip" console_username = zpe_username console_server = { "host": zpe_hostname, "username": console_username, "password": zpe_password, "device_type": "terminal_server", } print("ssh " + console_username + "@" + zpe_hostname) net_connect = ConnectHandler(**console_server) print(net_connect.find_prompt()) net_connect.write_channel("ssh username@router\n") time.sleep(1) net_connect.read_channel() net_connect.write_channel("Router_password\n") time.sleep(1) net_connect.read_channel() redispatch(net_connect, device_type='alcatel_sros') command_output = net_connect.send_command('/configure router policy-options')
def off(net_connect): redispatch(net_connect, device_type='terminal_server')
def config_worker(param): netmiko_delay = 0.1 client = ClientLibrary( param["virl_controller"], param["virl_username"], param["virl_password"], ssl_verify=False, ) client.wait_for_lld_connected() with print_lock: print(f"{param['hostname']}: Connected to VIRL") our_lab = client.find_labs_by_title(param["lab_id"])[0] our_node = our_lab.get_node_by_label(param["hostname"]) with print_lock: print( f"{param['hostname']}: Identified lab and device: /{our_lab.id}/{our_node.id}/0" ) c = netmiko.ConnectHandler( device_type="terminal_server", host=param["virl_controller"], username=param["virl_username"], password=param["virl_password"], ) with print_lock: print(f"{param['hostname']}: Connected to terminal server") c.write_channel("\r\n") time.sleep(1) c.write_channel("\r\n") time.sleep(1) c.write_channel(f"open /{our_lab.id}/{our_node.id}/0\r") c.write_channel("\r\n") time.sleep(1) c.write_channel("\r\n") time.sleep(1) c.write_channel("\r\n") time.sleep(1) c.write_channel("\r\n") with print_lock: print(f"{param['hostname']} : Switching to IOS interpreter") try: netmiko.redispatch(c, device_type="cisco_ios") except Exception as e: with print_lock: print( f"{param['hostname']} : Failed to switch to IOS interpreter. {e}" ) c.find_prompt() # c.enable() with print_lock: print(f"{param['hostname']} : Preparing config") try: with open("swtemplate.j2", "r") as f: template = jinja2.Template(f.read()) config_to_send = template.render(device=param).split("\n") except: with print_lock: print(f"{param['hostname']} : Failed to prepare config") with print_lock: print(f"{param['hostname']} : Sending config") try: # I have found that console messages can upset netmiko, # so turn them off with a timed command c.send_command_timing("enable", netmiko_delay) c.send_command_timing("conf t", netmiko_delay) c.send_command_timing("no logging console", netmiko_delay) c.send_command_timing("end", netmiko_delay) time.sleep(1) c.write_channel("\r\n") c.find_prompt() c.send_config_set(config_to_send) with print_lock: print(f"{param['hostname']} : Config sent") except Exception as e: with print_lock: print(f"{param['hostname']} : Error, send config failed. {e}")
def show_to_txt(namepass, command): b = len(namepass) d = len(command) jumpserver = { "device_type": "terminal_server", ##1 "ip": "192.168.32.10", ##2 "username": "******", ##3 "password": "******", ##4 "secret": "f**k" ##4 } net_connect = ConnectHandler(**jumpserver) # Manually handle interaction in the Terminal Server (fictional example, but # hopefully you see the pattern) time.sleep(3) net_connect.write_channel("\n") time.sleep(1) output = net_connect.read_channel() # Should hopefully see the terminal server prompt #print(output) for j in range(1, b): print('Now is checking ' + namepass[j][1] + ',the ip address is ' + namepass[j][6]) # Login to end device from terminal server net_connect.write_channel("telnet " + namepass[j][6] + "\n") time.sleep(3) # Manually handle the Username and Password max_loops = 5 i = 1 while i <= max_loops: output = net_connect.read_channel() if 'sername:' in output: net_connect.write_channel(namepass[j][7] + '\n') time.sleep(1) output = net_connect.read_channel() # Search for password pattern / send password if 'assword:' in output: net_connect.write_channel(namepass[j][8] + '\n') time.sleep(1) output = net_connect.read_channel() # Did we successfully login if '>' in output: net_connect.write_channel('enable\n') time.sleep(1) output = net_connect.read_channel() if 'assword:' in output: net_connect.write_channel(namepass[j][9] + '\n') time.sleep(1) output = net_connect.read_channel() if '#' in output: break elif '#' in output: break net_connect.write_channel('\n') time.sleep(1) i += 1 # We are now logged into the end device # Dynamically reset the class back to the proper Netmiko class redispatch(net_connect, device_type='cisco_ios') # #net_connect.send_command('show version') write_file = open(namepass[j][1] + '_' + date + '.txt', 'w') #模式为追加 for n in range(0, d): print(command[n][1], file=write_file) print("\n", file=write_file) output = net_connect.send_command(command[n][1]) print(output, file=write_file) print("\n=============================================\n", file=write_file) write_file.close() """ net_connect.write_channel("ssh [email protected]\n") #连接远程机器,必须得带回车 time.sleep(3) #必须得等待几秒,否则读取不到返回 result = net_connect.read_channel() #读取返回结果 if 'assword' in result: net_connect.write_channel("password\n") #输入密码 time.sleep(5) """ net_connect.disconnect()
import time logging.basicConfig(filename='netmiko_global.log', level=logging.DEBUG) logger = logging.getLogger("netmiko") device123 = { "device_type": "terminal_server", "ip": "192.168.29.141", "username": "******", "password": "******", } ssh123 = ConnectHandler(**device123) output123 = ssh123.send_command("ifconfig") print(output123) #cisco ip123 = [" 192.168.29.133"] for xyz123 in ip123: usernamer123 = "admin" ssh123.write_channel("ssh -l " + usernamer123 + xyz123 + "\n") max_trial = 4 i = 1 while i <= max_trial: ssh123.write_channel(input("enter the password for ") + "\n") time.sleep(1) output345 = ssh123.read_channel() if ">" in output345 or "#" in output345: break i += 1 redispatch(ssh123, device_type="cisco_ios") output124 = ssh123.send_config_set("logging host 2.2.2.2") print(output124) *redispatch used for changing device_type
) output += net_connect.send_command_timing( password, strip_prompt=False, strip_command=False ) if debug: print(">>>>") print(output) print(">>>>") prompt = net_connect.find_prompt() if "arista4" not in prompt: raise ValueError(f"Expecting 'arista4' in prompt: {prompt}") # Use redispatch to switch the Netmiko class print("\nUse redispatch to switch the class.") redispatch(net_connect, device_type="arista_eos") print(f"Current class: {str(net_connect)}") if "AristaSSH" not in str(net_connect): raise ValueError(f"Expecting AristaSSH class at this point: {str(net_connect)}") # Exit Arista device print("\nExit from 'arista4'") output = net_connect.send_command_timing("exit\n") prompt = net_connect.find_prompt() if debug: print(f"\nCurrent prompt: {prompt}") if "cisco3" not in prompt: raise ValueError(f"Expecting 'cisco3' in prompt: {prompt}")
# Manually handle the Username and Password max_loops = 10 i = 1 while i <= max_loops: output = net_connect.read_channel() if 'Username' in output: net_connect.write_channel(net_connect.username + '\r\n') time.sleep(1) output = net_connect.read_channel() # Search for password pattern / send password if 'Password' in output: net_connect.write_channel(net_connect.password + '\r\n') time.sleep(.5) output = net_connect.read_channel() # Did we successfully login if '>' in output or '#' in output: break net_connect.write_channel('\r\n') time.sleep(.5) i += 1 # We are now logged into the end device # Dynamically reset the class back to the proper Netmiko class redispatch(net_connect, device_type='cisco_ios') # Now just do your normal Netmiko operations new_output = net_connect.send_command("show ip int brief")
def Packet_Loss(): if DeviceType == 'f5': try: redispatch(net_connect, device_type='f5') hostname = net_connect.read_channel() if '(tmos)' not in hostname: net_connect.send_command('tmsh', delay_factor=5, max_loops=1000) # hostname = net_connect.send_command('show run | i hostname') devicename = re.findall('@\(([A-Za-z0-9]+)\)',str(hostname)) Clock = net_connect.send_command("show sys clock", delay_factor=5, max_loops=1000) Uptime = net_connect.send_command("run /util bash -c uptime", delay_factor=5, max_loops=1000) Last_Config = net_connect.send_command("show run | in Last configuration change", delay_factor=5,max_loops=1000) CPU_LOAD = net_connect.send_command("show process cpu | i utilization", delay_factor=5, max_loops=10) Memory_Util = net_connect.send_command("show memory statistics", delay_factor=5, max_loops=10) uptime_list = re.findall('([0-9]+)', str(Uptime)) print(uptime_list) if int(uptime_list[0]) == 0 and int(uptime_list[1]) == 0 and int(uptime_list[2]) == 0 : Uptime_Status = 'NotNormal' else: Uptime_Status = 'Normal' Last_Config_details = re.findall('at ([0-9:A-Za-z ]+) by', str(Last_Config)) print(Last_Config_details) date_time_obj_time = datetime.datetime.strptime(str(Last_Config_details[0]), '%H:%M:%S %Z %a %b %d %Y') date_time_obj_time1 = datetime.datetime.strptime(str(Clock), '%H:%M:%S.%f %Z %a %b %d %Y') date_time_last_config = date_time_obj_time1-date_time_obj_time date_time_last_config_main = str(date_time_last_config).split(' ') if int(date_time_last_config_main[0]) >0: Last_Config_change = 'Normal' else: Last_Config_change = 'NotNormal' CPU_Load = re.findall('seconds: ([0-9]+)', str(CPU_LOAD)) Load = int(CPU_Load[0]) if Load >= 70: print('Utilization is high') CPU_Status = 'NotNormal' else: CPU_Status = 'Normal' print(CPU_Status) Processor = re.findall('Processor +[0-9A-Za-z]+ +([0-9]+) +([0-9]+)', str(Memory_Util)) Processor_percentage = int(Processor[0][1]) * 100 / int(Processor[0][0]) Status = '' print(Processor_percentage) if Processor_percentage >= 70: Memory_Load = 'NotNormal' else: Memory_Load = 'Normal' print(Memory_Load) # Uptime_Status = 'n' if Uptime_Status == 'Normal' and Last_Config_change == 'Normal' and CPU_Status == 'Normal' and Memory_Load == 'Normal': # net_connect.send_command("clear counters", expect_string="\[confirm\]", delay_factor=5, max_loops=1000) # net_connect.send_command('\n', expect_string="#", delay_factor=5, max_loops=1000) # time.sleep(5) Interface_Details = '\n\nInterface details:\n' + '~' * 100 + '\n' Interface_Details += net_connect.send_command('show interfaces | inc reliability| errors| line| drops', delay_factor=5, max_loops=1000) value = Interface_Details.split('resets') # print(value) interface = [] utilization = [] Reliability = [] errors = [] CRC = [] drops1 = [] frame = [] collisions = [] for i in value: if 'administratively down' not in str(i) and 'notconnect' not in str(i) and 'disabled' not in str(i) and len(i) >= 100: line_status = re.findall('is ([a-zA-Z]+)', str(i)) drops = re.findall('Input queue: \d\/\d+\/([\d])+', str(i)) frames = re.findall('([0-9]+) frame', str(i)) crc = re.findall('([0-9]+) CRC', str(i)) colli = re.findall('([0-9]+) collisions', str(i)) for j in line_status: if 'down' in str(j): val = i.split(('\n')) val = str(val[2]) interface.append(val.split(' ')[0]) print(i.split('\n')) print(interface) txload = re.findall('txload ([0-9]+)', str(i)) rxload = re.findall('rxload ([0-9]+)', str(i)) print(txload) print(rxload) time.sleep(2) print(len(i)) txload_percentage = int(txload[0]) * 100 / int(255) rxload_percentage = int(rxload[0]) * 100 / int(255) if txload_percentage >= 70 or rxload_percentage >= 70: # print('Processor_percentage is high which is ' + str(Processor_percentage) + ' ') utilization.append(i.split(' ')[0]) input_errors = re.findall('([0-9]+) input', str(i)) output_errors = re.findall('([0-9]+) output', str(i)) if int(input_errors[0]) > 0 or int(output_errors[0]) > 0: print(i) val = i.split(('\n')) val = str(val[2]) errors.append(val.split(' ')[0]) # print(len(colli)) if int(frames[0]) > 0: val = i.split(('\n')) val = str(val[2]) frame.append(val.split(' ')[0]) if int(crc[0]) > 0: val = i.split(('\n')) val = str(val[2]) CRC.append(val.split(' ')[0]) # print(len(colli)) if len(colli) != 0: if int(colli[0]) > 0: val = i.split(('\n')) val = str(val[2]) collisions.append(val.split(' ')[0]) if int(drops[0]) > 1: val = i.split(('\n')) val = str(val[2]) drops1.append(val.split(' ')[0]) if len(interface) != 0 or len(utilization) != 0 or len(Reliability) != 0 or len(errors) != 0 or len(CRC) != 0 or len(frame) != 0 or len(collisions) != 0 or len(drops1) != 0: print('packet loss happening') issue = 'Manual Action Required' else: print('packet loss not happening') issue = 'Device is working fine' response_content = issue +'\nDevice name: ' + str(devicename) + ' , IP: ' + str(ip) + '\n Device Current Time: \n' +str(Clock)+ '\nUptime: \n'+ str(Uptime) +'\n Last Config Changed: \n'+str(Last_Config)+'\nCPU Load: \n'+str(CPU_LOAD)+'\nMemory Utilization: \n'+str(Memory_Util)+'\nInterface Details: \n'+str(Interface_Details) else: response_content = 'Device name: ' + str(devicename) + ' , IP: ' + str(ip) + '\n Device Current Time: \n' + str(Clock) + '\nUptime: \n' + str(Uptime) + '\n Last Config Changed: \n' + str(Last_Config) + '\nCPU Load: \n' + str(CPU_LOAD) + '\nMemory Utilization: \n' + str(Memory_Util) except Exception : response_content = 'Manual Action Required' return response_content
print(net_connect.find_prompt()) print(f"\n{'*'*10}Connected to the Jump host{'*'*10}") print(f"\n{'~'*50}\n2. Connecting to the Dest Router\n{'~'*50}") print(net_connect.find_prompt(),end='') net_connect.write_channel(f'ssh -l {router_user} {router_ip}\n') time.sleep(2) output = net_connect.read_channel() print(output) if 'Password' in output: print("**Received Password Prompt, Entering password**") net_connect.write_channel(router_password+'\n') time.sleep(2) print(f"\n{'~'*50}\nDestination Device Prompt\n{'~'*50}\n") print(net_connect.find_prompt()) cmds = ['show ip int brie','show ip route','show users'] redispatch(net_connect,device_type='cisco_ios') for cmd in cmds: print(f"\n{'~'*50}\nIn {net_connect.find_prompt()} Executing the Command: {cmd}\n{'~'*50}") router_output = net_connect.send_command(cmd) print(router_output) else: print("Unable to get output from the End Device") except ssh_exception.AuthenticationException: print("Jump host Auth failed") except ssh_exception.NetmikoTimeoutException: print("Jump Host not reachable") print(f"\n{'#'*50}\nFinished Executing Script\n{'#'*50}")
jumperbox = { "device_type": "linux", 'host': '192.168.1.1', 'username': '******', 'password': '******', } net_connect = netmiko.ConnectHandler(**jumperbox) print("SSH prompt: {}".format(net_connect.find_prompt())) net_connect.write_channel("ssh -l admin 10.2.2.2\n") #### or a ssh 10.30.1.11 time.sleep(6) output = net_connect.read_channel() print(output) if 'ssword' in output: net_connect.write_channel('admin\n') output = net_connect.read_channel() # Verify you logged in successfully print(output) time.sleep(1) netmiko.redispatch(net_connect, device_type="huawei") output2 = net_connect.send_command('dis ver') print(output2) config_commands = [ 'interface 10GE1/0/36', 'description netmiki_test', 'commit', ] output3 = net_connect.send_config_set(config_commands) print(output3)
def main(): dev = { 'device_type': 'terminal_server', 'ip': sys.argv[1], 'username': '******', 'password': '******', 'port': 830 } cn_host_pass = '******' net_connect = ConnectHandler(**dev) net_connect.write_channel("\r\n") time.sleep(1) net_connect.write_channel("\r\n") time.sleep(1) output = net_connect.read_channel() print(output) # Login to end device from "terminal server" ... ">" expected first if 10x ver or ui if 18x ver if ">" in output: print("Found 10x \n") net_connect.write_channel("diag shell\r\n") time.sleep(1) # output = net_connect.read_channel() net_connect.write_channel("ssh cn_core_host\r\n") time.sleep(1) # output = net_connect.read_channel() # print(output) else: print("Found 18x \n") net_connect.write_channel("ssh cn_core_host\r\n") time.sleep(1) # output = net_connect.read_channel() # print(output) # Manually handle the Username and Password max_loops = 5 i = 1 while i <= max_loops: output = net_connect.read_channel() print(output) # Search for password pattern / send password if 'yes/no' in output: net_connect.write_channel('yes\r\n') time.sleep(.5) elif "password" in output: net_connect.write_channel(cn_host_pass + '\r\n') time.sleep(.5) output = net_connect.read_channel() # Did we successfully login if 'NFV-FRU:' in output: print(output) break net_connect.write_channel('\r\n') time.sleep(.5) i += 1 # Dynamically reset the class back to the proper Netmiko class print("Doing redispatch to dev type linux") redispatch(net_connect, device_type='linux') cmd = "sudo virsh list --all" # net_connect.send_command("sudo su") print("sending command") res = net_connect.send_command(cmd) print(res) net_connect.disconnect() return