def cfgupload(ftp_ip, ftp_user, ftp_pass, clear=0): """ capture any information for testing of the configdownload - including mapspolicy --show mapsconfig --show flow --show flow --show -ctrlcfg relayconfig --show bottleneckmon --status then perform configupload config upload Nimbus_______________Odin_86__:FID25:root> configupload Protocol (scp, ftp, sftp, local) [ftp]: ftp Server Name or IP Address [host]: 10.38.38.138 User Name [user]: ftp2 Path/Filename [<home dir>/config.txt]: Odin_configupload.txt Section (all|chassis|FID# [all]): all Password: or configdownload [- all ] [-p ftp | -ftp] ["host","user","path"[,"passwd"]] configdownload [- all ] [-p scp | -scp ] ["host","user","path"] """ sw_info = anturlar.SwitchInfo() sw_info_ls = sw_info.ls() fid_now = sw_info.ls_now() cons_out = anturlar.fos_cmd(" ") sw_ip = sw_info.ipaddress() f = "%s%s%s" % ("logs/Configupload_test_case_file", sw_ip, ".txt") if clear == 1: ff = liabhar.FileStuff(f, 'w+b') #### reset the log file else: ff = liabhar.FileStuff(f, 'a+b') #### open for appending header = "%s%s%s%s" % ("\nCONFIGUPLOAD CAPTURE FILE \n", " sw_info ipaddr ", sw_ip, "\n==============================\n\n") ff.write(header) ff.close() ff = liabhar.FileStuff(f, 'a+b') #### open the log file for writing ff.write(str(sw_info_ls)) ff.write("\n" * 2) cons_out = anturlar.fos_cmd("setcontext %s" % fid_now) #cons_out = anturlar.fos_cmd(" ") configdown_cmd = ("configupload -all -p ftp %s,%s,/configs/%s.txt,%s") % ( ftp_ip, ftp_user, sw_ip, ftp_pass) ftp_ip, ftp_user, ftp_pass cons_out = anturlar.fos_cmd(configdown_cmd)
def send_cmds(filename, loops=10000): """ function to read cmds from a file and send them to the switch """ fullpath = "%s%s" % ("logs/configs/cmdset/", "send_cmd_output.txt") g = liabhar.FileStuff(fullpath, 'w+b') #f = liabhar.FileStuff(filename, 'r+b') cons_out = anturlar.fos_cmd("") with open(filename) as fileio: info = fileio.readlines() while loops >= 1: for line in info: line = line.rstrip('\n') cons_out = anturlar.fos_cmd(line) g.write(cons_out) g.write(" ") loops -= 1 g.close() return 0
def send_cmds(filename, loops=1): """ function to read cmds from a file and send them to the switch """ print('$$$$$$$$$$$$$$$$$$$$$') file = "LicenseShow1" ####Change this as needed fullpath = "%s%s%s" % ("logs/configs/", file, ".txt") print(fullpath) g = liabhar.FileStuff(fullpath, 'a+b') cons_out = anturlar.fos_cmd("") with open(filename) as fileio: info = fileio.readlines() print(info) while loops >= 1: for line in info: line = line.rstrip('\n') cons_out = anturlar.fos_cmd(line) g.write(cons_out) g.write(" ") loops -= 1 g.close() return 0
def write_pass_fail_to_file(pass_or_not, ip, stamp): """ write the results of looking for zero to the file """ dt = liabhar.dateTimeStuff( ) #### create the object for date and time stuff date_is = "%s" % (dt.current()) f = "%s%s%s%s%s" % ("logs/Flow_regression_result_", ip, "_", stamp, ".txt") ff = liabhar.FileStuff(f, 'a+b') #### open the log file for writing ff.write("\r\n") ff.write("@" * 80) ff.write("\r\n") ff.write("#" * 80) ff.write("\r\n") ff.write(date_is) ff.write("\r\n") if pass_or_not: ff.write("FOUND NO ZERO COUNTS") else: ff.write("ZERO WAS FOUND AT LEAST ONE TIME ") ff.write("FAIL ??? ") ff.write(str(pass_or_not)) ff.write("\r\n") ff.write("@" * 80) ff.write("\r\n") ff.write("#" * 80) ff.write("\r\n") ff.close() #### close this file return (True)
def check_gen_all_stats(): """ start the gen_all SIM ports test and capture the number of runs the percent of run, the frames generated brom IngrPort and frames generated to EgrPort """ sw_info = anturlar.SwitchInfo() sw_info_ls = sw_info.ls() fid_now = sw_info.ls_now() sw_ip = sw_info.ipaddress() fv = anturlar.FlowV() fv.toggle_all() #### default is to turn all ports to SIM ports fv.genAll("on") f = "%s%s%s" % ("logs/Gen_all_stats_test_case_file", sw_ip, ".txt") clear = 0 if clear == 1: ff = liabhar.FileStuff(f, 'w+b') #### reset the log file else: ff = liabhar.FileStuff(f, 'a+b') #### open for appending st = "Runs Percent Ingrport Egrport \n" header = "%s%s%s%s" % ("\nGEN ALL CAPTURE FILE \n", " sw_info ipaddr ", sw_ip, "\n==============================\n\n") ff.write(header) ff.write(st) d = 0 while d <= 1000: stats = fv.genAllStats() print(stats) print("run number %s" % d) ff.write(stats) liabhar.count_down(60) d += 1 ff.close()
def get_licenses(ip): anturlar.connect_tel_noparse(ip, 'root', 'password') sw_info = anturlar.SwitchInfo() #sw_ip = sw_info.ipaddr sw_name = sw_info.switch_name() f = "%s%s%s" % ("logs/Switch_Licenses/License_File_", sw_name, ".txt") ff = liabhar.FileStuff(f, 'a+b') ###open new file or clobber old header = "%s%s%s%s" % ("\nLICENSE FILE \n", ip + "\n", sw_name, "\n==============================\n\n") cons_out = anturlar.fos_cmd("licenseshow") ff.write(header) ff.write(cons_out + "\n") ff.close()
def write_to_results_file(what_to_write, ip, stamp): """ write to the Flow File """ dt = liabhar.dateTimeStuff( ) #### create the object for date and time stuff date_is = "%s" % (dt.current()) f = "%s%s%s%s%s" % ("logs/Flow_regression_result_", ip, "_", stamp, ".txt") ff = liabhar.FileStuff(f, 'a+b') #### open the log file for writing ff.write(date_is) ff.write("\r\n") ff.write(what_to_write) ff.write("\r\n") ff.close() #### close this file return (True)
def fab_wide_proxy_device_numbers(): """ Retrieve number of proxy device on all backbone switches in fabric. Drop those numbers into a file for later retreival (e.g. say after reboot testing). Also return a dictionary (e.g {switch_ip: # of proxy devices}) """ fcrinfo = anturlar.FcrInfo() backbone_ip = fcrinfo.fcr_backbone_ip() print(backbone_ip) sys.exit() bb_fab_num = (len(backbone_ip)) proxy_dev_count = [] for ip in backbone_ip: anturlar.connect_tel_noparse(ip, 'root', 'password') base = fcrinfo.base_check() # get the base FID number if base is not False: anturlar.fos_cmd("setcontext " + base) get_proxy = fcrinfo.fcr_proxy_dev() proxy_dev_count.extend(get_proxy) else: get_proxy = fcrinfo.fcr_proxy_dev() proxy_dev_count.extend(get_proxy) switch_list_with_proxy_dev = dict(zip(backbone_ip, proxy_dev_count)) proxy_dev_count = (str(proxy_dev_count)) f = ('logs/ProxyDev_Count.txt') ff = liabhar.FileStuff(f, 'w+b') ###open new file or clobber old ff.write(proxy_dev_count) ff.close() print('\n\n' + '=' * 20) print('Backbone Fabric consists of %s switches.' % (len(bb_fab_num))) print('IP addresses: Number of proxy devices found') print(switch_list_with_proxy_dev) print('=' * 20 + '\n\n') return (switch_list_with_proxy_dev)
def main(): global tn ####################################################################################################################### #### #### start with parsing the command line #### #### use the procedures parent_parser and parse_args #### to determine the command line switches #### ####################################################################################################################### pa = parse_args(sys.argv) print(pa) print(pa.ipaddr) print(pa.quiet) print(pa.verbose) print(pa.cmdprompt) print("@" * 40) print("@" * 40) ####################################################################################################################### ####################################################################################################################### #### #### if user enter ip address then get the chassisname from the #### SwitchMatrix file #### #### then get the info from the SwitchMatrix file using the Chassis Name #### #### #### Type,Chassisname,IP Address,Username,Password,Console1 IP,Console1 Port,Console2 IP,Console2 Port, #### Power1 IP,Power1 Port,Power2 IP,Power2 Port,Power3 IP,Power3 Port,Power4 IP,Power4 Port, #### KVM IP,KVM Port,Web Username,Web Password,Admin Password #### ####################################################################################################################### ####################################################################################################################### if pa.ipaddr: print("do IP steps") pa.chassis_name = sw_matrix_tools.console_info_from_ip(pa.ipaddr) cons_info = sw_matrix_tools.console_info(pa.chassis_name) console_ip = cons_info[0] console_port = cons_info[1] console_ip_bkup = cons_info[2] console_port_bkup = cons_info[3] power_pole_info = sw_matrix_tools.pwr_pole_info(pa.chassis_name) usr_pass = sw_matrix_tools.get_user_and_pass(pa.chassis_name) user_name = usr_pass[0] usr_psswd = usr_pass[1] ipaddr_switch = sw_matrix_tools.get_ip_from_file(pa.chassis_name) ###################################################################################################################### ###################################################################################################################### #### #### connect via telnet: #### if you want to connect to the console it is available in anturlar and an example below #### #### ###################################################################################################################### ###################################################################################################################### #### Config_up_down_compare.main() # cons_out = anturlar.fos_cmd("firmwareshow") #### send any command with anturlar.fos_cmd # print("\r\n") # liabhar.JustSleep(5) #### sleep without printing anything # print("now closing telnet session ") # #anturlar.close_tel() #### close the telnet session ####################################################################################################################### ####################################################################################################################### #### #### connect via console example and other "send command" commands #### #### ####################################################################################################################### ####################################################################################################################### #tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,usr_psswd) #### connect to console w/o parser info #cons_out = anturlar.fos_cmd("setcontext %s " % pa.fid) #### change to the fid given on the command #tn = anturlar.connect_console(console_ip,console_port) #### use the console ip and console port info #cons_out = anturlar.fos_cmd("switchshow") #### send a command via the console #cons_out = cofra.power_cycle(power_pole_info) #### powercycle switch via switchmatrix.csv file #liabhar.JustSleep(30) #### wait for the switch to boot #cons_out = anturlar.send_cmd_console("\r\n") #### send some commands to the console #cons_out = anturlar.send_cmd_console("setcontext %s " % pa.fid) #### send some commands to the console #cons_out = anturlar.send_cmd_console("firmwareshow") #### send some commands to the console #capture = cofra.cfgupload("10.38.35.131", "ftp1", "ftp2") #### send a cfgupload file to a ftp server #liabhar.count_down(5) #### set and observe a count down timer ####################################################################################################################### ####################################################################################################################### #### #### This starts the template for configshow output comparison (after some type of switch operation). #### First snippet of code simply opens a connection, changes to requested fid, sends output of configshow to a file. #### ####################################################################################################################### ####################################################################################################################### tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, usr_psswd) cons_out = anturlar.fos_cmd("setcontext %s " % pa.fid) dt = liabhar.dateTimeStuff( ) #### create the object for date and time stuff date_is = dt.current_no_dash_at_end( ) #### get the current time for file naming purposes #print("\n\nDate is %s" % date_is) liabhar.count_down(5) #### count down to the next command #configup_cmd = ("configupload -all -p ftp %s,%s,/configs/%s.txt,%s") % ("10.38.35.131","ftp1", ipaddr_switch, "ftp2") f = "%s%s%s%s" % ("logs/Configupload_test_case_file", ipaddr_switch, date_is, ".txt") ff = liabhar.FileStuff(f, 'w+b') #### open the log file for writing header = "%s%s%s%s" % ( "\nCONFIGUPLOAD CAPTURE FILE \n", " sw_info ipaddr ", ipaddr_switch, "\n==============================\n\n" ) #### write a header line at top of file ff.write(header) #cons_out = anturlar.fos_cmd (configup_cmd) ff.write(anturlar.fos_cmd("configshow")) ff.close() #### close this file for comparison later ####################################################################################################################### ####################################################################################################################### #### #### do anything else you want to try (small sample of examples): #### anturlar.fos_cmd("tsclockserver 10.38.2.80; tstimezone America/Denver") #### anturlar.fos_cmd("cfgenable") #### anturlar.fos_cmd("switchdisable") #### anturlar.fos_cmd("switchenable") #### #### In the below snippet we run tsclockerver: anturlar.fos_cmd("tsclockserver 10.38.2.80; tstimezone America/Denver") #### Then grab output of configshow, drop into a file and compare that with original #### ####################################################################################################################### ####################################################################################################################### anturlar.fos_cmd("tsclockserver 10.38.2.80; tstimezone America/Denver") date_is = dt.current_no_dash_at_end() f1 = "%s%s%s%s" % ("logs/Configupload_test_case_file", ipaddr_switch, date_is, ".txt") ff = liabhar.FileStuff(f1, 'w+b') #### reset the log file header = "%s%s%s%s" % ("\nCONFIGUPLOAD CAPTURE FILE \n", " sw_info ipaddr ", ipaddr_switch, "\n==============================\n\n") ff.write(header) #cons_out = anturlar.fos_cmd (configup_cmd) ff.write(anturlar.fos_cmd("configshow")) ff.close() diff_f = liabhar.file_diff(f, f1) print("#" * 80) print("#" * 80) print("#" * 80) print("#" * 80) print("Result ") print(diff_f) #return(cons_out) return (True)
def main(): global tn ############################################################################### #### #### #### ############################################################################### pa = parse_args(sys.argv) #print(pa) #print(pa.chassis_name) #print(pa.ipaddr) #print(pa.quiet) #print(pa.verbose) #print(pa.firmware) #print(porttype) #print("@"*40) #sys.exit() ########################################################################## ########################################################################## ### ### hold the ip address from the command line ### if pa.ipaddr: pa.chassis_name = console_info_from_ip(pa.ipaddr, pa.chassis_name) cons_info = console_info(pa.chassis_name) console_ip = cons_info[0] console_port = cons_info[1] power_pole_info = pwr_pole_info(pa.chassis_name) usr_pass = get_user_and_pass(pa.chassis_name) user_name = usr_pass[0] usr_psswd = usr_pass[1] tn = anturlar.connect_tel_noparse(pa.ipaddr,user_name,usr_psswd) fi = anturlar.FabricInfo() si = anturlar.SwitchInfo() #fcr = anturlar.FcrInfo() if pa.fabwide: ipaddr_switch = fi.ipv4_list() elif pa.csvall: ipaddr_switch = get_ip_from_file(pa.chassis_name) elif pa.fcrwide: anturlar.fos_cmd("setcontext %s" % fcr.base_check()) ipaddr_switch = fcr.fcr_fab_wide_ip() else: ipaddr_switch = [pa.ipaddr] anturlar.close_tel() #### pass ip(s)to login procedure #### and write the file for i in ipaddr_switch: try: tn = anturlar.connect_tel_noparse(i,user_name,usr_psswd) except OSError: print("Switch %s not available" % i) # f_ports = si.f_ports() # e_ports = si.e_ports() # print(f_ports) # print(e_ports) # sys.exit() #fabric_check = fi.fabric_members() cons_out = anturlar.fos_cmd("setcontext %s " % pa.fid) dt = liabhar.dateTimeStuff() #### create the object for date and time stuff date_is = dt.current_no_dash_at_end() #### get the current time for file naming purposes #print("\n\nDate is %s" % date_is) effectivezone = fi.zone_info(123) print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$") print(effectivezone) sys.exit() liabhar.count_down(1) #### count down to the next command #configup_cmd = ("configupload -all -p ftp %s,%s,/configs/%s.txt,%s") % ("10.38.35.131","ftp1", ipaddr_switch, "ftp2") f = "%s%s%s%s"%("logs/Extensive_Zoning_test_case_file_orig","_"+i+"_",date_is,".txt") f1 = "%s%s%s%s"%("logs/Extensive_Zoning_test_case_file_compare","_"+i+"_",date_is,".txt") f2 = "%s%s%s%s"%("logs/Extensive_original_zone","_"+i+"_",date_is,".txt") #### open f2 write original zone "cfgshow" so we can put the switch back to original zone cfg ff = liabhar.FileStuff(f2, 'w+b') header = "%s%s%s%s" % ("\nORIGINAL ZONING CAPTURE FILE \n", " sw_info ipaddr ",ipaddr_switch, "\n==============================\n\n") #### write a header line at top of file ff.write(header) ff.write(anturlar.fos_cmd("cfgshow")) ff.close() #### open f (Write original extensive zoning switchconfig, nsshow, nsallshow and config show for comparison later) ff = liabhar.FileStuff(f, 'w+b') ff.write(anturlar.fos_cmd("nsshow")) ff.write(anturlar.fos_cmd("nsallshow")) ff.write(anturlar.fos_cmd("configshow")) ff.close() # g = open(f, "r") # lines = g.readlines() # g.close() # ff = liabhar.FileStuff(f, 'w+b') # for l in lines: # if " date = " not in l: # ff.write(l) # ff.close() # f = ('logs/PortFlapper.txt') # try: # with open(f, 'w') as file: # file.write("F-Ports = %s\n" % str(fports)) # file.write("E-Ports = %s\n" % str(eports)) # except IOError: # print("\n\nThere was a problem opening the file:" , f) # sys.exit() # file.close() print(eports) ################ if...else statement to use eport or fport for i in eports: slot = i[0] port = i[1] if slot: anturlar.fos_cmd("portdisable %s/%s" % (slot, port)) liabhar.count_down(15) anturlar.fos_cmd("portenable %s/%s" % (slot, port)) liabhar.count_down(15) else: anturlar.fos_cmd("portdisable %s" % (port)) liabhar.count_down(15) anturlar.fos_cmd("portenable %s" % (port)) liabhar.count_down(15) fabric_check1 = fi.fabric_members() if fabric_check != fabric_check1: print ("WTF") #email_sender_html(you, me, subj, html_to_send, htmlfile_path = "" ) liabhar.email_sender_html("*****@*****.**","*****@*****.**","portflapper failed","portflapper failed","") sys.exit() liabhar.email_sender_html("*****@*****.**","*****@*****.**","portflapper passed","portflapper passed","") anturlar.close_tel() return(True) # else: # print("\n"+"@"*40) # print('\nTHIS IS A NOS SWITCH> SKIPPING') # print("\n"+"@"*40) # pass anturlar.close_tel() sys.exit()
def fabric_switch_config_show(): """ document how this works here 1. Retreive a list of all of the switches in the FID passed at start of the test 2. get Flow and MAPS basic setup information 3. write to logs/fabric_info_switch.txt """ cons_out = anturlar.fos_cmd("") swtch = anturlar.SwitchInfo() fab = anturlar.FabricInfo() fab_ip_list = fab.ipv4_list() this_fid = swtch.currentFID() ############################################################################### ############################################################################### #### #### write to the file the list of IP addresses that data will be captured for #### ############################################################################### ############################################################################### fname = "%s%s" % ("logs/fabric_info_logs/fabric_info_switch", ".txt" ) #### %s string %d number ff = liabhar.FileStuff(fname, 'w+b') ff.write( "#############################################################\r\n") ff.write( "#############################################################\r\n") ff.write("\r\n") for ip in fab_ip_list: ff.write(ip) ff.write("\r\n") ff.write( "#############################################################\r\n") ff.write( "#############################################################\r\n") ff.write( "#############################################################\r\n") ff.write( "#############################################################\r\n\r\n\r\n" ) ff.close() m_info = anturlar.Maps() f_info = anturlar.FlowV() maps_config = anturlar.fos_cmd("mapsconfig --show") firmware_ver = check_version() s_name = m_info.switch_name() s_type = m_info.switch_type() ls_list = m_info.ls() switch_id = m_info.switch_id() ls_domain = m_info.ls_and_domain() chass_name = m_info.chassisname() vf_state = m_info.vf_enabled() ff = liabhar.FileStuff(fname, 'a+b') ff.write("Seed switch Info \n") ff.write( "---------------------------------------------------------------------------------\n" ) ff.write("Switch ipv4 : %s \r\n" % ip) ff.write("Chassis Name : %s \r\n" % chass_name) ff.write("Firmware version : %s \r\n" % firmware_ver) ff.write("Switch Name : %s \r\n" % s_name) ff.write("Switch Type : %s \r\n" % s_type) ff.write("VF State : %s \r\n" % vf_state) ff.write("Logical Switches : %s \r\n" % ls_list) ff.write("Switch ID : %s \r\n" % switch_id) ff.write("ls and domain : %s \r\n" % ls_domain) ############################################################################### ############################################################################### #### #### loop through each switch in the fabric and collect and write the MAPS and Flow Info #### ############################################################################### for ip in fab_ip_list: tnn = anturlar.connect_tel_noparse(ip, 'root', 'password') cons_out = anturlar.fos_cmd("setcontext %s " % this_fid) m_info = anturlar.Maps() f_info = anturlar.FlowV() maps_config = anturlar.fos_cmd("mapsconfig --show") maps_policy_list = m_info.get_policies() maps_active_policy = m_info.get_active_policy() non_dflt_policy = m_info.get_nondflt_policies() flow_names = f_info.flow_names() flows_nondflt = f_info.get_nondflt_flows() flows_active = f_info.get_active_flows() #flow_cnfg = f_info.flow_config() flow_details = f_info.get_flow_details() anturlar.close_tel() ####### ####### remove line switchname FID ?? root> ####### m_no_root = s_name + ":FID" + str(this_fid) + ":root>" m = maps_config.replace(m_no_root, '') mc = m.lstrip() #### remove leading white space ####### ####### remove line switchname FID ?? root> ####### #### #### leave as capturing data for only one FID at a time #### have a switch for all fid data #### #### seperator(ff, ip) ff.write( "---------------------------------------------------------------------\r\n" ) #ff.write("MAPS config : %s \r\n" % maps_config) ff.write( "MAPS config :\r\n") ## maps config header ff.write(mc) ## write maps config ff.write( "\n---------------------------------------------------------------------\r\n" ) ff.write("MAPS Policy List : %s \r\n" % maps_policy_list) ff.write("MAPS Active Policy : %s \r\n" % maps_active_policy) ff.write("MAPS Non Default Policy : %s \r\n" % non_dflt_policy) ff.write( "---------------------------------------------------------------------\r\n" ) ff.write("FLOW Names list : %s \r\n" % flow_names) ff.write("FLOW non dflt Flows : %s \r\n" % flows_nondflt) ff.write("FLOWs Active : %s \r\n" % flows_active) ff.write("FLOW Details : %s \r\n" % flow_details) ff.write( "---------------------------------------------------------------------\r\n" ) ff = liabhar.FileStuff(fname, 'a+b') ff.write( "#####################################################################\r\n" ) ff.write( "#####################################################################\r\n" ) ff.write("##########\r\n") ff.write( "########## FABRIC SWITCHES INFO ##########\r\n" ) ff.write("##########\r\n") ff.write( "#####################################################################\r\n" ) for ip in fab_ip_list: tnnn = anturlar.connect_tel_noparse(ip, 'root', 'password') firmware_ver = check_version() chass_name = m_info.chassisname() sf = "{0:18} {1:25} {2:25}" print(sf.format(str(ip), str(chass_name), str(firmware_ver)), file=ff) ff.write("\r\n") ff.write( "#####################################################################\r\n" ) ff.write( "#####################################################################\r\n" ) ff.write( "#####################################################################\r\n" ) ff.write( "#####################################################################\r\n" ) ff.write( "#####################################################################\r\n" ) ff.close() print("\n") print("#" * 120) print( "\nFind the results in logs/fabric_info_logs/fabric_info_switchtxt\n" ) print("#" * 120) print("\n" * 10) return (True)
def main(): global tn ############################################################################### #### #### #### ############################################################################### pa = parse_args(sys.argv) #print(pa) #print(pa.chassis_name) #print(pa.ipaddr) #print(pa.quiet) #print(pa.verbose) #print(pa.firmware) #print("@"*40) #sys.exit() ########################################################################## ########################################################################## ### ### hold the ip address from the command line ### if pa.ipaddr: pa.chassis_name = console_info_from_ip(pa.ipaddr, pa.chassis_name) cons_info = console_info(pa.chassis_name) console_ip = cons_info[0] console_port = cons_info[1] power_pole_info = pwr_pole_info(pa.chassis_name) usr_pass = get_user_and_pass(pa.chassis_name) user_name = usr_pass[0] usr_psswd = usr_pass[1] tn = anturlar.connect_tel_noparse(pa.ipaddr, user_name, usr_psswd) fi = anturlar.FabricInfo() si = anturlar.SwitchInfo() fcr = anturlar.FcrInfo() if pa.fabwide: ipaddr_switch = fi.ipv4_list() #print(ipaddr_switch) elif pa.csvall: ipaddr_switch = get_ip_from_file(pa.chassis_name) elif pa.fcrwide: anturlar.fos_cmd("setcontext %s" % fcr.base_check()) ipaddr_switch = fcr.fcr_fab_wide_ip() else: ipaddr_switch = [pa.ipaddr] anturlar.close_tel() #### pass ip(s)to login procedure #### and write the file for i in ipaddr_switch: tn = anturlar.connect_tel_noparse(i, user_name, usr_psswd) nos = si.nos_check() if not nos: fi = anturlar.FcrInfo() lsanzone = anturlar.fos_cmd("lsanzoneshow -s") fcrproxy = anturlar.fos_cmd("fcrproxydevshow") fcrresource = anturlar.fos_cmd("fcrresourceshow") print(lsanzone) print(fcrproxy) print(fcrresource) f1 = "%s%s%s" % ("logs/LsanZoneInfo_", pa.ipaddr, "_base.txt") a = os.path.isfile(f1) if not a: print("Not there. Capturing file now") header = "%s%s%s%s" % ("\nLsanZoneShow CAPTURE FILE \n",\ "","", "==============================\n") ff = liabhar.FileStuff( f1, 'w+b') #### open the log file for writing ff.write(header) ff.write(lsanzone) ff.write(fcrproxy) ff.write(fcrresource) sys.exit(0) else: f2 = "%s%s%s" % ("logs/LsanZoneInfo_", pa.ipaddr, "_after.txt") header = "%s%s%s%s" % ("\nLsanZoneShow CAPTURE FILE \n",\ "","", "==============================\n") ff = liabhar.FileStuff( f2, 'w+b') #### open the log file for writing ff.write(header) ff.write(lsanzone) ff.write(fcrproxy) ff.write(fcrresource) #sys.exit(0) #f0 = ("logs/LsanZoneInfo_",pa.ipaddr,"_base.txt") #f1 = ("logs/LsanZoneInfo_",pa.ipaddr,"_after.txt") diff = fcr_tools.file_diff(f1, f2) print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!") print(diff) sys.exit() #sw_dict = cofra.get_info_from_the_switch() #switch_ip = sw_dict["switch_ip"] #sw_name = sw_dict["switch_name"] #sw_chass_name = sw_dict["chassis_name"] #sw_director_or_pizza = sw_dict["director"] #sw_domains = sw_dict["domain_list"] #sw_ls_list = sw_dict["ls_list"] #sw_base_fid = sw_dict["base_sw"] #sw_xisl = sw_dict["xisl_state"] #sw_type = sw_dict["switch_type"] #sw_license = sw_dict["license_list"] #sw_vf_setting = sw_dict["vf_setting"] #sw_fcr_enabled = sw_dict["fcr_enabled"] #sw_port_list = sw_dict["port_list"] # #print("\n"*20) #print("SWITCH IP : %s " % switch_ip) #print("SWITCH NAME : %s " % sw_name) #print("CHASSIS NAME : %s " % sw_chass_name) #print("DIRECTOR : %s " % sw_director_or_pizza) #print("SWITCH DOMAINS : %s " % sw_domains) #print("LOGICAL SWITCH LIST : %s " % sw_ls_list) #print("BASE FID : %s " % sw_base_fid) #print("XISL STATE : %s " % sw_xisl) #print("SWITCH TYPE : %s " % sw_type) #print("LICENSE LIST : %s " % sw_license) #print("VF SETTING : %s " % sw_vf_setting) #print("FCR SETTING : %s " % sw_fcr_enabled) #print("PORT LIST : %s " % sw_port_list) #print("@"*40) #print("CONSOLE INFO : %s " % cons_info) #print("@"*40) #print("POWER POLE INFO : %s " % power_pole_info) #print("@"*40) #print("\nSwitch_Info has been written this file in logs/Switch_Info_%s_restore.txt\n" % switch_ip) #print("@"*40) else: print("\n" + "@" * 40) print('\nTHIS IS A NOS SWITCH> SKIPPING') print("\n" + "@" * 40) pass anturlar.close_tel() sys.exit()
def fabric_switch_config_show(): """ document how this works here 1. Retreive a list of all of the switches in the FID passed during start 2. get Flow and MAPS basic setup information """ cons_out = anturlar.fos_cmd("") swtch = anturlar.SwitchInfo() fab = anturlar.FabricInfo() fab_ip_list = fab.ipv4_list() this_fid = swtch.currentFID() fname = "%s%s" % ("logs/fabric_info_switch" ,".txt") #### %s string %d number ff = liabhar.FileStuff(fname, 'w+b') ff.write("#############################################################\r\n") ff.write("#############################################################\r\n") ff.write("\r\n") for ip in fab_ip_list: ff.write(ip) ff.write("\r\n") ff.write("#############################################################\r\n") ff.write("#############################################################\r\n") ff.write("#############################################################\r\n") ff.write("#############################################################\r\n\r\n\r\n") ff.close() #ff = liabhar.FileStuff(fname, 'a+b') #for ip in fab_ip_list: # tnnn = anturlar.connect_tel_noparse(ip, 'root', 'password') # firmware_ver = check_version() # # ip_firm_ver_pair = "%s %s" % ( ip,firmware_ver) # # ff.write("\r\n") # ff.write(ip_firm_ver_pair) # #ff.write("\r\n") #ff.write("#############################################################\r\n") #ff.write("#############################################################\r\n") #ff.write("#############################################################\r\n") #ff.write("#############################################################\r\n") #ff.write("#############################################################\r\n") #ff.close() m_info = anturlar.Maps() f_info = anturlar.FlowV() maps_config = anturlar.fos_cmd("mapsconfig --show") firmware_ver = check_version() s_name = m_info.switch_name() s_type = m_info.switch_type() ls_list = m_info.ls() switch_id = m_info.switch_id() ls_domain = m_info.ls_and_domain() chass_name = m_info.chassisname() vf_state = m_info.vf_enabled() ff = liabhar.FileStuff(fname, 'a+b') ff.write("Switch ipv4 : %s \r\n" % ip) ff.write("Chassis Name : %s \r\n" % chass_name) ff.write("Firmware version : %s \r\n" % firmware_ver) ff.write("Switch Name : %s \r\n" % s_name) ff.write("Switch Type : %s \r\n" % s_type) ff.write("VF State : %s \r\n" % vf_state) ff.write("Logical Switches : %s \r\n" % ls_list) ff.write("Switch ID : %s \r\n" % switch_id) ff.write("ls and domain : %s \r\n" % ls_domain) for ip in fab_ip_list: tnn = anturlar.connect_tel_noparse(ip, 'root', 'password') cons_out = anturlar.fos_cmd("setcontext %s " % this_fid) maps_policy_list = m_info.get_policies() maps_active_policy = m_info.get_active_policy() non_dflt_policy = m_info.get_nondflt_policies() flow_names = f_info.flow_names() flows_nondflt = f_info.get_nondflt_flows() flows_active = f_info.get_active_flows() #flow_cnfg = f_info.flow_config() flow_details = f_info.get_flow_details() anturlar.close_tel() ####### ####### remove line switchname FID ?? root> ####### print("\n"*4) print(maps_config) print("\n"*4) m_no_root = s_name + ":FID" + str(this_fid) + ":root>" #m_no_name = maps_config.replace(s_name ,'') #m_no_fid = m_no_name.replace(str(this_fid), '') m = maps_config.replace(m_no_root, '') print("\n"*4) print(m) print("\n"*4) ####### ####### remove line switchname FID ?? root> ####### #### #### leave as capturing data for only one FID at a time #### have a switch for all fid data #### #### seperator(ff, ip) ff.write("---------------------------------------------------------------------\r\n") #ff.write("MAPS config : %s \r\n" % maps_config) ff.write("MAPS config : \r\n %s \r\n" % m) ## maps config ff.write("---------------------------------------------------------------------\r\n") ff.write("MAPS Policy List : %s \r\n" % maps_policy_list) ff.write("MAPS Active Policy : %s \r\n" % maps_active_policy) ff.write("MAPS Non Default Policy : %s \r\n" % non_dflt_policy) ff.write("---------------------------------------------------------------------\r\n") ff.write("FLOW Names list : %s \r\n" % flow_names) ff.write("FLOW non dflt Flows : %s \r\n" % flows_nondflt) ff.write("FLOWs Active : %s \r\n" % flows_active) ff.write("FLOW Details : %s \r\n" % flow_details) ff.write("---------------------------------------------------------------------\r\n") #ff.write("FLOW CONFIG : \r\n %s \r\n" % flow_cnfg) ff = liabhar.FileStuff(fname, 'a+b') ff.write("#####################################################################\r\n") ff.write("#####################################################################\r\n") ff.write("##########\r\n") ff.write("########## FABRIC SWITCHES INFO ##########\r\n") ff.write("##########\r\n") ff.write("#####################################################################\r\n") #for ip in fab_ip_list: # tnnn = anturlar.connect_tel_noparse(ip, 'root', 'password') # firmware_ver = check_version() # m_info = anturlar.Maps() # chass_name = m_info.chassisname() # # ip_firm_ver_pair = "%s\t\t%s\t\t%s " % ( ip,chass_name,firmware_ver) # # ff.write("\r\n") # ff.write(ip_firm_ver_pair) # #ff.write("\n"*5) for ip in fab_ip_list: tnnn = anturlar.connect_tel_noparse(ip, 'root', 'password') firmware_ver = check_version() m_info = anturlar.Maps() chass_name = m_info.chassisname() sf = "{0:18} {1:25} {2:25}" print(sf.format( str(ip), str(chass_name), str(firmware_ver) ), file=ff) ff.write("\r\n") ff.write("#####################################################################\r\n") ff.write("#####################################################################\r\n") ff.write("#####################################################################\r\n") ff.write("#####################################################################\r\n") ff.write("#####################################################################\r\n") ff.close() return(True)
def main(): global tn ####################################################################################################################### #### #### start with parsing the command line #### #### use the procedures parent_parser and parse_args #### to determine the command line switches #### ####################################################################################################################### pa = parse_args(sys.argv) print(pa) print("@" * 40) print("@" * 40) ####################################################################################################################### ####################################################################################################################### #### ####################################################################################################################### ######################################################################################################################## #### switchmatrix = 'ini/SwitchMatrix.csv' try: csv_file = csv.DictReader(open(switchmatrix, 'r'), delimiter=',', quotechar='"') except OSError: print("Cannot find the file SwitchMatrix.csv") return (False) #### print("\n\n ip address chassisname username password ") for line in csv_file: ipaddr_switch = (line['IP Address']) swtch_name = (line['Chassisname']) user_name = (line['Username']) usr_psswd = (line['Password']) print(" %s %s %s %s " % (ipaddr_switch, swtch_name, user_name, usr_psswd)) tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, usr_psswd) cons_out = anturlar.fos_cmd( "firmwareshow") #### send any command with anturlar.fos_cmd ht = anturlar.SwitchInfo() ls_numbs = ht.ls() #### str1 = ''.join(ls_numbs) ls_numbs_str = ' '.join(str(e) for e in ls_numbs) dt = liabhar.dateTimeStuff( ) #### create the object for date and time stuff port_list = [] date_is = dt.current_no_dash_at_end() f = "%s%s%s" % ("logs/Host_target_file", ipaddr_switch, ".txt") ff = liabhar.FileStuff(f, 'a+b') #### open the log file for writing header = "%s%s%s%s%s%s%s" % ("\n HOST TARGET CAPTURE FILE \n"," ",date_is,"\n ipaddress: ",\ " ",ipaddr_switch,"\n ==================================\n") #### write a header line at top of file ff.write(header) ff.write("\n") ff.write("LS NUMBERS ") ff.write(ls_numbs_str) for l in ls_numbs: port_list_str = "" nsoutput = anturlar.fos_cmd("setcontext %s " % l) reg_wwn = [b'.?;([:0-9a-f]{23,23})'] nsoutput = anturlar.fos_cmd("nsshow") ras = re.compile('Permanent Port Name: ([:0-9a-f]{23,23})') port_list = ras.findall(nsoutput) #port_list_str = ' '.join(str(e) for e in port_list) #cons_out = anturlar.fos_cmd("setcontext %s " % pa.fid) ff.write("\n") ff.write("LS %s PORTS \n" % l) ff.write("PORT WWN \n") for p in port_list: wwn_zone = anturlar.fos_cmd("nszoneshow -wwn %s " % p, 0) ras = re.compile('\s{2}([-_a-zA-Z0-9]+)(?=\r\n)') zones = ras.findall(wwn_zone) print("\n") print("$" * 80) print("$" * 80) print(zones) for z in zones: print(z) zone_cfg_members = anturlar.fos_cmd("zoneshow %s " % z, 0) ras = re.compile('([:0-9a-f]{23})') wwn_zoned_with = ras.findall(zone_cfg_members) print(wwn_zoned_with) print("$" * 80) print("$" * 80) print("$" * 80) ff.write(p) ff.write("\n=============================") ff.write("\n\t\t\t") for z in zones: ff.write(z) ff.write("; ") zone_cfg_members = anturlar.fos_cmd("zoneshow %s " % z, 0) ras = re.compile('([:0-9a-f]{23})') wwn_zoned_with = ras.findall(zone_cfg_members) ff.write("(") do_semi = False for w in wwn_zoned_with: if p != w: ff.write(w) if do_semi: ff.write("; ") else: do_semi = True ff.write(")") ff.write("\n\t\t\t") ff.write("\n") #ff.write(port_list_str) ff.write("\n") ff.close() #### close this file for comparison later anturlar.close_tel() #### close the telnet session
def main(): global tn ####################################################################################################################### #### #### start with parsing the command line #### #### use the procedures parent_parser and parse_args #### to determine the command line switches #### ####################################################################################################################### pa = parse_args(sys.argv) print(pa) print(pa.ipaddr) print(pa.quiet) print(pa.verbose) print(pa.cmdprompt) print(pa.iterations) #print(pa.zone_name_size) print("@" * 40) print("@" * 40) #sys.exit() ####################################################################################################################### ####################################################################################################################### #### #### if user enter ip address then get the chassisname from the #### SwitchMatrix file #### #### then get the info from the SwitchMatrix file using the Chassis Name #### #### #### Type,Chassisname,IP Address,Username,Password,Console1 IP,Console1 Port,Console2 IP,Console2 Port, #### Power1 IP,Power1 Port,Power2 IP,Power2 Port,Power3 IP,Power3 Port,Power4 IP,Power4 Port, #### KVM IP,KVM Port,Web Username,Web Password,Admin Password #### ####################################################################################################################### ####################################################################################################################### if pa.ipaddr: print("do IP steps") pa.chassis_name = sw_matrix_tools.console_info_from_ip(pa.ipaddr) cons_info = sw_matrix_tools.console_info(pa.chassis_name) console_ip = cons_info[0] console_port = cons_info[1] console_ip_bkup = cons_info[2] console_port_bkup = cons_info[3] power_pole_info = sw_matrix_tools.pwr_pole_info(pa.chassis_name) usr_pass = sw_matrix_tools.get_user_and_pass(pa.chassis_name) user_name = usr_pass[0] usr_psswd = usr_pass[1] ipaddr_switch = sw_matrix_tools.get_ip_from_file(pa.chassis_name) ###################################################################################################################### ###################################################################################################################### #### #### connect via telnet: #### if you want to connect to the console it is available in anturlar and an example is available below #### #### ###################################################################################################################### ###################################################################################################################### #### Config_up_down_compare.main() #cons_out = anturlar.fos_cmd("firmwareshow") #### send any command with anturlar.fos_cmd #print("\r\n") #liabhar.JustSleep(5) #### sleep without printing anything #print(cons_out) # print("now closing telnet session ") # #anturlar.close_tel() #### close the telnet session ####################################################################################################################### ####################################################################################################################### #### #### connect via console example and other "send command" commands #### #### ####################################################################################################################### ####################################################################################################################### #tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,usr_psswd) #### connect to console w/o parser info #cons_out = anturlar.fos_cmd("firmwareshow") #cons_out = anturlar.fos_cmd("setcontext %s " % pa.fid) #### change to the fid given on the command #tn = anturlar.connect_console(console_ip,console_port) #### use the console ip and console port info #cons_out = anturlar.fos_cmd("switchshow") #### send a command via the console #cons_out = cofra.power_cycle(power_pole_info) #### powercycle switch via switchmatrix.csv file #liabhar.JustSleep(30) #### wait for the switch to boot #cons_out = anturlar.send_cmd_console("\r\n") #### send some commands to the console #cons_out = anturlar.send_cmd_console("setcontext %s " % pa.fid) #### send some commands to the console #cons_out = anturlar.send_cmd_console("firmwareshow") #### send some commands to the console #capture = cofra.cfgupload("10.38.35.131", "ftp1", "ftp2") #### send a cfgupload file to a ftp server #liabhar.count_down(5) #### set and observe a count down timer ####################################################################################################################### ####################################################################################################################### #### #### This starts the template for configshow output comparison (after some type of switch operation). #### First snippet of code simply opens a connection, changes to requested fid, sends output of configshow to a file. #### ####################################################################################################################### ####################################################################################################################### tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, usr_psswd) cons_out = anturlar.fos_cmd("setcontext %s " % pa.fid) dt = liabhar.dateTimeStuff( ) #### create the object for date and time stuff date_is = dt.current_no_dash_at_end( ) #### get the current time for file naming purposes #print("\n\nDate is %s" % date_is) liabhar.count_down(3) #### count down to the next command #configup_cmd = ("configupload -all -p ftp %s,%s,/configs/%s.txt,%s") % ("10.38.35.131","ftp1", ipaddr_switch, "ftp2") f = "%s%s%s%s" % ("logs/CLITIZoneOperations_test_case_file", "_" + ipaddr_switch + "_", date_is, ".txt") ff = liabhar.FileStuff(f, 'w+b') #### open the log file for writing #header = "%s%s%s%s" % ("\nNAMESERVER CAPTURE FILE \n", " sw_info ipaddr ",ipaddr_switch,"\n==============================\n\n") #### write a header line at top of file header = "%s%s%s%s" % ("\nCLITIZoneOperations CAPTURE FILE \n", " sw_info ipaddr ", ipaddr_switch, "\n==============================\n\n") ff.write(header) ff.write(anturlar.fos_cmd("nsshow")) ff.write(anturlar.fos_cmd("nsallshow")) ff.close() g = open(f, "r") lines = g.readlines() g.close() ff = liabhar.FileStuff(f, 'w+b') for l in lines: if " date = " not in l: ff.write(l) ff.close() #### close this file for comparison later ####################################################################################################################### ####################################################################################################################### #### #### do anything else you want to try (small sample of examples): #### anturlar.fos_cmd("tsclockserver 10.38.2.80; tstimezone America/Denver") #### anturlar.fos_cmd("cfgenable") #### anturlar.fos_cmd("switchdisable") #### anturlar.fos_cmd("switchenable") #### #### In the below snippet we run tsclockerver: anturlar.fos_cmd("tsclockserver 10.38.2.80; tstimezone America/Denver") #### Then grab output of configshow, drop into a file and compare that with original #### ####################################################################################################################### ####################################################################################################################### # tn = cofra.clear_stats() # print(pa.porttype) # #sys.exit() # porttype = pa.porttype # print(porttype) # PortFlapper.main(porttype) ############################################################################################# si = anturlar.SwitchInfo() fi = anturlar.FabricInfo() # fabric_check = fi.fabric_members() cfgsz = anturlar.fos_cmd("cfgsize") # cfgshow = anturlar.fos_cmd("cfgshow") cfgtransshow = anturlar.fos_cmd("cfgtransshow") if "token" in cfgtransshow: print("Outstanding transaction in progress. Use cfgtransshow to view.") sys.exit() # print(fabric_check) # print(cfgsz) # print(cfgshow) # print(cfgtransshow) character = "$-^_" characters = ["$", "-", "^", "_"] size = random.randint(0, 61) ti_zonename = (''.join( random.choice(string.ascii_letters + string.digits + character) for _ in range(size)) + "_TI") ti_zonename = "$" + ti_zonename print(ti_zonename) while ti_zonename[0] in character: print("Can't have special characters at the beginning of a zone name") ti_zonename = (''.join( random.choice(string.ascii_letters + string.digits + character) for _ in range(size)) + "_TI") print(ti_zonename) sys.exit() # a = ("time zone --create -t ti %s -p \"1,1:2,2\"" % ti_zonename) # print(a) anturlar.fos_cmd("zone --create -t ti %s -p \"1,1;2,2\"" % ti_zonename) #anturlar.fos_cmd("echo Y | cfgsave") # anturlar.fos_cmd("echo Y | cfgsave") # anturlar.fos_cmd("cfgshow") sys.exit() # f_ports = si.f_ports() # e_ports = si.e_ports() # print("\n\n\n\n") # print(f_ports) # print(e_ports) # print("\n\n\n\n") # if pa.porttype == "eports": # ports = e_ports # else: # ports = f_ports # i = ipaddr_switch # try: # tn = anturlar.connect_tel_noparse(i,user_name,usr_psswd) # except OSError: # print("Switch %s not available" % i) nos = si.nos_check() if not nos: for i in ports: slot = i[0] port = i[1] if slot: anturlar.fos_cmd("portdisable %s/%s" % (slot, port)) liabhar.count_down(15) anturlar.fos_cmd("portenable %s/%s" % (slot, port)) liabhar.count_down(15) else: anturlar.fos_cmd("portdisable %s" % (port)) liabhar.count_down(15) anturlar.fos_cmd("portenable %s" % (port)) liabhar.count_down(15) fabric_check1 = fi.fabric_members() if fabric_check != fabric_check1: print("WTF") #email_sender_html(you, me, subj, html_to_send, htmlfile_path = "" ) liabhar.email_sender_html("*****@*****.**", "*****@*****.**", "NS_portflapper failed", "NS_portflapper failed", "") sys.exit() anturlar.close_tel() #return(True) else: print("\n" + "@" * 40) print('\nTHIS IS A NOS SWITCH> SKIPPING') print("\n" + "@" * 40) pass #anturlar.close_tel() #################################################################################################################### #anturlar.fos_cmd("tsclockserver 10.38.2.80; tstimezone America/Denver") #tn = cofra.ha_failover(pa.iterations) #tn = cofra.power_cycle_iterations(power_pole_info, pa.iterations) tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, usr_psswd) cons_out = anturlar.fos_cmd("setcontext %s " % pa.fid) date_is = dt.current_no_dash_at_end() f1 = "%s%s%s%s" % ("logs/NameServer_test_case_file", "_" + ipaddr_switch + "_", date_is, ".txt") ff = liabhar.FileStuff(f1, 'w+b') #### reset the log file #header = "%s%s%s%s" % ("\NAMESERVER CAPTURE FILE \n", " sw_info ipaddr ",ipaddr_switch,"\n==============================\n\n") #header = "%s%s%s%s" % ("\nCONFIGUPLOAD CAPTURE FILE \n", " sw_info ipaddr ",ipaddr_switch, "\n==============================\n\n") header = "%s%s%s%s" % ("\nNAMESERVER CAPTURE FILE \n", " sw_info ipaddr ", ipaddr_switch, "\n==============================\n\n") ff.write(header) ff.write(anturlar.fos_cmd("nsshow")) ff.write(anturlar.fos_cmd("nsallshow")) ff.close() g = open(f1, "r") lines = g.readlines() g.close() ff = liabhar.FileStuff(f1, 'w+b') for l in lines: if " date = " not in l: ff.write(l) ff.close() diff_f = liabhar.file_diff(f, f1) print("#" * 80) print("#" * 80) print("#" * 80) print("#" * 80) print("Result ") print(diff_f) liabhar.email_sender_html("*****@*****.**", "*****@*****.**", "NS_portflapper passed", "NS_portflapper passed", "") return (True)
def main(): global tn ################################################################################################################### # # start with parsing the command line # # use the procedures parent_parser and parse_args # to determine the command line switches # ################################################################################################################### pa = parse_args() print(pa) print(pa.ipaddr) print(pa.quiet) print(pa.verbose) print(pa.cmdprompt) print(pa.iterations) print(pa.porttype) print(pa.email) print("@" * 40) print("@" * 40) # sys.exit() ################################################################################################################### ################################################################################################################### # # if user enter ip address then get the chassisname from the # SwitchMatrix file # # then get the info from the SwitchMatrix file using the Chassis Name # # # Type,Chassisname,IP Address,Username,Password,Console1 IP,Console1 Port,Console2 IP,Console2 Port, # Power1 IP,Power1 Port,Power2 IP,Power2 Port,Power3 IP,Power3 Port,Power4 IP,Power4 Port, # KVM IP,KVM Port,Web Username,Web Password,Admin Password # ################################################################################################################### ################################################################################################################### if pa.ipaddr: print("do IP steps") pa.chassis_name = sw_matrix_tools.console_info_from_ip(pa.ipaddr) # cons_info = sw_matrix_tools.console_info(pa.chassis_name) # console_ip = cons_info[0] # console_port = cons_info[1] # console_ip_bkup = cons_info[2] # console_port_bkup = cons_info[3] # power_pole_info = sw_matrix_tools.pwr_pole_info(pa.chassis_name) usr_pass = sw_matrix_tools.get_user_and_pass(pa.chassis_name) user_name = usr_pass[0] usr_psswd = usr_pass[1] ipaddr_switch = sw_matrix_tools.get_ip_from_file(pa.chassis_name) ################################################################################################################### # # connect via telnet: # if you want to connect to the console it is available in anturlar and an example is available below # # ################################################################################################################### # Config_up_down_compare.main() # cons_out = anturlar.fos_cmd("firmwareshow") # send any command with anturlar.fos_cmd # print("\r\n") # liabhar.JustSleep(5) # sleep without printing anything # print(cons_out) # print("now closing telnet session ") # #anturlar.close_tel() #### close the telnet session ################################################################################################################### # # connect via console example and other "send command" commands # # ################################################################################################################### # tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,usr_psswd) # connect to console w/o parser info # cons_out = anturlar.fos_cmd("firmwareshow") # cons_out = anturlar.fos_cmd("setcontext %s " % pa.fid) # hange to the fid given on the command # tn = anturlar.connect_console(console_ip,console_port) # use the console ip and console port info # cons_out = anturlar.fos_cmd("switchshow") # send a command via the console # cons_out = cofra.power_cycle(power_pole_info) # powercycle switch w switchmatrix.csv file # liabhar.JustSleep(30) # wait for the switch to boot # cons_out = anturlar.send_cmd_console("\r\n") # end some commands to the console # cons_out = anturlar.send_cmd_console("setcontext %s " % pa.fid) # send some commands to the console # cons_out = anturlar.send_cmd_console("firmwareshow") # send some commands to the console # capture = cofra.cfgupload("10.38.35.131", "ftp1", "ftp2") # send a cfgupload file to a ftp server # liabhar.count_down(5) #### set and observe a count down timer ################################################################################################################### ################################################################################################################### # # This starts the template for configshow output comparison (after some type of switch operation). # First snippet of code simply opens a connection, changes to requested fid, sends output of configshow to a # file ################################################################################################################### ################################################################################################################### tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, usr_psswd) # cons_out = anturlar.fos_cmd("setcontext %s " % pa.fid) dt = liabhar.dateTimeStuff() # create the object for date and time stuff date_is = dt.current_no_dash_at_end() # get the current time for file naming purposes # print("\n\nDate is %s" % date_is) liabhar.count_down(3) # count down to the next command # configup_cmd = ("configupload -all -p ftp %s,%s,/configs/%s.txt,%s") % ("172.16.114.67","ftp1",/ # ipaddr_switch,"ftp2") f = "%s%s%s%s" % ("logs/Configupload_test_case_file_ORIG", "_" + ipaddr_switch + "_", date_is, ".txt") ff = liabhar.FileStuff(f, 'w+b') # open the log file for writing header = "%s%s%s%s" % ("\nCONFIGUPLOAD CAPTURE FILE \n", " sw_info ipaddr ", ipaddr_switch, "\n==============================\n\n") # write a header line at top of file ff.write(header) ff.write(anturlar.fos_cmd("configshow")) # ff.write("THE END") ff.close() # close this file for comparison later # g = open(f, "r") # lines = g.readlines() # g.close() # ff = liabhar.FileStuff(f, 'w+b') # for l in lines: # if " date = " not in l: # ff.write(l) # ff.close() ################################################################################################################## ################################################################################################################## # # do anything else you want to try (small sample of examples): # anturlar.fos_cmd("tsclockserver 10.38.2.80; tstimezone America/Denver") # anturlar.fos_cmd("cfgenable") # anturlar.fos_cmd("switchdisable") # anturlar.fos_cmd("switchenable") # # In the below snippet we run tsclockerver: anturlar.fos_cmd("tsclockserver 10.38.2.80;\ # tstimezone America/Denver") # Then grab output of configshow, drop into a file and compare that with original # ################################################################################################################## ################################################################################################################## # tn = cofra.clear_stats() # print(pa.porttype) # #sys.exit() # porttype = pa.porttype # print(porttype) # PortFlapper.main(porttype) ############################################################################################# si = anturlar.SwitchInfo() fi = anturlar.FabricInfo() fabric_check = fi.fabric_members() f_ports = si.f_ports() e_ports = si.e_ports() print("\n\n\n\n") print(f_ports) print(e_ports) print("\n\n\n\n") if pa.porttype == "eports": ports = e_ports else: ports = f_ports # try: # tn = anturlar.connect_tel_noparse(i,user_name,usr_psswd) # except OSError: # print("Switch %s not available" % i) g = pa.iterations while g > 0: for i in ports: slot = i[0] port = i[1] if slot: anturlar.fos_cmd("portdisable %s/%s" % (slot, port)) liabhar.count_down(15) anturlar.fos_cmd("portenable %s/%s" % (slot, port)) liabhar.count_down(15) else: anturlar.fos_cmd("portdisable %s" % port) liabhar.count_down(15) anturlar.fos_cmd("portenable %s" % port) liabhar.count_down(15) fabric_check1 = fi.fabric_members() if fabric_check != fabric_check1: print("WTF") # email_sender_html(you, me, subj, html_to_send, htmlfile_path = "" ) liabhar.email_sender_html(pa.email, pa.email, "portflapper failed", "portflapper failed", "") anturlar.close_tel() sys.exit(0) else: c = "%s%s%s%s" % ("logs/Configupload_test_case_file_COMPARE", "_" + ipaddr_switch + "_", date_is, ".txt") cc = liabhar.FileStuff(c, 'w+b') # open the log file for writing header = "%s%s%s%s" % ("\nCONFIGUPLOAD CAPTURE FILE \n", " sw_info ipaddr ", ipaddr_switch, "\n==============================\n\n") # write a header line at top of file cc.write(header) cc.write(anturlar.fos_cmd("configshow")) # ff.write("THE END") cc.close() # x = open(c, "r") # lines = x.readlines() # x.close() # cc = liabhar.FileStuff(f, 'w+b') # for l in lines: # if " date = " not in l: # cc.write(l) # cc.close() diff_f = liabhar.file_diff(f, c) print(diff_f) g = g - 1 print(g) if not diff_f: liabhar.email_sender_html(pa.email, pa.email, "PF_configshow_compare failed a checkpoint", "PF_configshow_compare failed" "a checkpoint. Support Save and trace dump transferred", "") cofra.DoSupportsave("172.16.114.67", "ftp1", "ftp2", pa.chassis_name) anturlar.close_tel() sys.exit(0) # diff_f = liabhar.file_diff(f, f1) print("#" * 80) print("#" * 80) print("#" * 80) print("#" * 80) print("Result ") print(diff_f) liabhar.email_sender_html(pa.email, pa.email, "PF_configshow_compare passed", "PF_configshow_compare passed", "") return True
def capture_switch_info(extend_name="", fid=128): """ """ si = anturlar.SwitchInfo() mi = anturlar.Maps() fi = anturlar.FlowV() fcr = anturlar.FcrInfo() vdx = si.nos_check() switch_ip = si.ipaddress() switch_cp_ips = si.cp_ipaddrs_get() license_list = si.getLicense() ls_list = si.ls() first_ls = si.ls_now() switch_id = si.switch_id() fid_now = si.currentFID() try: theswitch_name = si.switch_name() except IndexError: theswitch_name = "unknown" pass chassis_name = si.chassisname() director_pizza = si.director() vf_enabled = si.vf_enabled() sw_type = si.switch_type() base_sw = si.base_check() sim_ports = si.sim_ports() ex_ports = fcr.all_ex_ports() fcr_state = si.fcr_enabled() ports_and_ls = si.all_ports_fc_only() psw_reset_value = "YES" xisl_st_per_ls = si.allow_xisl() maps_policy_sum = mi.get_policies() maps_non_dflt_policy = mi.get_nondflt_policies() flow_per_ls = fi.flow_names() blades = si.blades() deflt_switch = si.default_switch() # sfp_info = si.sfp_info() maps_email_cfg = mi.get_email_cfg() maps_actions = mi.get_actions() logical_groups = mi.logicalgroup_count() relay_server_info = mi.get_relay_server_info() credit_recov_info = mi.credit_recovery() dns_info = mi.dns_config_info() ################################################################################################################### ################################################################################################################### #### #### print the variables for review #### ################################################################################################################### ################################################################################################################### print("\n\n\n") print("SWITCH IP : %s " % switch_ip) print("SWITCH NAME : %s " % theswitch_name) # print("SWITCH DOMAIN : %s " % domain_list) print("LS LIST : %s " % ls_list) print("DEFAULT SWITCH : %s " % deflt_switch) print("BASE SWITCH : %s " % base_sw) print("EX_PORTS : %s " % ex_ports) ######################NEW print("VF SETTING : %s " % vf_enabled) print("SWITCH TYPE : %s " % sw_type) print("TIMEOUT VALUE : 0 ") print("RESET PASSWORD : %s " % psw_reset_value) print("FCR ENABLED : %s " % fcr_state) print("BLADES : %s " % blades) print("LICENSE LIST : %s " % license_list) ####################################################################################################################### ####################################################################################################################### ####################################################################################################################### #### #### Write to the file #### ####################################################################################################################### ####################################################################################################################### ####################################################################################################################### # f = "%s%s%s" % ("logs/Switch_Info_cudc", switch_ip, "_%s.txt" % extend_name) f = "%s%s%s" % ("/home/runfromhere/logs/Switch_Info_cudc", switch_ip, "_%s.txt" % extend_name) header = "%s%s%s%s" % ("\nSwitch_info_for_playback CAPTURE FILE \n", \ "", "", "==============================\n") ff = liabhar.FileStuff(f, 'w+b') #### open the log file for writing ff.write(header) ################################################################################################################### ff.write("SWITCH IP : %s \n" % switch_ip) ff.write("LS LIST : %s \n" % ls_list) ff.write("DEFAULT SWITCH : %s \n" % deflt_switch) ff.write("BASE SWITCH : %s \n" % base_sw) ff.write("EX_PORTS : %s \n" % ex_ports) ff.write("SWITCH NAME : %s \n" % theswitch_name) ff.write("CHASSIS NAME : %s \n" % chassis_name) ff.write("DIRECTOR STATUS : %s \n" % director_pizza) ff.write("VF SETTING : %s \n" % vf_enabled) ff.write("SWITCH TYPE : %s \n" % sw_type) ff.write("TIMEOUT VALUE : 0 \n") ff.write("RESET PASSWORD : %s \n" % psw_reset_value) ff.write("FCR ENABLED : %s \n" % fcr_state) ff.write("Ports : %s \n" % ports_and_ls) ff.write("SIM PORTS : %s \n" % sim_ports) ff.write("Blades : %s \n" % blades) ff.write("LICENSE LIST : %s \n" % license_list) #ff.write("SFP INFO : %s \n" % sfpinfo) ff.write("=" * 80) ff.write("\n") ff.write("MAPS POLICIES : %s \n" % maps_policy_sum) ff.write("MAPS NON DFLT POLICIES : %s \n" % maps_non_dflt_policy) ff.write("EMAIL CFG : %s \n" % maps_email_cfg) ff.write("MAPS ACTIONS : %s \n" % maps_actions) ff.write("LOGICAL GROUPS : %s \n" % logical_groups) ff.write("RELAY SERVER HOST IP : %s \n" % relay_server_info) ff.write("CREDIT RECOVERY INFO : %s \n" % credit_recov_info) ff.write("DNS CONFIG INFO : %s \n" % dns_info) ff.write("=" * 80) ff.write("\n") ff.write("FLOW CONFIGURATION : %s \n" % flow_per_ls) ff.write("\n" * 2) ff.close() # cons_out = anturlar.fos_cmd("setcontext %s " % fid_now) return (True)
def capture_switch_info(extend_name="", fid=128): """ capture switch info to compare """ si = anturlar.SwitchInfo() mi = anturlar.Maps() fi = anturlar.FlowV() switch_ip = si.ipaddress() switch_cp_ips = si.cp_ipaddrs_get() license_list = si.getLicense() ls_list = si.ls() first_ls = si.ls_now() switch_id = si.switch_id() fid_now = si.currentFID() chassis_name = si.chassisname() director_pizza = si.director() vf_enabled = si.vf_enabled() sw_type = si.switch_type() base_sw = si.base_check() blades = si.blades() deflt_switch = si.default_switch() dns_info = mi.dns_config_info() ####################################################################################################################### ####################################################################################################################### ####################################################################################################################### #### #### Write to the file #### ####################################################################################################################### ####################################################################################################################### ####################################################################################################################### f = "%s%s%s"%("logs/Switch_Info_cudc",switch_ip,"_%s.txt" % extend_name) header = "%s%s%s%s" % ("\nSwitch_info_for_playback CAPTURE FILE \n",\ "","", "==============================\n") ff = liabhar.FileStuff(f, 'w+b') #### open the log file for writing ff.write(header) ################################################################################################################### ff.write("SWITCH IP : %s \n" % switch_ip) ff.write("CP IP : %s \n" % switch_cp_ips) ff.write("LICENSE LIST : %s \n" % license_list) ff.write("LS LIST : %s \n" % ls_list) ff.write("LS Test Start : %s \n" % first_ls) ff.write("Switch ID : %s \n" % switch_id) ff.write("Current FID : %s \n" % fid_now) ff.write("CHASSIS NAME : %s \n" % chassis_name) ff.write("DIRECTOR STATUS : %s \n" % director_pizza) ff.write("VF SETTING : %s \n" % vf_enabled) ff.write("SWITCH TYPE : %s \n" % sw_type) ff.write("BASE SWITCH : %s \n" % base_sw) ff.write("Blades : %s \n" % blades) ff.write("DEFAULT SWITCH : %s \n" % deflt_switch) ff.write("DNS CONFIG INFO : %s \n" % dns_info) for l in ls_list: cons_out = anturlar.fos_cmd("setcontext %s " % l ) try: theswitch_name = si.switch_name() except IndexError: theswitch_name = "unknown" pass sim_ports = si.sim_ports() ports_and_ls = si.all_ports_fc_only() xisl_st_per_ls = si.allow_xisl() maps_policy_sum = mi.get_policies() maps_non_dflt_policy = mi.get_nondflt_policies() flow_per_ls = fi.flow_names() maps_email_cfg = mi.get_email_cfg() maps_actions = mi.get_actions() logical_groups = mi.logicalgroup_count() relay_server_info = mi.get_relay_server_info() credit_recov_info = mi.credit_recovery() sfpinfo = si.sfp_info() ff.write("="*80) ff.write("\n") ff.write("="*80) ff.write("\n") ff.write("FID %s \n" % l) ff.write("SWITCH NAME : %s \n" % theswitch_name) ff.write("SIM PORTS : %s \n" % sim_ports) ff.write("Ports : %s \n" % ports_and_ls) ff.write("XISL state : %s \n" % xisl_st_per_ls) ff.write("MAPS POLICIES : %s \n" % maps_policy_sum ) ff.write("MAPS NON DFLT POLICIES : %s \n" % maps_non_dflt_policy) ff.write("FLOW CONFIGURATION : %s \n" % flow_per_ls) ff.write("EMAIL CFG : %s \n" % maps_email_cfg) ff.write("MAPS ACTIONS : %s \n" % maps_actions) ff.write("LOGICAL GROUPS : %s \n" % logical_groups) ff.write("RELAY SERVER HOST IP : %s \n" % relay_server_info) ff.write("CREDIT RECOVERY INFO : %s \n" % credit_recov_info) ff.write("SFP INFO : %s \n" % sfpinfo) ff.write("\n") ff.write("=END"*20) ff.write("\n") ff.close() cons_out = anturlar.fos_cmd("setcontext %s " % fid_now) return(True)
def switch_config_show(): """ get information for a switch for each FID """ cons_out = anturlar.fos_cmd("") swtch = anturlar.SwitchInfo() fab = anturlar.FabricInfo() #fab_ip_list = fab.ipv4_list() ip = swtch.ipaddress() this_fid = swtch.currentFID() fname = "%s%s" % ("logs/Switch_info_per_FID_", ".txt" ) #### %s string %d number ff = liabhar.FileStuff(fname, 'w+b') ff.write( "#############################################################\r\n") ff.close() tnn = anturlar.connect_tel_noparse(ip, 'root', 'password') ff = liabhar.FileStuff(fname, 'a+b') ls_list_fids = swtch.ls() m_info = anturlar.Maps() f_info = anturlar.FlowV() firmware_ver = check_version() s_type = m_info.switch_type() ls_list = m_info.ls() switch_id = m_info.switch_id() ls_domain = m_info.ls_and_domain() chass_name = m_info.chassisname() vf_state = m_info.vf_enabled() ff.write("Switch ipv4 : %s \r\n" % ip) ff.write("Chassis Name : %s \r\n" % chass_name) ff.write("Firmware version : %s \r\n" % firmware_ver) #ff.write("Switch Name : %s \r\n" % s_name) ff.write("Switch Type : %s \r\n" % s_type) ff.write("VF State : %s \r\n" % vf_state) ff.write("Logical Switches : %s \r\n" % ls_list) ff.write("Switch ID : %s \r\n" % switch_id) ff.write("ls and domain : %s \r\n" % ls_domain) print(ls_list_fids) for i in ls_list_fids: print(i) print("\n" * 10) for ls in ls_list_fids: cons_out = anturlar.fos_cmd("setcontext %s " % ls) s_name = m_info.switch_name() maps_policy_list = m_info.get_policies() maps_active_policy = m_info.get_active_policy() non_dflt_policy = m_info.get_nondflt_policies() flow_names = f_info.flow_names() flows_nondflt = f_info.get_nondflt_flows() flows_active = f_info.get_active_flows() flow_details = f_info.get_flow_details() #flow_cnfg = f_info.flow_config() maps_config = anturlar.fos_cmd("mapsconfig --show") ####### ####### remove line switchname FID ?? root> ####### print("\n" * 4) print(maps_config) print("\n" * 4) m_no_root = s_name + ":FID" + str(ls) + ":root>" #m_no_name = maps_config.replace(s_name ,'') #m_no_fid = m_no_name.replace(str(this_fid), '') m = maps_config.replace(m_no_root, '') print("\n" * 4) print(m) print("\n" * 4) ####### ####### remove line switchname FID ?? root> ####### seperator_switch(ff, ls) ff.write("Switch Name : %s \r\n" % s_name) ff.write( "---------------------------------------------------------------------\r\n" ) #ff.write("MAPS config : %s \r\n" % maps_config) ff.write("MAPS config : \r\n\r\n %s \r\n" % m) ## maps config ff.write( "---------------------------------------------------------------------\r\n" ) ff.write("MAPS Policy List : %s \r\n" % maps_policy_list) ff.write("MAPS Active Policy : %s \r\n" % maps_active_policy) ff.write("MAPS Non Default Policy : %s \r\n" % non_dflt_policy) ff.write( "---------------------------------------------------------------------\r\n" ) ff.write("FLOW Names list : %s \r\n" % flow_names) ff.write("FLOW non dflt Flows : %s \r\n" % flows_nondflt) ff.write("FLOWs Active : %s \r\n" % flows_active) ff.write("FLOW Details : %s \r\n" % flow_details) ff.write( "---------------------------------------------------------------------\r\n" ) ff.close() anturlar.close_tel()
def configdl(clear=0): """ capture any information for testing of the configdownload - including mapspolicy --show mapsconfig --show flow --show flow --show -ctrlcfg relayconfig --show bottleneckmon --status then perform configupload config upload Nimbus_______________Odin_86__:FID25:root> configupload Protocol (scp, ftp, sftp, local) [ftp]: ftp Server Name or IP Address [host]: 10.38.38.138 User Name [user]: ftp2 Path/Filename [<home dir>/config.txt]: Odin_configupload.txt Section (all|chassis|FID# [all]): all Password: or configdownload [- all ] [-p ftp | -ftp] ["host","user","path"[,"passwd"]] configdownload [- all ] [-p scp | -scp ] ["host","user","path"] """ #### capture maps config all FIDS #### capture flow config all FIDS #### sw_info = anturlar.SwitchInfo() sw_info_ls = sw_info.ls() #print('$$$$$$$$$$$$$$$$$$$') #print(sw_info_ls) fid_now = sw_info.ls_now() cons_out = anturlar.fos_cmd(" ") sw_ip = sw_info.ipaddr f = "%s%s%s" % ("logs/Configupload_test_case_file", sw_ip, ".txt") if clear == 1: ff = liabhar.FileStuff(f, 'w+b') #### reset the log file else: ff = liabhar.FileStuff(f, 'a+b') #### open for appending header = "%s%s%s%s" % ("\nCONFIGUPLOAD CAPTURE FILE \n", " sw_info ipaddr ", sw_ip, "\n==============================\n\n") ff.write(header) ff.close() ff = liabhar.FileStuff(f, 'a+b') #### open the log file for writing ff.write(str(sw_info_ls)) ff.write("\n" * 2) for i in sw_info_ls: cons_out = anturlar.fos_cmd("setcontext " + i) cons_out = anturlar.fos_cmd("mapsconfig --show") ff.write("=" * 80 + "\n") ff.write("=" * 80 + "\n") ff.write("LOGICAL SWITCH :: " + i + "\n") ff.write("=" * 80 + "\n") ff.write("\nMAPS CONFIG::" + i + "\n") ff.write(cons_out + "\n\n") ff.write("#" * 80 + "\n") ff.write("#" * 80 + "\n") cons_out = anturlar.fos_cmd("mapspolicy --show -summary") ff.write("=" * 80 + "\n") ff.write(cons_out + "\n\n") ff.write("#" * 80 + "\n") ff.write("#" * 80 + "\n") cons_out = anturlar.fos_cmd("flow --show") ff.write("=" * 80 + "\n") ff.write(cons_out + "\n\n") ff.write("#" * 80 + "\n") ff.write("#" * 80 + "\n") cons_out = anturlar.fos_cmd("flow --show -ctrlcfg") ff.write("=" * 80 + "\n") ff.write(cons_out + "\n\n") ff.write("#" * 80 + "\n") ff.write("#" * 80 + "\n") cons_out = anturlar.fos_cmd("relayconfig --show") ff.write("=" * 80 + "\n") ff.write(cons_out + "\n\n") ff.write("#" * 80 + "\n") ff.write("#" * 80 + "\n") cons_out = anturlar.fos_cmd("bottleneckmon --status") ff.write("=" * 80 + "\n") ff.write(cons_out + "\n\n") ff.write("#" * 80 + "\n") ff.write("#" * 80 + "\n") ff.write("=" * 80 + "\n") ff.write("\n" * 10) cons_out = anturlar.fos_cmd("setcontext %s" % fid_now) cons_out = anturlar.fos_cmd(" ") configdown_cmd = "configupload -all -p ftp 10.38.38.138,ftp2,configupload_test.txt,ftp" cons_out = anturlar.fos_cmd(configdown_cmd)