Exemple #1
0
def ap_migration(request):
    if os.path.exists('config_for_wlc.txt'):
        os.remove('config_for_wlc.txt')
    # provide list of selected AP:
    if request.method == "GET":
        return render(request, 'Migration_Website/ap_migration.html', {'context': ap_to_migration})
    if request.method == "POST":
        wlc_name = request.POST.get['wlc_name']
        wlc_ip = request.POST.get['wlc_ip']
        config = open('config_for_wlc.txt', 'w+')
        for ap in ap_to_migration:
            config.write("config ap primary-base {} {} {} \n ".format(wlc_name, ap, wlc_ip))
        config.close()
        ap_to_migration.clear()
        # Connect to controller and send commands:
        cisco1 = {
            "ip": ip_address
            "username": username1,
            "password": password1,
            "device_type": "cisco_wlc_ssh",
            'global_delay_factor': 4,
            'banner_timeout': 7
        }
        net_connect = Netmiko(**cisco1)
        net_connect.send_config_from_file('config_for_wlc.txt')
        net_connect.disconnect()
        return HttpResponse("Udało się ?")
Exemple #2
0
def dhcp_pool(ip):
    show_result("Reading dhcp_pool file...")
    net_connect = Netmiko(**get_dic(ip))
    print("-------------------------------------------------")
    net_connect.enable()
    # Envoie la configuration du fichier dhcp_pool
    net_connect.send_config_from_file("dhcp_pool")
    show_result("DHCP pool configured !")
    # Demande de write la conf
    save = input(show_input("Do you want to write configuration ? (y/n) : "))
    if save == "y" or save == "yes":
        write_conf(ip)
    end_task()
    print("-------------------------------------------------")
Exemple #3
0
def main():

    my_device = {
        'host': 'ios-xe-mgmt.cisco.com',
        'username': '******',
        'password': '',
        'device_type': 'cisco_ios',
        'port': 8181
    }
    net_connect = Netmiko(**my_device)

    #    commands = ['int gi3', 'ip addr 1.2.3.4 255.255.255.0']
    #
    #    output = net_connect.send_config_set(commands)
    #    print(output)
    #
    #    output = net_connect.send_command('sh run int gi3')
    #    print(output)
    #
    output = net_connect.send_config_from_file('commands_file')
    print(output)

    output = net_connect.send_command('sh run int gi3')
    print(output)

    net_connect.disconnect()
Exemple #4
0
def Input(ip):

    my_device = {
        "host": ip,
        "username": "******",
        "password": "******",
        "device_type": "cisco_ios",
    }
    try:
        net_connect = Netmiko(**my_device)
        result = net_connect.send_config_from_file(config_file='commands.txt')
        net_connect.disconnect()
        return "done"
    except:
        return "something wrong"
Exemple #5
0
 def config_file(self, host, set_file):
     '''
     this method can be use if you want to write the command in file
     :param host: IP or hostname the device
     :param set_file: file location that contain some command
     :return:
     '''
     device = {
         'ip': host,
         'username': self.username,
         'password': self.password,
         'use_keys': self.keys,
         'device_type': 'cisco_ios',
     }
     net_connect = Netmiko(**device)
     return net_connect.send_config_from_file(set_file)
Exemple #6
0
def Input(ip):

    my_device = {
        "host": ip,
        "username": "******",
        "password": "******",
        "device_type": "cisco_ios",
    }
    try:
        net_connect = Netmiko(
            **my_device)  #Netmiko是一个类,net_connect是一个实例,my_device是产生实例时需要的数据属性
        result = net_connect.send_config_from_file(
            config_file='commands.txt'
        )  #通过实例去调用类函数,实例本身并没有函数属性,是通过风湿理论去调用类里的函数
        net_connect.disconnect()
        return "done"
    except:
        return "something wrong"
Exemple #7
0
def get_prompt(dev):
    ping_reply = subprocess.call(
        ['ping', '-c', '3', '-w', '3', '-q', '-n', dev['host']],
        stdout=subprocess.PIPE)
    if ping_reply == 0:
        net_conn = Netmiko(**dev)
        print("device %s is reachable" % dev['host'])
        # the commnad file used associated wit the ip address
        cfg_file = "%s.txt" % dev['host']
        output = net_conn.send_config_from_file(cfg_file)
        print(output)
        net_conn.save_config()
        net_conn.disconnect()
        # its always a good idea to write output to file to make sure that your commands have been executed successfully to the device
        print(
            "\nWriting output to file for %s ..please wait while output is printed and saved to File.\n"
            % dev['host'])
        with open('cfg-%s.txt' % dev['host'], 'a') as f:
            f.writelines(output)
    else:
        status = "%s is not reachable..skipping" % dev['host']
        print(status)
        pass
