def run(self): self.logfile = open(os.getcwd() + '/' + 'linkfailure_log', 'a') while True: while self.failed() == False: time.sleep(1) # select a router r_number = random.randint(1,len(self.rtr)) - 1 # select a random interface i_number = random.randint(1, len(self.rtr[r_number]['interfaces'])) - 1 #set interfaces ge-1/0/3 disable cmd = 'set interfaces ' + self.rtr[r_number]['interfaces'][i_number]['name'] + ' disable' dev = Device(host=self.rtr[r_number]['ip'], user='******', password='******') dev.open() dev.timeout = 60 cu = Config(dev) cu.lock() cu.load(cmd, format='set', merge=True) cu.commit() cu.unlock() dev.close() link__data = { 'status': 'failed', 'timestamp': datetime.datetime.fromtimestamp(time.time()).strftime('%a:%H:%M:%S'), 'router_id': self.rtr[r_number]['router_id'], 'router_name': self.rtr[r_number]['name'], 'interface_address': self.rtr[r_number]['interfaces'][i_number]['address'], 'interface_name': self.rtr[r_number]['interfaces'][i_number]['name'] } jd = json.dumps(link__data) self.redis.publish('link_event', jd) self.logfile.write("Link failed: " + datetime.datetime.fromtimestamp(time.time()).strftime('%a:%H:%M:%S') + " " + self.rtr[r_number]['name'] + " " + self.rtr[r_number]['ip'] + " " + self.rtr[r_number]['interfaces'][i_number]['name'] + "\n") self.logfile.flush() # now repair the link while self.repaired() == False: time.sleep(1) cmd = 'delete interfaces ' + self.rtr[r_number]['interfaces'][i_number]['name'] + ' disable' dev = Device(host=self.rtr[r_number]['ip'], user='******', password='******') dev.open() dev.timeout = 60 cu = Config(dev) cu.lock() cu.load(cmd, format='set', merge=True) cu.commit() cu.unlock() dev.close() link__data = { 'status': 'healed', 'timestamp': datetime.datetime.fromtimestamp(time.time()).strftime('%a:%H:%M:%S'), 'router_id': self.rtr[r_number]['router_id'], 'router_name': self.rtr[r_number]['name'], 'interface_address': self.rtr[r_number]['interfaces'][i_number]['address'], 'interface_name': self.rtr[r_number]['interfaces'][i_number]['name'] } jd = json.dumps(link__data) self.redis.publish('link_event', jd) self.logfile.write("Link healed: " + datetime.datetime.fromtimestamp(time.time()).strftime('%a:%H:%M:%S') + " " + self.rtr[r_number]['name'] + " " + self.rtr[r_number]['ip'] + " " + self.rtr[r_number]['interfaces'][i_number]['name'] + "\n") self.logfile.flush()
def device(connect_string): """Return a connected device. This should be run as a context. Devices will be kept open and reused. If a device is already in use, entering the context will block until the device is ready. """ with device_lock: device, lock = device_list.get(connect_string, (None, None)) if device is None: # Parse the connect string mo = connect_re.match(connect_string) if not mo: raise ValueError("unparsable host string") args = {k: v for k, v in mo.groupdict().items() if v is not None} device = Device(**args) lock = threading.Lock() device_list[connect_string] = device, lock with lock: if not device.connected: device.open(gather_facts=False, attempts=3) device.timeout = 60 yield device
def main(): #iterate over csv for row in devList: #Make Device Connection dev = Device(host=row[1], user=userName, password=userPassword) try: #Print Opening Header for Status now1 = datetime.datetime.now() pprint("Work starts on " + row[0] + " | " + row[1] + " at " + now1.strftime("%Y-%m-%d %H:%M")) #Open Device with Custom Timer dev.open() dev.timeout = 300 except Exception as err: sys.stderr.write('Cannot connect to device: {0}\n'.format(err)) #Do RPC/Work try: #Start Work here #Write Element Seperator print("+++++++++++++++++++++++++++++++++++++++++++++++++") #Close Device dev.close() except Exception as err: sys.stderr.write('Cannot perform RPC on device: ' + row[1] + '\n'.format(err)) print("+++++++++++++++++++++++++++++++++++++++++++++++++")
def deployConfig(my_device_list_dict, my_username, my_password, my_config_template_file): my_hostname="" try: my_hostname=my_device_list_dict["mgmt_ip"] printProgress("INFO",my_hostname,"Connecting to device through netconf.") dev=Device(my_hostname,user=my_username,password=my_password) dev.open() dev.timeout=3*60 cu = Config(dev) printProgress("INFO",my_hostname,"Going to load template the config now.") # Determine if template file is in "set" or "bracketed" format if isSet(my_config_template_file): rsp=cu.load(template_path=my_config_template_file,format='set',template_vars=my_device_list_dict) else: rsp=cu.load(template_path=my_config_template_file,template_vars=my_device_list_dict) printProgress("INFO",my_hostname,"Performing diff between active and candidate config.") cu.pdiff() printProgress("INFO",my_hostname,"Performing commit check") if cu.commit_check(): printProgress("INFO",my_hostname,"commit check was successfull.") printProgress("INFO",my_hostname,"performing commit now.") commit_status=cu.commit() printProgress("INFO",my_hostname,"disconnecting from device.") dev.close() return commit_status else: return False except Exception,err: printProgress("ERROR",my_hostname,"Encountered exception while deploying config") printProgress("ERROR",my_hostname,str(err)) return False
def connect(module): host = get_param(module, 'host') kwargs = { 'port': get_param(module, 'port') or 830, 'user': get_param(module, 'username') } if get_param(module, 'password'): kwargs['passwd'] = get_param(module, 'password') if get_param(module, 'ssh_keyfile'): kwargs['ssh_private_key_file'] = get_param(module, 'ssh_keyfile') kwargs['gather_facts'] = False try: device = Device(host, **kwargs) device.open() device.timeout = get_param(module, 'timeout') or 10 except ConnectError: exc = get_exception() module.fail_json('unable to connect to %s: %s' % (host, str(exc))) return device
def main(): parser = argparse.ArgumentParser(description='Displays configuration elements with select hashtag. Hashtags are configured at any level using "set apply-macro ht <hashtag-name>" command.') for key in arguments: parser.add_argument(('-' + key), required=True, help=arguments[key]) args = parser.parse_args() dev = Device() dev.open() dev.timeout = 300 xml_config = dev.rpc.get_config(options={'database':'committed','inherit':'inherit'}) paths = [] #select all elements matching pattern for ht_element in xml_config.findall( './/apply-macro/data/[name=\'{}\']/../'.format( args.hashtag)): #filter by node id just in case if ht_element.text == 'ht': s = build_xml_filter( xml_config, ht_element.getparent().getparent()) paths.append( s) if paths: path = '<configuration>'+"".join( paths)+'</configuration>' #17.x versions of PyEz expect filter_xml to be an etree instance xml_config = dev.rpc.get_config( filter_xml= etree.XML( path),options={'database':'committed','inherit':'inherit', 'format':'text'}) print xml_config.text else: print 'hashtag \'{}\' is not found'.format( args.hashtag) dev.close()
def get_connected_device(self, requester_name, device): LOGGER.debug('get_connected_device, request by [%s]', requester_name) time1 = time.time() dev_name = device.get('ip_address') password_encoded = self.config.get('password_encoded', False) if password_encoded: pwd = utils.decrypt_passwd(device.get('password')) else: pwd = device.get('password') try: dev = Device(host=dev_name, user=device.get('user'), password=pwd, port=device.get('port', 22), gather_facts=False, auto_probe=5) rpc_timeout = self.config.get('rpc_timeout', 1) * 60 dev.open() if dev.connected: dev.timeout = rpc_timeout return dev except Exception as e: LOGGER.error( 'connect, for device [%s, %s] failed', dev_name, e) finally: LOGGER.debug( 'connect, for device %s %d(s)', dev_name, (time.time() - time1)) return None
def main(device_ip, peer_ip): config = ConfigDictionary() username = config.username() password = config.password() print (device_ip + " logging in as " + username) jdev = Device(user=username, host=device_ip, password=password) jdev.open(gather_facts=False) jdev.timeout=6000 try: resultxml = jdev.rpc.get_route_information(table='inet.0',protocol='bgp',peer=peer_ip,extensive=True) except Exception as err: print "CMD:" etree.dump(err.cmd) print "RSP:" etree.dump(err.rsp) for routexml in resultxml.findall('.//rt'): route = RouteData(routexml) print "destination: " + route.prefix() + "as-path: " + route.aspath() jdev.close()
def main(args): '''Acquire necessary input options, interact with SRX device as specified per CLI args.''' parser = argparse.ArgumentParser( description='Interact with specified SRX device as specified') parser.add_argument('--version', action='version', version=__version__) parser.add_argument('-d', '--datafile', help='specify YAML file to read router info from', default=SRX_FILE) parser.add_argument('--prompt', action='store_true', help='prompt for router info (do not try to read in from file)', default=False) parser.add_argument('-v', '--verbose', action='store_true', help='display verbose output', default=False) args = parser.parse_args() # Debugging #if args.verbose: # print 'Args = {}'.format(args) # Initialize data structures mysrx = {} if not args.prompt: mysrx = yaml_input(args.datafile, args.verbose) # Debugging #if args.verbose: # print 'mysrx = {}'.format(mysrx) else: if args.verbose: print 'Prompting specified - asking user for all connection details' check_input(mysrx, args.verbose) mysrx_conn = Device(host=mysrx['HOST'], user=mysrx['USER'], password=mysrx['PASSWORD']) if args.verbose: print 'Opening NETCONF connection to {}...'.format(mysrx['HOST']) mysrx_conn.open() # Set timeout - default of 30 seconds can be problematic, must set after open() mysrx_conn.timeout = TIMEOUT mysrx_cfg = Config(mysrx_conn) # Change 1 if args.verbose: print '\nChange #1' srx_conf(mysrx, mysrx_cfg, SRX_CONF_CHG1, 'set', True, False, verbose=args.verbose) # Change 2 if args.verbose: print '\nChange #2' srx_conf(mysrx, mysrx_cfg, SRX_CONF_FILE, 'text', True, True, 'Temporarily changing hostname.', args.verbose) # Change 3 if args.verbose: print '\nChange #3' srx_conf(mysrx, mysrx_cfg, SRX_XML_FILE, 'xml', True, True, 'Restoring original hostname.', args.verbose) # Cleanup mysrx_conn.close()
def _connect(self): """Connect to a device. :returns: a connection to a Juniper Networks device. :rtype: ``Device`` """ dev = Device(self.hostname, user=self.user, password=self.password) dev.open() dev.timeout = self.timeout return dev
def juniper_connection_setup(): django.setup() device = NetworkDevice.objects.get(device_name='juniper-srx') print "Connecting to device: %s" % device.device_name jnp_dev = Device(host=device.ip_address, user=device.credentials.username, password=device.credentials.password) jnp_dev.open() jnp_dev.timeout = 120 if jnp_dev.facts: return jnp_dev else: return None
def main(args): '''Acquire necessary input options, interact with SRX device as specified per CLI args.''' parser = argparse.ArgumentParser( description='Interact with specified SRX device as specified') parser.add_argument('--version', action='version', version=__version__) parser.add_argument('-d', '--datafile', help='specify YAML file to read router info from', default=SRX_FILE) parser.add_argument('--prompt', action='store_true', help='prompt for router info (do not try to read in from file)', default=False) parser.add_argument('-v', '--verbose', action='store_true', help='display verbose output', default=False) args = parser.parse_args() # Debugging #if args.verbose: # print 'Args = {}'.format(args) # Initialize data structures mysrx = {} if not args.prompt: mysrx = yaml_input(args.datafile, args.verbose) # Debugging #if args.verbose: # print 'mysrx = {}'.format(mysrx) else: if args.verbose: print 'Prompting specified - asking user for all connection details' check_input(mysrx, args.verbose) mysrx_conn = Device(host=mysrx['HOST'], user=mysrx['USER'], password=mysrx['PASSWORD']) if args.verbose: print 'Opening NETCONF connection to {}...'.format(mysrx['HOST']) mysrx_conn.open() # Set timeout - default of 30 seconds can be problematic, must set after open() mysrx_conn.timeout = TIMEOUT ethports = EthPortTable(mysrx_conn) if args.verbose: print 'Gathering EthPortTable info from {}...'.format(mysrx['HOST']) ethports.get() print 'Device Ethernet Port information for {}:'.format(mysrx['HOST']) for int_key in ethports.keys(): print '{}:'.format(int_key) for int_subkey in ethports[int_key].keys(): if int_subkey == 'oper': print ' \\Operational Status: {}'.format(ethports[int_key][int_subkey]) elif int_subkey == 'rx_packets': print ' \\Received Packets: {}'.format(ethports[int_key][int_subkey]) elif int_subkey == 'tx_packets': print ' \\Transmitted Packets: {}'.format(ethports[int_key][int_subkey]) mysrx_conn.close()
def main(): #iterate over csv for row in devList: #Make Device Connection dev = Device(host=row[1], user=userName, password=userPassword) try: #Print Opening Header for Status now1 = datetime.datetime.now() pprint("Work starts on " + row[0] + " | " + row[1] + " at " + now1.strftime("%Y-%m-%d %H:%M")) #Open Device with Custom Timer dev.open() dev.timeout = 900 except Exception as err: sys.stderr.write('Cannot connect to device: {0}\n'.format(err)) #Do RPC/Work try: #Start Work here #Create an instance of SW sw = SW(dev) try: ok = sw.install(package=package, remote_path=remote_path, progress=myprogress, validate=validate, no_copy=noCopy, timeout=1800) except Exception as err: msg = 'Unable to install software, {0}'.format(err) print(msg) ok = False if ok is True: print('Software installation complete. Rebooting') rsp = sw.reboot() print('Upgrade pending reboot cycle, please be patient.') print(rsp) else: msg = 'Unable to install software, {0}'.format(ok) print(msg) #Write Element Seperator print("+++++++++++++++++++++++++++++++++++++++++++++++++") #Close Device dev.close() except Exception as err: sys.stderr.write('Cannot perform RPC on device: ' + row[1] + '\n'.format(err)) print("+++++++++++++++++++++++++++++++++++++++++++++++++")
def main(): print("\nWelcome to Junos Upgrade Tool \n") # Request which code to upgrade with fileList = getFileList(code_path) package = getOptionAnswer("Choose a junos package", fileList) package = code_path + package # Request IP for the system to upgrade host = getInputAnswer("IP Address of the host") # Get username and password parameters username=getInputAnswer("\nEnter your device username") password=getpass(prompt="\nEnter your device password: ") # initialize logging logging.basicConfig(filename=logfile, level=logging.INFO, format='%(asctime)s:%(name)s: %(message)s') logging.getLogger().name = host sys.stdout.write('Information logged in {0}\n'.format(logfile)) # verify package exists if (os.path.isfile(package)): found = True else: msg = 'Software package does not exist: {0}. '.format(package) sys.exit(msg + '\nExiting program') dev = Device(host,user=username,password=password) try: dev.open() except Exception as err: sys.stderr.write('Cannot connect to device: {0}\n'.format(err)) return # Increase the default RPC timeout to accommodate install operations dev.timeout = 300 # Create an instance of SW sw = SW(dev) try: do_log('Starting the software upgrade process: {0}'.format(package)) ok = sw.install(package=package, remote_path=remote_path, progress=update_progress, validate=validate) except Exception as err: msg = 'Unable to install software, {0}'.format(err) do_log(msg, level='error') else: if ok is True: do_log('Software installation complete. Rebooting') rsp = sw.reboot() do_log('Upgrade pending reboot cycle, please be patient.') do_log(rsp) # End the NETCONF session and close the connection dev.close()
def main(): # iterate over csv for row in devList: # Make Device Connection dev = Device(host=row[1], user=userName, password=userPassword) try: # Print Opening Header for Status now1 = datetime.datetime.now() pprint("Work starts on " + row[0] + " | " + row[1] + " at " + now1.strftime("%Y-%m-%d %H:%M")) # Open Device with Custom Timer dev.open() dev.timeout = 900 except Exception as err: sys.stderr.write("Cannot connect to device: {0}\n".format(err)) # Do RPC/Work try: # Start Work here # Create an instance of SW sw = SW(dev) try: ok = sw.safe_copy( package=package, remote_path=remote_path, progress=myprogress, clean_fs=freeSpace, timeout=1800 ) except Exception as err: msg = "Unable to copy software, {0}".format(err) print (msg) ok = False if ok is True: print ("Software copy complete.") else: msg = "Unable to copy software, {0}".format(ok) print (msg) # Write Element Seperator print ("+++++++++++++++++++++++++++++++++++++++++++++++++") # Close Device dev.close() except Exception as err: sys.stderr.write("Cannot perform RPC on device: " + row[1] + "\n".format(err)) print ("+++++++++++++++++++++++++++++++++++++++++++++++++")
def main(peer_asn): list_peering_ips_of_target_asn = [] config = ConfigDictionary("/home/andy/etc/pypeer.ini") username = config.username() password = config.password() for router in config.get_list_of_router_names(): jdev = Device(user=username, host=config.get_router_ip(router), password=password) jdev.open(gather_facts=False) jdev.timeout = 600 try: resultxml = jdev.rpc.get_bgp_summary_information() except Exception as err: print "CMD:" etree.dump(err.cmd) print "RSP:" etree.dump(err.rsp) bgpsum = BgpData(resultxml) for thispeeringip in bgpsum.get_list_ipaddr_from_asn(peer_asn): list_peering_ips_of_target_asn.append(thispeeringip) exchange = Exchange() list_sessions_configured_peeringdbid_exchanges_of_target_asn = [] for peering_ip in list_peering_ips_of_target_asn: if not is_valid_ipv4_address(peering_ip): next else: peeringdb_id = exchange.get_exchange_from_peerip(peering_ip)['peeringdbid'] list_sessions_configured_peeringdbid_exchanges_of_target_asn.append(peeringdb_id) # todo: pull this from config file list_my_exchanges = [26, 806, 87, 59, 33, 31, 804, 1, 255, 5, 359, 48, 387, 435, 583, 745, 18, 777, 53, 297, 35, 70, 64, 60, 325, 587] peeringdb = PeeringDBClient() list_their_exchanges = peeringdb.get_list_connected_ixp(peer_asn) mutual_exchanges = set(list_my_exchanges).intersection(list_their_exchanges) missing_exchanges = set(mutual_exchanges).difference(list_sessions_configured_peeringdbid_exchanges_of_target_asn) print "Missing exchanges are:" + str(missing_exchanges) for pdbid in missing_exchanges: print str(pdbid) + ": " + peeringdb.get_name_of_ixp_from_pdbid(pdbid)
def main(): #Setup for output now = datetime.datetime.now() txt = os.path.join(save_path, filePrefix + "-" + now.strftime("%Y%m%d-%H%M") + ".txt") text_file = open(txt, "w") #Write Opening Seperator text_file.write("+++++++++++++++++++++++++++++++++++++++++++++++++" + '\n') #iterate over csv for row in devList: #Make Device Connection dev = Device(host=row[1], user=userName, password=userPassword) try: #Print Opening Header for Status now1 = datetime.datetime.now() pprint("Work starts on " + row[0] + " | " + row[1] + " at " + now1.strftime("%Y-%m-%d %H:%M")) #Open Device with Custom Timer dev.open() dev.timeout = 300 except Exception as err: sys.stderr.write('Cannot connect to device: {0}\n'.format(err)) text_file.write('Cannot connect to device: {0}\n'.format(err) + '\n') #Do RPC/Work try: #Start Work here #Write Element Seperator print("+++++++++++++++++++++++++++++++++++++++++++++++++") text_file.write("+++++++++++++++++++++++++++++++++++++++++++++++++" '\n') #Close Device dev.close() except Exception as err: sys.stderr.write('Cannot perform RPC on device: ' + row[1] + '\n'.format(err)) print("+++++++++++++++++++++++++++++++++++++++++++++++++") text_file.write('Cannot perform RPC on device: ' + row[1] + '\n'.format(err) + '\n') text_file.write("+++++++++++++++++++++++++++++++++++++++++++++++++" + '\n')
def get_connected_device(self, requester_name, device): LOGGER.debug('get_connected_device, request by [%s]', requester_name) time1 = time.time() dev_name = device.get('ip_address') password_encoded = self.config.get('password_encoded', False) if password_encoded: pwd = utils.decrypt_passwd(device.get('password')) else: pwd = device.get('password') dev = Device(host=dev_name, user=device.get('user'), password=pwd, port=device.get('port', 22), gather_facts=False, auto_probe=5) event = threading.Event() def dev_open(): try: dev.open() except Exception as e: LOGGER.error( 'connect, for device [%s, %s] failed', dev_name, e) finally: LOGGER.debug( 'connect, for device %s %d(s)', dev_name, (time.time() - time1)) event.set() thread = threading.Thread( target=dev_open, name='DevThread-' + dev_name) thread.start() time_out = self.config.get('connect_timeout', 1) * 60 rpc_timeout = self.config.get('rpc_timeout', 1) * 60 event.wait(time_out) if not event.isSet(): LOGGER.critical( 'connect, not returned, close forcefully [%s] ', dev_name) self.close_connected_device('self', dev) return None if dev.connected: dev.timeout = rpc_timeout return dev return None
def main(peer_asn): list_peering_ips_of_target_asn = [] config = ConfigDictionary("etc/pypeer.ini") username = config.username() password = config.password() for router in config.get_list_of_router_names(): jdev = Device(user=username, host=config.get_router_ip(router), password=password) jdev.open(gather_facts=False) jdev.timeout = 600 try: resultxml = jdev.rpc.get_bgp_summary_information() except Exception as err: print "CMD:" etree.dump(err.cmd) print "RSP:" etree.dump(err.rsp) bgpsum = BgpData(resultxml) for thispeeringip in bgpsum.get_list_ipaddr_from_asn(peer_asn): list_peering_ips_of_target_asn.append(thispeeringip) exchange = Exchange() list_sessions_configured_peeringdbid_exchanges_of_target_asn = [] for peering_ip in list_peering_ips_of_target_asn: if not is_valid_ipv4_address(peering_ip): next else: peeringdb_id = exchange.get_exchange_from_peerip(peering_ip)['peeringdbid'] list_sessions_configured_peeringdbid_exchanges_of_target_asn.append(peeringdb_id) peeringdb = PeeringDBClient() peeringjson = PeeringDBParser(peeringdb.asn(peer_asn)) list_their_exchanges = peeringjson.get_list_of_asn_exchanges() mutual_exchanges = set(config.get_list_of_connected_exchanges()).intersection(list_their_exchanges) missing_exchanges = set(mutual_exchanges).difference(list_sessions_configured_peeringdbid_exchanges_of_target_asn) print "Missing exchanges are:" + str(missing_exchanges) for pdbid in missing_exchanges: ixpparser = PeeringDBParser(peeringdb.ixlan(pdbid)) print str(pdbid) + ": " + ixpparser.get_name_of_ixorg_from_ixlan()
def main(peer_asn, output): config = ConfigDictionary() username = config.username() password = config.password() local_preferences = config.get_list_of_localpref() for router in config.get_list_of_router_names(): jdev = Device(user=username, host=config.get_router_ip(router), password=password) jdev.open(gather_facts=False) jdev.timeout = 600 regex_asn = ".* " + peer_asn try: resultxml = jdev.rpc.get_route_information(table='inet.0', aspath_regex=regex_asn, extensive=True) except Exception as err: print "CMD:" etree.dump(err.cmd) print "RSP:" etree.dump(err.rsp) jdev.close() sorted_routes = {} sorted_routes["peer"] = [] sorted_routes["peer-indirect"] = [] sorted_routes["peer-routeserver"] = [] sorted_routes["transit"] = [] sorted_routes["customer"] = [] sorted_routes["outofrange"] = [] for routexml in resultxml.findall('.//rt'): route = RouteData(routexml) full_prefix = route.prefix() session_type = route.get_adjacency_type(local_preferences) sorted_routes[session_type].append(full_prefix) if output == 'machine': print json.dumps(sorted_routes) else: print "For " + router + " in " + config.get_router_location(router) + " Routes: " + str(len(sorted_routes["peer"])) + " via bilateral peering, " + str(len(sorted_routes["peer-routeserver"])) + " via peering at mlp, " + str(len(sorted_routes["peer-indirect"])) + " via peering in other cities " + str(len(sorted_routes["customer"])) + " via customer, and " + str(len(sorted_routes["transit"])) + " via transit."
def main(args): '''Acquire necessary input options, interact with SRX device as specified per CLI args.''' parser = argparse.ArgumentParser( description='Interact with specified SRX device as specified') parser.add_argument('--version', action='version', version=__version__) parser.add_argument('-d', '--datafile', help='specify YAML file to read router info from', default=SRX_FILE) parser.add_argument('--prompt', action='store_true', help='prompt for router info (do not try to read in from file)', default=False) parser.add_argument('-v', '--verbose', action='store_true', help='display verbose output', default=False) args = parser.parse_args() # Debugging #if args.verbose: # print 'Args = {}'.format(args) # Initialize data structures mysrx = {} if not args.prompt: mysrx = yaml_input(args.datafile, args.verbose) # Debugging #if args.verbose: # print 'mysrx = {}'.format(mysrx) else: if args.verbose: print 'Prompting specified - asking user for all connection details' check_input(mysrx, args.verbose) mysrx_conn = Device(host=mysrx['HOST'], user=mysrx['USER'], password=mysrx['PASSWORD']) if args.verbose: print 'Opening NETCONF connection to {}...'.format(mysrx['HOST']) mysrx_conn.open() # Set timeout - default of 30 seconds can be problematic, must set after open() mysrx_conn.timeout = TIMEOUT print 'Device facts for {}:'.format(mysrx['HOST']) pprint(mysrx_conn.facts) mysrx_conn.close()
def main(device_ip, peer_asn, output): config = ConfigDictionary() username = config.username() password = config.password() jdev = Device(user=username, host=device_ip, password=password) jdev.open(gather_facts=False) jdev.timeout = 600 regex_asn = ".* " + peer_asn try: resultxml = jdev.rpc.get_route_information(table='inet.0', aspath_regex=regex_asn, extensive=True) except Exception as err: print "CMD:" etree.dump(err.cmd) print "RSP:" etree.dump(err.rsp) jdev.close() sorted_routes = {} sorted_routes["peer"] = [] sorted_routes["transit"] = [] sorted_routes["customer"] = [] sorted_routes["outofrange"] = [] for routexml in resultxml.findall('.//rt'): route = RouteData(routexml) full_prefix = route.prefix() session_type = config.get_type_from_localpref(route.activelocalpref()) sorted_routes[session_type].append(full_prefix) if output == 'machine': print json.dumps(sorted_routes) else: print "Number of routes: " + str(len(sorted_routes["peer"])) + " via peering, " + str(len(sorted_routes["customer"])) + " via customer, and " + str(len(sorted_routes["transit"])) + " via transit. (use -m for full output and breakdown)"
def main(): list_peeringdbid_of_connected_exchanges = [] config = ConfigDictionary("/home/andy/etc/pypeer.ini") username = config.username() password = config.password() exchange = Exchange() peeringdb = PeeringDBClient() for router in config.get_list_of_router_names(): jdev = Device(user=username, host=config.get_router_ip(router), password=password) jdev.open(gather_facts=False) jdev.timeout = 600 try: resultxml = jdev.rpc.get_bgp_summary_information() except Exception as err: print "CMD:" etree.dump(err.cmd) print "RSP:" etree.dump(err.rsp) bgpsum = BgpData(resultxml) for thispeeringip in bgpsum.get_list_peering_ips(): if not is_valid_ipv4_address(thispeeringip): next else: peeringdb_id = exchange.get_exchange_from_peerip(thispeeringip)['peeringdbid'] if peeringdb_id==0: next elif peeringdb_id in list_peeringdbid_of_connected_exchanges: next else: list_peeringdbid_of_connected_exchanges.append(peeringdb_id) ixpjson = peeringdb.ixlan(peeringdb_id) ixpparser = PeeringDBParser(ixpjson) print "%s: %s # %s" % (peeringdb_id, router, ixpparser.get_name_of_ixorg_from_ixlan())
def main(): #iterate over csv for row in devList: #Make Device Connection dev = Device(host=row[1], user=userName, password=userPassword) try: #Print Opening Header for Status now1 = datetime.datetime.now() pprint("Work starts on " + row[0] + " | " + row[1] + " at " + now1.strftime("%Y-%m-%d %H:%M")) #Open Device with Custom Timer dev.open() dev.timeout = 300 except Exception as err: sys.stderr.write('Cannot connect to device: {0}\n'.format(err)) #Do RPC/Work try: #Start Work here rsp = dev.rpc.file_archive(destination='/var/tmp/logs', source='/var/log/*', compress=True) with SCP(dev, progress=True) as scp1: scp1.get("/var/tmp/logs.tgz", local_path=output+"/"+row[0]+"-"+now1.strftime("%Y-%m-%d-%H%M")+"-logs.tgz") #Write Element Seperator print("+++++++++++++++++++++++++++++++++++++++++++++++++") #Close Device dev.close() except Exception as err: sys.stderr.write('Cannot perform RPC on device: ' + row[1] + '\n'.format(err)) print("+++++++++++++++++++++++++++++++++++++++++++++++++")
from jnpr.junos import Device from jnpr.junos.utils.config import Config from getpass import getpass a_device = Device(host="srx2.lasthop.io", user="******", password=getpass()) a_device.open() a_device.timeout = 60 cfg = Config(a_device) cfg.lock() cfg.load(path="test_config.xml", format="xml", merge=True) # overwrite=True - full configuration replace so be careful # cfg.commit(confirm=1) # cfg.commit() # cfg.unlock()
logger.info('[%s]: timestamp_tracking - CLI collection %s', host, timestamp_tracking['collector_ssh_ends']-timestamp_tracking['collector_ssh_start']) else: # By default it's a junos device # We need to CATCH errors then print then but we need to continue with next host... connected = False logger.info('Connecting to host: %s', host) target_commands = get_target_commands(host) timestamp_tracking={} timestamp_tracking['collector_start'] = int(datetime.today().strftime('%s')) # Establish connection to hosts user, passwd = get_credentials(host) jdev = Device(user=user, host=host, password=passwd, gather_facts=False, auto_probe=True, port=22) for i in range(1, max_connection_retries+1): try: jdev.open() jdev.timeout = default_junos_rpc_timeout connected = True break except Exception, e: if i < max_connection_retries: logger.error('[%s]: Connection failed %s time(s), retrying....', host, i) time.sleep(1) continue else: logging.exception(e) connected = False # Notify about the specific problem with the host BUT we need to continue with our list # First collect all kpi in datapoints {} then at the end we insert them into DB (performance improvement) if connected: datapoints = [] # By default execute show version in order to get version and platform as default tags for all kpi related to this host kpi_tags = {}
#!/usr/bin/python from jnpr.junos import Device from jnpr.junos.utils.config import Config from jnpr.junos.factory import loadyaml from getpass import getpass host = raw_input('hostname or address: ') username = raw_input('username: '******'password: '******'showinterface.yml')) dev = Device(host, user=username, password=passwd) #dev = Device(hostname, user=username, password=passwd) dev.open() dev.timeout = 60 interface_table = ShowInterface(dev) interface_table.get() for i in interface_table: if "ge" in i.name or "fe" in i.name or "vlan" in i.name: if i.addrfamily == 'inet' and i.status == 'up': print str(i.logicalname) + " " + str(i.logicalinetaddr) # print i.name + " " + str(i.description) + " " + str(i.linkmode) + " " + str(i.linkspeed) + " " + str(i.logicalname) + " " + str(i.logicalinetaddr) dev.close()
def reboot_device(self, ip, hostname): # Reboots a device # Status dictionary for post-upgrade reporting statusDict = {} if Menu.upgrade_list == '': statusDict['Upgrade_List'] = 'Juniper-Upgrade_' + Menu.username else: statusDict['Upgrade_List'] = Menu.upgrade_list statusDict['Upgrade_Start'] = '' statusDict['Upgrade_Finish'] = '-' statusDict['IP'] = ip statusDict['Connected'] = 'N' statusDict['OS_installed'] = '-' statusDict['Rebooted'] = 'N' statusDict['IST_Confirm_Loaded'] = '-' statusDict['IST_Confirm_Rebooted'] = '' statusDict['Comments'] = '' # Start the logging now = datetime.datetime.now() date_time = now.strftime("%Y-%m-%d-%H%M") reboot_log = Menu.log_dir + "juniper-reboot-LOG_" + date_time + "_" + Menu.username + ".log" logging.basicConfig(filename=reboot_log, level=logging.INFO, format='%(asctime)s:%(name)s: %(message)s') logging.getLogger().name = ip print('Information logged in {0}'.format(reboot_log)) # Display basic information self.do_log("Device: {0} ({1})".format(hostname, ip)) now = datetime.datetime.now() formattime = now.strftime("%Y-%m-%d %H:%M") self.do_log("Timestamp: {0}".format(formattime)) # Verify package exists before starting upgrade process dev = Device(ip, user=Menu.username, password=Menu.password) # Try to open a connection to the device try: self.do_log('\n') self.do_log( '------------------------- Opening connection to: {0} -------------------------\n' .format(ip)) self.do_log('User: {0}'.format(Menu.username)) dev.open() # If there is an error when opening the connection, display error and exit upgrade process except Exception as err: sys.stderr.write('Cannot connect to device: {0}\n'.format(err)) else: # Record connection achieved statusDict['Connected'] = 'Y' # Increase the default RPC timeout to accommodate install operations dev.timeout = 600 # Create an instance of SW sw = SW(dev) # Logging now = datetime.datetime.now() statusDict['Upgrade_Start'] = now.strftime("%Y-%m-%d %H:%M") self.do_log('Timestamp: {0}'.format(statusDict['Upgrade_Start'])) self.do_log('Beginning reboot cycle, please be patient.') # Attempt to reboot try: rsp = sw.reboot() self.do_log(rsp) except Exception as err: msg = 'Unable to reboot system, {0}'.format(err) self.do_log(msg, level='error') else: # Record reboot statusDict['Rebooted'] = 'Y' # End the NETCONF session and close the connection dev.close() self.do_log('\n') self.do_log( '------------------------- Closed connection to: {0} -------------------------\n' .format(ip)) return statusDict
if __name__ == '__main__': # Create instance of device object device_conn = Device(**srx2) # Establish the NETCONF connection device_conn.open() # Call the gather_routes function to get the routing tale of the device old_routing_table = gather_routes() # Print the routing table print("Routing table before the change") pprint(old_routing_table) print('-' * 40) # Exercise 4b # Increase the timeout device_conn.timeout = 60 # Pass NETCONRF connection into Config Object cnfg = Config(device_conn) # Lock configuration exclusively to us cnfg.lock() # Load configuration from external file in curly brace notation cnfg.load(path='routing.conf', format='text', merge=True) # Commit the configuration cnfg.commit() # Exercise 4c new_routing_table = gather_routes() # Print the routing table after the change so we can compare print("Routing table after the change") pprint(new_routing_table)
def getInterfaces(ipAddress, junosUsername, junosPassword): #Creates a view for PyEZ yml = ''' --- EthPortTable: rpc: get-interface-information args: extensive: True interface_name: '[agxe][et]*' args_key: interface_name item: physical-interface view: EthPortView EthPortView: fields: interface: name description: description admin_status: admin-status link_status: oper-status bpdu_error: bpdu-error mtu: mtu mode: logical-interface/address-family/address-family-flags/ifff-port-mode-trunk inet: logical-interface/address-family/interface-address lacp: logical-interface/address-family/ae-bundle-name ''' globals().update(FactoryLoader().load(yaml.load(yml, Loader=yaml.FullLoader))) #loads the yaml file dev = Device(host=ipAddress, user=junosUsername, password=junosPassword) try: dev.open(auto_probe=5) except: return {"Error": "Connection refused"} dev.timeout=120 interfaceTable = EthPortTable(dev).get() if len(interfaceTable)<1: dev.close() return {"Error":"Failed to find interface"} interfaceList=[] for i in interfaceTable: scripts=[{"script":"setInterfaceDescription","name":"Set Description"}, {"script":"getInterfaceConfig","name":"Get Configuration"}] if i.mtu=="9216": jumbo="enabled" else: jumbo="disabled" try: if len(i.mode)>0: mode="trunk" except: try: if len(i.inet)>0: mode="layer 3" except: try: if len(i.lacp)>0: mode="lacp-"+i.lacp.split(".")[0] except: mode="access" if mode=="trunk": scripts.append({"script":"trunkVLANdelete","name":"Delete Trunk VLAN"}) scripts.append({"script":"changeAccessVLAN","name":"Change Access VLAN"}) scripts.append({"script":"trunkVLANadd","name":"Add Trunk VLAN"}) if mode=="access": scripts.append({"script":"changeAccessVLAN","name":"Change Access VLAN"}) scripts.append({"script":"trunkVLANadd","name":"Add Trunk VLAN"}) if i.link_status=="up" and (mode=="trunk" or mode=="access"): scripts.append({"script":"getMACtable","name":"Get MAC Table"}) interfaceList.append({ 'name':i.name, 'description' : i.description, 'admin_status' : i.admin_status, 'link_status' : i.link_status, 'jumbo_frames':jumbo, 'mode':mode, 'scripts':scripts }) dev.close() upCount=0 #counts up interfaces for i in interfaceList: if i['link_status']=='up': upCount+=1 try: alarmCount=getAlarms(ipAddress=ipAddress)[1]['alarm-summary']['active-alarm-count'] except: alarmCount=0 updateSwitchInterfaceList(ipAddress=ipAddress, intNum=len(interfaceList), intUp=upCount, alarm_count=int(alarmCount)) return interfaceList
def collector(**kwargs): for host in kwargs["host_list"]: kpi_tags={} latest_datapoints={} # if ((db_schema == 1) and (not(use_hostname))): if (not(use_hostname)): latest_datapoints = get_latest_datapoints(host=host) logger.debug("Latest Datapoints are:") logger.debug(pformat(latest_datapoints)) # kpi_tags = get_host_base_tags(host=host) # Check host tag to identify what kind of connections will be used (ej junos / others / etc) if "non_junos_devices" in hosts[host].split(): pass # Reserved for future purposes else: # By default it's a junos device # We need to CATCH errors then print then but we need to continue with next host... connected = False logger.info('Connecting to host: %s', host) target_commands = get_target_commands(host) timestamp_tracking={} timestamp_tracking['collector_start'] = int(datetime.today().strftime('%s')) # Establish connection to hosts user, passwd, authMethod,authKey_file = get_credentials(host) if dynamic_args['test']: #Open an emulated Junos device instead of connecting to the real one _rpc_reply_dict = rpc_reply_dict() _rpc_reply_dict['dir'] = BASE_DIR_INPUT jdev = mocked_device(_rpc_reply_dict) # First collect all kpi in datapoints {} then at the end we insert them into DB (performance improvement) connected = True else: if authMethod in "key": jdev = Device(user=user, host=host, ssh_private_key_file=authKey_file, gather_facts=False, auto_probe=True, port=22) elif authMethod in "enc_key": jdev = Device(user=user, host=host, ssh_private_key_file=authKey_file, password=passwd, gather_facts=False, auto_probe=True, port=22) else: # Default is jdev = Device(user=user, host=host, password=passwd, gather_facts=False, auto_probe=True, port=22) for i in range(1, max_connection_retries+1): try: jdev.open() jdev.timeout = default_junos_rpc_timeout connected = True break except Exception, e: if i < max_connection_retries: logger.error('[%s]: Connection failed %s time(s), retrying....', host, i) time.sleep(1) continue else: logging.exception(e) connected = False # Notify about the specific problem with the host BUT we need to continue with our list # First collect all kpi in datapoints {} then at the end we insert them into DB (performance improvement) if connected: datapoints = [] # By default execute show version in order to get version and platform as default tags for all kpi related to this host kpi_tags = {} target_command = 'show version | display xml' version_xpath = "//package-information/comment" product_model_xpath = "//product-model" logger.info('[%s]: Executing command: %s', host, target_command) result = execute_command(jdev,target_command) if result: logger.debug('[%s]: Parsing command: %s', host, target_command) xml_data = etree.fromstring(result) value_tmp = xml_data.xpath(version_xpath)[0].text.strip() version = re.search('\[(.*?)\]$', value_tmp) if version: kpi_tags['version'] = version.group(1) else: kpi_tags['version'] = 'unknown' value_tmp = xml_data.xpath(product_model_xpath)[0].text.strip() kpi_tags['product-model'] = convert_variable_type(value_tmp) ## Based on parameter defined in config file if use_hostname: hostname_xpth = "//host-name" hostname_tmp = xml_data.xpath(hostname_xpth)[0].text.strip() hostname = convert_variable_type(hostname_tmp) logger.info('[%s]: Host will now be referenced as : %s', host, hostname) host = hostname # if (db_schema == 1): # latest_datapoints = get_latest_datapoints(host=host) # logger.info("Latest Datapoints are:") # logger.info(pformat(latest_datapoints)) latest_datapoints = get_latest_datapoints(host=host) logger.debug("Latest Datapoints are:") logger.debug(pformat(latest_datapoints)) else: logger.info('[%s]: Host will be referenced as : %s', host, host) kpi_tags['device']=host kpi_tags['kpi']="base-info" match={} match["variable-name"]="base-info" # We'll add a dummy kpi in oder to have at least one fixed kpi with version/platform data. get_metadata_and_add_datapoint(datapoints=datapoints,match=match,value_tmp=value_tmp,latest_datapoints=latest_datapoints,host=host,kpi_tags=kpi_tags) # Now we have all hosts tags that all host kpis will inherit # For each target_command execute it, parse it, and insert values into DB timestamp_tracking['collector_cli_start'] = int(datetime.today().strftime('%s')) for target_command in target_commands: logger.info('[%s]: Executing command: %s', host, target_command) # Execute rpc/command on host and get result result = execute_command(jdev,target_command) if result: logger.debug('[%s]: Parsing command: %s', host, target_command) parse_result(host,target_command,result,datapoints,latest_datapoints,kpi_tags) time.sleep(delay_between_commands) try: jdev.close() time.sleep(0.5) except Exception, e: print "ERROR: Something wrong happens when closing the connection with the device" logging.exception(e) timestamp_tracking['collector_cli_ends'] = int(datetime.today().strftime('%s')) logger.info('[%s]: timestamp_tracking - CLI collection %s', host, timestamp_tracking['collector_cli_ends']-timestamp_tracking['collector_cli_start']) timestamp_tracking['collector_ends'] = int(datetime.today().strftime('%s')) # Add open-nti internal kpi collection_time = timestamp_tracking['collector_ends']-timestamp_tracking['collector_start'] #kpi_tags['device']=host kpi_tags['stats']="collection-time" match={} match["variable-name"]="open-nti-stats" value_tmp =collection_time # We'll add a dummy kpi in oder to have at least one fixed kpi with version/platform data. get_metadata_and_add_datapoint(datapoints=datapoints,match=match,value_tmp=value_tmp,latest_datapoints=latest_datapoints,host=host,kpi_tags=kpi_tags) #kpi_tags['device']=host kpi_tags['stats']="collection-successful" match={} match["variable-name"]="open-nti-stats" value_tmp = 1 # We'll add a dummy kpi in oder to have at least one fixed kpi with version/platform data. get_metadata_and_add_datapoint(datapoints=datapoints,match=match,value_tmp=value_tmp,latest_datapoints=latest_datapoints,host=host,kpi_tags=kpi_tags) if datapoints: # Only insert datapoints if there is any :) insert_datapoints(datapoints) logger.info('[%s]: timestamp_tracking - total collection %s', host, collection_time) else: logger.error('[%s]: Skipping host due connectivity issue', host) datapoints = [] latest_datapoints = get_latest_datapoints(host=host) # By default execute show version in order to get version and platform as default tags for all kpi related to this host kpi_tags['device']=host kpi_tags['stats']="collection-failure" match={} match["variable-name"]="open-nti-stats" value_tmp = 1 # We'll add a dummy kpi in oder to have at least one fixed kpi with version/platform data. get_metadata_and_add_datapoint(datapoints=datapoints,match=match,value_tmp=value_tmp,latest_datapoints=latest_datapoints,host=host,kpi_tags=kpi_tags) if datapoints: # Only insert datapoints if there is any :) insert_datapoints(datapoints)
Add code to attempt to lock the configuration again. Gracefully handle the "LockError" exception (meaning the configuration is already locked). """ from jnpr_devices import srx2 # SRX device dictionary from jnpr.junos import Device # Device class from jnpr.junos.utils.config import Config # Config class from jnpr.junos.exception import LockError # For gracefully handling lock error from getpass import getpass # Create device object device_conn = Device(**srx2) device_conn.open() # Establish NETCONF connection device_conn.timeout = 60 # Change device timeout # Pass in NETCONF connection to Config object cnfg = Config(device_conn) print(cnfg.lock()) # Lock device to others so only we can be in config mode # Put pause in the program otherwise after program ends and connection terminates the lock is automatically released pause = input("Go check if you can go into config mode on the device: ") # Gracefully catch the lock error exception which is thrown when we try to lock the config a 2nd time try: cnfg.lock() pause = input("Wait: ") except LockError: # Run this code if this exception thrown print("Error: The configuration is already locked for editing") pause = input("Wait: ")
def myprint(str): print(time.strftime(" %H:%M:%S", time.gmtime()) + " " + str) host = raw_input('hostname: ') user = raw_input('username: '******'password: '******'Unable to connect: ', error exit() dev.timeout = 2500 js = SnapAdmin() config_file = "junos-upgrade.yml" myprint("waiting 10 seconds before taking post snapshot....") time.sleep(10) myprint("gathering snapshot after upgrade....") snapvalue = js.snap(config_file, "post", dev=dev) print myprint("Comparing pre and post snapshots") snapvalue = js.check(config_file, "pre", "post", dev=dev)
for value in line: device.append(value) device = [x.strip('\n') for x in device] for item in device: dev = Device(user=user, host=item, password=passwd) dev.probe() print 'Opening connection to %s for user %s ...' % (item, user) if dev.probe() is False: print '%s is not reachable. Skipping..' % (item) elif dev.probe() is True: dev.open() print 'Setting device parameter' dev.timeout = 10 * 60 cu = Config(dev) print 'Setting banner message' set_cmd = 'set system login message "WARNING - THIS IS A PRIVATE SYSTEM"' cu.load(set_cmd, format='set') cu.pdiff() cu.commit_check print 'Check passed, committing changes...' cu.commit() print 'Exiting %s ' % (item)
} template_file = 'build_bgp.j2' with open(template_file) as f: bgp_template = f.read() for router_id, router_vars in my_vars.items(): template = jinja2.Template(bgp_template) rtr_cfg = template.render(router_vars) print() print('-' * 60) print("This is router: {}".format(router_id)) print(rtr_cfg) print() # Connecting to device host = router_vars['management_ip'] a_device = Device(host=host, user=USER, password=PASSWD) a_device.open() a_device.timeout = 90 cfg = Config(a_device) cfg.load(rtr_cfg, format="text", merge=False) diff = cfg.diff() print(diff) hit_enter() if diff: print("Commit changes") cfg.commit() else: print("No changes")
""" from jnpr.junos import Device from jnpr.junos.utils.config import Config from jnpr.junos.op.lldp import LLDPNeighborTable from jnpr.junos.op.ethport import EthPortTable from jnpr.junos.op.routes import RouteTable from jnpr.junos.exception import LockError from getpass import getpass from pprint import pprint password = getpass() a_device = Device(host='184.105.247.76', user='******', password=password) print a_device.open() a_device.timeout = 300 #### Facts pprint(a_device.facts) #### Getter operations print "\nLLDP Get" print '-' * 50 lldp = LLDPNeighborTable(a_device) lldp.get() for k, v in lldp.items(): print k for entry in v: print entry
#!/usr/bin/env/python from jnpr.junos import Device from jnpr.junos.op.routes import RouteTable from jnpr.junos.utils.config import Config from pprint import pprint from jnpr_devices import srx2 from task2 import gather_routes connection = Device(**srx2) connection.open() connection.timeout = 60 pprint(gather_routes()) print("\n" + "#" * 20 + "\n") cfg = Config(connection) cfg.lock() cfg.load(path="task4.conf", format="text", merge=True) cfg.commit() pprint(gather_routes()) print("\n" + "#" * 20 + "\n") cfg.load("delete routing-options static route 203.0.113.55/32 discard", format="set", merge=True) cfg.load("delete routing-options static route 203.0.113.56/32 discard", format="set", merge=True) cfg.commit()
copy_Manifest_to_tempManifest() print name create_newFeed(feed) create_manifest_entry(name) copy_tempManifest_to_Manifest() #print "Completed, add the following line to your SRX to accept feed:\n set security dynamic-address address-name "+name+ " profile category IPFilter feed "+name username = raw_input("Please enter your SRX Username:"******"Logging into SRX "+srx login=str(srx) dev = Device(host=login,user=username,password=password) dev.open() dev.timeout = 300 cu = Config(dev) set_cmd = 'set security dynamic-address address-name '+name+' profile category IPFilter feed '+name cu.load(set_cmd, format='set') print "Applying changes, please wait...." cu.commit() dev.close() if sys.argv[1]=='drop':
if ssh.connect: # SCPCLient takes a paramiko transport as an argument scp = SCPClient(ssh.get_transport()) print(style.BOLD + "- Transferring CA Cert file to vSRX..." + style.END) scp.put(filename) else: print("!! No active ssh connection. Exiting!!") ###################################### # Configure SSL Proxy on vSRX ###################################### # Make connection to the vSRX and check to see if the cert already exists try: dev.open() dev.timeout = 300 look = dev.rpc.get_pki_local_certificate(certificate_id=cert_id) except ConnectError as err: print("!!..The vSRX appears to be down..!!") print("Cannot connect to device: {0}".format(err)) sleep(3) sys.exit(1) except Exception as err: print("!!..The vSRX appears to be down..!!") print(err) sleep(3) sys.exit(1) # Figure out what to do
ROUTES_LIST_DIFF = list(ROUTES_SET_DIFF) print("#" * 50) print("ROUTES THAT WERE ADDED: ") print("#" * 50) print(ROUTES_LIST_DIFF) print() if __name__ == "__main__": srx2_device = Device(**jnpr_devices.srx2) srx2_device.open() srx2_device.timeout = 60 # Checking the RIB before the change rib_table = gather_routes(srx2_device) print_rib(rib_table, "BEFORE") # Inventory Routes before the change ROUTES_BEFORE = list() for k in rib_table.keys(): ROUTES_BEFORE.append(k)
#!/usr/bin/env python from jnpr.junos import Device from jnpr.junos.utils.config import Config from jnpr.junos.exception import LockError from pprint import pprint from jnpr_devices import srx2 jnpr_device = Device(**srx2) jnpr_device.open() jnpr_device.timeout = 60 # 3a jnpr_device_cfg = Config(jnpr_device) jnpr_device_cfg.lock() try: jnpr_device_cfg.lock() except LockError as e: print("Config session already locked") # 3b print("Set new hostname in candidate config") jnpr_device_cfg.load("set system host-name srx2-new-name", format="set", merge=True) # 3c print("Check diff") print(jnpr_device_cfg.diff())
from jnpr.junos import Device from getpass import getpass pwd = getpass() a_device = Device(host='50.242.94.227', user='******', password=pwd) a_device.timeout = 120 a_device.open() a_device.facts from jnpr.junos.utils.config import Config cfg = Config(a_device) cfg.lock() cfg.load("set system host-name pytest", format="set", merge=True) cfg.rollback(0) print cfg.diff() cfg.commit(comment="testing commit comment using PyEZ")
def update_process(type,host,package,threadIns): # verify package exists if type=='OS' or type=='Firmware': if not (os.path.isfile(package)): msg = 'Software package does not exist: {0}. '.format(package) logging.error(msg) print msg sys.exit() time.sleep(20) dev=None dev = Device(host=host,user=junos_username, passwd=junos_password) rebootTime=10 rebootOK=False while not rebootOK: try: time.sleep(10) rebootOK=True dev.open() except Exception as err: print threadIns.hostIP+threadIns.serialNumber+':wait device time='+str(rebootTime)+"Sec "+str(err) logging.info(threadIns.hostIP+threadIns.serialNumber+':wait device time='+str(rebootTime)+"Sec "+str(err)) rebootTime+=10 rebootOK=False if rebootTime>=rebootTimeout: logging.error('Cannot connect to device\n') print 'Cannot connect to device\n' return if type=='createLogFile': threadIns.status="createLog" dev.timeout = 100 create_log(dev) dev.close() return if type=='checkSerialNumber': threadIns.status="checkSN" threadIns.serialNumber=dev.facts['serialnumber'] dev.close() return if type=='Snapshot': threadIns.status="Snapshot" dev.timeout = 600 dev.rpc.request_snapshot(slice='alternate') dev.close() return if type=='setFixIP': threadIns.status="setFixIP" cu = Config(dev) cu.load('delete interfaces ge-0/0/0', format='set') cu.load('set interfaces ge-0/0/0 unit 0 family inet address '+threadIns.hostIP+'/'+str(dhcpNetmask), format='set') cu.pdiff() cu.commit() return # Create an instance of SW sw = SW(dev) threadIns.status="install"+type try: logging.info('Starting the software upgrade process: {0}'.format(package)) okOS = sw.install(package=package, remote_path=remote_path,progress=update_progress, validate=validate) #okOS=True except Exception as err: msg = 'Unable to install software, {0}'.format(err) logging.error(msg) okOS = False if type=="Firmware": #UPGRADED SUCCESSFULLY logging.info("!!!!!!!!!!!!!") logging.info(dev.cli("request system firmware upgrade pic pic-slot 0 fpc-slot 1")) threadIns.status="checkFirmware" okFirmware=False #okFirmware=True firmwareTime=0 while not okFirmware and okOS: xmlStr=etree.tostring(dev.rpc.get_system_firmware_information(), encoding='unicode') xmlRoot = ET.fromstring(xmlStr) for firmware_status in xmlRoot.iter('firmware-status'): #UPGRADED SUCCESSFULLY if firmware_status.text=='UPGRADED SUCCESSFULLY':okFirmware=True if firmware_status.text!='OK':print firmware_status.text print threadIns.hostIP+threadIns.serialNumber+":wate firmware upgrade "+str(firmwareTime)+" Sec" time.sleep(1) firmwareTime=firmwareTime+1 #print okFirmware elif type=="OS":okFirmware=True threadIns.status="reboot after install"+type if okOS is True and okFirmware is True: logging.info('Software installation complete. Rebooting') rsp = sw.reboot() logging.info('Upgrade pending reboot cycle, please be patient.') logging.info(rsp) else: msg = 'Unable to install software, {0}'.format(okOS) logging.error(msg) # End the NETCONF session and close the connection dev.close()
def upgrade_device(self, ip, hostname, tar_code, reboot="askReboot"): # Upgrade single device # Status dictionary for post-upgrade reporting statusDict = {} if Menu.upgrade_list == '': statusDict['Upgrade_List'] = 'Juniper-Upgrade_' + Menu.username else: statusDict['Upgrade_List'] = Menu.upgrade_list statusDict['Upgrade_Start'] = '' statusDict['Upgrade_Finish'] = '' statusDict['IP'] = ip statusDict['Connected'] = 'N' statusDict['OS_installed'] = 'N' statusDict['Rebooted'] = 'N' statusDict['IST_Confirm_Loaded'] = '' statusDict['IST_Confirm_Rebooted'] = '' statusDict['Comments'] = '' # Start Logging now = datetime.datetime.now() date_time = now.strftime("%Y-%m-%d-%H%M") install_log = Menu.log_dir + "juniper-install-LOG_" + date_time + "_" + Menu.username + ".log" logging.basicConfig(filename=install_log, level=logging.INFO, format='%(asctime)s:%(name)s: %(message)s') logging.getLogger().name = ip print('Information logged in {0}'.format(install_log)) # Upgrade Information self.do_log("Device: {0} ({1})".format(hostname, ip)) self.do_log("JunOS: {0}".format(tar_code)) # Verify package exists before starting upgrade process fullpathfile = Menu.image_dir + tar_code if os.path.isfile(fullpathfile): dev = Device(ip, user=Menu.username, password=Menu.password) self.do_log('\n') self.do_log( '------------------------- Opening connection to: {0} -------------------------\n' .format(ip)) self.do_log('User: {0}'.format(Menu.username)) # Try to open a connection to the device try: dev.open() # If there is an error when opening the connection, display error and exit upgrade process except Exception as err: sys.stderr.write('Cannot connect to device {0} : {1}'.format( ip, err)) # If else: # Record connection achieved statusDict['Connected'] = 'Y' # Increase the default RPC timeout to accommodate install operations dev.timeout = 600 # Create an instance of SW sw = SW(dev) try: # Logging... self.do_log( 'Starting the software upgrade process: {0}'.format( tar_code)) now = datetime.datetime.now() statusDict['Upgrade_Start'] = now.strftime( "%Y-%m-%d %H:%M") self.do_log('Timestamp: {0}'.format( statusDict['Upgrade_Start'])) # Actual Upgrade Function ok = sw.install(package=fullpathfile, remote_path=Menu.remote_path, progress=True, validate=True) # Failed install method... # ok = sw.install(package=fullPathFile, remote_path=Menu.remote_path, progress=self.update_progress, validate=True) except Exception as err: msg = 'Unable to install software, {0}'.format(err) self.do_log(msg, level='error') else: if ok is True: # Logging... statusDict['OS_installed'] = 'Y' self.do_log('Software installation complete.') now = datetime.datetime.now() statusDict['Upgrade_Finish'] = now.strftime( "%Y-%m-%d %H:%M") self.do_log('Timestamp: {0}'.format( statusDict['Upgrade_Finish'])) # Check rebooting status... if reboot == "askReboot": answer = getYNAnswer('Would you like to reboot') if answer == 'y': reboot = "doReboot" else: reboot = "noReboot" if reboot == "doReboot": rsp = sw.reboot() statusDict['Rebooted'] = 'Y' self.do_log( 'Upgrade pending reboot cycle, please be patient.' ) self.do_log(rsp) # Open a command terminal to monitor device connectivity # os.system("start cmd /c ping -t " + ip) elif reboot == "noReboot": self.do_log( 'Reboot NOT performed. System must be rebooted to complete upgrade.' ) # End the NETCONF session and close the connection dev.close() self.do_log('\n') self.do_log( '------------------------- Closed connection to: {0} -------------------------\n' .format(ip)) else: msg = 'Software package does not exist: {0}. '.format(fullpathfile) sys.exit(msg + '\nExiting program') return statusDict
cmdline.add_argument("-u", metavar="username", help="Remote username", default=getpass.getuser()) args = cmdline.parse_args() password = getPass(args.u + "@" + args.target) if 'getPass' in globals() else "" if (args.a == None and args.d == None): print "Nothing to do!" sys.exit(1) dev = Device(host=args.t, user=args.u, port=args.p, password=password) dev.open() dev.timeout = 120 with Config(dev, mode="private") as config: if args.d != None: for p in args.d: try: config.load("delete policy-options prefix-list %s %s" % (args.l, p), format="set") except ConfigLoadError, e: if (e.rpc_error['severity'] == 'warning'): print "Warning: %s" % e.message else: raise if args.a != None: for p in args.a:
def main(): hosts = ['XX.YY.ZZ.EE'] user = '******' for host in hosts: # https://www.juniper.net/techpubs/en_US/junos-pyez1.0/topics/topic-map/junos-pyez-authenticating-users-with-ssh-keys.html dev = Device(host=host, user='******', ssh_private_key_file='/home/bot/.ssh/id_rsa.pub' ) # password=password) # Open the connection & config try: print "Opening connnection to:", host dev.open() except Exception as err: print "Cannot connect to device:", err return dev.timeout = 300 yaml_plkanet = ''' --- prefixlist: name: pl-kanet prefixes:''' # Getting information through Table/View tblrt = RouteTable(dev) tblrt.get(table='RI-PPPoE-INET.inet.0', community_name='community-city') ip_list = [] for route_item in tblrt.keys(): ip_list.append(IPNetwork(route_item)) # summarize groups of IP subnets and addresses, # merging them together where possible to create the smallest possible list of CIDR subnets ip_list = cidr_merge(ip_list) for route_item in ip_list: yaml_plkanet += "\n - " + str(route_item) pl_config = yaml.load(yaml_plkanet) dev.bind(cu=Config) # Lock the configuration, load changes, commit print "Locking the configuration on:", host try: dev.cu.lock() except LockError: print "Error: Unable to lock configuration on:", host dev.close() return print "Loading configuration changes on:", host try: dev.cu.load('''delete policy-options prefix-list pl-kanet''', format='set') dev.cu.load(template=pl_template, template_vars=pl_config, format='text') except ValueError as err: print err.message except Exception as err: if err.rsp.find('.//ok') is None: rpc_msg = err.rsp.findtext('.//error-message') print "Unable to load config changes: ", rpc_msg print "Unlocking the configuration on:", host try: dev.cu.unlock() except UnlockError: print "Error: Unable to unlock configuration on:", host dev.close() return if dev.cu.diff() is None: print "configuration is up-to-date" else: print "configuration differences:", dev.cu.pdiff() print "Committing the configuration on:", host try: dev.cu.commit() except CommitError: print "Error: Unable to commit configuration on:", host print "Unlocking the configuration on:", host try: dev.cu.unlock() except UnlockError: print "Error: Unable to unlock configuration on:", host dev.close() return print "Unlocking the configuration on:", host try: dev.cu.unlock() except UnlockError: print "Error: Unable to unlock configuration on:", host print "Closing connection to:", host dev.close()
def collector(**kwargs): for host in kwargs["host_list"]: kpi_tags = {} latest_datapoints = {} # if ((db_schema == 1) and (not(use_hostname))): if (not (use_hostname)): latest_datapoints = get_latest_datapoints(host=host) logger.info("Latest Datapoints are:") logger.info(pformat(latest_datapoints)) # kpi_tags = get_host_base_tags(host=host) # Check host tag to identify what kind of connections will be used (ej junos / others / etc) if "non_junos_devices" in hosts[host].split(): pass # Reserved for future purposes else: # By default it's a junos device # We need to CATCH errors then print then but we need to continue with next host... connected = False logger.info('Connecting to host: %s', host) target_commands = get_target_commands(host) timestamp_tracking = {} timestamp_tracking['collector_start'] = int( datetime.today().strftime('%s')) # Establish connection to hosts user, passwd = get_credentials(host) jdev = Device(user=user, host=host, password=passwd, gather_facts=False, auto_probe=True, port=22) for i in range(1, max_connection_retries + 1): try: jdev.open() jdev.timeout = default_junos_rpc_timeout connected = True break except Exception, e: if i < max_connection_retries: logger.error( '[%s]: Connection failed %s time(s), retrying....', host, i) time.sleep(1) continue else: logging.exception(e) connected = False # Notify about the specific problem with the host BUT we need to continue with our list # First collect all kpi in datapoints {} then at the end we insert them into DB (performance improvement) if connected: datapoints = [] # By default execute show version in order to get version and platform as default tags for all kpi related to this host kpi_tags = {} target_command = 'show version | display xml' version_xpath = "//package-information/comment" product_model_xpath = "//product-model" logger.info('[%s]: Executing command: %s', host, target_command) result = execute_command(jdev, target_command) if result: logger.debug('[%s]: Parsing command: %s', host, target_command) xml_data = etree.fromstring(result) value_tmp = xml_data.xpath(version_xpath)[0].text.strip() version = re.search('\[(.*?)\]$', value_tmp) if version: kpi_tags['version'] = version.group(1) else: kpi_tags['version'] = 'unknown' value_tmp = xml_data.xpath( product_model_xpath)[0].text.strip() kpi_tags['product-model'] = convert_variable_type( value_tmp) ## Based on parameter defined in config file if use_hostname: hostname_xpth = "//host-name" hostname_tmp = xml_data.xpath( hostname_xpth)[0].text.strip() hostname = convert_variable_type(hostname_tmp) logger.info( '[%s]: Host will now be referenced as : %s', host, hostname) host = hostname # if (db_schema == 1): # latest_datapoints = get_latest_datapoints(host=host) # logger.info("Latest Datapoints are:") # logger.info(pformat(latest_datapoints)) latest_datapoints = get_latest_datapoints(host=host) logger.info("Latest Datapoints are:") logger.info(pformat(latest_datapoints)) else: logger.info('[%s]: Host will be referenced as : %s', host, host) kpi_tags['device'] = host kpi_tags['kpi'] = "base-info" match = {} match["variable-name"] = "base-info" # We'll add a dummy kpi in oder to have at least one fixed kpi with version/platform data. get_metadata_and_add_datapoint( datapoints=datapoints, match=match, value_tmp=value_tmp, latest_datapoints=latest_datapoints, host=host, kpi_tags=kpi_tags) # Now we have all hosts tags that all host kpis will inherit # For each target_command execute it, parse it, and insert values into DB timestamp_tracking['collector_cli_start'] = int( datetime.today().strftime('%s')) for target_command in target_commands: logger.info('[%s]: Executing command: %s', host, target_command) # Execute rpc/command on host and get result result = execute_command(jdev, target_command) if result: logger.debug('[%s]: Parsing command: %s', host, target_command) parse_result(host, target_command, result, datapoints, latest_datapoints, kpi_tags) time.sleep(delay_between_commands) jdev.close() timestamp_tracking['collector_cli_ends'] = int( datetime.today().strftime('%s')) logger.info( '[%s]: timestamp_tracking - CLI collection %s', host, timestamp_tracking['collector_cli_ends'] - timestamp_tracking['collector_cli_start']) if datapoints: # Only insert datapoints if there is any :) insert_datapoints(datapoints) timestamp_tracking['collector_ends'] = int( datetime.today().strftime('%s')) logger.info( '[%s]: timestamp_tracking - total collection %s', host, timestamp_tracking['collector_ends'] - timestamp_tracking['collector_start']) else: logger.error('[%s]: Skipping host due connectivity issue', host)
continue entry = dict(name=old_entry.findtext('name').strip(), admin-status=old_entry.findtext('admin-status').strip(), oper-status=old_entry.findtext('oper-status').strip(), description=old_entry.findtext('description').strip(), mtu=old_entry.findtext('mtu').strip(), speed=old_entry.findtext('speed').strip()) table.append(entry) return table def __init__(self, *args, **kwargs): self.hostname = args[0] if len(args) else kwargs.get('host') self.user = kwargs.get('user', getenv('USER')) self.password = kwargs.get('password') self.timeout = kwargs.get('timeout') self.vpn = kwargs.get('vpn', 'default') def _connect(self): """Connect to a device. :returns: a connection to a Juniper Networks device. :rtype: ``Device`` """ if self.password='': dev = Device(self.hostname, user=self.user) else: dev = Device(self.hostname, user=self.user, password=self.password) dev.open() dev.timeout = self.timeout return dev
from jnpr.junos.utils.config import Config ################## Opening the device ###################################### dev_ip_address = '192.168.124.39' dev_username = '******' dev_password = '******' dev_ssh = Device(host=dev_ip_address, user=dev_username, passwd=dev_password, port='22') try: dev_ssh.open() dev_ssh.timeout = 300 except ConnectError as err: print("Cannot connect to device: {0}".format(err)) sys.exit(1) except Exception as err: print(err) sys.exit(1) with Config(dev_ssh, mode='private') as cu: cu.load(url="mx104_baseconfig.conf", overwrite=True) #cu.pdiff() cu.commit() for i in xrange(40, 0, -1): time.sleep(1)