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 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 get_time_stamp(): """ """ dt = liabhar.dateTimeStuff() #### create the object for date and time stuff stamp = dt.stamp() date_is = str(stamp) date_is = date_is[:-8] return(date_is)
def get_time_stamp(): """ """ dt = liabhar.dateTimeStuff( ) #### create the object for date and time stuff stamp = dt.stamp() date_is = str(stamp) date_is = date_is[:-8] return (date_is)
def main(): global tn ####################################################################################################################### #### #### Parse the command line indo #### ####################################################################################################################### pa = parse_args(sys.argv) print(pa) #print(pa.chassis_name) print(pa.ipaddr) print(pa.quiet) print(pa.verbose) #print(pa.firmware) #print(pa.cmdprompt) 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 #### #### #### #### If the fabric is selected power cycle all of the switches in the SwitchMatrix.csv file #### #### #### ####################################################################################################################### ####################################################################################################################### if pa.fabwide: print("power cycle all of the switches in SwitchMatrix File") pwr_cycle_fabric() else: if pa.ipaddr: print("do IP steps") pa.chassis_name = console_info_from_ip(pa.ipaddr) cons_info = console_info(pa.chassis_name) power_pole_info = pwr_pole_info(pa.chassis_name) cons_out = power_cycle(power_pole_info) dt = liabhar.dateTimeStuff() date_is = dt.current() print(date_is)
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 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 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 ####################################################################################################################### #### #### 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 #### varable for telnet session ####################################################################################################################### #### #### #### ####################################################################################################################### pa = parse_args(sys.argv) print(pa) print(pa.ipaddr) print(pa.quiet) print(pa.verbose) print(pa.cmdprompt) 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 #### #### #### if pa.ipaddr: print("do IP steps") pa.chassis_name = console_info_from_ip(pa.ipaddr) cons_info = 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 = 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] ipaddr_switch = get_ip_from_file(pa.chassis_name) steps_to_run = pa.steps fid_to_compare = 128 fid_to_compare = pa.fid ################################################################################################################### #### if the user does not enter a value for which steps to run prompt for user input value #### if not steps_to_run: # pa.start = user_start() steps_to_run = pa.start = user_start() tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, usr_psswd) ################################################################################################################### #### #### configure some settings that are not defualt to confirm they remain after disruptions #### cons_out = send_cmd("creditrecovmode --cfg onLrThresh") cons_out = send_cmd("creditrecovmode --cfg onLrThresh -lrthreshold 7") cons_out = send_cmd("creditrecovmode --fe_crdloss off") cons_out = send_cmd("creditrecovmode --be_crdloss off") cons_out = send_cmd("creditrecovmode --be_losync off") cons_out = send_cmd("creditrecovmode --fault edgeblade") ################################################################################################################### #### #### capture teh configuration file if the user selected 1 or 3 #### if steps_to_run == 1 or steps_to_run == 3: # cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_base_policy") # cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_aggressive_policy") switch_info = capture_switch_info("compare_orig", fid_to_compare) ################################################################################################################### #### path to the first file to compare # switch_data_0 = "logs/Switch_Info_cudc%s_compare_orig.txt" % pa.ipaddr #switch_data_0 = "logs/Switch_Info_cudc%s_compare_orig.txt" % ipaddr_switch switch_data_0 = "/home/runfromhere/logs/Switch_Info_cudc%s_compare_orig.txt" % ipaddr_switch liabhar.JustSleep(10) ################################################################################################################### ################################################################################################################### ################################################################################################################### #### #### do configupload or other test steps here #### make other changes here before configupload or other commands #### ################################################################################################################### #### #### REBOOT and RECONNECT WAIT 60 SECONDS and CONTINUE #### print("START Switch Update Class") liabhar.JustSleep(10) pp = cofra.SwitchUpdate() # tn = pp.reboot_reconnect() # liabhar.count_down(60) ################################################################################################################### #### #### hafailover or hareboot on pizza box #### call the failover function from cofra and send the number of failovers #### print("START HA FAILOVER") liabhar.JustSleep(10) tn = cofra.ha_failover(100) liabhar.count_down(600) ################################################################################################################### #### #### power cycle slots #### ss = anturlar.SwitchInfo() slot_list = ss.blades(True) #### skip if switch is a pizza box # if "not a d" not in slot_list: # pc_result = slot_pwr_cycle(slot_list) # else: # print("NOT A DIRECTOR SO PASSING SLOT POWER CYCLE TEST") # #### #### #### other interuptions #### #### ################################################################################################################### ################################################################################################################### ################################################################################################################### if steps_to_run == 2 or steps_to_run == 3: liabhar.JustSleep(10) liabhar.count_down(360) # cons_out = anturlar.fos_cmd("setcontext 128") # cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_base_policy") # cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_aggressive_policy") switch_info = capture_switch_info("compare", fid_to_compare) ################################################################################################################### #### path to the second file to compare switch_data_1 = "logs/Switch_Info_cudc%s_compare.txt" % ipaddr_switch liabhar.cls() #### compare the two files print("#" * 80) print("#" * 80) print("#######") print("####### @@@@@ @@@@@ @@@@@ @ @ @ @@@@@ @ ") print("####### @ @ @ @ @ @ @ @ @ ") print("####### @@@ @@@@ @@@@ @ @ @ @ @ ") print("####### @ @ @ @ @ @ @ @ ") print("####### @ @ @@@@@ @@@@@ @@@ @@@@@ @ @ ") print("#" * 80) print("#" * 80) diff_f = liabhar.file_diff(switch_data_0, switch_data_1) print("#" * 80) print("#" * 80) print("#" * 80) print("#" * 80) print("Result ") print(diff_f) ################################################################################################################### #### put additional commands here before disconnecting from telnet #### # cons_out = anturlar.fos_cmd("mapsdb --show all") # print(cons_out) # cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_base_policy") #cons_out = anturlar.fos_cmd("mapspolicy --enable Nervio") anturlar.close_tel() dt = liabhar.dateTimeStuff() date_is = dt.current() print(date_is) print(type(steps_to_run)) print(steps_to_run)
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 ####################################################################################################################### #### #### 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 #### #### ###################################################################################################################### ###################################################################################################################### tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, usr_psswd) cons_out = anturlar.fos_cmd( "setcontext %s " % pa.fid) #### change to the fid given on the command cons_out = anturlar.fos_cmd( "firmwareshow") #### send any command with anturlar.fos_cmd print("\r\n") liabhar.JustSleep(30) #### sleep without printing anything print("now closing telnet session ") anturlar.close_tel() #### close the telnet session liabhar.JustSleep(30) ####################################################################################################################### ####################################################################################################################### #### #### connect via console example #### #### ####################################################################################################################### ####################################################################################################################### #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) #### power cycle the switch using the # #### Switch Matrix info #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) #### #cons_out = anturlar.send_cmd_console("firmwareshow") #### ####################################################################################################################### ####################################################################################################################### #### #### do anything else you want to try #### #### ####################################################################################################################### ####################################################################################################################### dt = liabhar.dateTimeStuff( ) #### create the object for date and time stuff date_is = dt.current() #### get the current time print(date_is) print("Leaving the script\r\n\r\n") liabhar.count_down(30) #### count down to the next command
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 main(): global tn #### varable for telnet session ####################################################################################################################### #### #### #### ####################################################################################################################### pa = parse_args(sys.argv) print(pa) #print(pa.chassis_name) print(pa.ipaddr) print(pa.quiet) print(pa.verbose) #print(pa.firmware) print(pa.cmdprompt) 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 #### #### #### if pa.ipaddr: print("do IP steps") pa.chassis_name = console_info_from_ip(pa.ipaddr) cons_info = 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 = 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] ipaddr_switch = get_ip_from_file(pa.chassis_name) steps_to_run = pa.steps ################################################################################################################### #### if the user does not enter a value for which steps to run prompt for user input value #### if not steps_to_run: #pa.start = user_start() steps_to_run = pa.start = user_start() tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,usr_psswd) if steps_to_run == 1 or steps_to_run == 3: #cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_base_policy") switch_info = cofra.get_info_from_the_switch("compare_orig") #switch_data_0 = "logs/Switch_Info_for_playback_",pa.ipaddr,".orig.txt" # this failed the compare # the because it sees it # as a tuple ################################################################################################################### #### path to the first file to compare switch_data_0 = "logs/Switch_Info_%s_compare_orig.txt" % pa.ipaddr liabhar.JustSleep(10) ################################################################################################################### #### this is how to reconnect with telnet #print("reconnect via telnet") #tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,"fibranne") ########################################################################### #### do configupload or other test steps here ########################################################################### #### if steps_to_run == 2 or steps_to_run == 3: liabhar.JustSleep(10) cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_conservative_policy") switch_info = cofra.get_info_from_the_switch("compare") ################################################################################################################### #### path to the second file to compare switch_data_1 = "logs/Switch_Info_%s_compare.txt" % pa.ipaddr liabhar.cls() #### compare the two files diff_f = liabhar.file_diff(switch_data_0,switch_data_1) print("#"*80) print("#"*80) print("#"*80) print("#"*80) print("Result ") print(diff_f) ################################################################################################################### #### put additional commands here before disconnecting from telnet #### #cons_out = anturlar.fos_cmd("mapsdb --show all") print(cons_out) anturlar.close_tel() dt = liabhar.dateTimeStuff() date_is = dt.current() print(date_is)
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.delay_before_on) print(pa.delay_before_next_off) print(pa.count_power_cycles) print("@"*40) ################################################################################################################### ################################################################################################################### #### #### get the info from the SwitchMatrix file using the Chassis Name #### #### the only args required are chassisname #### power_pole_info = pwr_pole_info(pa.chassis_name) ################################################################################################################### ################################################################################################################### #### # ####################################################################################################################### # #### # #### # #### ####################################################################################################################### ####################################################################################################################### #### this step is the same for director or pizza box #### #### turn each port off then turn each port on (otherwise the delay between did not power cycle the switch) #### ####################################################################################################################### liabhar.count_down(20) cycles = 0 while cycles < pa.count_power_cycles: pass for pp in range(0, len(power_pole_info), 2): print('POWERPOLE') print(power_pole_info[pp]) print(power_pole_info[pp+1]) #pwr_cycle(power_pole_info[pp],power_pole_info[pp+1], "off" ,10) #time.sleep(4) try: for pp in range(0, len(power_pole_info), 2): print('POWERPOLE') print(power_pole_info[pp]) print(power_pole_info[pp+1]) pwr_cycle(power_pole_info[pp],power_pole_info[pp+1], "off",10) time.sleep(4) liabhar.count_down(pa.delay_before_on) for pp in range(0, len(power_pole_info), 2): print('POWERPOLE') print(power_pole_info[pp]) print(power_pole_info[pp+1]) pwr_cycle(power_pole_info[pp],power_pole_info[pp+1], "on",10) time.sleep(4) except: if '' == power_pole_info[0]: print("\n"*20) print("NO POWER POLE INFO FOUND ") print("HA "*10) print("you have to walk to power cycle the switch") print("I will wait ") liabhar.JustSleep(30) else: print("POWER TOWER INFO") print(power_pole_info[0]) print(power_pole_info) liabhar.JustSleep(30) cycles += 1 print("power cycle %s of %s" % (cycles, pa.count_power_cycles) ) liabhar.JustSleep(6) liabhar.count_down(pa.delay_before_next_off) ####################################################################################################################### ####################################################################################################################### #### #### #### ####################################################################################################################### dt = liabhar.dateTimeStuff() date_is = dt.current() print(date_is)
def main(): global tn # variable for telnet session pa = parse_args() # print(pa) # print(pa.chassis_name) # print(pa.ipaddr) # print(pa.quiet) # print(pa.verbose) # print(pa.firmware) # print(pa.cmdprompt) 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 # # # if pa.ipaddr: print("do IP steps") pa.chassis_name = console_info_from_ip(pa.ipaddr) # cons_info = 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 = 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] ipaddr_switch = get_ip_from_file(pa.chassis_name) # steps_to_run = pa.steps ################################################################################################################### # if the user does not enter a value for which steps to run prompt for user input value # # if not steps_to_run: # pa.start = user_start() # steps_to_run = pa.start = user_start() tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, usr_psswd) ################################################################################################################### # # configure some settings that are not defualt to confirm they remain after disruptions # # cons_out = send_cmd("creditrecovmode --cfg onLrThresh") # cons_out = send_cmd("creditrecovmode --fe_crdloss off") # cons_out = send_cmd("creditrecovmode --be_crdloss off") # cons_out = send_cmd("creditrecovmode --be_losync off") # cons_out = send_cmd("creditrecovmode --fault edgeblade") ################################################################################################################### # # capture the configuration file if the user selected 1 or 3 # # switchdata_1 = "logs/Switch_Info_cudc%s_compare.txt" % ipaddr_switch # if steps_to_run == 1 or steps_to_run == 3: # cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_base_policy") # cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_aggressive_policy") # switch_info_orig = capture_switch_info("compare_orig", fid_to_compare) ###### File to compare before operations # switchdata_0 = ("logs/Switch_Info_cudc%s_compare_orig.txt" % ipaddr_switch) ################################################################################################################### # path to the first file to compare # switch_data_0 = ("logs/Switch_Info_cudc%s_compare_orig.txt" % ipaddr_switch) # switchdata_1 = "logs/Switch_Info_cudc%s_compare.txt" % ipaddr_switch # liabhar.JustSleep(10) ################################################################################################################### # this is how to reconnect with telnet # print("reconnect via telnet") # tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,"fibranne") ################################################################################################################### ################################################################################################################### ################################################################################################################### # # do configupload or other test steps here # make other changes here before configupload or other commands # ################################################################################################################ # # hafailover or hareboot on pizza box # call the failover function from cofra and send the number of failovers # capture_switch_info("switch_info_orig", pa.fid) # Original File1 # if steps_to_run == 1: # print('\n\nFile written') # sys.exit(0) g = pa.iterations tn = cofra.ha_failover(g) liabhar.count_down(30) capture_switch_info("switch_info_compare", pa.fid) # File to compare after operations orig = "/home/runfromhere/logs/Switch_Info_cudc%s_switch_info_orig.txt" % ipaddr_switch compare = "/home/runfromhere/logs/Switch_Info_cudc%s_switch_info_compare.txt" % ipaddr_switch diff_f = liabhar.file_diff(orig, compare, "HA_FAILOVER_DIFFERENCES") print(diff_f) # g = g-1 if not diff_f: liabhar.email_sender_html( pa.email, pa.email, "HA Failover failed a checkpoint", "HA_Failover failed a checkpoint.\ Look in logs for HA_FAILOVER_DIFFERENCES file", "") cofra.DoSupportsave(ftp_ip, ftp_username, ftp_password, pa.chassis_name) print("Support Save captured") sys.exit(0) # g = pa.iterations # print(g) # while g > 0: # tn = cofra.ha_failover(g) # liabhar.count_down(60) # capture_switch_info("switch_info_compare", pa.fid) # File to compare after operations # orig = "/home/runfromhere/logs/Switch_Info_cudc%s_switch_info_orig.txt" % ipaddr_switch # compare = "/home/runfromhere/logs/Switch_Info_cudc%s_switch_info_compare.txt" % ipaddr_switch # diff_f = liabhar.file_diff(orig, compare) # print(diff_f) # # g = g-1 # if not diff_f: # liabhar.email_sender_html(pa.email, pa.email, # "HA Failover failed a checkpoint", "HA_Failover failed a checkpoint", "") # cofra.DoSupportsave("172.16.114.67", "ftp1", "ftp2", pa.chassis_name) # sys.exit(1) # g = g - 1 ################################################################################################################### # # power cycle slots # # ss = anturlar.SwitchInfo() # slot_list = ss.blades(True) # skip if switch is a pizza box # if "not a d" not in slot_list: # pc_result = slot_pwr_cycle(slot_list) # else: # print("NOT A DIRECTOR SO PASSING SLOT POWER CYCLE TEST") # # # # other interuptions # # ################################################################################################################### ################################################################################################################### ################################################################################################################### # if steps_to_run == 2 or steps_to_run == 3: liabhar.JustSleep(10) # liabhar.count_down(360) # cons_out = anturlar.fos_cmd("setcontext 128") # cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_base_policy") # cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_aggressive_policy") ################################################################################################################### liabhar.cls() print("#" * 80) print("#" * 80) print("#######") print("####### @@@@@ @@@@@ @@@@@ @ @ @ @@@@@ @ ") print("####### @ @ @ @ @ @ @ @ @ ") print("####### @@@ @@@@ @@@@ @ @ @ @ @ ") print("####### @ @ @ @ @ @ @ @ ") print("####### @ @ @@@@@ @@@@@ @@@ @@@@@ @ @ ") print("#" * 80) print("#" * 80) diff_f = liabhar.file_diff(orig, compare) print(diff_f) print('\n\n') print("#" * 80) print("#" * 80) print("#" * 80) print("#" * 80) ################################################################################################################### # put additional commands here before disconnecting from telnet # # cons_out = anturlar.fos_cmd("mapsdb --show all") # print(cons_out) # cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_base_policy") anturlar.close_tel() dt = liabhar.dateTimeStuff() date_is = dt.current() print(date_is) liabhar.email_sender_html(pa.email, pa.email, "HA_Failover passed", "HA_Failover passed", "")
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(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 ####################################################################################################################### #### #### #### ####################################################################################################################### pa = parse_args(sys.argv) print(pa) #print(pa.chassis_name) print(pa.ipaddr) print(pa.quiet) print(pa.verbose) #print(pa.firmware) print(pa.cmdprompt) print(pa.fid) 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 #### #### #### if pa.ipaddr: print("do IP steps") pa.chassis_name = console_info_from_ip(pa.ipaddr) cons_info = 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 = 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] ipaddr_switch = get_ip_from_file(pa.chassis_name) tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,usr_psswd) print("\r\n\r\nLICENSE ADD TO SWITCH \r\n\r\n") print(ipaddr_switch) en = anturlar.Maps() fab_stuff = anturlar.FabricInfo(en.currentFID()) print("$$$$$$$$$$$$$$") print(fab_stuff) cons_out = anturlar.fos_cmd("setcontext %s" % pa.fid) cons_out = anturlar.fos_cmd("switchshow") #fabmems = fab_stuff.fabric_members() myzone_info = fab_stuff.zone_info(1) try: myzone = myzone_info[0][1] except IndexError: myzone = "NewZone" liabhar.JustSleep(10) cons_out = anturlar.fos_cmd("switchshow") add_zones(myzone) print(cons_out) anturlar.close_tel() dt = liabhar.dateTimeStuff() date_is = dt.current() print(date_is)
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(pa.cmdprompt) print("@" * 40) #sys.exit(0) ################################################################################################################### ################################################################################################################### #### #### 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 #### #### the only args required are firmware and ip or chassisname #### if pa.ipaddr: print("do IP steps") pa.chassis_name = console_info_from_ip(pa.ipaddr) cons_info = 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 = 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] ipaddr_switch = get_ip_from_file(pa.chassis_name) user_start() ################################################################################################################### ################################################################################################################### #### if the switch is NOT at the command prompt #### then get all the info from the switch and save to a file #### cofra.get_info_from_the_switch creates a file #### #### If the switch is at the command prompt #### then args -cp must be used #### if not pa.cmdprompt: try: tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, usr_psswd) except OSError: print( "\n If the Switch is at the command prompt use the -cp and -t switch" ) print( "\n ./APM/switch_playback.py -cp -t <no> -c <chassisname> <firmware>" ) print("\n\n Popular switch types are:\n") print(" Type Model\n") print( "\t62 DCX\n\t64 5300\n\t66 5100\n\t71 300 \n" ) print( "\t77 DCX-4S\n\t83 7800\n\t109 6510\n\t118 6505\n" ) print("\t120 DCX 8510-8\n\t121 DCX 8510-4") print("\t133 6520/Odin\n\t148 Skybolt ") print("\n" * 5) sys.exit() sw_dict = cofra.get_info_from_the_switch("for_playback") my_ip = sw_dict["switch_ip"] my_cp_ip_list = sw_dict["cp_ip_list"] 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("SWITHC IP : %s " % my_ip) print("CP IP List : %s " % my_cp_ip_list) 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("@" * 40) print("CONSOLE INFO : %s " % cons_info) print("\n") print("POWER POLE INFO : %s " % power_pole_info) ################################################################################################################### #### #### close telnet connection #### ################################################################################################################### anturlar.close_tel() else: sw_type = pa.switchtype my_ip = ipaddr_switch sw_director_or_pizza = False my_cp_ip_list = [] ################################################################################################################### ################################################################################################################### #### #### if I am Director then get the CP0 and CP1 IP addresses #### before connecting to the console #### ################################################################################################################### ################################################################################################################### print("@" * 40) print("switch is a director %s " % sw_director_or_pizza) print("console_ip %s " % console_ip) print("console port %s " % console_port) print("user name is %s " % user_name) print("password %s " % usr_pass) print("console_ip backup %s " % console_ip_bkup) print("console port backup %s " % console_port_bkup) print("CP IP list (chassis CP0 CP1) %s " % my_cp_ip_list) if sw_director_or_pizza: print("CP0 %s " % my_cp_ip_list[1]) print("CP1 %s " % my_cp_ip_list[2]) #sys.exit() stop here for getting the switch info only ################################################################################################################### ################################################################################################################### #### #### if I am Director then connect to console 1 and find the cmdprompt #### then connect to console 2 and find the cmdprompt #### #### switch IP now needs to be the CP0 and CP1 values #### tn_list = [] if sw_director_or_pizza: tn_cp0 = connect_console(console_ip, user_name, usr_pass, console_port, 0) tn_cp1 = connect_console(console_ip_bkup, user_name, usr_pass, console_port_bkup, 0) #tn_list = [] tn_list.append(tn_cp0) tn_list.append(tn_cp1) for tn in tn_list: cons_out = send_cmd("switchshow") ####################################################################################################################### #### #### reboot and find the command prompt #### cnt = 1 #if not pa.cmdprompt: # for tn in tn_list: # cons_out = stop_at_cmd_prompt(0) # print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") # print(cons_out) # print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") # print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") # #for tn in tn_list: #cons_out = env_variables(sw_type, 0) #print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") #print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") #print(cons_out) # #load_kernel(sw_type, my_cp_ip_list[cnt], pa.firmware) #cnt += 1 else: ########################################################################### #### im a pizza box ########################################################################### tn = connect_console(console_ip, user_name, usr_pass, console_port, 0) tn_list.append(tn) ####################################################################################################################### #### #### reboot and find the command prompt #### #if not pa.cmdprompt: # cons_out = stop_at_cmd_prompt(9) # print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") # print(cons_out) # print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") # print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") #cons_out = env_variables(sw_type, 9) #print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") #print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") #print(cons_out) #load_kernel(sw_type, my_ip, pa.firmware) ####################################################################################################################### ####################################################################################################################### #### this step is the same for director or pizza box #### #### turn each port off then turn each port on (otherwise the delay between did not power cycle the switch) #### ####################################################################################################################### liabhar.JustSleep(20) for pp in range(0, len(power_pole_info), 2): print('POWERPOLE') print(power_pole_info[pp]) print(power_pole_info[pp + 1]) pwr_cycle(power_pole_info[pp], power_pole_info[pp + 1], "off", 10) time.sleep(4) try: for pp in range(0, len(power_pole_info), 2): print('POWERPOLE') print(power_pole_info[pp]) print(power_pole_info[pp + 1]) pwr_cycle(power_pole_info[pp], power_pole_info[pp + 1], "off", 10) time.sleep(4) for pp in range(0, len(power_pole_info), 2): print('POWERPOLE') print(power_pole_info[pp]) print(power_pole_info[pp + 1]) pwr_cycle(power_pole_info[pp], power_pole_info[pp + 1], "on", 10) time.sleep(4) except: if '' == power_pole_info[0]: print("\n" * 20) print("NO POWER POLE INFO FOUND ") print("HA " * 10) print("you have to walk to power cycle the switch") print("I will wait ") liabhar.JustSleep(30) else: print("POWER TOWER INFO") print(power_pole_info[0]) print(power_pole_info) liabhar.JustSleep(30) ####################################################################################################################### ####################################################################################################################### #### #### #### is there another way to tell if switch is ready ?? #### instead of waiting #### maybe looking at switch Domain and if it is uncomfirmed then switch is not ready #### ####################################################################################################################### ####################################################################################################################### #### #### ####################################################################################################################### connect_console(console_ip, user_name, usr_psswd, console_port) print("\r\n" * 6) print("@" * 40) print("Close Console sessions and login via telnet") print("Sleep for a minute") print("\r\n" * 6) #liabhar.count_down(300) #time.sleep(360) #cons_out = sw_set_pwd_timeout(usr_psswd,10) #print("@"*40) #print("TN TN TN") #print(tn_list) #print("@"*40) for tn in tn_list: tn.close() liabhar.JustSleep(600) try: tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, "password") except: tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, "fibranne") #cons_out = sw_set_pwd_timeout(usr_psswd, tn) #tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,usr_psswd) anturlar.close_tel() #tn.write(b"exit\n") #tn.close() dt = liabhar.dateTimeStuff() date_is = dt.current() print(date_is)
def chck_a(): #global tn si = anturlar.SwitchInfo() does_allow_xisl = si.allow_xisl() show_all_ports = si.all_ports() show_all_ports_fc = si.all_ports_fc_only() base_y_n = si.base_check() blade_8G = si.blade_search_8GB() blades = si.blades() blade_blank = si.blank_type() fid_now = si.currentFID() chass_name = si.chassisname() dport = si.d_ports() dflt_switch = si.default_switch() dir_y_n = si.director() disbled_ports = si.disabled_ports() eports = si.e_ports() exports = si.ex_ports() vexports = si.vex_ports() fports = si.f_ports() fans = si.fan_count() fcr_y_n = si.fcr_enabled() gports = si.g_ports() lic_lst = si.getLicense() sw_ip = si.ipaddress() lport = si.loopback() ls_lst = si.ls() ls_crnt = si.ls_now() nports = si.n_ports() pdports = si.persistent_disabled_ports() sensors_lst_t = si.sensor_t_f_ps("t") sensors_lst_t = si.sensor_t_f_ps("f") sensors_lst_t = si.sensor_t_f_ps("ps") sfpinfo = si.sfp_info() sports = si.sim_ports() swstate = si.switch_state() sw_id = si.switch_id() sw_name = si.switch_name() sw_status = si.switch_status() ### fcr info sw_type = si.switch_type() sw_sync = si.synchronized() sw_tmp = si.temp_sensors() vf_y_n = si.vf_enabled() #### Fabric fi = anturlar.FabricInfo() sid_nums = fi.sid_numbers() sw_cnt = fi.switch_count() ipv4_lst = fi.ipv4_list() print("$"*80) print(ipv4_lst) print("@"*80) ipv4_fcr = fi.ipv4_plus_fcr_list('root','password') print("$"*80) print(ipv4_fcr) print("@"*80) fab_name = fi.name() fab_all = fi.all_info() fab_memb = fi.fabric_members() fab_zone = fi.zone_info() ##### FCIP info # fc = anturlar.FcipInfo() fc_ge_ports = fc.all_online_ge_ports() fc_ge_ports_dble = fc.all_ge_port_disabled() fc_vex_ports = fc.vex_ports() fc_ex_ports = fc.ex_ports() fc_ge_ports = fc.ge_ports() #### DATE TIME STUFF #### dt = liabhar.dateTimeStuff() crrnt_date = dt.current() time_stamp = dt.stamp() time_simple = dt.simple() #### other stuff print("\r\n"*5) print(crrnt_date) print(time_stamp) print(time_simple) liabhar.cls() liabhar.count_down(3) some_string_0 = "this is to compare different text strings" some_string_1 = "this is to compare diff erent text strings" some_string_2 = "this is to compare different text strings" case_1_diff = liabhar.diff_compare(some_string_0, some_string_1) case_2_diff = liabhar.diff_compare(some_string_0, some_string_2) print("result of case 1 diff test %s " % case_1_diff ) print("result of case 2 diff test %s " % case_2_diff ) this_pltfrm_is = liabhar.platform() print("this platform is %s " % this_pltfrm_is ) print(liabhar.random_number()) print(liabhar.random_number_int(23)) #### COFRA bld_port_map_info = cofra.bladeportmap_Info(3) port_stats_0 = cofra.PortStats() fid_to_check = "24" fids_0 = cofra.fids_check(fid_to_check) print("THIS IS FID CHECK %s is on the switch %s " % (fid_to_check, fids_0 )) print("Blade Port Map Info ") print(bld_port_map_info) print("PORT STATS ") print(port_stats_0) clr_stats = cofra.clear_stats()
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 #### #### ###################################################################################################################### ###################################################################################################################### tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,usr_psswd) cons_out = anturlar.fos_cmd("setcontext %s " % pa.fid) #### change to the fid given on the command cons_out = anturlar.fos_cmd("firmwareshow") #### send any command with anturlar.fos_cmd print("\r\n") liabhar.JustSleep(30) #### sleep without printing anything print("now closing telnet session ") anturlar.close_tel() #### close the telnet session liabhar.JustSleep(30) ####################################################################################################################### ####################################################################################################################### #### #### connect via console example #### #### ####################################################################################################################### ####################################################################################################################### #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) #### power cycle the switch using the # #### Switch Matrix info #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) #### #cons_out = anturlar.send_cmd_console("firmwareshow") #### ####################################################################################################################### ####################################################################################################################### #### #### do anything else you want to try #### #### ####################################################################################################################### ####################################################################################################################### dt = liabhar.dateTimeStuff() #### create the object for date and time stuff date_is = dt.current() #### get the current time print(date_is) print("Leaving the script\r\n\r\n") liabhar.count_down(30) #### count down to the next command
def main(): global tn # variable for telnet session pa = parse_args() # print(pa) # print(pa.chassis_name) # print(pa.ipaddr) # print(pa.quiet) # print(pa.verbose) # print(pa.firmware) # print(pa.cmdprompt) 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 # # # if pa.ipaddr: print("do IP steps") pa.chassis_name = console_info_from_ip(pa.ipaddr) # cons_info = 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 = 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] ipaddr_switch = get_ip_from_file(pa.chassis_name) # steps_to_run = pa.steps ################################################################################################################### # if the user does not enter a value for which steps to run prompt for user input value # # if not steps_to_run: # pa.start = user_start() # steps_to_run = pa.start = user_start() tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, usr_psswd) ################################################################################################################### # # configure some settings that are not defualt to confirm they remain after disruptions # # cons_out = send_cmd("creditrecovmode --cfg onLrThresh") # cons_out = send_cmd("creditrecovmode --fe_crdloss off") # cons_out = send_cmd("creditrecovmode --be_crdloss off") # cons_out = send_cmd("creditrecovmode --be_losync off") # cons_out = send_cmd("creditrecovmode --fault edgeblade") ################################################################################################################### # # capture the configuration file if the user selected 1 or 3 # # switchdata_1 = "logs/Switch_Info_cudc%s_compare.txt" % ipaddr_switch # if steps_to_run == 1 or steps_to_run == 3: # cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_base_policy") # cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_aggressive_policy") # switch_info_orig = capture_switch_info("compare_orig", fid_to_compare) ###### File to compare before operations # switchdata_0 = ("logs/Switch_Info_cudc%s_compare_orig.txt" % ipaddr_switch) ################################################################################################################### # path to the first file to compare # switch_data_0 = ("logs/Switch_Info_cudc%s_compare_orig.txt" % ipaddr_switch) # switchdata_1 = "logs/Switch_Info_cudc%s_compare.txt" % ipaddr_switch # liabhar.JustSleep(10) ################################################################################################################### # this is how to reconnect with telnet # print("reconnect via telnet") # tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,"fibranne") ################################################################################################################### ################################################################################################################### ################################################################################################################### # # do configupload or other test steps here # make other changes here before configupload or other commands # ################################################################################################################ # # hafailover or hareboot on pizza box # call the failover function from cofra and send the number of failovers # capture_switch_info("switch_info_orig", pa.fid) # Original File1 # if steps_to_run == 1: # print('\n\nFile written') # sys.exit(0) g = pa.iterations tn = cofra.ha_failover(g) liabhar.count_down(30) capture_switch_info("switch_info_compare", pa.fid) # File to compare after operations orig = "/home/runfromhere/logs/Switch_Info_cudc%s_switch_info_orig.txt" % ipaddr_switch compare = "/home/runfromhere/logs/Switch_Info_cudc%s_switch_info_compare.txt" % ipaddr_switch diff_f = liabhar.file_diff(orig, compare, "HA_FAILOVER_DIFFERENCES") print(diff_f) # g = g-1 if not diff_f: liabhar.email_sender_html(pa.email, pa.email, "HA Failover failed a checkpoint", "HA_Failover failed a checkpoint.\ Look in logs for HA_FAILOVER_DIFFERENCES file", "") cofra.DoSupportsave(ftp_ip, ftp_username, ftp_password, pa.chassis_name) print("Support Save captured") sys.exit(0) # g = pa.iterations # print(g) # while g > 0: # tn = cofra.ha_failover(g) # liabhar.count_down(60) # capture_switch_info("switch_info_compare", pa.fid) # File to compare after operations # orig = "/home/runfromhere/logs/Switch_Info_cudc%s_switch_info_orig.txt" % ipaddr_switch # compare = "/home/runfromhere/logs/Switch_Info_cudc%s_switch_info_compare.txt" % ipaddr_switch # diff_f = liabhar.file_diff(orig, compare) # print(diff_f) # # g = g-1 # if not diff_f: # liabhar.email_sender_html(pa.email, pa.email, # "HA Failover failed a checkpoint", "HA_Failover failed a checkpoint", "") # cofra.DoSupportsave("172.16.114.67", "ftp1", "ftp2", pa.chassis_name) # sys.exit(1) # g = g - 1 ################################################################################################################### # # power cycle slots # # ss = anturlar.SwitchInfo() # slot_list = ss.blades(True) # skip if switch is a pizza box # if "not a d" not in slot_list: # pc_result = slot_pwr_cycle(slot_list) # else: # print("NOT A DIRECTOR SO PASSING SLOT POWER CYCLE TEST") # # # # other interuptions # # ################################################################################################################### ################################################################################################################### ################################################################################################################### # if steps_to_run == 2 or steps_to_run == 3: liabhar.JustSleep(10) # liabhar.count_down(360) # cons_out = anturlar.fos_cmd("setcontext 128") # cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_base_policy") # cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_aggressive_policy") ################################################################################################################### liabhar.cls() print("#" * 80) print("#" * 80) print("#######") print("####### @@@@@ @@@@@ @@@@@ @ @ @ @@@@@ @ ") print("####### @ @ @ @ @ @ @ @ @ ") print("####### @@@ @@@@ @@@@ @ @ @ @ @ ") print("####### @ @ @ @ @ @ @ @ ") print("####### @ @ @@@@@ @@@@@ @@@ @@@@@ @ @ ") print("#" * 80) print("#" * 80) diff_f = liabhar.file_diff(orig, compare) print(diff_f) print('\n\n') print("#" * 80) print("#" * 80) print("#" * 80) print("#" * 80) ################################################################################################################### # put additional commands here before disconnecting from telnet # # cons_out = anturlar.fos_cmd("mapsdb --show all") # print(cons_out) # cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_base_policy") anturlar.close_tel() dt = liabhar.dateTimeStuff() date_is = dt.current() print(date_is) liabhar.email_sender_html (pa.email, pa.email, "HA_Failover passed", "HA_Failover passed", "")
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(pa.cmdprompt) print("@"*40) #sys.exit(0) ################################################################################################################### ################################################################################################################### #### #### 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 #### #### the only args required are firmware and ip or chassisname #### if pa.ipaddr: print("do IP steps") pa.chassis_name = console_info_from_ip(pa.ipaddr) cons_info = 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 = 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] ipaddr_switch = get_ip_from_file(pa.chassis_name) ################################################################################################################### ################################################################################################################### #### if the switch is NOT at the command prompt #### then get all the info from the switch and save to a file #### cofra.get_info_from_the_switch creates a file #### #### If the switch is at the command prompt #### then args -cp must be used #### if not pa.cmdprompt: try: tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,usr_psswd) except OSError: print("\n If the Switch is at the command prompt use the -cp and -t switch") print("\n ./APM/switch_playback.py -cp -t <no> -c <chassisname> <firmware>") print("\n\n Popular switch types are:\n") print(" Type Model\n") print("\t62 DCX\n\t64 5300\n\t66 5100\n\t71 300 \n") print("\t77 DCX-4S\n\t83 7800\n\t109 6510\n\t118 6505\n") print("\t120 DCX 8510-8\n\t121 DCX 8510-4") print("\t133 6520/Odin\n\t148 Skybolt ") print("\n"*5) sys.exit() sw_dict = cofra.get_info_from_the_switch() my_ip = sw_dict["switch_ip"] my_cp_ip_list = sw_dict["cp_ip_list"] 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("SWITHC IP : %s " % my_ip) print("CP IP List : %s " % my_cp_ip_list) 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("@"*40) print("CONSOLE INFO : %s " % cons_info) print("\n") print("POWER POLE INFO : %s " % power_pole_info) ################################################################################################################### #### #### close telnet connection #### ################################################################################################################### anturlar.close_tel() else: sw_type = pa.switchtype my_ip = ipaddr_switch sw_director_or_pizza = False my_cp_ip_list = [] ################################################################################################################### ################################################################################################################### #### #### if I am Director then get the CP0 and CP1 IP addresses #### before connecting to the console #### ################################################################################################################### ################################################################################################################### print("@"*40) print("switch is a director %s " % sw_director_or_pizza) print("console_ip %s " % console_ip) print("console port %s " % console_port) print("user name is %s " % user_name) print("password %s " % usr_pass) print("console_ip backup %s " % console_ip_bkup) print("console port backup %s " % console_port_bkup) print("CP IP list (chassis CP0 CP1) %s " % my_cp_ip_list) if sw_director_or_pizza: print("CP0 %s " % my_cp_ip_list[1]) print("CP1 %s " % my_cp_ip_list[2]) #sys.exit() stop here for getting the switch info only ################################################################################################################### ################################################################################################################### #### #### if I am Director then connect to console 1 and find the cmdprompt #### then connect to console 2 and find the cmdprompt #### #### switch IP now needs to be the CP0 and CP1 values #### tn_list = [] if sw_director_or_pizza: tn_cp0 = connect_console(console_ip, user_name, usr_pass, console_port, 0) tn_cp1 = connect_console(console_ip_bkup, user_name,usr_pass,console_port_bkup,0) #tn_list = [] tn_list.append(tn_cp0) tn_list.append(tn_cp1) for tn in tn_list: cons_out = send_cmd("switchshow") ####################################################################################################################### #### #### reboot and find the command prompt #### cnt = 1 if not pa.cmdprompt: for tn in tn_list: cons_out = stop_at_cmd_prompt(0) print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") print(cons_out) print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") for tn in tn_list: cons_out = env_variables(sw_type, 0) print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") print(cons_out) load_kernel(sw_type, my_cp_ip_list[cnt], pa.firmware) cnt += 1 else: ########################################################################### #### im a pizza box ########################################################################### tn = connect_console(console_ip, user_name, usr_pass, console_port, 0) tn_list.append(tn) ####################################################################################################################### #### #### reboot and find the command prompt #### if not pa.cmdprompt: cons_out = stop_at_cmd_prompt(9) print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") print(cons_out) print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") cons_out = env_variables(sw_type, 9) print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") print("\n\n\n\n\n&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") print(cons_out) load_kernel(sw_type, my_ip, pa.firmware) ####################################################################################################################### ####################################################################################################################### #### this step is the same for director or pizza box #### #### turn each port off then turn each port on (otherwise the delay between did not power cycle the switch) #### ####################################################################################################################### try: for pp in range(0, len(power_pole_info), 2): print('POWERPOLE') print(power_pole_info[pp]) print(power_pole_info[pp+1]) pwr_cycle(power_pole_info[pp],power_pole_info[pp+1], "off") time.sleep(2) for pp in range(0, len(power_pole_info), 2): print('POWERPOLE') print(power_pole_info[pp]) print(power_pole_info[pp+1]) pwr_cycle(power_pole_info[pp],power_pole_info[pp+1], "on") time.sleep(2) except: if '' == power_pole_info[0]: print("\n"*20) print("NO POWER POLE INFO FOUND ") print("HA "*10) print("you have to walk to power cycle the switch") print("I will wait ") liabhar.JustSleep(30) else: print("POWER TOWER INFO") print(power_pole_info[0]) print(power_pole_info) liabhar.JustSleep(30) ####################################################################################################################### ####################################################################################################################### #### #### #### is there another way to tell if switch is ready ?? #### instead of waiting #### maybe looking at switch Domain and if it is uncomfirmed then switch is not ready #### ####################################################################################################################### ####################################################################################################################### #### #### ####################################################################################################################### print("\r\n"*6) print("@"*40) print("Close Console sessions and login via telnet") print("Sleep for a minute") print("\r\n"*6) #liabhar.count_down(300) #time.sleep(360) #cons_out = sw_set_pwd_timeout(usr_psswd,10) #print("@"*40) #print("TN TN TN") #print(tn_list) #print("@"*40) for tn in tn_list: tn.close() liabhar.JustSleep(600) tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,"fibranne") cons_out = sw_set_pwd_timeout(usr_psswd, tn) #tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,usr_psswd) print("\r\n\r\nLICENSE ADD TO SWITCH \r\n\r\n") print(my_ip) cc = cofra.SwitchUpdate() cons_out = cc.playback_licenses() cons_out = cc.playback_ls() cons_out = cc.playback_switch_names() cons_out = cc.playback_switch_domains() cons_out = cc.playback_add_ports() tn = cc.reboot_reconnect() cons_out = anturlar.fos_cmd("switchshow") print(cons_out) cons_out = anturlar.fos_cmd("timeout 0") print(cons_out) anturlar.close_tel() #tn.write(b"exit\n") #tn.close() dt = liabhar.dateTimeStuff() date_is = dt.current() print(date_is)
def main(): global tn #### varable for telnet session ####################################################################################################################### #### #### #### ####################################################################################################################### pa = parse_args(sys.argv) print(pa) #print(pa.chassis_name) print(pa.ipaddr) print(pa.quiet) print(pa.verbose) #print(pa.firmware) print(pa.cmdprompt) 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 #### #### #### if pa.ipaddr: print("do IP steps") pa.chassis_name = console_info_from_ip(pa.ipaddr) cons_info = 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 = 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] ipaddr_switch = get_ip_from_file(pa.chassis_name) steps_to_run = pa.steps fid_to_compare = 128 ################################################################################################################### #### if the user does not enter a value for which steps to run prompt for user input value #### if not steps_to_run: #pa.start = user_start() steps_to_run = pa.start = user_start() tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,usr_psswd) ################################################################################################################### #### #### configure some settings that are not defualt to confirm they remain after disruptions #### cons_out = send_cmd("creditrecovmode --cfg onLrThresh") cons_out = send_cmd("creditrecovmode --fe_crdloss off") cons_out = send_cmd("creditrecovmode --be_crdloss off") cons_out = send_cmd("creditrecovmode --be_losync off") cons_out = send_cmd("creditrecovmode --fault edgeblade") ################################################################################################################### #### #### capture the configuration file if the user selected 1 or 3 #### switch_data_1 = "logs/Switch_Info_cudc%s_compare.txt" % ipaddr_switch if steps_to_run == 1 or steps_to_run == 3: #cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_base_policy") #cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_aggressive_policy") #switch_info_orig = capture_switch_info("compare_orig", fid_to_compare) ###### File to compare before operations switch_data_0 = ("logs/Switch_Info_cudc%s_compare_orig.txt" % ipaddr_switch) ################################################################################################################### #### path to the first file to compare #switch_data_0 = ("logs/Switch_Info_cudc%s_compare_orig.txt" % ipaddr_switch) switch_data_1 = "logs/Switch_Info_cudc%s_compare.txt" % ipaddr_switch liabhar.JustSleep(10) ################################################################################################################### #### this is how to reconnect with telnet #print("reconnect via telnet") #tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,"fibranne") ################################################################################################################### ################################################################################################################### ################################################################################################################### #### #### do configupload or other test steps here #### make other changes here before configupload or other commands #### ################################################################################################################### #### #### hafailover or hareboot on pizza box #### call the failover function from cofra and send the number of failovers #### g = pa.iterations while g > 0: tn = cofra.ha_failover(g) liabhar.count_down(120) #switch_info_compare = capture_switch_info("compare", fid_to_compare) ###### File to compare after operations switch_data_1 = "logs/Switch_Info_cudc%s_compare.txt" % ipaddr_switch diff_f = liabhar.file_diff(switch_data_0, switch_data_1) print(diff_f) g = g-1 if not diff_f: liabhar.email_sender_html("*****@*****.**","*****@*****.**","NS_portflapper failed a checkpoint","NS_portflapper failed a checkpoint","") sys.exit() ################################################################################################################### #### #### power cycle slots #### #ss = anturlar.SwitchInfo() #slot_list = ss.blades(True) #### skip if switch is a pizza box #if "not a d" not in slot_list: # pc_result = slot_pwr_cycle(slot_list) #else: # print("NOT A DIRECTOR SO PASSING SLOT POWER CYCLE TEST") # #### #### #### other interuptions #### #### ################################################################################################################### ################################################################################################################### ################################################################################################################### if steps_to_run == 2 or steps_to_run == 3: liabhar.JustSleep(10) #liabhar.count_down(360) #cons_out = anturlar.fos_cmd("setcontext 128") #cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_base_policy") #cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_aggressive_policy") ################################################################################################################### #### path to the second file to compare switch_data_1 = "logs/Switch_Info_cudc%s_compare.txt" % ipaddr_switch liabhar.cls() print("#"*80) print("#"*80) print("#######") print("####### @@@@@ @@@@@ @@@@@ @ @ @ @@@@@ @ ") print("####### @ @ @ @ @ @ @ @ @ ") print("####### @@@ @@@@ @@@@ @ @ @ @ @ ") print("####### @ @ @ @ @ @ @ @ ") print("####### @ @ @@@@@ @@@@@ @@@ @@@@@ @ @ ") print("#"*80) print("#"*80) diff_f = liabhar.file_diff(switch_data_0, switch_data_1) print("#"*80) print("#"*80) print("#"*80) print("#"*80) print("Result ") print(diff_f) ################################################################################################################### #### put additional commands here before disconnecting from telnet #### #cons_out = anturlar.fos_cmd("mapsdb --show all") #print(cons_out) cons_out = anturlar.fos_cmd("mapspolicy --enable dflt_base_policy") #cons_out = anturlar.fos_cmd("mapspolicy --enable Nervio") anturlar.close_tel() dt = liabhar.dateTimeStuff() date_is = dt.current() print(date_is) liabhar.email_sender_html("*****@*****.**","*****@*****.**","HA_Failover passed","HA_Failover passed","")
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(pa.cmdprompt) 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 #### #### #### if pa.ipaddr: print("do IP steps") pa.chassis_name = console_info_from_ip(pa.ipaddr) cons_info = 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 = 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] ipaddr_switch = get_ip_from_file(pa.chassis_name) tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, usr_psswd) liabhar.JustSleep(10) #cons_out = cc.power_cycle() cons_out = anturlar.fos_cmd("switchshow") print(cons_out) rt = create_flow(pa.chassis_name, pa.flowMatrixFile) print("\n\ncreated flows now waiting for while to reboot\n\n") liabhar.JustSleep(120) p_info = pwr_pole_info(pa.chassis_name) p_turn = power_cycle(p_info) liabhar.JustSleep(120) tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, usr_psswd) cons_out = anturlar.fos_cmd("flow --show all") print("\n" * 30) print(cons_out) anturlar.close_tel() dt = liabhar.dateTimeStuff() date_is = dt.current() print(date_is)
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 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 d = liabhar.dateTimeStuff() pa.cust_date = d.simple_no_dash() pa.cust_date = d.current_no_dash() pa.filename = pa.cust_date + pa.filename for i in ipaddr_switch: tn = anturlar.connect_tel_noparse(i,user_name,usr_psswd) nos = si.nos_check() if not nos: sw_dict = cofra.get_info_from_the_switch(pa.filename, 128) my_ip = sw_dict["switch_ip"] my_cp_ip_list = sw_dict["cp_ip_list"] 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"] sw_ex_port_list = sw_dict["ex_ports"] print("\n"*20) print("SWITHC IP : %s " % my_ip) print("CP IP List : %s " % my_cp_ip_list) 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("EX_PORT_LIST : %s " % sw_ex_port_list) print("@"*40) print("@"*40) print("CONSOLE INFO : %s " % cons_info) print("\n") print("POWER POLE INFO : %s " % power_pole_info) else: print("\n"+"@"*40) print('\nTHIS IS A NOS SWITCH> SKIPPING') print("\n"+"@"*40) pass anturlar.close_tel() sys.exit() ###### You are here. Need to grab EX-Ports then Port Flapping function next????? ############################################################################### #### #### close telnet connection and #### connect to the console #### ############################################################################### cc = cofra.SwitchUpdate() cons_out = cc.playback_licenses() cons_out = cc.playback_ls() cons_out = cc.playback_switch_names() cons_out = cc.playback_switch_domains() cons_out = cc.playback_add_ports() tn = cc.reboot_reconnect() cons_out = anturlar.fos_cmd("switchshow") print(cons_out) anturlar.close_tel()
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(pa.cmdprompt) 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 #### #### #### if pa.ipaddr: print("do IP steps") pa.chassis_name = console_info_from_ip(pa.ipaddr) cons_info = 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 = 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] ipaddr_switch = get_ip_from_file(pa.chassis_name) tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,usr_psswd) liabhar.JustSleep(10) #cons_out = cc.power_cycle() cons_out = anturlar.fos_cmd("switchshow") print(cons_out) rt = create_flow(pa.chassis_name,pa.flowMatrixFile) print("\n\ncreated flows now waiting for while to reboot\n\n") liabhar.JustSleep(120) p_info = pwr_pole_info(pa.chassis_name) p_turn = power_cycle(p_info) liabhar.JustSleep(120) tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,usr_psswd) cons_out = anturlar.fos_cmd("flow --show all") print("\n"*30) print(cons_out) anturlar.close_tel() dt = liabhar.dateTimeStuff() date_is = dt.current() print(date_is)
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.delay_before_on) print(pa.delay_before_next_off) print(pa.count_power_cycles) print("@" * 40) ################################################################################################################### ################################################################################################################### #### #### get the info from the SwitchMatrix file using the Chassis Name #### #### the only args required are chassisname #### power_pole_info = pwr_pole_info(pa.chassis_name) ################################################################################################################### ################################################################################################################### #### # ####################################################################################################################### # #### # #### # #### ####################################################################################################################### ####################################################################################################################### #### this step is the same for director or pizza box #### #### turn each port off then turn each port on (otherwise the delay between did not power cycle the switch) #### ####################################################################################################################### liabhar.count_down(20) cycles = 0 while cycles < pa.count_power_cycles: pass for pp in range(0, len(power_pole_info), 2): print('POWERPOLE') print(power_pole_info[pp]) print(power_pole_info[pp + 1]) #pwr_cycle(power_pole_info[pp],power_pole_info[pp+1], "off" ,10) #time.sleep(4) try: for pp in range(0, len(power_pole_info), 2): print('POWERPOLE') print(power_pole_info[pp]) print(power_pole_info[pp + 1]) pwr_cycle(power_pole_info[pp], power_pole_info[pp + 1], "off", 10) time.sleep(4) liabhar.count_down(pa.delay_before_on) for pp in range(0, len(power_pole_info), 2): print('POWERPOLE') print(power_pole_info[pp]) print(power_pole_info[pp + 1]) pwr_cycle(power_pole_info[pp], power_pole_info[pp + 1], "on", 10) time.sleep(4) except: if '' == power_pole_info[0]: print("\n" * 20) print("NO POWER POLE INFO FOUND ") print("HA " * 10) print("you have to walk to power cycle the switch") print("I will wait ") liabhar.JustSleep(30) else: print("POWER TOWER INFO") print(power_pole_info[0]) print(power_pole_info) liabhar.JustSleep(30) cycles += 1 print("power cycle %s of %s" % (cycles, pa.count_power_cycles)) liabhar.JustSleep(6) liabhar.count_down(pa.delay_before_next_off) ####################################################################################################################### ####################################################################################################################### #### #### #### ####################################################################################################################### dt = liabhar.dateTimeStuff() date_is = dt.current() print(date_is)
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.porttype) 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/NameServer_test_case_file","_"+ipaddr_switch+"_",date_is,".txt") f1 = "%s%s%s%s"%("logs/NameServer_test_case_file_compare","_"+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" % ("\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.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() #### 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() f_ports = si.f_ports() e_ports = si.e_ports() if pa.porttype == "eports": ports = e_ports print("\n\n\n\n") print(e_ports) else: ports = f_ports print("\n\n\n\n") print(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: h = pa.iterations for i in range(h): print("\n\nWe are on loop number:") print(i+1) print("\n\n") for i in ports: slot = i[0] port = i[1] if slot: anturlar.fos_cmd("portdisable %s/%s" % (slot, port)) liabhar.count_down(5) anturlar.fos_cmd("portenable %s/%s" % (slot, port)) liabhar.count_down(5) else: anturlar.fos_cmd("portdisable %s" % (port)) liabhar.count_down(5) anturlar.fos_cmd("portenable %s" % (port)) liabhar.count_down(5) #g = g-1 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 becasue of Fabric Check","NS_portflapper failed because of Fabric Check","") anturlar.close_tel() sys.exit() 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") 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.write(anturlar.fos_cmd("configshow")) 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(diff_f) if not diff_f: liabhar.email_sender_html("*****@*****.**","*****@*****.**","NS_portflapper failed a checkpoint","NS_portflapper failed a checkpoint","") sys.exit() else: print("\n"+"@"*40) print('\nTHIS IS A NOS SWITCH> SKIPPING') print("\n"+"@"*40) liabhar.email_sender_html("*****@*****.**","*****@*****.**","NS_portflapper failed becasue of NOS Check","NS_portflapper failed because of NOS Check","") sys.exit() anturlar.close_tel() 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) sys.exit()
def chck_a(): #global tn si = anturlar.SwitchInfo() does_allow_xisl = si.allow_xisl() show_all_ports = si.all_ports() show_all_ports_fc = si.all_ports_fc_only() base_y_n = si.base_check() blade_8G = si.blade_search_8GB() blades = si.blades() blade_blank = si.blank_type() fid_now = si.currentFID() chass_name = si.chassisname() dport = si.d_ports() dflt_switch = si.default_switch() dir_y_n = si.director() disbled_ports = si.disabled_ports() eports = si.e_ports() exports = si.ex_ports() vexports = si.vex_ports() fports = si.f_ports() fans = si.fan_count() fcr_y_n = si.fcr_enabled() gports = si.g_ports() lic_lst = si.getLicense() sw_ip = si.ipaddress() lport = si.loopback() ls_lst = si.ls() ls_crnt = si.ls_now() nports = si.n_ports() pdports = si.persistent_disabled_ports() sensors_lst_t = si.sensor_t_f_ps("t") sensors_lst_t = si.sensor_t_f_ps("f") sensors_lst_t = si.sensor_t_f_ps("ps") sfpinfo = si.sfp_info() sports = si.sim_ports() swstate = si.switch_state() sw_id = si.switch_id() sw_name = si.switch_name() sw_status = si.switch_status() ### fcr info sw_type = si.switch_type() sw_sync = si.synchronized() sw_tmp = si.temp_sensors() vf_y_n = si.vf_enabled() #### Fabric fi = anturlar.FabricInfo() sid_nums = fi.sid_numbers() sw_cnt = fi.switch_count() ipv4_lst = fi.ipv4_list() print("$" * 80) print(ipv4_lst) print("@" * 80) ipv4_fcr = fi.ipv4_plus_fcr_list('root', 'password') print("$" * 80) print(ipv4_fcr) print("@" * 80) fab_name = fi.name() fab_all = fi.all_info() fab_memb = fi.fabric_members() fab_zone = fi.zone_info() ##### FCIP info # fc = anturlar.FcipInfo() fc_ge_ports = fc.all_online_ge_ports() fc_ge_ports_dble = fc.all_ge_port_disabled() fc_vex_ports = fc.vex_ports() fc_ex_ports = fc.ex_ports() fc_ge_ports = fc.ge_ports() #### DATE TIME STUFF #### dt = liabhar.dateTimeStuff() crrnt_date = dt.current() time_stamp = dt.stamp() time_simple = dt.simple() #### other stuff print("\r\n" * 5) print(crrnt_date) print(time_stamp) print(time_simple) liabhar.cls() liabhar.count_down(3) some_string_0 = "this is to compare different text strings" some_string_1 = "this is to compare diff erent text strings" some_string_2 = "this is to compare different text strings" case_1_diff = liabhar.diff_compare(some_string_0, some_string_1) case_2_diff = liabhar.diff_compare(some_string_0, some_string_2) print("result of case 1 diff test %s " % case_1_diff) print("result of case 2 diff test %s " % case_2_diff) this_pltfrm_is = liabhar.platform() print("this platform is %s " % this_pltfrm_is) print(liabhar.random_number()) print(liabhar.random_number_int(23)) #### COFRA bld_port_map_info = cofra.bladeportmap_Info(3) port_stats_0 = cofra.PortStats() fid_to_check = "24" fids_0 = cofra.fids_check(fid_to_check) print("THIS IS FID CHECK %s is on the switch %s " % (fid_to_check, fids_0)) print("Blade Port Map Info ") print(bld_port_map_info) print("PORT STATS ") print(port_stats_0) clr_stats = cofra.clear_stats()