Exemple #8
0
    'username': '******',
    'password': password,
    'device_type': 'cisco_ios'
}

net_conn = Netmiko(**R1)

output = net_conn.send_config_set('snmp-server community cisco123')

print()
print('-' * 80)
print(output)
print('-' * 80)
print()

output = net_conn.send_config_from_file('file_commands.txt')

print()
print('-' * 80)
print(output)
print('-' * 80)
print()

output = net_conn.send_command('show run | inc snmp-server')

print()
print('-' * 80)
print(output)
print('-' * 80)
print()
Exemple #9
0
"""
4. Use send_config_set() and send_config_from_file() to make
configuration changes.

The configuration changes should be benign. For example, on Cisco IOS
I typically change the logging buffer size.

As part of your program verify that the configuration change occurred
properly. For example, use send_command() to execute 'show run' and
verify the new configuration.
"""

from getpass import getpass
from netmiko import Netmiko

device = {
    "host": "sw01.test.domain",
    "username": "******",
    "password": getpass(),
    "device_type": "cisco_s300",
}

net_conn = Netmiko(**device)
output = net_conn.send_config_set("logging buffered 999")
output += net_conn.send_config_from_file("config.txt")
output += net_conn.send_command("show run")
net_conn.disconnect()

print(output)
Exemple #10
0
from getpass import getpass

password = getpass()

csr1000v = {
    'device_type': 'cisco_ios',
    'username': '******',
    'password': password,
    'secret': password,
    'ip': '192.168.8.136'
}

connection = Netmiko(**csr1000v)

print connection.find_prompt()

cmd = ['logging on', 'logging buffered']
print()
print('Sending logging config to device')
print('-' * 80)
output = connection.send_config_set(cmd)
#print(output)
print('Saving Configuration to NVRAM')
print('-' * 80)
connection.save_config()
output = connection.send_config_from_file('logging_config.txt')
print(output)
show_run = connection.send_command('show run | include logging')
print(show_run)
connection.disconnect()
Exemple #11
0
from netmiko import Netmiko

username = ''
password = ''

nxos1 = {
    'host': 'nxos1.lasthop.io',
    'username': username,
    'password': password,
    'device_type': 'cisco_nxos',
}

nxos2 = {
    'host': 'nxos2.lasthop.io',
    'username': username,
    'password': password,
    'device_type': 'cisco_nxos',
}

devices = [nxos1, nxos2]

for dev in devices:
    conn = Netmiko(**dev)
    output = conn.send_config_from_file('config.txt')
    conn.save_config()
    print(output)
    conn.disconnect()
Exemple #12
0
#!/usr/bin/env python
from netmiko import Netmiko
from getpass import getpass

nxos1 = {
    'host': 'nxos1.twb-tech.com', 
    'username': '******', 
    'password': getpass(), 
    'device_type': 'cisco_nxos',
}

cfg_file = 'config_changes.txt'
net_connect = Netmiko(**nxos1)

print()
print(net_connect.find_prompt())
output = net_connect.send_config_from_file(cfg_file)
print(output)
print()

net_connect.save_config()
net_connect.disconnect()
}

# Establish SSH connection to the network device using **kwargs to pull in details from dictionary
net_connection = Netmiko(**cisco_device)

# Send show run command to device to see current logging status and print to console
output = net_connection.send_command('show run | inc logging')
print(output)
# Send command to change logging buffer size
net_connection.send_config_set('logging buffered 4000000')
# Commit this change on IOS-XR device
net_connection.commit()

# Send show run command again to verify successful config change and print to console
output = net_connection.send_command('show run | inc logging')
print('-' * 30)
print(output)

# This time send command to device from a txt file
net_connection.send_config_from_file('config.txt')
# Commit this change on IOS-XR device
net_connection.commit()

# Send show run command again to verify successful config change
output = net_connection.send_command('show run | inc logging')
# Check if logging buffer size is as we set it via config and print confirmation to console
if '4000000' in output:
    print('Configuration change was successful')
else:
    print('Logging buffer size not correct')
