def main(): ip_addr = '50.76.53.27' port_rtr1 = 22 port_rtr2 = 8022 username = '******' password = '******' #password = getpass() pynet1 = { 'device_type': 'cisco_ios', 'ip': ip_addr, 'username': username, 'password': password, 'port': port_rtr1, } pynet_rtr1 = ConnectHandler(**pynet1) pynet_rtr1.find_prompt() print "we are getting into config mode" pynet_rtr1.config_mode() if pynet_rtr1.check_config_mode(): print "yes, we are in config mode" else: print "sometthing is wrong, we are not in config mode!"
def main(): #password = getpass() password = '******' # Define libraries for devices we will connect to pynet1 = { 'device_type': 'cisco_ios', 'ip': '50.76.53.27', 'username': '******', 'password': password, 'port': 22, } pynet2 = { 'device_type': 'cisco_ios', 'ip': '50.76.53.27', 'username': '******', 'password': password, 'port': 8022, } srx = { 'device_type': 'juniper', 'ip': '50.76.53.27', 'username': '******', 'password': password, 'port': 9822, } pynet_rtr2 = ConnectHandler(**pynet2) pynet_rtr2.config_mode() outp = pynet_rtr2.find_prompt() print outp outp2 = pynet_rtr2.check_config_mode() print 'Config mode status is ' + str(outp2)
def main(): password = getpass() py_router_2 = { 'device_type':'cisco_ios', 'ip':'50.76.53.27', 'username':'******', 'password':password, 'port':8022, } rtr2 = ConnectHandler(**py_router_2) rtr2.config_mode() output = rtr2.check_config_mode() print "RTR Config mode is %s" % output if (output is True): #config_command = ['loggin buffered 5555'] #output = rtr2.send_config_set(config_command) output = rtr2.send_config_from_file(config_file='config_file.txt') print "Changes send to router.\n %s" % output rtr2.exit_config_mode() else: print "Could not get to config mode.\n"
def main(): username = '******' password = '******' pynet1 = { 'device_type': 'cisco_ios', 'ip': '50.76.53.27', 'username': username, 'password': password, 'port': 22, } pynet2 = { 'device_type': 'cisco_ios', 'ip': '50.76.53.27', 'username': username, 'password': password, 'port': 8022, } juniper_srx = { 'device_type': 'juniper', 'ip': '50.76.53.27', 'username': username, 'password': password, 'secret': '', 'port': 9822, } pynet_rtr2 = ConnectHandler( **pynet2 ) pynet_rtr2.config_mode() if pynet_rtr2.check_config_mode() : print "We are in config mode for pynet rtr2" else: print "No config mode for pynet rtr2"
def main(): password = getpass pynet_rtr2 = ConnectHandler(**pynet2) pynet_rtr2.config_mode() if pynet_rtr2.check_config_mode(): print "You are in config mode.\n" else: print "Config mode failed.\n"
def main(): '''Main function, opens connection, enters config mode and verifies''' pynet_rtr1 = ConnectHandler(**device_list.RTR1) pynet_rtr1.config_mode() if pynet_rtr1.check_config_mode(): print "We are in Config mode" else: print "We are NOT in Config mode"
def main(): '''Main function, opens connection, enters config mode, changes logging and verifies''' pynet_rtr2 = ConnectHandler(**RTR2) pynet_rtr2.config_mode() if pynet_rtr2.check_config_mode(): pynet_rtr2.send_command("logging buffered 16384") pynet_rtr2.exit_config_mode() output = pynet_rtr2.send_command("show run | include logging buff") print output else: print "We are NOT in Config mode"
def main(): ''' Use Netmiko to enter into configuration mode on pynet-rtr2. Also use Netmiko to verify your state (i.e. that you are currently in configuration mode). ''' pynet_rtr2 = ConnectHandler(**pynet2) pynet_rtr2.config_mode() output = pynet_rtr2.check_config_mode() print print 'Checking to see if we are in config mode:' print output print
def main(): my_device = { 'device_type': 'cisco_ios', 'ip': '10.40.0.1', 'username': '******', 'password': '******' } # Connect to device device_conn = ConnectHandler(**my_device) # Enter Config mode device_conn.config_mode() # Verify current mode print device_conn.check_config_mode() # Print the current prompt print device_conn.find_prompt() # Close connection device_conn.disconnect()
def main(): password = getpass() for a_dict in (pynet1, pynet2, juniper_srx): a_dict['password'] = password net_connect2 = ConnectHandler(**pynet2) net_connect2.config_mode() print "Config mode:{}".format(net_connect2.check_config_mode()) print "Current prompt: {}".format(net_connect2.find_prompt())
def main(): pynet2 = { 'device_type': 'cisco_ios', 'ip' : '50.76.53.27', 'username' : 'pyclass', 'port' : 8022, 'password' : '88newclass' } pynet_rtr2 = ConnectHandler(**pynet2) pynet_rtr2.config_mode() if pynet_rtr2.check_config_mode(): print "We're in config mode" pynet_rtr2.send_command("logging buffered 33333") else: print "Nope, We're NOT in config mode"
def main(): ''' Connects to router and switches to config mode ''' pynet_rtr2 = ConnectHandler(**pynet2) pynet_rtr2.enable() pynet_rtr2.config_mode() ''' Checks to see if you are in enable mode and prints results to screen ''' if pynet_rtr2.check_config_mode() is True: output = pynet_rtr2.find_prompt() print output else: print 'You are NOT in config mode'
def main(): ''' Using Netmiko enter into configuration mode on a network device. Verify that you are currently in configuration mode. ''' password = getpass() for a_dict in (pynet1, pynet2, juniper_srx): a_dict['password'] = password net_connect2 = ConnectHandler(**pynet2) net_connect2.config_mode() print "\n>>>>" print "Checking pynet-rtr2 is in configuration mode." print "Config mode check: {}".format(net_connect2.check_config_mode()) print "Current prompt: {}".format(net_connect2.find_prompt()) print ">>>>\n"
def main(): password = getpass() py_router_2 = { 'device_type':'cisco_ios', 'ip':'50.76.53.27', 'username':'******', 'password':password, 'port':8022, } rtr2 = ConnectHandler(**py_router_2) rtr2.config_mode() output = rtr2.check_config_mode() print "RTR Config mode is %s" % output rtr2.exit_config_mode()
def main(): ''' Use Netmiko to enter into configuration mode on pynet-rtr2. Also use Netmiko to verify your state (i.e. that you are currently in configuration mode). ''' ip_address = raw_input("Please enter IP: ") password = getpass() pynet_rtr2['ip'] = ip_address pynet_rtr2['password'] = password ssh_conn = ConnectHandler(**pynet_rtr2) ssh_conn.config_mode() if ssh_conn.check_config_mode(): print "In config mode"
def main(): pynet2 = { 'device_type': 'cisco_ios', 'ip' : '50.76.53.27', 'username' : 'pyclass', 'port' : 8022, 'password' : '88newclass' } pynet_rtr2 = ConnectHandler(**pynet2) pynet_rtr2.config_mode() if pynet_rtr2.check_config_mode(): print "We're in config mode" else: print "Nope, We're NOT in config mode" print pynet_rtr2.find_prompt() pynet_rtr2.exit_config_mode() print pynet_rtr2.find_prompt()
def main(): ''' Using Netmiko enter into configuration mode on a network device. Verify that you are currently in configuration mode. ''' ip_addr = raw_input("Enter IP Address: ") password = getpass() for a_dict in (pynet1, pynet2, juniper_srx): a_dict['ip'] = ip_addr a_dict['password'] = password pynet_rtr2 = ConnectHandler(**pynet2) pynet_rtr2.config_mode() print "\n>>>>" print "Checking pynet-rtr2 is in configuration mode" print "Config mode check: {}".format(pynet_rtr2.check_config_mode()) print "Current prompt: {}".format(pynet_rtr2.find_prompt()) print ">>>>\n"
def main(): password = getpass() pynet1 = { 'device_type': 'cisco_ios', 'ip': '50.76.53.27', 'username': '******', 'password': password, } pynet2 = { 'device_type': 'cisco_ios', 'ip': '50.76.53.27', 'username': '******', 'password': password, 'port': 8022, } juniper_srx = { 'device_type': 'juniper', 'ip': '50.76.53.27', 'username': '******', 'password': password, 'secret': '', 'port': 9822, } # pynet_rtr1 = ConnectHandler(**pynet1) pynet_rtr2 = ConnectHandler(**pynet2) time.sleep(5) # srx = ConnectHandler(**juniper_srx) pynet_rtr2.config_mode() time.sleep(5) output = pynet_rtr2.check_config_mode() print "\nConfig mode? (true/false):" print output
def main(): print 'Username:'******'device_type':DEV_TYPE, 'ip':dev, 'username':usern, 'password':passwd } # Initiating netmiko connection net_connect = ConnectHandler(**net_dev) resp = net_connect.find_prompt() print resp # Entering config mode net_connect.config_mode() # Verifying we're in config mode resp = net_connect.check_config_mode() print 'Entered Config mode? {}'.format(resp) # Exiting config mode net_connect.exit_config_mode()
def main(): # Definition of rtr2. rtr2 = { 'device_type': 'cisco_ios', 'ip': '50.76.53.27', 'username': '******', 'password': '******', 'port': 8022, } # Log into router. net_connect = ConnectHandler(**rtr2) # Enter configuration mode. output = net_connect.config_mode() # Verify whether we are in configuration mode. output = net_connect.check_config_mode() print print "Are we in config mode?" print output print
def main(): ''' Using Netmiko enter into configuation mode on a network device. Verify that you are currently in configration mode. ''' ip_addr = raw_input("Enter IP Address: ") password = getpass() for a_dict in (pynet1, pynet2): a_dict['ip'] = ip_addr a_dict['password'] = password net_connect2 = ConnectHandler(**a_dict) net_connect2.config_mode() print "\n>>>" print "Checking {}:{} is in configuration mode.".format(net_connect2.ip, net_connect2.port) print "Config mode check: {}".format(net_connect2.check_config_mode()) print "Current prompt: {}".format(net_connect2.find_prompt()) print ">>>>\n"
from netmiko import ConnectHandler from getpass import getpass password = getpass() NB_3850_8 = { 'device_type': 'cisco_ios', 'ip': '50.76.53.27', 'username' : 'pyclass', 'password': password, 'port' : 8022, } nick_3850 = ConnectHandler(**NB_3850_8) nick_3850.find_prompt() nick_3850.exit_config_mode() nick_3850.config_mode() output = nick_3850.check_config_mode() print 'In configuration mode:' , output
from netmiko import ConnectHandler from getpass import getpass password = getpass() NB_3850_8 = { 'device_type': 'cisco_ios', 'ip': '50.76.53.27', 'username': '******', 'password': password, 'port': 8022, } nick_3850 = ConnectHandler(**NB_3850_8) nick_3850.find_prompt() nick_3850.exit_config_mode() nick_3850.config_mode() output = nick_3850.check_config_mode() print 'In configuration mode:', output
#!/usr/bin/env python '''Simple script to connect to pynet-rtr2 with Netmiko. Use Netmiko to enter into configuration mode on pynet-rtr2. Also use Netmiko to verify that you are in configuration mode.''' from netmiko import ConnectHandler from getpass import getpass password = getpass() pynet2 = { 'device_type': 'cisco_ios', 'ip': '184.105.247.71', 'username': '******', 'password': password, 'port': 22, } pynet_rtr2 = ConnectHandler(**pynet2) print 10 * '>', 'Show me current prompt:\n', pynet_rtr2.find_prompt(), '\n' print 10 * '>', 'Enter config mode:\n', pynet_rtr2.config_mode(), '\n' print 10 * '>', 'Check if you are in config mode:\n', pynet_rtr2.check_config_mode(), '\n' if pynet_rtr2.check_config_mode() == True: print 10 * '_','The config mode prompt is:', 10 * '_', '\n', pynet_rtr2.find_prompt() else: print 'You are not in config mode - try again.'
from netmiko import ConnectHandler pynet1 = {'device_type': 'cisco_ios','ip': '172.31.33.81','username': '******','password': '******',} pynet1_rtr = ConnectHandler(**pynet1) ''' METHODS >>> dir(pynet1_rtr) ['RESPONSE_RETURN', 'RETURN', 'TELNET_RETURN', '__class__', '__delattr__', '__dict__', '__doc__', '__enter__', '__exit__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_autodetect_fs', '_build_ssh_client', '_connect_params_dict', '_first_line_handler', '_lock_netmiko_session', '_modify_connection_params', '_read_channel', '_read_channel_expect', '_read_channel_timing', '_sanitize_output', '_session_locker', '_session_log_close', '_session_log_fin', '_test_channel_read', '_timeout_exceeded', '_try_session_preparation', '_unlock_netmiko_session', '_use_ssh_config', '_write_channel', '_write_session_log', 'allow_agent', 'allow_auto_change', 'alt_host_keys', 'alt_key_file', 'ansi_escape_codes', 'auth_timeout', 'base_prompt', 'blocking_timeout', 'check_config_mode', 'check_enable_mode', 'cleanup', 'clear_buffer', 'close_session_log', 'commit', 'config_mode', 'device_type', 'disable_paging', 'disconnect', 'enable', 'encoding', 'establish_connection', 'exit_config_mode', 'exit_enable_mode', 'fast_cli', 'find_prompt', 'global_delay_factor', 'host', 'ip', 'is_alive', 'keepalive', 'key_file', 'key_policy', 'normalize_cmd', 'normalize_linefeeds', 'open_session_log', 'paramiko_cleanup', 'passphrase', 'password', 'pkey', 'port', 'protocol', 'read_channel', 'read_until_pattern', 'read_until_prompt', 'read_until_prompt_or_pattern', 'remote_conn', 'remote_conn_pre', 'save_config', 'secret', 'select_delay_factor', 'send_command', 'send_command_expect', 'send_command_timing', 'send_config_from_file', 'send_config_set', 'serial_login', 'serial_settings', 'session_log', 'session_log_record_writes', 'session_preparation', 'session_timeout', 'set_base_prompt', 'set_terminal_width', 'special_login_handler', 'ssh_config_file', 'strip_ansi_escape_codes', 'strip_backspaces', 'strip_command', 'strip_prompt', 'system_host_keys', 'telnet_login', 'timeout', 'use_keys', 'username', 'verbose', 'write_channel'] >>> pynet1_rtr.find_prompt() u'router#' ''' pynet1_rtr.config_mode() pynet1_rtr.check_config_mode() pynet1_rtr.exit_config_mode() pynet1_rtr.check_config_mode() outp = pynet1_rtr.send_command('show ip interface brief') print (outp) outp = pynet1_rtr.send_command('show version') print (outp) #Make configuration changes and show that the changes have been made config_commands = ['logging buffered 19999', 'no logging console'] output = pynet1_rtr.send_config_set(config_commands) outp = pynet1_rtr.send_command('show run | inc logging') print(outp)
class CEDriver(NetworkDriver): """Napalm driver for HUAWEI CloudEngine.""" def __init__(self, hostname, username, password, timeout=60, optional_args=None): """NAPALM Huawei CloudEngine Handler.""" self.device = None self.hostname = hostname self.username = username self.password = password self.timeout = timeout # Get optional arguments if optional_args is None: optional_args = {} # Netmiko possible arguments netmiko_argument_map = { 'port': None, 'verbose': False, 'conn_timeout': self.timeout, 'global_delay_factor': 1, 'use_keys': False, 'key_file': None, 'ssh_strict': False, 'system_host_keys': False, 'alt_host_keys': False, 'alt_key_file': '', 'ssh_config_file': None, 'allow_agent': False, 'keepalive': 30 } # Build dict of any optional Netmiko args self.netmiko_optional_args = { k: optional_args.get(k, v) for k, v in netmiko_argument_map.items() } self.transport = optional_args.get('transport', 'ssh') self.port = optional_args.get('port', 22) self.changed = False self.loaded = False self.backup_file = '' self.replace = False self.merge_candidate = '' self.replace_file = '' self.profile = ["ce"] def open(self): """Open a connection to the device.""" try: if self.transport == 'ssh': device_type = 'huawei' else: raise ConnectionException("Unknown transport: {}".format( self.transport)) self.device = ConnectHandler(device_type=device_type, host=self.hostname, username=self.username, password=self.password, **self.netmiko_optional_args) # self.device.enable() except NetMikoTimeoutException: raise ConnectionException('Cannot connect to {}'.format( self.hostname)) def close(self): """Close the connection to the device.""" if self.changed and self.backup_file != "": self._delete_file(self.backup_file) self.device.disconnect() self.device = None def is_alive(self): """Return a flag with the state of the SSH connection.""" null = chr(0) try: if self.device is None: return {'is_alive': False} else: # Try sending ASCII null byte to maintain the connection alive self.device.send_command(null) except (socket.error, EOFError): # If unable to send, we can tell for sure that the connection is unusable, # hence return False. return {'is_alive': False} return {'is_alive': self.device.remote_conn.transport.is_active()} def compare_config(self): """Compare candidate config with running.""" if self.loaded: if not self.replace: return self._get_merge_diff() # return self.merge_candidate diff = self._get_diff(self.replace_file.split('/')[-1]) return diff return '' def discard_config(self): """Discard changes.""" if self.loaded: self.merge_candidate = '' # clear the buffer if self.loaded and self.replace: self._delete_file(self.replace_file) self.loaded = False def get_facts(self): """Return a set of facts from the devices.""" # default values. vendor = u'Huawei' uptime = -1 serial_number, fqdn, os_version, hostname, model = (u'Unknown', u'Unknown', u'Unknown', u'Unknown', u'Unknown') # obtain output from device show_ver = self.device.send_command('display version') show_hostname = self.device.send_command( 'display current-configuration | inc sysname') show_int_status = self.device.send_command('display interface brief') # serial_number/IOS version/uptime/model for line in show_ver.splitlines(): if 'VRP (R) software' in line: search_result = re.search( r"\((?P<serial_number>CE\S+)\s+(?P<os_version>V\S+)\)", line) if search_result is not None: serial_number = search_result.group('serial_number') os_version = search_result.group('os_version') if 'HUAWEI' in line and 'uptime is' in line: search_result = re.search(r"CE\S+", line) if search_result is not None: model = search_result.group(0) uptime = self._parse_uptime(line) break if 'sysname ' in show_hostname: _, hostname = show_hostname.split("sysname ") hostname = hostname.strip() # interface_list filter interface_list = [] if 'Interface' in show_int_status: _, interface_part = show_int_status.split("Interface") re_intf = r"(?P<interface>\S+)\s+(?P<physical_state>down|up|offline|\*down)\s+" \ r"(?P<protocal_state>down|up|\*down)" search_result = re.findall(re_intf, interface_part, flags=re.M) for interface_info in search_result: interface_list.append(interface_info[0]) return { 'uptime': int(uptime), 'vendor': vendor, 'os_version': str(os_version), 'serial_number': str(serial_number), 'model': str(model), 'hostname': str(hostname), 'fqdn': fqdn, # ? fqdn(fully qualified domain name) 'interface_list': interface_list } def cli(self, commands): """Execute raw CLI commands and returns their output.""" cli_output = {} if type(commands) is not list: raise TypeError('Please enter a valid list of commands!') for command in commands: output = self.device.send_command(command) cli_output[str(command)] = output return cli_output def commit_config(self): """Commit configuration.""" if self.loaded: try: self.backup_file = 'config_' + datetime.now().strftime( "%Y%m%d_%H%M") + '.cfg' if self._check_file_exists(self.backup_file): self._delete_file(self.backup_file) self._save_config(self.backup_file) if self.replace: self._load_config(self.replace_file.split('/')[-1]) else: self._commit_merge() self.merge_candidate = '' # clear the merge buffer self.changed = True self.loaded = False self._save_config() except Exception as e: raise CommitError(str(e)) else: raise CommitError('No config loaded.') def load_merge_candidate(self, filename=None, config=None): """Open the candidate config and merge.""" if not filename and not config: raise MergeConfigException( 'filename or config param must be provided.') self.merge_candidate += '\n' # insert one extra line if filename is not None: with open(filename, "r") as f: self.merge_candidate += f.read() else: self.merge_candidate += config self.replace = False self.loaded = True def load_replace_candidate(self, filename=None, config=None): """Open the candidate config and replace.""" if not filename and not config: raise ReplaceConfigException( 'filename or config param must be provided.') self._replace_candidate(filename, config) self.replace = True self.loaded = True def get_interfaces(self): """ Get interface details (last_flapped is not implemented). Sample Output: { "Vlanif3000": { "is_enabled": false, "description": "", "last_flapped": -1.0, "is_up": false, "mac_address": "0C:45:BA:7D:83:E6", "speed": 1000, 'mtu': 1500 }, "Vlanif100": { "is_enabled": false, "description": "", "last_flapped": -1.0, "is_up": false, "mac_address": "0C:45:BA:7D:83:E4", "speed": 1000, 'mtu': 1500 } } """ interfaces = {} output = self.device.send_command('display interface') if not output: return {} separator = r"(^(?!Line protocol).*current state.*$)" re_intf_name_state = r"^(?!Line protocol)(?P<intf_name>\S+).+current state\W+(?P<intf_state>.+)$" re_protocol = r"Line protocol current state\W+(?P<protocol>.+)$" re_mac = r"Hardware address is\W+(?P<mac_address>\S+)" re_speed = r"^Speed\W+(?P<speed>\d+|\w+)" re_description = r"^Description:(?P<description>.*)$" re_mtu = r"(Maximum Transmit Unit|Maximum Frame Length) is (?P<mtu>\d+)" new_interfaces = self._separate_section(separator, output) for interface in new_interfaces: interface = interface.strip() match_intf = re.search(re_intf_name_state, interface, flags=re.M) match_proto = re.search(re_protocol, interface, flags=re.M) if match_intf is None or match_proto is None: msg = "Unexpected interface format: {}".format(interface) raise ValueError(msg) intf_name = match_intf.group('intf_name') intf_state = match_intf.group('intf_state') is_enabled = bool('up' in intf_state.lower()) protocol = match_proto.group('protocol') is_up = bool('up' in protocol.lower()) match_mac = re.search(re_mac, interface, flags=re.M) if match_mac: mac_address = match_mac.group('mac_address') mac_address = napalm.base.helpers.mac(mac_address) else: mac_address = "" speed = mtu = 0 match_speed = re.search(re_speed, interface, flags=re.M) if match_speed: speed = match_speed.group('speed') if speed.isdigit(): speed = int(speed) match_mtu = re.search(re_mtu, interface, flags=re.M) if match_mtu: mtu = match_mtu.group('mtu') if mtu.isdigit(): mtu = int(mtu) description = '' match = re.search(re_description, interface, flags=re.M) if match: description = match.group('description').strip() interfaces.update({ intf_name: { 'description': description, 'is_enabled': is_enabled, 'is_up': is_up, 'last_flapped': -1.0, 'mac_address': mac_address, 'speed': speed, 'mtu': mtu } }) return interfaces def get_interfaces_ip(self): """ Get interface IP details. Returns a dictionary of dictionaries. Sample output: { "LoopBack0": { "ipv4": { "192.168.0.9": { "prefix_length": 32 } } }, "Vlanif2000": { "ipv4": { "192.168.200.3": { "prefix_length": 24 }, "192.168.200.6": { "prefix_length": 24 }, "192.168.200.8": { "prefix_length": 24 } }, "ipv6": { "FC00::1": { "prefix_length": 64 } } } } """ interfaces_ip = {} output_v4 = self.device.send_command('display ip interface') output_v6 = self.device.send_command('display ipv6 interface') v4_interfaces = {} separator = r"(^(?!Line protocol).*current state.*$)" new_v4_interfaces = self._separate_section(separator, output_v4) for interface in new_v4_interfaces: re_intf_name_state = r"^(?!Line protocol)(?P<intf_name>\S+).+current state\W+(?P<intf_state>.+)$" re_intf_ip = r"Internet Address is\s+(?P<ip_address>\d+.\d+.\d+.\d+)\/(?P<prefix_length>\d+)" match_intf = re.search(re_intf_name_state, interface, flags=re.M) if match_intf is None: msg = "Unexpected interface format: {}".format(interface) raise ValueError(msg) intf_name = match_intf.group('intf_name') # v4_interfaces[intf_name] = {} match_ip = re.findall(re_intf_ip, interface, flags=re.M) for ip_info in match_ip: val = {'prefix_length': int(ip_info[1])} # v4_interfaces[intf_name][ip_info[0]] = val v4_interfaces.setdefault(intf_name, {})[ip_info[0]] = val v6_interfaces = {} separator = r"(^(?!IPv6 protocol).*current state.*$)" new_v6_interfaces = self._separate_section(separator, output_v6) for interface in new_v6_interfaces: re_intf_name_state = r"^(?!IPv6 protocol)(?P<intf_name>\S+).+current state\W+(?P<intf_state>.+)$" re_intf_ip = r"(?P<ip_address>\S+), subnet is.+\/(?P<prefix_length>\d+)" match_intf = re.search(re_intf_name_state, interface, flags=re.M) if match_intf is None: msg = "Unexpected interface format: {}".format(interface) raise ValueError(msg) intf_name = match_intf.group('intf_name') match_ip = re.findall(re_intf_ip, interface, flags=re.M) for ip_info in match_ip: val = {'prefix_length': int(ip_info[1])} v6_interfaces.setdefault(intf_name, {})[ip_info[0]] = val # Join data from intermediate dictionaries. for interface, data in v4_interfaces.items(): interfaces_ip.setdefault(interface, {'ipv4': {}})['ipv4'] = data for interface, data in v6_interfaces.items(): interfaces_ip.setdefault(interface, {'ipv6': {}})['ipv6'] = data return interfaces_ip def get_interfaces_counters(self): """Return interfaces counters.""" def process_counts(tup): for item in tup: if item != "": return int(item) return 0 interfaces = {} # command "display interface counters" lacks of some keys output = self.device.send_command('display interface') if not output: return {} separator = r"(^(?!Line protocol).*current state.*$)" re_intf_name_state = r"^(?!Line protocol)(?P<intf_name>\S+).+current state\W+(?P<intf_state>.+)$" re_unicast = r"Unicast:\s+(\d+)|(\d+)\s+unicast" re_multicast = r"Multicast:\s+(\d+)|(\d+)\s+multicast" re_broadcast = r"Broadcast:\s+(\d+)|(\d+)\s+broadcast" re_dicards = r"Discard:\s+(\d+)|(\d+)\s+discard" re_rx_octets = r"Input.+\s+(\d+)\sbytes|Input:.+,(\d+)\sbytes" re_tx_octets = r"Output.+\s+(\d+)\sbytes|Output:.+,(\d+)\sbytes" re_errors = r"Total Error:\s+(\d+)|(\d+)\s+errors" new_interfaces = self._separate_section(separator, output) for interface in new_interfaces: interface = interface.strip() match_intf = re.search(re_intf_name_state, interface, flags=re.M) if match_intf is None: msg = "Unexpected interface format: {}".format(interface) raise ValueError(msg) intf_name = match_intf.group('intf_name') intf_counter = { 'tx_errors': 0, 'rx_errors': 0, 'tx_discards': 0, 'rx_discards': 0, 'tx_octets': 0, 'rx_octets': 0, 'tx_unicast_packets': 0, 'rx_unicast_packets': 0, 'tx_multicast_packets': 0, 'rx_multicast_packets': 0, 'tx_broadcast_packets': 0, 'rx_broadcast_packets': 0 } match = re.findall(re_errors, interface, flags=re.M) if match: intf_counter['rx_errors'] = process_counts(match[0]) if len(match) == 2: intf_counter['tx_errors'] = process_counts(match[1]) match = re.findall(re_dicards, interface, flags=re.M) if len(match) == 2: intf_counter['rx_discards'] = process_counts(match[0]) intf_counter['tx_discards'] = process_counts(match[1]) match = re.findall(re_unicast, interface, flags=re.M) if len(match) == 2: intf_counter['rx_unicast_packets'] = process_counts(match[0]) intf_counter['tx_unicast_packets'] = process_counts(match[1]) match = re.findall(re_multicast, interface, flags=re.M) if len(match) == 2: intf_counter['rx_multicast_packets'] = process_counts(match[0]) intf_counter['tx_multicast_packets'] = process_counts(match[1]) match = re.findall(re_broadcast, interface, flags=re.M) if len(match) == 2: intf_counter['rx_broadcast_packets'] = process_counts(match[0]) intf_counter['tx_broadcast_packets'] = process_counts(match[1]) match = re.findall(re_rx_octets, interface, flags=re.M) if match: intf_counter['rx_octets'] = process_counts(match[0]) match = re.findall(re_tx_octets, interface, flags=re.M) if match: intf_counter['tx_octets'] = process_counts(match[0]) interfaces.update({intf_name: intf_counter}) return interfaces def get_environment(self): """ Return environment details. Sample output: { "cpu": { "0": { "%usage": 18.0 } }, "fans": { "FAN1": { "status": true } }, "memory": { "available_ram": 3884224, "used_ram": 784552 }, "power": { "PWR1": { "capacity": 600.0, "output": 92.0, "status": true } }, "temperature": { "CPU": { "is_alert": false, "is_critical": false, "temperature": 45.0 } } } """ environment = {} fan_cmd = 'display device fan' power_cmd = 'display device power' temp_cmd = 'display device temperature all' cpu_cmd = 'display cpu' mem_cmd = 'display memory' output = self.device.send_command(fan_cmd) environment.setdefault('fans', {}) match = re.findall(r"(?P<id>FAN\S+).+(?P<status>Normal|Abnormal)", output, re.M) # if match: for fan in match: status = True if fan[1] == "Normal" else False environment['fans'].setdefault(fan[0], {})['status'] = status output = self.device.send_command(power_cmd) environment.setdefault('power', {}) re_power = r"(?P<id>PWR\S+).+(?P<status>Supply|NotSupply|Sleep)\s+\S+\s+\S+\s+" \ r"(?P<output>\d+)\s+(?P<capacity>\d+)" match = re.findall(re_power, output, re.M) for power in match: status = True if power[1] == "Supply" else False environment['power'].setdefault(power[0], {})['status'] = status environment['power'][power[0]]['output'] = float(power[2]) environment['power'][power[0]]['capacity'] = float(power[3]) output = self.device.send_command(temp_cmd) environment.setdefault('temperature', {}) re_temp = r"(?P<name>\S+)\s+(?P<status>NORMAL|MAJOR|FATAL|ABNORMAL)\s+\S+\s+\S+\s+(?P<temperature>\d+)" match = re.findall(re_temp, output, re.M) for temp in match: environment['temperature'].setdefault(temp[0], {}) name = temp[0] is_alert = True if temp[1] == "MAJOR" else False is_critical = True if temp[1] == "FATAL" else False environment['temperature'][name]['temperature'] = float(temp[2]) environment['temperature'][name]['is_alert'] = is_alert environment['temperature'][name]['is_critical'] = is_critical output = self.device.send_command(cpu_cmd) environment.setdefault('cpu', {}) match = re.findall(r"cpu(?P<id>\d+)\s+(?P<usage>\d+)%", output, re.M) for cpu in match: usage = float(cpu[1]) environment['cpu'].setdefault(cpu[0], {})['%usage'] = usage output = self.device.send_command(mem_cmd) environment.setdefault('memory', {'available_ram': 0, 'used_ram': 0}) match = re.search(r"System Total Memory:\s+(?P<available_ram>\d+)", output, re.M) if match is not None: environment['memory']['available_ram'] = int( match.group("available_ram")) match = re.search(r"Total Memory Used:\s+(?P<used_ram>\d+)", output, re.M) if match is not None: environment['memory']['used_ram'] = int(match.group("used_ram")) return environment def get_arp_table(self, vrf=""): """ Get arp table information. Return a list of dictionaries having the following set of keys: * interface (string) * mac (string) * ip (string) * age (float) Sample output: [ { 'interface' : 'MgmtEth0/RSP0/CPU0/0', 'mac' : '5c:5e:ab:da:3c:f0', 'ip' : '172.17.17.1', 'age' : -1 }, { 'interface': 'MgmtEth0/RSP0/CPU0/0', 'mac' : '66:0e:94:96:e0:ff', 'ip' : '172.17.17.2', 'age' : -1 } ] """ if vrf: msg = "VRF support has not been implemented." raise NotImplementedError(msg) arp_table = [] output = self.device.send_command('display arp') re_arp = r"(?P<ip_address>\d+\.\d+\.\d+\.\d+)\s+(?P<mac>\S+)\s+(?P<exp>\d+|)\s+" \ r"(?P<type>I|D|S|O)\s+(?P<interface>\S+)" match = re.findall(re_arp, output, flags=re.M) for arp in match: if arp[2].isdigit(): exp = round(float(arp[2]) * 60, 1) else: exp = -1.0 entry = { 'interface': arp[4], 'mac': napalm.base.helpers.mac(arp[1]), 'ip': arp[0], 'age': exp } arp_table.append(entry) return arp_table def get_config(self, retrieve="all", full=False, sanitized=False): """ Get config from device. Returns the running configuration as dictionary. The candidate and startup are always empty string for now, since CE does not support candidate configuration. """ config = {'startup': '', 'running': '', 'candidate': ''} if retrieve.lower() in ('running', 'all'): command = 'display current-configuration' config['running'] = str(self.device.send_command(command)) if retrieve.lower() in ('startup', 'all'): # command = 'display saved-configuration last' # config['startup'] = str(self.device.send_command(command)) pass return config def get_lldp_neighbors(self): """ Return LLDP neighbors details. Sample output: { "10GE4/0/1": [ { "hostname": "HUAWEI", "port": "10GE4/0/25" }, { "hostname": "HUAWEI2", "port": "10GE4/0/26" } ] } """ results = {} command = 'display lldp neighbor brief' output = self.device.send_command(command) re_lldp = r"(?P<local>\S+)\s+\d+\s+(?P<port>\S+)\s+?(?:$|(?P<hostname>\S+).+?$)" match = re.findall(re_lldp, output, re.M) for neighbor in match: local_iface = neighbor[0] if local_iface not in results: results[local_iface] = [] neighbor_dict = dict() neighbor_dict['port'] = str(neighbor[1]) neighbor_dict['hostname'] = str(neighbor[2]) results[local_iface].append(neighbor_dict) return results def get_mac_address_table(self): """ Return the MAC address table. Sample output: [ { "active": true, "interface": "10GE1/0/1", "last_move": -1.0, "mac": "00:00:00:00:00:33", "moves": -1, "static": false, "vlan": 100 }, { "active": false, "interface": "10GE1/0/2", "last_move": -1.0, "mac": "00:00:00:00:00:01", "moves": -1, "static": true, "vlan": 200 } ] """ mac_address_table = [] command = 'display mac-address' output = self.device.send_command(command) re_mac = r"(?P<mac>\S+)\s+(?P<vlan>\d+|-)\S*\s+(?P<interface>\S+)\s+(?P<type>\w+)\s+(?P<age>\d+|-)" match = re.findall(re_mac, output, re.M) for mac_info in match: mac_dict = { 'mac': napalm.base.helpers.mac(mac_info[0]), 'interface': str(mac_info[2]), 'vlan': int(mac_info[1]), 'static': True if mac_info[3] == "static" else False, 'active': True if mac_info[3] == "dynamic" else False, 'moves': -1, 'last_move': -1.0 } mac_address_table.append(mac_dict) return mac_address_table def get_users(self): """ Return the configuration of the users. Sample output: { "admin": { "level": 3, "password": "", "sshkeys": [] } } """ result = {} command = 'display aaa local-user' output = self.device.send_command(command) re_user = r"(?P<username>\S+)\s+(Active|Block)(\s+\S+){3}\s+(\d+|--)" match = re.findall(re_user, output, re.M) try: for user in match: # level = -1 can not pass unit test level = 0 if user[3] == '--' else int(user[3]) result.setdefault(user[0], {})['level'] = level result[user[0]]['password'] = '' result[user[0]]['sshkeys'] = [] except Exception: msg = "Unexpected output data:\n{}".format(output) raise ValueError(msg) # Password is encrypted and cannot be read # command = 'display current-configuration | inc user' # output = self.device.send_command(command) return result def rollback(self): """Rollback to previous commit.""" if self.changed: self._load_config(self.backup_file) self.changed = False self._save_config() def ping(self, destination, source=c.PING_SOURCE, ttl=c.PING_TTL, timeout=c.PING_TIMEOUT, size=c.PING_SIZE, count=c.PING_COUNT, vrf=c.PING_VRF): """Execute ping on the device.""" ping_dict = {} command = 'ping' # Timeout in milliseconds to wait for each reply, the default is 2000 command += ' -t {}'.format(timeout * 1000) # Specify the number of data bytes to be sent command += ' -s {}'.format(size) # Specify the number of echo requests to be sent command += ' -c {}'.format(count) if source != '': command += ' -a {}'.format(source) command += ' {}'.format(destination) output = self.device.send_command(command) if 'Error' in output: ping_dict['error'] = output elif 'PING' in output: ping_dict['success'] = { 'probes_sent': 0, 'packet_loss': 0, 'rtt_min': 0.0, 'rtt_max': 0.0, 'rtt_avg': 0.0, 'rtt_stddev': 0.0, 'results': [] } match_sent = re.search(r"(\d+).+transmitted", output, re.M) match_received = re.search(r"(\d+).+received", output, re.M) try: probes_sent = int(match_sent.group(1)) probes_received = int(match_received.group(1)) ping_dict['success']['probes_sent'] = probes_sent ping_dict['success'][ 'packet_loss'] = probes_sent - probes_received except Exception: msg = "Unexpected output data:\n{}".format(output) raise ValueError(msg) match = re.search(r"min/avg/max = (\d+)/(\d+)/(\d+)", output, re.M) if match: ping_dict['success'].update({ 'rtt_min': float(match.group(1)), 'rtt_avg': float(match.group(2)), 'rtt_max': float(match.group(3)), }) results_array = [] match = re.findall(r"Reply from.+time=(\d+)", output, re.M) for i in match: results_array.append({ 'ip_address': str(destination), 'rtt': float(i) }) ping_dict['success'].update({'results': results_array}) return ping_dict def __get_snmp_information(self): snmp_information = {} # command = 'display snmp-agent sys-info' # output = self.device.send_command(command) snmp_information = { 'contact': str(''), 'location': str(''), 'community': {}, 'chassis_id': str('') } return snmp_information def __get_lldp_neighbors_detail(self, interface=''): """ Return a detailed view of the LLDP neighbors as a dictionary. Sample output: { 'TenGigE0/0/0/8': [ { 'parent_interface': u'Bundle-Ether8', 'remote_chassis_id': u'8c60.4f69.e96c', 'remote_system_name': u'switch', 'remote_port': u'Eth2/2/1', 'remote_port_description': u'Ethernet2/2/1', 'remote_system_description': u'''huawei os''', 'remote_system_capab': u'B, R', 'remote_system_enable_capab': u'B' } ] } """ lldp_neighbors = {} return lldp_neighbors def __get_ntp_peers(self): """ Return the NTP peers configuration as dictionary. Sample output: { '192.168.0.1': {}, '17.72.148.53': {}, '37.187.56.220': {}, '162.158.20.18': {} } """ ntp_server = {} # command = "display ntp session" # output = self.device.send_command(command) return ntp_server def __get_ntp_servers(self): """ Return the NTP servers configuration as dictionary. Sample output: { '192.168.0.1': {}, '17.72.148.53': {}, '37.187.56.220': {}, '162.158.20.18': {} } """ ntp_server = {} # command = "display ntp trace" # output = self.device.send_command(command) return ntp_server def __get_ntp_stats(self): ntp_stats = [] # command = "display ntp status" # output = self.device.send_command(command) return ntp_stats @staticmethod def _separate_section(separator, content): if content == "": return [] # Break output into per-interface sections interface_lines = re.split(separator, content, flags=re.M) if len(interface_lines) == 1: msg = "Unexpected output data:\n{}".format(interface_lines) raise ValueError(msg) # Get rid of the blank data at the beginning interface_lines.pop(0) # Must be pairs of data (the separator and section corresponding to it) if len(interface_lines) % 2 != 0: msg = "Unexpected output data:\n{}".format(interface_lines) raise ValueError(msg) # Combine the separator and section into one string intf_iter = iter(interface_lines) try: new_interfaces = [line + next(intf_iter, '') for line in intf_iter] except TypeError: raise ValueError() return new_interfaces def _delete_file(self, filename): command = 'delete /unreserved /quiet {0}'.format(filename) self.device.send_command(command) def _save_config(self, filename=''): """Save the current running config to the given file.""" command = 'save {}'.format(filename) save_log = self.device.send_command(command, max_loops=10, expect_string=r'Y/N') # Search pattern will not be detected when set a new hostname, so don't use auto_find_prompt=False save_log += self.device.send_command('y', expect_string=r'<.+>') search_result = re.search("successfully", save_log, re.M) if search_result is None: msg = "Failed to save config. Command output:{}".format(save_log) raise CommandErrorException(msg) def _load_config(self, config_file): command = 'rollback configuration to file {0}'.format(config_file) rollback_result = self.device.send_command(command, expect_string=r'Y/N') rollback_result += self.device.send_command( 'y', expect_string=r'[<\[].+[>\]]') search_result = re.search("clear the information", rollback_result, re.M) if search_result is not None: rollback_result += self.device.send_command('y', expect_string=r'<.+>') search_result = re.search("succeeded|finished", rollback_result, re.M) if search_result is None: msg = "Failed to load config. Command output:{}".format( rollback_result) raise CommandErrorException(msg) def _replace_candidate(self, filename, config): if not filename: filename = self._create_tmp_file(config) else: if not os.path.isfile(filename): raise ReplaceConfigException( "File {} not found".format(filename)) self.replace_file = filename if not self._enough_space(self.replace_file): msg = 'Could not transfer file. Not enough space on device.' raise ReplaceConfigException(msg) need_transfer = True if self._check_file_exists(self.replace_file): if self._check_md5(self.replace_file): need_transfer = False if need_transfer: dest = os.path.basename(self.replace_file) # full_remote_path = 'flash:/{}'.format(dest) with paramiko.SSHClient() as ssh: ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect(hostname=self.hostname, username=self.username, password=self.password, port=self.port, look_for_keys=False) try: with paramiko.SFTPClient.from_transport( ssh.get_transport()) as sftp_client: sftp_client.put(self.replace_file, dest) # with SCPClient(ssh.get_transport()) as scp_client: # scp_client.put(self.replace_file, dest) except Exception as e: msg = 'Could not transfer file. There was an error during transfer:' + str( e) raise ReplaceConfigException(msg) self.config_replace = True if config and os.path.isfile(self.replace_file): os.remove(self.replace_file) def _verify_remote_file_exists(self, dst, file_system='flash:'): command = 'dir {0}/{1}'.format(file_system, dst) output = self.device.send_command(command) if 'No file found' in output: raise ReplaceConfigException('Could not transfer file.') def _check_file_exists(self, cfg_file): command = 'dir {}'.format(cfg_file) output = self.device.send_command(command) if 'No file found' in output: return False return True def _check_md5(self, dst): dst_hash = self._get_remote_md5(dst) src_hash = self._get_local_md5(dst) if src_hash == dst_hash: return True return False @staticmethod def _get_local_md5(dst, blocksize=2**20): md5 = hashlib.md5() local_file = open(dst, 'rb') buf = local_file.read(blocksize) while buf: md5.update(buf) buf = local_file.read(blocksize) local_file.close() return md5.hexdigest() def _get_remote_md5(self, dst): command = 'display system file-md5 {0}'.format(dst) output = self.device.send_command(command) filename = os.path.basename(dst) match = re.search(filename + r'\s+(?P<md5>\w+)', output, re.M) if match is None: msg = "Unexpected format: {}".format(output) raise ValueError(msg) return match.group('md5') def _commit_merge(self): commands = [ command for command in self.merge_candidate.splitlines() if command ] output = '' try: output += self.device.send_command('system-view', expect_string=r'\[.+\]') for command in commands: output += self.device.send_command(command, expect_string=r'\[.+\]') if self.device.check_config_mode(): check_error = re.search("error", output, re.IGNORECASE) if check_error is not None: return_log = self.device.send_command( 'return', expect_string=r'[<\[].+[>\]]') if 'Uncommitted configurations' in return_log: # Discard uncommitted configuration return_log += self.device.send_command( 'n', expect_string=r'<.+>') output += return_log raise MergeConfigException('Error while applying config!') output += self.device.send_command('commit', expect_string=r'\[.+\]') output += self.device.send_command('return', expect_string=r'<.+>') else: raise MergeConfigException('Not in configuration mode.') except Exception as e: msg = str(e) + '\nconfiguration output: ' + output raise MergeConfigException(msg) def _get_merge_diff(self): diff = [] running_config = self.get_config(retrieve='running')['running'] running_lines = running_config.splitlines() for line in self.merge_candidate.splitlines(): if line not in running_lines and line: if line[0].strip() != '!': diff.append(line) return '\n'.join(diff) def _get_diff(self, filename=None): """Get a diff between running config and a proposed file.""" if filename is None: return self.device.send_command('display configuration changes') return self.device.send_command( 'display configuration changes running file ' + filename) def _enough_space(self, filename): flash_size = self._get_flash_size() file_size = os.path.getsize(filename) if file_size > flash_size: return False return True def _get_flash_size(self): command = 'dir {}'.format('flash:') output = self.device.send_command(command) match = re.search(r'\(\d.*KB free\)', output, re.M) if match is None: msg = "Failed to get free space of flash (not match). Log: {}".format( output) raise ValueError(msg) kbytes_free = 0 num_list = map(int, re.findall(r'\d+', match.group())) for index, val in enumerate(reversed(num_list)): kbytes_free += val * (1000**index) bytes_free = kbytes_free * 1024 return bytes_free @staticmethod def _parse_uptime(uptime_str): """Return the uptime in seconds as an integer.""" (years, weeks, days, hours, minutes, seconds) = (0, 0, 0, 0, 0, 0) years_regx = re.search(r"(?P<year>\d+)\syear", uptime_str) if years_regx is not None: years = int(years_regx.group(1)) weeks_regx = re.search(r"(?P<week>\d+)\sweek", uptime_str) if weeks_regx is not None: weeks = int(weeks_regx.group(1)) days_regx = re.search(r"(?P<day>\d+)\sday", uptime_str) if days_regx is not None: days = int(days_regx.group(1)) hours_regx = re.search(r"(?P<hour>\d+)\shour", uptime_str) if hours_regx is not None: hours = int(hours_regx.group(1)) minutes_regx = re.search(r"(?P<minute>\d+)\sminute", uptime_str) if minutes_regx is not None: minutes = int(minutes_regx.group(1)) seconds_regx = re.search(r"(?P<second>\d+)\ssecond", uptime_str) if seconds_regx is not None: seconds = int(seconds_regx.group(1)) uptime_sec = (years * YEAR_SECONDS) + (weeks * WEEK_SECONDS) + (days * DAY_SECONDS) + \ (hours * 3600) + (minutes * 60) + seconds return uptime_sec @staticmethod def _create_tmp_file(config): tmp_dir = tempfile.gettempdir() rand_fname = str(uuid.uuid4()) filename = os.path.join(tmp_dir, rand_fname) with open(filename, 'wt') as fobj: fobj.write(config) return filename
# "secret": password, # "device_type": "cisco_ios", # "session_log": "my_output.txt", # } # Execute the following sequence of events using Netmiko: # Execute the config_mode() method and print the new prompt using find_prompt() from netmiko import ConnectHandler from getpass import getpass from datetime import datetime password = getpass() device = { "host": "cisco4.lasthop.io", "username": "******", "password": password, "secret": password, "device_type": "cisco_ios", "session_log": "my_output.txt", } net_connect = ConnectHandler(**device) print("\nEnter Config mode") net_connect.config_mode() print("\n>>>>>>>") print("Checking if it's in config mode") print("Config mode check: {}".format(net_connect.check_config_mode())) print("Current Prompt: {}".format(net_connect.find_prompt())) print() net_connect.disconnect()
'device_type': 'juniper', 'ip': '50.76.53.27', 'username': '******', 'password': '******', 'port': 9822 } rtr2 = ConnectHandler(**pynetrtr2) # passes in dictionary key values into the function output = rtr2.find_prompt() print output output = rtr2.send_command('show run | in logging') print output output = rtr2.config_mode() print output output = rtr2.check_config_mode() print output output = rtr2.send_command('logging buffered 32769') print output output = rtr2.send_command('end') print output output = rtr2.send_command('show run | in logging') print output
def run(self): if self.device['device_type'] == 'cisco_ios_serial': try: console = ConnectHandler( **self.device ) # Connect to the Device to verify credentials. config_mode = console.check_config_mode() if config_mode is True: console.exit_config_mode() self.signal.emit('Router was in config mode try again.') return console.enable() # Enter Enable Mode show_ver = console.send_command('show run | inc version 1') self.signal.emit(show_ver) version = self.get_version_cisco(show_ver) if version >= 15.4: pass else: show_flash = console.send_command('dir flash: | i .bin') self.signal.emit('----ERROR----\n' ' Old version of IOS Detected\n' ' Correct version may be in flash:') self.signal.emit(show_flash) self.signal.emit( '\n>========== Reminder ==========<\n' 'Ensure the config you plan to load is compatible\n' ' with the version of IOS you are using.\n ' 'If not contact the help desk.\n' '>========== Reminder ==========<\n') console.disconnect( ) # disconnect so it can be modified later on the LoadTab self.signal.emit( 'Credentials Verified on Console!') # Congrats you made it except ValueError: # most likely com port fault. self.signal.emit( '...COM Port does not appear to be working. \nTry one of these:' ) ports = list(serial.tools.list_ports.comports() ) # You used the wrong one here let me help you. for p in ports: # may just automate this in the future using this method if only one port is found self.signal.emit(p[0]) return except NetMikoAuthenticationException: # Exactly what it says in the error. self.signal.emit( "Check your username/password. Make sure you have an account on this device." ) return elif self.device['device_type'] == 'cisco_ios_telnet': try: telnet = ConnectHandler( **self.device ) # Connect to the Device to verify credentials. telnet.enable() # Enter Enable Mode if telnet == True: telnet.send_command('exit') show_ver = telnet.send_command('show run | inc version 1') self.signal.emit(show_ver) version = self.get_version_cisco(show_ver) if version >= 15.4: pass else: show_flash = telnet.send_command('dir flash: | i .bin') self.signal.emit('----ERROR----\n' ' Old version of IOS Detected\n' ' Correct version may be in flash:') self.signal.emit(show_flash) self.signal.emit( '\n>========== Reminder ==========<\n' 'Ensure the config you plan to load is compatible\n' ' with the version of IOS you are using.\n ' 'If not contact the help desk.\n' '>========== Reminder ==========<\n') telnet.disconnect() self.signal.emit('Credentials Verified on Telnet!') except TimeoutError: # Exactly what it says in the error. self.signal.emit( "Telnet Error: Make sure the IP address is correct.") return except NetMikoAuthenticationException: # Exactly what it says in the error. self.signal.emit( "Check your username/password. Make sure you have an account on this device." ) return elif self.device['device_type'] == 'cisco_ios': try: ssh = ConnectHandler( **self.device ) # Connect to the Device to verify credentials. ssh.enable() # Enter Enable Mode if ssh == True: ssh.send_command('exit') show_ver = ssh.send_command('show run | inc version 1') self.signal.emit(show_ver) version = self.get_version_cisco(show_ver) if version >= 15.4: pass else: show_flash = ssh.send_command('dir flash: | i .bin') self.signal.emit('----ERROR----\n' ' Old version of IOS Detected\n' ' Correct version may be in flash:') self.signal.emit(show_flash) self.signal.emit( '\n>========== Reminder ==========<\n' 'Ensure the config you plan to load is compatible\n' ' with the version of IOS you are using.\n ' 'If not contact the help desk.\n' '>========== Reminder ==========<\n') ssh.disconnect() self.signal.emit('Credentials Verified on SSH!') except NetMikoTimeoutException: # Exactly what it says in the error. self.signal.emit( "SSH Error: Make sure the IP address is correct.") return except NetMikoAuthenticationException: # Exactly what it says in the error. self.signal.emit( "Check your username/password. Make sure you have an account on this device." ) return else: return
import pexpect import time import netmiko from netmiko import ConnectHandler password = '******' pynet1 = { 'device_type': 'cisco_ios', 'ip': '50.76.53.27', 'username': '******', 'password': password, } pynet2 = { 'device_type': 'cisco_ios', 'ip': '50.76.53.27', 'username': '******', 'password': password, 'port': 8022, } rc = ConnectHandler(**pynet2) rc.config_mode() output = rc.find_prompt() print output output = rc.check_config_mode() print output
'device_type': 'cisco_ios', 'ip': '192.168.32.200', 'username': '******', 'password': '******', 'port': 22, 'secret': 'cisco123', # no username admin pri 15 // # enable secret cisco123 'verbose': True, } # connection123 = object, ** = dictionary used to call function connection123 = ConnectHandler(**cisco_device) prompt = connection123.find_prompt() print(prompt) if '>' in prompt: connection123.enable() # mode = connection123.check_enable_mode() # print(mode) output = connection123.send_command('show ip int br') print(output) mode = connection123.check_config_mode() # print(mode) if not mode: connection123.config_mode() # mode = connection123.check_config_mode() # print(mode) output = connection123.send_command('username joy password python123') output = connection123.send_command('do show run | i user') print(output)
def main(): net_connect = ConnectHandler(**pynet.rtr1) print "Entering config mode..." print net_connect.config_mode() print "In config mode: " + str(net_connect.check_config_mode()) print "Current Prompt: " + net_connect.find_prompt()
'username': '******', 'password': '******', # optional, defaults to 22 'secret': 'cpe', # optional, defaults to '' } connection = ConnectHandler(**cisco_device) # Enter enable() mode connection.enable() if connection.check_enable_mode(): # Enter config mode connection.config_mode() # Check if in config mode if connection.check_config_mode(): # config command = [ "hostname C-SW-5", "int g1/0/24", "no sw", "ip address 172.58.10.6 255.255.255.252", "exit", "ip routing", "ip route 100.254.10.4 255.255.255.252 172.58.10.5", "ip route 100.254.10.0 255.255.255.252 172.58.10.5", "ip route 172.58.10.0 255.255.255.252 172.58.10.5" ] connection.send_config_set(config_commands=command) # Verify # Show hostname prompt = connection.find_prompt() print("#Verify hostname\n") print(prompt)
from netmiko import ConnectHandler pynet1 = { 'device_type': 'cisco_ios', 'ip': '184.105.247.70', 'username': '******', 'password': '******', } pynet2 = { 'device_type': 'cisco_ios', 'ip': '184.105.247.71', 'username': '******', 'password': '******', } juniper_srx = { 'device_type': 'juniper', 'ip': '184.105.247.76', 'username': '******', 'password': '******', 'secret': '' } sess1=ConnectHandler(**pynet2) sess1.config_mode() print "CONFIG MODE %s" %sess1.check_config_mode() sess1.send_config_set(['logging buffer 10000']) print sess1.send_command("sho run | i logging")
def ConfigurationTest(ip, Device_Type_Num=0, User_Pass_Num=0, Passowrd_Enable_Num=0): # def ConfigurationTest(ip,Device_Type_Num= 0,User_Pass_Num= 0): if ConfigurationTest_Boolen == 1: return ConfigurationTest_Boolen == 1 # If increment of Num is out of range for User_Pass_Num and Device_Type_Num return 1 elif User_Pass_Num >= len(Username_Device): print(f"Username Not in Range For IP\t{ip}\n") return ConfigurationTest_Boolen == 1 elif Device_Type_Num >= len(Device_Type): print(f"Connection type Not in Range For IP\t{ip}\n") return ConfigurationTest_Boolen == 1 elif Passowrd_Enable_Num >= len(Passowrd_Device_Enable): print(f"Enable Pass Not in Range For IP\t{ip}\n") return ConfigurationTest_Boolen == 1 # If increment of Num is in range for User_Pass_Num and Device_Type_Num contune else: iosv_l2 = { 'device_type': str(Device_Type[Device_Type_Num] ), ##### Type of connection SSH/Telnet 'ip': str(ip), 'username': Username_Device[User_Pass_Num], 'password': Passowrd_Device[User_Pass_Num], # 'global_delay_factor': 10, # 'secret':'cs' 'secret': Passowrd_Device_Enable[Passowrd_Enable_Num], # 'timeout':5 # 'session_timeout':5 } try: # time.sleep(3) Conf_Variables = [ ] # To check if any faliure on the configuration after sending it net_connect = ConnectHandler(**iosv_l2) # print(net_connect.find_prompt()) ############ function to check output to send any confirmation message as pass or confirmation of yes or no def SpecialConfirmation(command, message, reply): net_connect.config_mode() #To enter config mode print("SpecialConfirmation Config") try: if Device_Type[Device_Type_Num] == "cisco_ios_telnet": print("First Write Telnet") net_connect.remote_conn.write(str(command) + '\n') else: net_connect.remote_conn.sendall(str(command) + '\n') except: print("Exception For Sendall ") print("SpecialConfirmation Before Sleep") time.sleep(3) print("SpecialConfirmation after Sleep") if Device_Type[Device_Type_Num] == "cisco_ios_telnet": print("First READ Telnet") output = net_connect.remote_conn.read_very_eager().decode( "utf-8", "ignore") else: output = net_connect.remote_conn.recv(65535).decode( 'utf-8') ReplyAppend = '' print("SpecialConfirmation output") print(output) try: if str(message) in output: for i in range(0, (len(reply))): ReplyAppend += str(reply[i]) + '\n' if Device_Type[Device_Type_Num] == "cisco_ios_telnet": print("SECOND Telnet") net_connect.remote_conn.write(ReplyAppend) output = net_connect.remote_conn.read_very_eager( ).decode("utf-8", "ignore") else: net_connect.remote_conn.sendall(ReplyAppend) output = net_connect.remote_conn.recv( 65535).decode('utf-8') print(output) except: print("Confirmation Exception Error") return output print("Entered Device Successfully \t" + ip + "\n") ###################################################################### ################ Here Is The Cisco Configuration #################### ###################################################################### print("check enable mode for " + str(ip)) if not net_connect.check_enable_mode(): net_connect.enable() print("entered enable mode for " + str(ip)) ################################################################## ########### Check if in config mode or not to exit config mode ################################################################## if net_connect.check_config_mode(): net_connect.exit_config_mode() print("After exiting config " + str(ip)) print("After checking config " + str(ip)) ###################################################################### print("Terminal length \n") Configuration_Output = net_connect.send_command_timing( "termin len 0" + '\n\n') Configuration_Output = net_connect.send_command_timing( "show run " + '\n\n', strip_prompt=False, strip_command=False) Configuration_Output += net_connect.send_command_timing( "show ip inte br " + '\n\n', strip_prompt=False, strip_command=False) # Configuration_Switch=net_connect.send_command_timing("show fex "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show cdp neighbors detail "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Switch+=net_connect.send_command_timing("show interfaces status "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show inter desc "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Router=net_connect.send_command_timing("show ip ospf neighbor "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show version "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show cdp neighbors "+'\n\n' ,strip_prompt=False,strip_command=False) ################### for ARP ############################################################### ###################################################################### # Configuration_Output_ID2=net_connect.send_command_timing("show ip arp vrf ID2 "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Output_ID254=net_connect.send_command_timing("show ip arp vrf ID254 "+'\n\n' ,strip_prompt=False,strip_command=False) ###################################################################### # Configuration_Output=net_connect.send_command_timing("termin len 0"+'\n\n',delay_factor=5) # Configuration_Output=net_connect.send_command_timing("show run "+'\n\n' ,delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show ip inte br "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Switch=net_connect.send_command_timing("show fex "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show cdp neighbors detail "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Switch+=net_connect.send_command_timing("show interfaces status "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show inter desc "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Router=net_connect.send_command_timing("show ip ospf neighbor "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show version "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show cdp neighbors "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) # Hostname_Output=net_connect.send_command("show run | i hostname"+'\n\n') # Configuration_Output+=net_connect.send_command_timing("show ip inte br "+'\n\n',strip_prompt=False,strip_command=False) print(f"This is after getting SHOW for IP\t{ip}") Hostname_Output = net_connect.send_command( "show run | i hostname" + '\n\n', delay_factor=5) ########################################################################################################### ################## Add new IPs from CDP Command ################################################## ########################################################################################################### CDP_ALL = net_connect.send_command_timing( "show cdp neighbors detail | i IP address: " + '\n\n') # print("CDP_ALL\n") # print(CDP_ALL) # print(type(CDP_ALL)) # change output to list of lines CDP_Lines_List = CDP_ALL.splitlines( ) # change output to list of lines CDP_IPs_List = [] # change list of line to list of IPs wihtout IP address sentence for i in CDP_Lines_List: j = i.lstrip("IP address: ") CDP_IPs_List.append(j) # print("CDP_IPs_List for "+str(ip)) # print(CDP_IPs_List) # check on each ip if it's in the mangement range or not and append it to new list if it's not exsit in the IPs list for i in CDP_IPs_List: if "192" in i: # check on the IP to add it to the list if i not in num: num_New.append(i) # num.append(i) # CDP_IPs_List.remove(i) ########################################################################################################### ########################################################################################################### # if ip =="192.168.233.13": # print (str (SpecialConfirmation("crypto key generate rsa general-keys" ,"modulus" ,"1024"))) if net_connect.check_config_mode(): net_connect.exit_config_mode() print("After second check config " + str(ip)) # for k in TestPingIPs : # ping_result=net_connect.send_command_timing("ping "+k) # print (str(k)+" is "+str(ping_is_successful(ping_result))+" from "+str(ip)) ################################################################################ ####################### Test Ping For Rang Of IP ############################## ################################################################################ # for IpPing in TestPingIPs : # PingPool="ping "+IpPing # TestPingResult=net_connect.send_command_timing(PingPool+'\n\n') # if ping_is_successful(TestPingResult) : # TruePing.append(IpPing) # else : # FalsePing.append(IpPing) Spilt_Hostname_Ouput = Hostname_Output.split() Hostname_Output = ip + ".__" + Spilt_Hostname_Ouput[-1] # print ("After Split") ############### Append Configuration Variables to Global Variable ########## Conf_Variables.append(Hostname_Output) Conf_Variables.append(Configuration_Output) ############### Search in Configuration if any command error and return its IP ################ for y in Conf_Variables: if "% Invalid input detected at '^' marker." in y: FailedIps.append(ip + " Invalid input") ######################################################################################################### # Configuration_Output+=Configuration_Switch # Configuration_Output+=Configuration_Router Hostname_Output_list.append(Hostname_Output) test = Configuration_Switch test += Configuration_Output test += Configuration_Router Configuration_Output_list.append(test) Configuration_Output_ID2_list.append(Configuration_Output_ID2) Configuration_Output_ID254_list.append(Configuration_Output_ID254) ############### SAVE Output IN FILES ####################### Global_Output.append(Hostname_Output) net_connect.disconnect() ################### Exception ################################### except socket_error as socket_err: ################ Print error from msg from the main Lib print(f"Socket Error: \n{socket_err}\t for IP {ip}\n") print("Continue") if '111' in f"Type {socket_err}": Device_Type_Num += 1 if Device_Type_Num >= len(Device_Type): FailedIps.append(ip + " Socket or connection type Error") return ConfigurationTest(ip, Device_Type_Num, User_Pass_Num, Passowrd_Enable_Num) if '113' in f"Type {socket_err}": FailedIps.append(ip + " No route to the host") return ConfigurationTest_Boolen == 1 return ConfigurationTest_Boolen == 1 except paramiko.ssh_exception.BadHostKeyException as badHostKeyException: ################ Print error from msg from the main Lib print( f"Unable to verify server's host key: \n{badHostKeyException}\n" ) except paramiko.ssh_exception.NoValidConnectionsError as noValidConnectionsError: ################ Print error from msg from the main Lib print(f"no Valid Connections Error: \n{noValidConnectionsError}\n") except (NetMikoAuthenticationException ) as netmikoAuthenticationException: # print ('Authentication Failure\t' + ip) print( str(User_Pass_Num) + " " + str(Username_Device[User_Pass_Num]) + " failed Authentication\t" + ip) ################ Print error from msg from the main Lib print( f"netmikoAuthenticationException : {netmikoAuthenticationException}\n" ) User_Pass_Num += 1 # If it tried all users and pass and failed add it to failedIps if User_Pass_Num >= len(Username_Device): FailedIps.append(ip + " Authentication Error ") # if User_Pass_Num < len(Username_Device) : # print("this is Authentication "+str(ip)+" Device_Type "+str(Device_Type[Device_Type_Num])+" Username_Device " +str(Username_Device[User_Pass_Num])+" Passowrd_Device " +str(Passowrd_Device[User_Pass_Num])) # Recursive function return ConfigurationTest(ip, Device_Type_Num, User_Pass_Num, Passowrd_Enable_Num) except (NetMikoTimeoutException) as netmikoTimeoutException: # print ('Timeout Failure\t' + ip) print(str(Device_Type_Num) + "\tTimeoutException\t" + ip) ################ Print error from msg from the main Lib print(f"netmikoTimeoutException : \n{netmikoTimeoutException}\n") Device_Type_Num += 1 if Device_Type_Num >= len(Device_Type): FailedIps.append(ip + " Timeout Error") # if Device_Type_Num < len(Device_Type) : # print("this is Timeout "+str(ip)+" Device_Type "+str(Device_Type[Device_Type_Num])+" Username_Device " +str(Username_Device[User_Pass_Num])+" Passowrd_Device " +str(Passowrd_Device[User_Pass_Num])) return ConfigurationTest(ip, Device_Type_Num, User_Pass_Num, Passowrd_Enable_Num) except (paramiko.ssh_exception.SSHException) as sshException: # print ('SSH Failure\t' + ip) print(str(Device_Type_Num) + "\tSSHException\t" + ip + "\n") ################ Print error from msg from the main Lib print( f"Unable to establish SSH connection: \n{sshException}\t for IP {ip}\n" ) Device_Type_Num += 1 if Device_Type_Num >= len(Device_Type): FailedIps.append(ip + " SSHException Error ") # if Device_Type_Num < len(Device_Type) : # print("this is SSHException "+str(ip)+" Device_Type "+str(Device_Type[Device_Type_Num])+" Username_Device " +str(Username_Device[User_Pass_Num])+" Passowrd_Device " +str(Passowrd_Device[User_Pass_Num])) return ConfigurationTest(ip, Device_Type_Num, User_Pass_Num, Passowrd_Enable_Num) except (ValueError): print( str(Passowrd_Enable_Num) + " " + str(Passowrd_Device_Enable[Passowrd_Enable_Num]) + " Failed Enable Authentication\t" + ip) Passowrd_Enable_Num += 1 if Passowrd_Enable_Num >= len(Passowrd_Device_Enable): FailedIps.append(ip + " Enable Authentication Error ") return ConfigurationTest(ip, Device_Type_Num, User_Pass_Num, Passowrd_Enable_Num) except (EOFError) as eof_Error: ################ Print error from msg from the main Lib print(f"eof_Error : \n{eof_Error}\n") # print ('End of File wihle attempting device\t' +ip) FailedIps.append(ip + " EOFError") # print("this is EOFError "+str(ip)+" Device_Type "+str(Device_Type[Device_Type_Num])+" Username_Device " +str(Username_Device[User_Pass_Num])+" Passowrd_Device " +str(Passowrd_Device[User_Pass_Num])) return ConfigurationTest_Boolen == 1 #################################################################### ########## if you want to show error , comment next lines if you want to show which Ips have error remove comment ############## #################################################################### except Exception as e: # print ('End of File wihle attempting device\t' +ip) FailedIps.append(ip + " Exception as e") # print("this is EOFError "+str(ip)+" Device_Type "+str(Device_Type[Device_Type_Num])+" Username_Device " +str(Username_Device[User_Pass_Num])+" Passowrd_Device " +str(Passowrd_Device[User_Pass_Num])) return ConfigurationTest_Boolen == 1 #################################################################### return ConfigurationTest_Boolen == 1
from getpass import getpass import time Pass = getpass() Pynet2 = { 'device_type': 'cisco_ios', 'ip': '184.105.247.71', 'username': '******', 'password': Pass, 'port': 22, } Pynet2Connect = ConnectHandler(**Pynet2) print "Logging in..." time.sleep(1) Pynet2Prompt = Pynet2Connect.find_prompt() print "\n", Pynet2Prompt, "\n\n" print "Entering configuration mode..." time.sleep(2) Pynet2Config = Pynet2Connect.config_mode() print "\n", Pynet2Config, "\n\n" print "Checking if the router is in configuration mode..." time.sleep(1) print Pynet2Connect.check_config_mode()
# Use Netmiko to enter into configuration mode on pynet-rtr2. Also use Netmiko to verify your state (i.e. that you are currently in configuration mode). from netmiko import ConnectHandler from getpass import getpass rtr2 = { 'device_type':'cisco_ios','ip':'184.105.247.71','username':'******', 'password':'******'} pynet_rtr2 = ConnectHandler(**rtr2) pynet_rtr2.config_mode() print ('Are we in config mode for pynet_rtr2?') print (pynet_rtr2.check_config_mode())
password = getpass() pynet2 = { 'device_type': 'cisco_ios', 'ip': '50.76.53.27', 'username': '******', 'password': password, 'port': 8022, } # Connect to Cisco Router 2 pynet_rtr2 = ConnectHandler(**pynet2) # Enter Config mode pynet_rtr2.config_mode() if (pynet_rtr2.check_config_mode()): outp = pynet_rtr2.send_command('logging buffered 25000') # Exit Config mode pynet_rtr2.exit_config_mode() # Obtain the running Config outp = pynet_rtr2.send_command('show runn | inc logging buffered 25000') if re.search(r'logging buffered 25000', outp): print "Config changed successfully!" else: print "Config changed unsuccessfully!" else: print "Failed to enter Config mode!"
rtr1_conn = ConnectHandler(**rtr1) rtr2_conn = ConnectHandler(**rtr2) juniper_srx_conn = ConnectHandler(**juniper_srx) print rtr1_conn.find_prompt() print rtr2_conn.find_prompt() print juniper_srx_conn.find_prompt() rtr2_conn.config_mode() print "On rtr1 are we in config mode?" print rtr1_conn.check_config_mode() print "On rtr2 are we in config mode?" print rtr2_conn.check_config_mode() print "On juniper_srx are we in config mode?" print juniper_srx_conn.check_config_mode() rtr2_conn.exit_config_mode() show_commands = ['show arp'] output = rtr1_conn.send_command(show_commands[0]) print output output = rtr2_conn.send_command(show_commands[0])
routers = [router1, router2, router3] for router in routers: #VMs are running a little hot, give them some time. time.sleep(5) #Print the dictionary used to establish the connection print(router) rtr = ConnectHandler(**router) #Print the established connection print(rtr) #Enter enable mode if one exists rtr.enable() #Send the command show version and print the output output = rtr.send_command('show version') print(output) #Send the command show version and print the output output = rtr.send_command('show arp') print(output) #show the current prompt print(rtr.find_prompt()) #Enter config mode rtr.config_mode() #show the current prompt print(rtr.find_prompt()) #Check if or if not in config mode print(rtr.check_config_mode())
'cisco_ios', #device type from https://github.com/ktbyers/netmiko/blob/master/netmiko/ssh_dispatcher.py 'host': '10.0.0.1', 'username': '******', 'password': '******', 'port': 22, # optional, default 22 'secret': 'cisco', # this is the enable password 'verbose': True # optional, default False } # connecting to the device and returning an ssh connection object connection = ConnectHandler(**cisco_device) # sending a command and getting the output #prompt = connection.find_prompt() #if '>' in prompt: # connection.enable() output = connection.send_command('sh run') print(output) if not connection.check_config_mode(): connection.config_mode() #print(connection.check_config_mode()) #connection.send_command('username u1 secret cisco') connection.exit_config_mode() print(connection.check_config_mode()) # closing the connection print('Closing connection') connection.disconnect()
pynet_rtr2 = ConnectHandler(**pynet2) #Print the prompts from both routers prompt1 = pynet_rtr1.find_prompt() prompt2 = pynet_rtr2.find_prompt() print prompt1 print prompt2 #Get into config mode response1 = pynet_rtr1.config_mode() response2 = pynet_rtr2.config_mode() print response1 print response2 #Double check config mode response1 = pynet_rtr1.check_config_mode() response2 = pynet_rtr2.check_config_mode() print response1 print response2 #Exit config mode response1 = pynet_rtr1.exit_config_mode() response2 = pynet_rtr2.exit_config_mode() print response1 print response2 #Send the command 'show ip int br' and print the output response1 = pynet_rtr1.send_command('show ip int brief') response2 = pynet_rtr2.send_command('show ip int brief') print response1 print response2
class NetmikoSSH(object): """Contains methods for managing and using SSH connections for Network Devices using Netmiko""" __MAX_RECV_BUF = 10 * 1024 * 1024 __existing_connections = {} def __init__(self): self._session = None self._node = None self._device = {} @staticmethod def _node_hash(node, port): """Get IP address and port hash from node dictionary. :param node: Node in topology. :param port: :type node: dict :return: IP address and port for the specified node. :rtype: int """ return hash(frozenset([node['mgmt_ip'], port])) @staticmethod def _get_device_type(node): device_os = node['os'] if str(device_os) in os_netmiko_map.keys(): return os_netmiko_map[str(device_os)] return None def net_connect(self, node): """Connect to node using Netmiko's inbuilt libraries. :param node: The node to disconnect from. :type node: dict """ self._node = node ssh_port = Topology.get_ssh_port_from_node(node) node_hash = NetmikoSSH._node_hash(node, ssh_port) if node_hash in NetmikoSSH.__existing_connections: self._session = NetmikoSSH.__existing_connections[node_hash] logger.debug('reusing ssh: {0}'.format(self._session)) else: start = time() self._device = { 'device_type': NetmikoSSH._get_device_type(node), 'ip': node['mgmt_ip'], 'username': node['username'], 'password': node['password'], 'port': ssh_port } self._session = ConnectHandler(**self._device) NetmikoSSH.__existing_connections[node_hash] = self._session logger.trace('connect took {} seconds'.format(time() - start)) logger.debug('new connection: {0}'.format(self._session)) logger.debug('Connections: {0}'.format( str(NetmikoSSH.__existing_connections))) def net_disconnect(self, node): """Close SSH connection to the node. :param node: The node to disconnect from. :type node: dict """ ssh_port = Topology.get_ssh_port_from_node(node) node_hash = NetmikoSSH._node_hash(node, ssh_port) if node_hash in NetmikoSSH.__existing_connections: logger.debug('Disconnecting peer: {}, {}'.format( node['name'], ssh_port)) ssh = NetmikoSSH.__existing_connections.pop(node_hash) self._session.disconnect() def _reconnect(self): """Close the SSH connection and open it again.""" node = self._node self.net_disconnect(node) self.net_connect(node) def config_mode(self): """Enter into config mode """ self.net_connect(self._node) self._session.config_mode() def check_config_mode(self): """ Check if session is currently in config mode""" self.net_connect(self._node) return self._session.check_config_mode() def exit_config_mode(self): """Exit config mode""" self.net_connect(self._node) self._session.exit_config_mode() def clear_buffer(self): """ Clear logging buffer """ self.net_connect(self._node) self._session.clear_buffer() def enable(self): """ Enter Enable Mode""" self.net_connect(self._node) self._session.enable() def exit_enable_mode(self): """ Exit enable mode """ self.net_connect(self._node) self._session.exit_enable_mode() def find_prompt(self): """Return the current router prompt""" self.net_connect(self._node) self._session.find_prompt() def send_command(self, cmd): """Send command down the SSH channel and return output back :param cmd :type cmd: str """ if cmd is None: raise TypeError('Command parameter is None') if len(cmd) == 0: raise ValueError('Empty command parameter') self.net_connect(self._node) return self._session.send_command(cmd) def send_config_set(self, config_cmds): """Send a set of configuration commands to remote device :param config_cmds :type config_cmds: str """ if config_cmds is None: raise TypeError('Config Cmds parameter is None') self.net_connect(self._node) print "Netmiko NODE !!!\n\n" print self._node return self._session.send_config_set(config_cmds) def send_config_from_file(self, cfg_file): """Send a set of configuration commands loaded from a file :param cfg_file :type cfg_file: file """ if not os.path.isfile(cfg_file): raise TypeError('Config file does not exist') self.net_connect(self._node) self._session.send_config_from_file(cfg_file)
def main(): try: hostname = raw_input("Enter remote host to test: ") username = raw_input("Enter remote username: "******"Enter remote host to test: ") username = input("Enter remote username: "******"***** Testing enable mode *****") net_connect.enable() if net_connect.check_enable_mode(): print("Success: in enable mode") else: print("Fail...") print(net_connect.find_prompt()) net_connect.exit_enable_mode() print("Out of enable mode") print(net_connect.find_prompt()) # Test config mode print() print("***** Testing config mode *****") net_connect.config_mode() if net_connect.check_config_mode(): print("Success: in config mode") else: print("Fail...") print(net_connect.find_prompt()) net_connect.exit_config_mode() print("Out of config mode") print(net_connect.find_prompt()) # Test config mode (when already at root prompt) print() print("***** Testing config mode when already root *****") net_connect.enable() if net_connect.check_enable_mode(): print("Success: in enable mode") else: print("Fail...") print(net_connect.find_prompt()) print("Test config_mode while already at root prompt") net_connect.config_mode() if net_connect.check_config_mode(): print("Success: still at root prompt") else: print("Fail...") net_connect.exit_config_mode() # Should do nothing net_connect.exit_enable_mode() print("Out of config/enable mode") print(net_connect.find_prompt()) # Send config commands print() print("***** Testing send_config_set *****") print(net_connect.find_prompt()) output = net_connect.send_config_set(['ls -al']) print(output) print()
#!/usr/bin/env python from netmiko import ConnectHandler rtr2 = { 'device_type': 'cisco_ios', 'ip': '184.105.247.71', 'username': '******', 'secret': '', 'port': '22', 'password': '******' } conn1 = ConnectHandler(**rtr2) conn1.config_mode() if conn1.check_config_mode(): print "here you are in config mode" print "your prompt is :", print conn1.find_prompt() else: print "you are not in config mode" print "your prompt is :", print conn1.find_prompt()
'device_type': 'cisco_ios', #device type from https://github.com/ktbyers/netmiko/blob/master/netmiko/ssh_dispatcher.py 'host': '10.1.1.10', 'username': '******', 'password': '******', 'port': 22, # optional, default 22 'secret': 'cisco', # this is the enable password 'verbose': True # optional, default False } connection = ConnectHandler(**cisco_device) # getting the router's prompt prompt = connection.find_prompt() if '>' in prompt: connection.enable() # entering the enable mode output = connection.send_command('sh run') print(output) if not connection.check_config_mode( ): # returns True if it's already in the global config mode connection.config_mode() # entering the global config mode # print(connection.check_config_mode()) connection.send_command('username u3 secret cisco') connection.exit_config_mode() # exiting the global config mode print(connection.check_config_mode()) print('Closing connection') connection.disconnect()
'password': password, } net_connect1 = ConnectHandler(**pynet_rtr1) output = net_connect1.send_command('show ip int brief') print output device_list = [pynet_rtr1, pynet_rtr2, pynet_jnpr_srx1] for i in device_list: net_connect2 = ConnectHandler(**i) output = net_connect2.send_command('show arp') print output net_connect3 = ConnectHandler(**pynet_rtr2) net_connect3.config_mode() if net_connect3.check_config_mode() == True: print 'You are in configuration mode for {}'.format('pynet_rtr2') net_connect3.send_command('logging buffered 19999') net_connect3.exit_config_mode() outp = net_connect3.send_command('show run | sec logging') print outp net_connect3.send_config_from_file(config_file='config_commands.txt') outp = net_connect3.send_command('show run | sec log') print outp
connection = ConnectHandler(**router1) #output = connection.send_command('show ip int brief') #print(output) prompt = connection.find_prompt() print(prompt) if '>' in prompt: connection.enable() output1 = connection.send_command('show run | in hostname') print(output1) connection.disconnect() connection1 = ConnectHandler(**router2) prompt1 = connection1.find_prompt() print(prompt1) if '>' in prompt1: connection1.enable() output2 = connection1.send_command('show run | in username') print(output2) mode = connection1.check_config_mode() print(mode) if not mode: connection1.config_mode() mode = connection1.check_config_mode() print(mode) #output = connection1.send_command('username test1 password test123\n') connection.disconnect()
conn = ConnectHandler( **cisco_device ) #** this is a kwargs style of calling functions, it unpacks a DICTIONARY into the FUNCTION ARGUMENTs print(" *** Connecting to a device *** ") ### PROMPT - we can find it in which prompt we are prompt = conn.find_prompt() print(prompt) # calling the enable method of the CONN OBJECT conn.enable( ) # need to pass enable secret : ValueError: Failed to enter enable mode. Please ensure you pass the 'secret' argument to ConnectHandler. prompt = conn.find_prompt() print(prompt) ## Sending command to the device : #variable_output = conn.send_command('show run') #print(variable_output) '''Global configuration mode''' print( conn.check_config_mode() ) ###Checking if we are already in global conf mode, it returns FALSE it means we are not in global mode conf_mode = conn.config_mode( ) ###entering global configuration mode, we call config mode method of CONN object print(conf_mode) '''we can use also if not conn.check_config_mode() conn.config_mode() ''' #Closing connection print(' *** Connection is diconnected *** ') conn.disconnect()
'username': '******', 'password': password, 'port': 8022, } juniper_srx = { 'device_type': 'juniper', 'ip': '50.76.53.27', 'username': '******', 'password': password, 'secret': '', 'port': 9822, } #rtr1=ConnectHandler(**pynet1) rtr2 = ConnectHandler(**pynet2) #srx=ConnectHandler(**juniper_srx) rtr2.find_prompt() rtr2.config_mode() if rtr2.check_config_mode(): print 'Pynet-rtr2 is indeed in configuration mode\n' else: print 'Pynet-rtr2 is in global configuration mode \n' #print rtr1.send_command('show ip int brief') #print rtr1.send_command('show run | inc logging buffered') #config_set=['logging buffered 65000'] #print rtr1.send_config_set(config_set) #print rtr1.send_command('show run | inc logging buffered') #print dir(rtr1)
def ConfigurationTest(ip, Device_Type_Num=0, User_Pass_Num=0, Passowrd_Enable_Num=0): global num_New # so we can edit it in this Function # def ConfigurationTest(ip,Device_Type_Num= 0,User_Pass_Num= 0): if ConfigurationTest_Boolen == 1: return ConfigurationTest_Boolen == 1 # If increment of Num is out of range for User_Pass_Num and Device_Type_Num return 1 elif User_Pass_Num >= len(Username_Device): print(f"Username Not in Range For IP\t{ip}\n") return ConfigurationTest_Boolen == 1 elif Device_Type_Num >= len(Device_Type): print(f"Connection type Not in Range For IP\t{ip}\n") return ConfigurationTest_Boolen == 1 elif Passowrd_Enable_Num >= len(Passowrd_Device_Enable): print(f"Enable Pass Not in Range For IP\t{ip}\n") return ConfigurationTest_Boolen == 1 # If increment of Num is in range for User_Pass_Num and Device_Type_Num contune else: iosv_l2 = { 'device_type': str(Device_Type[Device_Type_Num] ), ##### Type of connection SSH/Telnet 'ip': str(ip), 'username': Username_Device[User_Pass_Num], 'password': Passowrd_Device[User_Pass_Num], 'global_delay_factor': 15, # if there is authentication problem allow this # 'secret':'cs' 'secret': Passowrd_Device_Enable[Passowrd_Enable_Num], # 'timeout':10 'session_timeout': 10 # if there is authentication problem allow this } try: # time.sleep(3) Conf_Variables = [ ] # To check if any faliure on the configuration after sending it net_connect = ConnectHandler(**iosv_l2) # print(net_connect.find_prompt()) ############ function to check output to send any confirmation message as pass or confirmation of yes or no def SpecialConfirmation(command, message, reply): net_connect.config_mode() #To enter config mode print("SpecialConfirmation Config") try: if Device_Type[Device_Type_Num] == "cisco_ios_telnet": print("First Write Telnet") net_connect.remote_conn.write(str(command) + '\n') else: net_connect.remote_conn.sendall(str(command) + '\n') except: print("Exception For Sendall ") print("SpecialConfirmation Before Sleep") time.sleep(3) print("SpecialConfirmation after Sleep") if Device_Type[Device_Type_Num] == "cisco_ios_telnet": print("First READ Telnet") output = net_connect.remote_conn.read_very_eager().decode( "utf-8", "ignore") else: output = net_connect.remote_conn.recv(65535).decode( 'utf-8') ReplyAppend = '' print("SpecialConfirmation output") print(output) try: if str(message) in output: for i in range(0, (len(reply))): ReplyAppend += str(reply[i]) + '\n' if Device_Type[Device_Type_Num] == "cisco_ios_telnet": print("SECOND Telnet") net_connect.remote_conn.write(ReplyAppend) output = net_connect.remote_conn.read_very_eager( ).decode("utf-8", "ignore") else: net_connect.remote_conn.sendall(ReplyAppend) output = net_connect.remote_conn.recv( 65535).decode('utf-8') print(output) except: print("Confirmation Exception Error") return output print("Entered Device Successfully \t" + ip + "\n") ###################################################################### ################ Here Is The Cisco Configuration #################### ###################################################################### print("check enable mode for " + str(ip)) if not net_connect.check_enable_mode(): net_connect.enable() print("entered enable mode for " + str(ip)) ################################################################## ########### Check if in config mode or not to exit config mode ################################################################## if net_connect.check_config_mode(): net_connect.exit_config_mode() print("After exiting config to perform show commands " + str(ip)) print("After checking config to perform show commands " + str(ip)) ###################################################################### print("Terminal length \n") ## Try this First Configuration_Output = "" Configuration_Output = net_connect.send_command_timing( "termin len 0" + '\n\n') # Configuration_Output=net_connect.send_command_timing("show run "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show ip inte br "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Switch=net_connect.send_command_timing("show fex "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show cdp neighbors detail "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Switch+=net_connect.send_command_timing("show interfaces status "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show inter desc "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Router=net_connect.send_command_timing("show ip ospf neighbor "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show version "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show cdp neighbors "+'\n\n' ,strip_prompt=False,strip_command=False) ################### for ARP ############################################################### ###################################################################### # Configuration_Output_ID2=net_connect.send_command_timing("show ip arp vrf ID2 "+'\n\n' ,strip_prompt=False,strip_command=False) # Configuration_Output_ID254=net_connect.send_command_timing("show ip arp vrf ID254 "+'\n\n' ,strip_prompt=False,strip_command=False) ###################################################################### # Configuration_Output=net_connect.send_command_timing("termin len 0"+'\n\n',delay_factor=5) # Configuration_Output=net_connect.send_command_timing("show run "+'\n\n' ,delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show ip inte br "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Switch=net_connect.send_command_timing("show fex "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show cdp neighbors detail "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Switch+=net_connect.send_command_timing("show interfaces status "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show inter desc "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Router=net_connect.send_command_timing("show ip ospf neighbor "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show version "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) # Configuration_Output+=net_connect.send_command_timing("show cdp neighbors "+'\n\n',delay_factor=5,strip_prompt=False,strip_command=False) ########################################################################################################### ############################ Use TEXTFSM Template to get Show version ############################ ########################################################################################################### try: # Show_Version_TEXTFSM_List=net_connect.send_command_timing("show version "+'\n\n' ,strip_prompt=False,strip_command=False, use_textfsm=True, textfsm_template="/home/khayat/Textfsm_Templates/cisco_ios_show_version.textfsm") # Test_Expect=net_connect.send_command("show ip inte br "+'\n\n' ,strip_prompt=False,strip_command=False) # print ("\t\tTest_Expect") # print (Test_Expect) Show_Version_TEXTFSM_List = net_connect.send_command_timing( "show version " + '\n\n', strip_prompt=False, strip_command=False, use_textfsm=True) Show_Version_TEXTFSM_Dict = Show_Version_TEXTFSM_List[ 0] # this is because the output is in list then in Dict # print (type(Show_Version_TEXTFSM_List)) # print ((Show_Version_TEXTFSM_List)) # print (type(Show_Version_TEXTFSM_Dict)) # print ((Show_Version_TEXTFSM_Dict)) # print ("\n\n\n") # print ("\t\tConfiguration_Output_TEXTFSM") # for k,v in Show_Version_TEXTFSM_Dict.items() : # print (f"{k} :: {v}") if Show_Version_TEXTFSM_Dict["hardware"]: Hardware_IP = "\t\t" + str( Show_Version_TEXTFSM_Dict["hardware"] [0]) + f" {ip}___" + str( Show_Version_TEXTFSM_Dict["hostname"]) All_Hardware_Module_List.append(Hardware_IP) else: Hardware_IP_Empty_List.append(ip + " Hardware Empty") Hostname_Output = ip + ".__" + str( Show_Version_TEXTFSM_Dict["hostname"]) Worked_IPs_Old.append(ip) except Exception as e: print('Exception in show version\t' + ip) FailedIps.append(ip + " Exception in show version") IPs_ForIteration.append(ip) ########################################################################################################### # Hostname_Output=net_connect.send_command("show run | i hostname"+'\n\n') # Configuration_Output+=net_connect.send_command_timing("show ip inte br "+'\n\n',strip_prompt=False,strip_command=False) print(f"This is after getting SHOW for IP\t{ip}") # Hostname_Output=net_connect.send_command("show run | i hostname"+'\n\n',delay_factor=5) ########################################################################################################### ################## Get each interfaces status using Script ################################################## ########################################################################################################### # List_Of_Inter=net_connect.send_command_timing("show interface status "+'\n\n') # # print ("\t\tList_Of_Inter") # List_of_Lines= Get_All_Inter(List_Of_Inter) # print ("\t\tList_of_Lines\n") # print (List_of_Lines) # print ("\t\tGet_Ports_Status") # Returned_List=Get_Ports_Status(List_of_Lines) # for i in Returned_List : # print (f"key\t{i}\tValue\t{Returned_List.get(i)} ") # ########################################################################################################### # ################## Get each interfaces IP using Script ################################################## # ########################################################################################################### # IPs_All_Interfaces=net_connect.send_command_timing("show ip interface br "+'\n\n') # Inter_IPs= Get_Interfaces_IP(IPs_All_Interfaces) # for x in Inter_IPs : # if x[-1] =="up" and x[-2]=="up" : # print (x) # print (x[1]) ################################################################## ########### Check if in config mode or not to exit config mode ################################################################## if not net_connect.check_config_mode(): net_connect.config_mode() print("After entering config " + str(ip)) print("After checking config to perform configuration commands " + str(ip)) ###################################################################### ################ Set list of configuration ########################### ###################################################################### # List_cmd=[f"inte {Returned_List["disabled"][0]}","no shutd","ip add 192.168.100.100 255.255.255.0"] # print ("Returned_List[disabled][0]") # print (Returned_List.get("disabled")[0]) # Temp=str(Returned_List.get("disabled")[0]) # List_cmd=[f"inte {Temp}","no shutd"] # Output_Setting_Inter=net_connect.send_config_set(config_commands=List_cmd) # print ("Output_Setting_Inter") # print (Output_Setting_Inter) ################################################################## ########### Check if in config mode or not to exit config mode ################################################################## if net_connect.check_config_mode(): net_connect.exit_config_mode() print("After exiting config " + str(ip)) print("After checking config for CDP command\t" + str(ip)) ########################################################################################################### ################## Add new IPs from CDP Command ################################################## ########################################################################################################### ############################################################################### ######################## Using Script for cdp neighbors to get New IPs ############################################################################### # CDP_ALL=net_connect.send_command_timing("show cdp neighbors detail | i IP address: "+'\n\n') # print ("\t\tGet_CDP_Neighbors") # num_New = list(num_New) + list(Get_CDP_Neighbors (CDP_ALL , num)) ############################################################################### ######################## Using TextFSM for cdp neighbors ############################################################################### try: Show_CDP_Details_TEXTFSM_List = net_connect.send_command_timing( "show cdp neighbors detail " + '\n\n', strip_prompt=False, strip_command=False, use_textfsm=True) for n in Show_CDP_Details_TEXTFSM_List: Show_CDP_Details_TEXTFSM_Dict = n # this is because the output is in list then in Dict # print (type(Show_CDP_Details_TEXTFSM_List)) # print (Show_CDP_Details_TEXTFSM_List) # print (type(Show_CDP_Details_TEXTFSM_Dict)) # print (Show_CDP_Details_TEXTFSM_Dict) # print (type(Show_CDP_Details_TEXTFSM_Dict["management_ip"])) # print (Show_CDP_Details_TEXTFSM_Dict["management_ip"]) if "172." in Show_CDP_Details_TEXTFSM_Dict[ "management_ip"]: if Show_CDP_Details_TEXTFSM_Dict[ "management_ip"] not in num and Show_CDP_Details_TEXTFSM_Dict[ "management_ip"] not in num_New and Show_CDP_Details_TEXTFSM_Dict[ "management_ip"] not in Worked_IPs_Old: num_New.append( Show_CDP_Details_TEXTFSM_Dict["management_ip"]) except Exception as e: print('Exception in show cdp neighbors \t' + ip) FailedIps.append(ip + " Exception in show cdp neighbors ") IPs_ForIteration.append(ip) ########################################################################################################### ################ Example on confirmation message Function ########################################################################################################### # if ip =="192.168.233.13": # print (str (SpecialConfirmation("crypto key generate rsa general-keys" ,"modulus" ,"1024"))) ########################################################################################################### ########################################################################################################### if net_connect.check_config_mode(): net_connect.exit_config_mode() print("After last check config " + str(ip)) ################################################################################ ####################### Test Ping For Rang Of IP ############################## ################################################################################ # Active_ping_ip=[] # InActive_ping_ip=[] # Sub_Ip_ping="2.0.32." # for x in range(1,255) : # print (x) # Ip_ping=Sub_Ip_ping+str(x) # ping_result=net_connect.send_command_timing("ping "+Ip_ping+'\n\n' ,strip_prompt=False,strip_command=False) # # print (ping_result) # # ping_is_successful(ping_result) # # print (ping_is_successful(ping_result)) # # print (type(ping_is_successful(ping_result))) # if ping_is_successful(ping_result) : # Active_ping_ip.append(Ip_ping) # else : # InActive_ping_ip.append(Ip_ping) # print ("Active_ping_ip") # for x in Active_ping_ip : # print (x) # print ("\n\n\nInActive_ping_ip") # for x in InActive_ping_ip : # print (x) ############### Append Configuration Variables to Global Variable ########## # Conf_Variables.append(Hostname_Output) # print (Configuration_Output) # Conf_Variables.append(Configuration_Output) ############### Search in Configuration if any command error and return its IP ################ for y in Conf_Variables: if "% Invalid input detected at '^' marker." in y: FailedIps.append(ip + " Invalid input") ######################################################################################################### Hostname_Output_list.append(Hostname_Output) test = Configuration_Switch test += Configuration_Output test += Configuration_Router Configuration_Output_list.append(test) Configuration_Output_ID2_list.append(Configuration_Output_ID2) Configuration_Output_ID254_list.append(Configuration_Output_ID254) ############### SAVE Output IN FILES ####################### Global_Output.append(Hostname_Output) print("Exiting " + str(ip)) net_connect.disconnect() print("After Exiting " + str(ip)) ################### Exception ################################### except (NetMikoAuthenticationException ) as netmikoAuthenticationException: # print ('Authentication Failure\t' + ip) print( str(User_Pass_Num) + " " + str(Username_Device[User_Pass_Num]) + " failed Authentication\t" + ip) ################ Print error from msg from the main Lib print( f"netmikoAuthenticationException : {netmikoAuthenticationException}\n" ) User_Pass_Num += 1 # If it tried all users and pass and failed add it to failedIps if User_Pass_Num >= len(Username_Device): FailedIps.append(ip + " Authentication Error ") IPs_ForIteration.append(ip) # if User_Pass_Num < len(Username_Device) : # print("this is Authentication "+str(ip)+" Device_Type "+str(Device_Type[Device_Type_Num])+" Username_Device " +str(Username_Device[User_Pass_Num])+" Passowrd_Device " +str(Passowrd_Device[User_Pass_Num])) # Recursive function return ConfigurationTest(ip, Device_Type_Num, User_Pass_Num, Passowrd_Enable_Num) except (ValueError): print(str(Passowrd_Enable_Num) + "\tEnable Authentication\t" + ip) Passowrd_Enable_Num += 1 if Passowrd_Enable_Num >= len(Passowrd_Device_Enable): FailedIps.append(ip + " Enable Authentication Error ") IPs_ForIteration.append(ip) return ConfigurationTest(ip, Device_Type_Num, User_Pass_Num, Passowrd_Enable_Num) except socket_error as socket_err: ################ Print error from msg from the main Lib print( f"Socket Error: \n{socket_err}\t for IP {ip} trying another type of Connection\n" ) print("Continue") if '111' in f"Type {socket_err}": Device_Type_Num += 1 if Device_Type_Num >= len(Device_Type): FailedIps.append(ip + " Socket or connection type Error") IPs_ForIteration.append(ip) return ConfigurationTest(ip, Device_Type_Num, User_Pass_Num, Passowrd_Enable_Num) if '113' in f"Type {socket_err}": FailedIps.append(ip + " No route to the host") IPs_ForIteration.append(ip) return ConfigurationTest_Boolen == 1 FailedIps.append(ip + " Socket or connection type Error") IPs_ForIteration.append(ip) return ConfigurationTest_Boolen == 1 except (NetMikoTimeoutException) as netmikoTimeoutException: # print ('Timeout Failure\t' + ip) print(str(Device_Type_Num) + "\tTimeoutException\t" + ip) ################ Print error from msg from the main Lib print(f"netmikoTimeoutException : \n{netmikoTimeoutException}\n") Device_Type_Num += 1 if Device_Type_Num >= len(Device_Type): FailedIps.append(ip + " Timeout Error") IPs_ForIteration.append(ip) # if Device_Type_Num < len(Device_Type) : # print("this is Timeout "+str(ip)+" Device_Type "+str(Device_Type[Device_Type_Num])+" Username_Device " +str(Username_Device[User_Pass_Num])+" Passowrd_Device " +str(Passowrd_Device[User_Pass_Num])) return ConfigurationTest(ip, Device_Type_Num, User_Pass_Num, Passowrd_Enable_Num) # except (paramiko.ssh_exception.SSHException) as sshException : except (SSHException) as sshException: # print ('SSH Failure\t' + ip) print(str(Device_Type_Num) + "\tSSHException\t" + ip + "\n") ################ Print error from msg from the main Lib print( f"Unable to establish SSH connection: \n{sshException}\t for IP {ip}\n" ) Device_Type_Num += 1 if Device_Type_Num >= len(Device_Type): FailedIps.append(ip + " SSHException Error ") IPs_ForIteration.append(ip) # if Device_Type_Num < len(Device_Type) : # print("this is SSHException "+str(ip)+" Device_Type "+str(Device_Type[Device_Type_Num])+" Username_Device " +str(Username_Device[User_Pass_Num])+" Passowrd_Device " +str(Passowrd_Device[User_Pass_Num])) return ConfigurationTest(ip, Device_Type_Num, User_Pass_Num, Passowrd_Enable_Num) except (ValueError): print( str(Passowrd_Enable_Num) + " " + str(Passowrd_Device_Enable[Passowrd_Enable_Num]) + " Failed Enable Authentication\t" + ip) Passowrd_Enable_Num += 1 if Passowrd_Enable_Num >= len(Passowrd_Device_Enable): FailedIps.append(ip + " Enable Authentication Error ") IPs_ForIteration.append(ip) return ConfigurationTest(ip, Device_Type_Num, User_Pass_Num, Passowrd_Enable_Num) except (EOFError) as eof_Error: ################ Print error from msg from the main Lib print(f"eof_Error : \n{eof_Error}\n") # print ('End of File wihle attempting device\t' +ip) FailedIps.append(ip + " EOFError") IPs_ForIteration.append(ip) # print("this is EOFError "+str(ip)+" Device_Type "+str(Device_Type[Device_Type_Num])+" Username_Device " +str(Username_Device[User_Pass_Num])+" Passowrd_Device " +str(Passowrd_Device[User_Pass_Num])) return ConfigurationTest_Boolen == 1 ################################################################### ######### if you want to show error , comment next lines if you want to show which Ips have error remove comment ############## ################################################################### # except Exception as e: # # print ('End of File wihle attempting device\t' +ip) # FailedIps.append(ip+" Exception as e") # # print("this is EOFError "+str(ip)+" Device_Type "+str(Device_Type[Device_Type_Num])+" Username_Device " +str(Username_Device[User_Pass_Num])+" Passowrd_Device " +str(Passowrd_Device[User_Pass_Num])) # return ConfigurationTest_Boolen==1 #################################################################### return ConfigurationTest_Boolen == 1
'device_type': 'cisco_ios', 'ip': '50.76.53.27', 'username': '******', 'password': passwd, 'port': 8022, } juniper_srx= { 'device_type': 'juniper', 'ip': '50.76.53.27', 'username': '******', 'password': passwd, 'port': 9822, } pynet_rtr2= ConnectHandler(**pynet2) pynet_rtr1= ConnectHandler(**pynet1) pynet_juniper= ConnectHandler(**juniper_srx) pynet_rtr2.config_mode() print pynet_rtr2.check_config_mode() print "sh arp rtr1:\n" outp=pynet_rtr1.send_command("show arp") print outp print "sh arp juniper:\n" outp=pynet_juniper.send_command("show arp") print outp pynet_rtr2.send_command("logging buffered 40960") #tim2.sleep(1)
'port':8022 } juniper_srx={ 'device_type':'juniper', 'ip':'50.76.53.27', 'username':'******', 'password':password, 'secret':'', 'port':9822 } pynet_rtr1=ConnectHandler(**pynet1) pynet_rtr2=ConnectHandler(**pynet2) srx=ConnectHandler(**juniper_srx) print pynet_rtr1.find_prompt() print pynet_rtr2.find_prompt() print srx.find_prompt() pynet_rtr1.config_mode() print pynet_rtr1.check_config_mode() print pynet_rtr1.find_prompt() pynet_rtr1.send_command("end") print pynet_rtr1.send_command("sh version") list_of_command=['logging buffer 9800','logging buffer 1000'] print pynet_rtr1.send_config_set(list_of_command) time.sleep(2) print pynet_rtr1.find_prompt() print pynet_rtr1.send_command("sh logging | inc Log Buffer") print pynet_rtr1.send_config_from_file(config_file='test.txt')
'password': '******', } pynetrtr2 = { 'device_type': 'cisco_ios', 'ip': '50.76.53.27', 'username': '******', 'password': '******', 'port': 8022 } srx = { 'device_type': 'juniper', 'ip': '50.76.53.27', 'username': '******', 'password': '******', 'port': 9822 } rtr2 = ConnectHandler(**pynetrtr2) # passes in dictionary key values into the function output = rtr2.find_prompt() print output output = rtr2.config_mode() print output output = rtr2.check_config_mode() print output
class NetworkDeviceIOS(NetworkDevice): #--------------------------------------------------------------------------- def __init__(self, name, ip, user='******', pw='cisco', secret=''): NetworkDevice.__init__(self, name, ip, user, pw) self.secret = secret self.device = { 'device_type': 'cisco_ios', 'ip': self.ip_address, 'username': self.username, 'password': self.password, 'secret': self.secret, 'port': 22, } self.session = None logger.info('devclass: created IOS device: %s %s', name, ip) #--------------------------------------------------------------------------- def connect(self): try: print('--- connecting IOS: telnet: ' + self.ip_address + ' for: ' + self.username) self.session = ConnectHandler(**self.device) logger.info('devclass: successful login at: %s for user: %s', self.ip_address, self.username) return self.session except Exception as err: logger.error('devclass: Erro no login at: %s for user: %s', self.ip_address, self.username) print('Ocorreu um Erro: ' + str(err)) raise Exception('Erro em devclass.connect') #--------------------------------------------------------------------------- def disconnect(self): if self.esta_connectado(): print('--- disconnecting IOS: telnet: ' + self.ip_address + ' for: ' + self.username) self.session.disconnect() logger.info('devclass: successful logoff at: %s for user: %s', self.ip_address, self.username) else: logger.warn('devclass: --- Erro ao desconectar.') print("Não há sessão para desconectar!") #--------------------------------------------------------------------------- def get_interfaces(self): if self.esta_connectado(): self.interfaces = self.session.send_command("show int status") logger.info( 'devclass: successful get_interfaces at: %s for user: %s', self.ip_address, self.username) return self.interfaces else: logger.error( 'devclass: Erro ao executar devclass.get_interfaces() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.get_interfaces() - Sessao nao estabelecida.' ) return "Erro " #--------------------------------------------------------------------------- def get_int_connected(self): if self.esta_connectado(): output = self.session.send_command("show int status | i cted") logger.info( 'devclass: successful get_int_connected at: %s for user: %s', self.ip_address, self.username) return output else: logger.error( 'devclass: Erro ao executar devclass.get_int_connected() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.get_int_connected() - Sessao nao estabelecida.' ) return "erro" #--------------------------------------------------------------------------- def do_wr(self): if self.esta_connectado(): output = self.session.send_command('write memory') logger.info('devclass: successful do_wr at: %s for user: %s', self.ip_address, self.username) return output else: logger.error( 'devclass: Erro ao executar devclass.do_wr() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.do_wr() - Sessao nao estabelecida.') #--------------------------------------------------------------------------- def config_mode(self): if self.esta_connectado(): output = self.session.config_mode() logger.info( 'devclass: successful config_mode() at: %s for user: %s', self.ip_address, self.username) return output else: logger.error( 'devclass: Erro ao executar devclass.config_mode() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.config_mode() - Sessao nao estabelecida.' ) #--------------------------------------------------------------------------- def exit_config_mode(self): if self.esta_connectado(): output = self.sessionc.exit_config_mode() logger.info( 'devclass: successful exit_config_mode() at: %s for user: %s', self.ip_address, self.username) return output else: logger.error( 'devclass: Erro ao executar devclass.exit_config_mode() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.exit_config_mode() - Sessao nao estabelecida.' ) #--------------------------------------------------------------------------- def check_config_mode(self): if self.esta_connectado(): output = self.session.check_config_mode() logger.info( 'devclass: successful check_config_mode() at: %s for user: %s', self.ip_address, self.username) return output else: logger.error( 'devclass: Erro ao executar devclass.check_config_mode() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.check_config_mode() - Sessao nao estabelecida.' ) #--------------------------------------------------------------------------- def enable(self): if self.esta_connectado(): output = self.session.enable() logger.info('devclass: successful enable() at: %s for user: %s', self.ip_address, self.username) return output else: logger.error( 'devclass: Erro ao executar devclass.enable() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.enable() - Sessao nao estabelecida.' ) #--------------------------------------------------------------------------- def exit_enable_mode(self): if self.esta_connectado(): output = self.session.exit_enable_mode() logger.info( 'devclass: successful exit_enable_mode() at: %s for user: %s', self.ip_address, self.username) return output else: logger.error( 'devclass: Erro ao executar devclass.exit_enable_mode() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.exit_enable_mode() - Sessao nao estabelecida.' ) #--------------------------------------------------------------------------- def find_prompt(self): if self.esta_connectado(): output = self.session.find_prompt() logger.info( 'devclass: successful find_prompt() at: %s for user: %s', self.ip_address, self.username) return output else: logger.error( 'devclass: Erro ao executar devclass.find_prompt() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.find_prompt() - Sessao nao estabelecida.' ) #--------------------------------------------------------------------------- def send_command(self, arguments): if self.esta_connectado(): output = self.session.send_command(arguments) logger.info( 'devclass: successful send_command() at: %s for user: %s', self.ip_address, self.username) return output else: logger.error( 'devclass: Erro ao executar devclass.send_command() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.send_command() - Sessao nao estabelecida.' ) #--------------------------------------------------------------------------- def send_config_set(self, arguments_list): if self.esta_connectado(): output = self.session.send_config_set(arguments_list) logger.info( 'devclass: successful send_config_set() at: %s for user: %s', self.ip_address, self.username) return output else: logger.error( 'devclass: Erro ao executar devclass.send_config_set() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.send_config_set() - Sessao nao estabelecida.' ) #--------------------------------------------------------------------------- def send_config_from_file(self, file): if self.esta_connectado(): output = self.session.send_config_from_file(file) logger.info( 'devclass: successful send_config_from_file() at: %s for user: %s', self.ip_address, self.username) return output else: logger.error( 'devclass: Erro ao executar devclass.send_config_from_file() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.send_config_from_file() - Sessao nao estabelecida.' ) #--------------------------------------------------------------------------- def esta_connectado(self): if self.session != None: return True else: return False #--------------------------------------------------------------------------- def debug_devclass(self): filename_log = self.ip_address + '_.log' logging.basicConfig(filename=filename_log, format='%(asctime)s - %(levelname)s - %(message)s', level=logging.DEBUG) debugClass = logging.getLogger("netmiko") #--------------------------------------------------------------------------- def get_hostname(self): if self.esta_connectado(): output = self.session.send_command("show conf | i hostname") logger.info( 'devclass: successful get_hostname at: %s for user: %s', self.ip_address, self.username) hostname = (output.split())[1] return hostname else: logger.error( 'devclass: Erro ao executar devclass.get_hostname() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.get_hostname() - Sessao nao estabelecida.' ) return "Erro " #--------------------------------------------------------------------------- def get_nbem(self): if self.esta_connectado(): output = self.session.send_command("show run | i chassis") logger.info('devclass: successful get_nbem at: %s for user: %s', self.ip_address, self.username) output = (output.split())[2] return output else: logger.error( 'devclass: Erro ao executar devclass.get_nbem() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.get_nbem() - Sessao nao estabelecida.' ) #--------------------------------------------------------------------------- def get_serial(self): if self.esta_connectado(): output = self.session.send_command( "show version | i System [s,S]erial") logger.info('devclass: successful get_serial at: %s for user: %s', self.ip_address, self.username) outputlines = output.splitlines() serial = [] for line in outputlines: serial.append((line.split(": "))[1]) return serial else: logger.error( 'devclass: Erro ao executar devclass.get_serial() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.get_serial() - Sessao nao estabelecida.' ) #--------------------------------------------------------------------------- #retorna o MAC pelo IP def busca_mac(self, end_ip): if self.esta_connectado(): output = self.session.send_command("show arp | i %s" % end_ip) logger.info('devclass: successful busca_mac at: %s for user: %s', self.ip_address, self.username) #output = (output.split())[2] return output else: logger.error( 'devclass: Erro ao executar devclass.busca_mac() - Sessão não estabelecida. at: %s for user: %s', self.ip_address, self.username) raise Exception( 'Erro ao executar devclass.busca_mac() - Sessao nao estabelecida.' ) #---------------------------------------------------------------------------
#!/usr/bin/env python from __future__ import print_function from netmiko import ConnectHandler pynet2 = { 'device_type': 'cisco_ios', 'ip': '184.105.247.71', 'username': '******', 'password': '******', 'port': 22 } net_connect = ConnectHandler(**pynet2) net_connect.config_mode() if net_connect.check_config_mode() is True: print(net_connect.find_prompt()) net_connect.exit_config_mode() net_connect.disconnect()
from netmiko import ConnectHandler pynet2 = { 'device_type': 'cisco_ios', 'ip': '184.105.247.71', 'username': '******', 'password': '******', } pynet_rtr2 = ConnectHandler(**pynet2) pynet_rtr2.config_mode() pynet_rtr2.check_config_mode() pynet_rtr2.exit_config_mode() pynet_rtr2.disconnect()