print('-' * 30)
def gns3_send_start_config_telnet(gns3_server, project_id,
                                  gns3_code_topology_data,
                                  global_delay_factor):

    print("""
    ╔═╗┌┬┐┌─┐┌─┐  ╦╦  ╦  ┌─┐┌─┐┌┐┌┌┬┐  ┌─┐┌┬┐┌─┐┬─┐┌┬┐┬ ┬┌─┐  ┌─┐┌─┐┌┐┌┌─┐┬┌─┐
    ╚═╗ │ ├┤ ├─┘  ║╚╗╔╝  └─┐├┤ │││ ││  └─┐ │ ├─┤├┬┘ │ │ │├─┘  │  │ ││││├┤ ││ ┬
    ╚═╝ ┴ └─┘┴    ╩ ╚╝.  └─┘└─┘┘└┘─┴┘  └─┘ ┴ ┴ ┴┴└─ ┴ └─┘┴    └─┘└─┘┘└┘└  ┴└─┘.
    """)

    gns3_host_ip = gns3_code_topology_data['gns3_host_ip']
    START_CFGS_PATH = gns3_code_topology_data['START_CFGS_PATH']

    list_start_config_nodes = []

    for node in gns3_code_topology_data['gns3_startup_config_telnet']:
        name = node['name']
        list_start_config_nodes.append(name)

    for node_name in list_start_config_nodes:
        print()
        print(
            'Applying startup config to', node_name + ' from',
            '[' + gns3_code_topology_data['START_CFGS_PATH'] + node_name + ']')
        print()

        r_get_nodes = requests.get(gns3_server + '/v2/projects/' +
                                   str(project_id) + '/nodes')
        r_get_nodes_dict = r_get_nodes.json()

        for dictionary_node in r_get_nodes_dict:
            if dictionary_node['name'] == node_name:
                # For VPCS
                if dictionary_node['node_type'] == 'vpcs':
                    device_type = 'generic_termserver_telnet'

                    config_path = os.path.abspath(START_CFGS_PATH + node_name)
                    telnet_port = dictionary_node['console']

                    device = {
                        "host": gns3_host_ip,
                        "device_type": device_type,
                        "port": telnet_port,
                        "global_delay_factor": global_delay_factor
                    }

                    net_connect = Netmiko(**device)
                    net_connect.send_config_from_file(config_file=config_path,
                                                      exit_config_mode=False)
                    net_connect.disconnect()
                    continue
                # For VyOS.
                elif dictionary_node['port_name_format'] == 'eth{0}':
                    device_type = 'generic_termserver_telnet'

                    config_path = os.path.abspath(START_CFGS_PATH + node_name)
                    telnet_port = dictionary_node['console']

                    device = {
                        "host": gns3_host_ip,
                        "device_type": device_type,
                        "port": telnet_port,
                        "global_delay_factor": global_delay_factor
                    }

                    vyos = pexpect.spawn('telnet ' + gns3_host_ip + ' ' +
                                         str(telnet_port))
                    vyos.expect('')
                    vyos.sendline('\n')
                    vyos.expect('login: '******'vyos\n')
                    vyos.expect('Password:'******'vyos')

                    net_connect = Netmiko(**device)
                    net_connect.send_config_from_file(config_file=config_path,
                                                      exit_config_mode=False)
                    net_connect.disconnect()
                    continue
                # For JunOS.
                elif dictionary_node['port_name_format'] == 'ge-0/0/{0}':
                    device_type = 'juniper_junos_telnet'

                    config_path = os.path.abspath(START_CFGS_PATH + node_name)
                    telnet_port = dictionary_node['console']

                    device = {
                        "host": gns3_host_ip,
                        "device_type": device_type,
                        "port": telnet_port,
                        "global_delay_factor": global_delay_factor
                    }

                    juniper = pexpect.spawn('telnet ' + gns3_host_ip + ' ' +
                                            str(telnet_port))
                    juniper.expect('')
                    juniper.sendline('\n')
                    juniper.expect('login: '******'root\n')
                    juniper.expect('')
                    juniper.sendline('\n')
                    juniper.expect('root@% ', timeout=120)
                    juniper.sendline('cli')

                    with open(config_path) as f:
                        lines = f.read().splitlines()

                    net_connect = Netmiko(**device)
                    net_connect.config_mode()

                    for line in lines:
                        net_connect.send_command_timing(line)
                        time.sleep(1)
                    net_connect.disconnect()
                    continue
                # For Cisco IOS and Cisco ASA.
                else:
                    device_type = 'cisco_ios_telnet'

                    config_path = os.path.abspath(START_CFGS_PATH + node_name)
                    telnet_port = dictionary_node['console']

                    device = {
                        "host": gns3_host_ip,
                        "device_type": device_type,
                        "port": telnet_port,
                        "global_delay_factor": global_delay_factor
                    }

                    net_connect = Netmiko(**device)
                    net_connect.enable()
                    net_connect.send_config_from_file(config_file=config_path)
                    net_connect.disconnect()
                    continue
        print('Success -', node_name)
    print('=' * 100)
from netmiko import Netmiko

IP_LIST = open('09_devices')
for IP in IP_LIST:
    print ('\n ##### '+ IP.strip() + ' ##### \n' )
    RTR = {
    'ip':   IP,
    'username': '******',
    'password': '******',
    'device_type': 'cisco_ios',
    }

    net_connect = Netmiko(**RTR)

    output = net_connect.send_config_from_file(config_file = '16_config')
    print(output)

    output = net_connect.send_command('show ip int brief')
    print(output)
#!/usr/bin/env python
from __future__ import print_function, unicode_literals

# Netmiko is the same as ConnectHandler
from netmiko import Netmiko
from getpass import getpass

my_device = {
    'host': "host.domain.com",
    'username': '******',
    'password': getpass(),
    'device_type': 'cisco_ios',
}

net_connect = Netmiko(**my_device)

# Make configuration changes using an external file
output = net_connect.send_config_from_file("change_file.txt")
print(output)

net_connect.disconnect()
Exemple #17
0
### Configuring a Networking Device from a File

from netmiko import Netmiko
connection_object = Netmiko(device_type='cisco_ios',
                            host='192.168.128.129',
                            port=22,
                            username='******',
                            password='******',
                            secret='automation')

print(' \n   *** Entering Enable Mode *** \n')
connection_object.enable()

## Netmiko offers us a method called SEND_CONFIG_FROM_FILE and it send all from that file into SSH connection
print(' ... Sending commands from file ospf.txt ...\n')
output_var = connection_object.send_config_from_file(
    'ospf.txt ')  ## the ARGUMENT will be file ospf.txt
print(output_var)

print(' \n     *** Closing the connection *** ')
connection_object.disconnect()
Exemple #18
0
from netmiko import Netmiko
from getpass import getpass

ip_addr = sys.argv[1]
username = sys.argv[2]

my_device = {
    'host': ip_addr,
    'username': username,
    'password': getpass(),
    'device_type': 'cisco_ios'
}

cfg_commands = ['logging buffered 10000', 'no logging console']

net_conn = Netmiko(**my_device)

cfg_cmds_output = net_conn.send_config_set(cfg_commands)

cfg_file_output = net_conn.send_config_from_file('config.txt')
print(cfg_file_output)

sh_run_output = net_conn.send_command('show running-config all | i logging')

if cfg_commands[0] in sh_run_output and cfg_commands[1] in sh_run_output:
    print("Commands committed successfully!")
else:
    print("Commands not committed.")

net_conn.disconnect()
Exemple #19
0
#!/usr/bin/env python
from netmiko import Netmiko

# Sending device ip's stored in a file
with open('device_list') as f:
    device_list = f.read().splitlines()

# Iterate through device list and configure the devices
for device in device_list:
    print('Connecting to device ' + device)
    ip_address_of_device = device

    # SSH Connection details
    ios_device = {
        'device_type': 'cisco_ios',
        'ip': ip_address_of_device,
        'username': '******',
        'password': '******'
    }

    net_connect = Netmiko(**ios_device)
    output = net_connect.send_config_from_file('reset_config')
    print(output)
Exemple #20
0
from netmiko import Netmiko

my_dev = {
    'host': '10.99.236.231',
    'username': '******',
    'password': '',
    'device_type': 'fortinet',
}

net_conn = Netmiko(**my_dev)


# Config
cfg_cmds = [
    'config system global', 
      'set hostname fgvm_test',
    'end'
]

out = net_conn.send_config_set(cfg_cmds)

out = net_conn.send_config_from_file('config_changes.txt')

# Check
cmd = 'sh sys gl'
out = net_conn.send_command(cmd)

print(out)

net_conn.disconnect()
Exemple #21
0
from netmiko import Netmiko
from getpass import getpass

#use same password for config and enable mode
password = getpass()

my_device = {
    'host': '10.8.20.100',
    'username': '******',
    'password': password,
    'secret': password,
    'device_type': 'cisco_ios'
    # Use invalid device type to see all supported devices
    # 'device_type': 'foo'
}

net_conn = Netmiko(**my_device)

output = net_conn.send_config_from_file("change_file.txt")

print()
print('-' * 80)
print(output)
print('-' * 80)
print()
Exemple #22
0
from netmiko import Netmiko
import logging

devices = [{
    "device_type": "cisco_xe",
    "ip": "ios-xe-mgmt-latest.cisco.com",
    "username": "******",
    "password": "******",
    "port": "8181",
}]

logging.basicConfig(filename="test.log", level=logging.DEBUG)
logger = logging.getLogger("netmiko")

for device in devices:
    net_connect = Netmiko(**device)
    output = net_connect.send_config_from_file('changes.txt')
    print(output)
    net_connect.disconnect()
Exemple #23
0
from netmiko import Netmiko
from credentials import password1, username1
cisco1 = {
    "host": "10.223.44.102",
    "username": username1,
    "password": password1,
    "device_type": "cisco_ios",
}

cfg_file = "change_file.txt"

net_connect = Netmiko(**cisco1)

print()
print(net_connect.find_prompt())
net_connect.send_config_from_file(cfg_file)
output = net_connect.send_command("sh run | i logging ")
print(output)
print()

# net_connect.save_config()
net_connect.disconnect()
Exemple #24
0
    inp_file = in_file.readlines()

for ip in inp_file:

    Devices = {
        'device_type': 'cisco_ios',
        'host': ip,
        'username': '******',
        'password': '******',
        'port': 22,  # optional, defaults to 22
        'secret': '',  # optional, defaults to ''
        'auth_timeout': 20
    }

    net_connect = Netmiko(**Devices)
    time.sleep(20)

    cfg_file = "configfile.txt"

    print()
    print(net_connect.find_prompt())
    output = net_connect.enable()
    output = net_connect.send_config_from_file(cfg_file)
    print(output)
    print()

    net_connect.save_config()
    net_connect.disconnect()

#---------------------------------------------[Code Ends]------------------------------------------------------#
Exemple #25
0
    print("vlan " + str(i))
    print("name wireless_user-v"+ str(i))
    print("tagged 3")
for i in range(150,200):
    print("vlan " + str(i))
    print("name server-v"+ str(i))
    print("tagged 3")
for i in range(200,250):
    print("vlan " + str(i))
    print("name wired_user-v"+ str(i))
    print("tagged 3")

# close the file, stop redirecting stdout 
sys.stdout.close()
sys.stdout = orig_stdout

# setup Netmiko
switch = {
            'host': '10.139.146.3',
            'username': '******',
            'password': '******',
            'device_type': 'hp_procurve',
            }
switchconnect = Netmiko(**switch)
switchconnect.enable()

# run Netmiko, print what happens on switch, disconnect
output = switchconnect.send_config_from_file("switchfile")
print(output)
switchconnect.disconnect()
Exemple #26
0
    print ('Connecting to device ' + devices)
    ip_address_of_device = devices
    ios_device = {
        'device_type': 'cisco_ios',
        'ip': ip_address_of_device,
        'username': username,
        'password': password
    }
    # Error handling parameters
    try:
        net_connect = Netmiko(**ios_device)
    except (AuthenticationException):
        print ('Authentication failure: ' + ip_address_of_device)
        continue
    except (NetMikoTimeoutException):
        print ('Timeout to device: ' + ip_address_of_device)
        continue
    except (EOFError):
        print ("End of file while attempting device " + ip_address_of_device)
        continue
    except (SSHException):
        print ('SSH Issue. Are you sure SSH is enabled? ' + ip_address_of_device)
        continue
    except Exception as unknown_error:
        print ('Some other error: ' + str(unknown_error))
        continue

    # Configure the device and save config
    output = net_connect.send_config_from_file('config_commands')
    output += net_connect.send_command('wr mem')
    print (output)
Exemple #27
0
    print("ip address 10.1." + str(i) + ".1 255.255.255.0")
    print("security-level 75")
for i in range(200, 250):
    print("interface GigabitEthernet0/3." + str(i))
    print("vlan " + str(i))
    print("nameif wired_user-v" + str(i))
    print("ip address 10.1." + str(i) + ".1 255.255.255.0")
    print("security-level 75")

# close the file, stop redirecting stdout
sys.stdout.close()
sys.stdout = orig_stdout

# setup Netmiko
firewall = {
    'host': '10.139.146.1',
    'username': '******',
    'password': '******',
    'device_type': 'cisco_asa',
    'secret': 'not_the_real_enable_password_either',
}
firewallconnect = Netmiko(**firewall)
firewallconnect.enable()

# run Netmiko, print what happens on firewall, disconnect
# https://github.com/ktbyers/netmiko/issues/2025 for why we want that cmd_verify=False here
output = firewallconnect.send_config_from_file("firewallfile",
                                               cmd_verify=False)
print(output)
firewallconnect.disconnect()
Exemple #28
0
from getpass import getpass 
from netmiko import Netmiko

password = getpass()

device = {
   'host': '192.168.122.72',
   'username': '******',
   'password': password,
   'device_type': 'cisco_ios'
}

ios_commands = ['logging trap alerts', 'spanning-tree portfast bpduguard default']
net_connect = Netmiko(**device)

net_connect.send_command_set(ios_commands)
net_connect.send_config_from_file('cmd_file')

Exemple #29
0
    'secret' : password,
    'device_type' : 'cisco_ios',
}

my_routers = [IOU1, IOU2]
net_conn = Netmiko(**IOU1)

print(net_conn.find_prompt())
# send_command for execute command not in config mode
print(net_conn.send_command("show run | inc hostname"))
set1 = ['hostname IOU_1', 'logging console']
#send config from list
print(net_conn.send_config_set(set1))
#send from file
print("send config from file")
print(net_conn.send_config_from_file("D:/Python/Python for NE/Week6/config.txt"))

for device_ip in my_routers:
    net_conn = Netmiko(**device_ip)
    print(f"----- Interface UP on router {device_ip} -----")
    print(net_conn.send_command("show ip int bri | inc up"))









Exemple #30
0
    'username': '******',
    'password': '******',
    'secret': 'ENABLE',
}

cisco_riv202 = {
    'device_type': 'cisco_ios',
    'ip': '10.214.128.202',
    'username': '******',
    'password': '******',
    'secret': 'ENABLE',
}

cisco_riv203 = {
    'device_type': 'cisco_ios',
    'ip': '10.214.128.203',
    'username': '******',
    'password': '******',
    'secret': 'ENABLE',
}

for cisco_access_riv in (cisco_riv200, cisco_riv201, cisco_riv202, cisco_riv203):
    net_connect = Netmiko(**cisco_access_riv)
    net_connect.enable()
    output = net_connect.send_config_from_file('vlan1000.txt')
print((cisco_riv200)output)

net_connect.disconnect()


Exemple #31
0
import os
from netmiko import Netmiko
from getpass import getpass
from pprint import pprint
from datetime import datetime

#password = getpass()
hosts = ["cisco1.lasthop.io", "cisco2.lasthop.io"]

for host in hosts:
    device = {'host': host, 'username': '******', 'password': '******', 'device_type': 'cisco_ios', 'session_log': 'logging.txt', 'fast_cli': True}
    ssh_conn = Netmiko(**device)
    print(ssh_conn.find_prompt())

    print("Configuration of vlan 100-105")
    sent_vlan = ssh_conn.send_config_from_file("vlans.txt")
    print("Commit")
    write_conf = ssh_conn.save_config()
    print(write_conf)





Exemple #32
0
except NameError:
    host = input("Enter host to connect to: ")

password = getpass()
device = {
    'host': host,
    'username': '******',
    'password': password,
    'device_type': 'cisco_ios',
    "secret": "cisco"
}

net_connect = Netmiko(**device)
net_connect.enable()
# Use send_config_set() to make config change
config = ['logging console', 'logging buffer 15000']
output = net_connect.send_config_set(config)
output_printer(output)

# Use send_config_from_file() to make config change
output = net_connect.send_config_from_file('config.txt')
output_printer(output)

message = "Verifying config change\n"
output = net_connect.send_command("show run | inc logging")
if '8000' in output:
    message += "Logging buffer is size 8000"
else:
    message += "Logging buffer size is not correct!"
output_printer(message)
Exemple #33
0
except NameError:
    host = input("Enter host to connect to: ")

password = getpass()
device = {
    'host': host,
    'username': '******',
    'password': password,
    'device_type': 'cisco_ios',
}

net_connect = Netmiko(**device)

# Use send_config_set() to make config change
config = ['logging console', 'logging buffer 15000']
output = net_connect.send_config_set(config)
output_printer(output)

# Use send_config_from_file() to make config change
output = net_connect.send_config_from_file('config.txt')
output_printer(output)


message = "Verifying config change\n"
output = net_connect.send_command("show run | inc logging")
if '8000' in output:
    message += "Logging buffer is size 8000"
else:
    message += "Logging buffer size is not correct!"
output_printer(message)