def start_windows_pre_3_2(h, start_cmd): db_level = 9 remote_list = [] start_pain = start_cmd cmdout = anturlar.traff_cmd("catapult -p") ras = re.compile('[ \d]+/dev/sd([a-z]+)\s+[:0-9]+\s+[A-Z]+\s+([A-Z]+)') remove_lunz = ras.findall(cmdout) for i in [1,2,3,4]: cmdout = anturlar.traff_cmd("bcu port --statsclr %s/0" % i, db_level) cmdout = anturlar.traff_cmd("bcu rport --osname %s/0" % i , db_level ) ras = re.compile('rive([0-9]+)') ras = ras.findall(cmdout) print("ras"*30) print(ras) print(remove_lunz) print(remote_list) print("ras"*30) for r in ras: remote_list += [r] cmdout = anturlar.traff_cmd("bcu port --statsclr %s/1" % i, db_level) cmdout = anturlar.traff_cmd("bcu rport --osname %s/1" % i , db_level ) ras = re.compile('rive([0-9]+)') ras = ras.findall(cmdout) for r in ras: remote_list += [r] print("remote port list : %s " % remote_list ) print("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA") #### put the list is the correct syntax new_list = ",".join(remote_list) print("NEW LIST IS : %s " % new_list) #### combine the command with the drive list start_pain_sd = start_pain + ' -f"\\\.\PhysicalDrive;%s"' % new_list print("NEWEST COMMAND %s " % start_pain_sd) reg_list = [b'([\w\d]+)'] cmdout = anturlar.fos_cmd_regex(start_pain_sd , reg_list) cmdout = anturlar.traff_output() anturlar.close_tel()
def start_windows_pre_3_2(h, start_cmd): db_level = 9 remote_list = [] start_pain = start_cmd cmdout = anturlar.traff_cmd("catapult -p") ras = re.compile('[ \d]+/dev/sd([a-z]+)\s+[:0-9]+\s+[A-Z]+\s+([A-Z]+)') remove_lunz = ras.findall(cmdout) for i in [1, 2, 3, 4]: cmdout = anturlar.traff_cmd("bcu port --statsclr %s/0" % i, db_level) cmdout = anturlar.traff_cmd("bcu rport --osname %s/0" % i, db_level) ras = re.compile('rive([0-9]+)') ras = ras.findall(cmdout) print("ras" * 30) print(ras) print(remove_lunz) print(remote_list) print("ras" * 30) for r in ras: remote_list += [r] cmdout = anturlar.traff_cmd("bcu port --statsclr %s/1" % i, db_level) cmdout = anturlar.traff_cmd("bcu rport --osname %s/1" % i, db_level) ras = re.compile('rive([0-9]+)') ras = ras.findall(cmdout) for r in ras: remote_list += [r] print("remote port list : %s " % remote_list) print("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA") #### put the list is the correct syntax new_list = ",".join(remote_list) print("NEW LIST IS : %s " % new_list) #### combine the command with the drive list start_pain_sd = start_pain + ' -f"\\\.\PhysicalDrive;%s"' % new_list print("NEWEST COMMAND %s " % start_pain_sd) reg_list = [b'([\w\d]+)'] cmdout = anturlar.fos_cmd_regex(start_pain_sd, reg_list) cmdout = anturlar.traff_output() anturlar.close_tel()
def main(): my_ip = "10.38.37.50" user_name = "root" psswd = "pass" cons_out = anturlar.login() cons_out = anturlar.fos_cmd("") cons_out = anturlar.clear_stats() cons_out = anturlar.fos_cmd("switchshow") print(cons_out) ################################################################################# ################################################################################# #### test the SWICH INFO CLASS ## si = anturlar.SwitchInfo() print(si) cons_out = anturlar.close_tel()
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 fabric_switch_config_show(): """ document how this works here 1. Retreive a list of all of the switches in the FID passed at start of the test 2. get Flow and MAPS basic setup information 3. write to logs/fabric_info_switch.txt """ cons_out = anturlar.fos_cmd("") swtch = anturlar.SwitchInfo() fab = anturlar.FabricInfo() fab_ip_list = fab.ipv4_list() this_fid = swtch.currentFID() ############################################################################### ############################################################################### #### #### write to the file the list of IP addresses that data will be captured for #### ############################################################################### ############################################################################### fname = "%s%s" % ("logs/fabric_info_logs/fabric_info_switch" ,".txt") #### %s string %d number ff = liabhar.FileStuff(fname, 'w+b') ff.write("#############################################################\r\n") ff.write("#############################################################\r\n") ff.write("\r\n") for ip in fab_ip_list: ff.write(ip) ff.write("\r\n") ff.write("#############################################################\r\n") ff.write("#############################################################\r\n") ff.write("#############################################################\r\n") ff.write("#############################################################\r\n\r\n\r\n") ff.close() m_info = anturlar.Maps() f_info = anturlar.FlowV() maps_config = anturlar.fos_cmd("mapsconfig --show") firmware_ver = check_version() s_name = m_info.switch_name() s_type = m_info.switch_type() ls_list = m_info.ls() switch_id = m_info.switch_id() ls_domain = m_info.ls_and_domain() chass_name = m_info.chassisname() vf_state = m_info.vf_enabled() ff = liabhar.FileStuff(fname, 'a+b') ff.write("Seed switch Info \n") ff.write("---------------------------------------------------------------------------------\n") ff.write("Switch ipv4 : %s \r\n" % ip) ff.write("Chassis Name : %s \r\n" % chass_name) ff.write("Firmware version : %s \r\n" % firmware_ver) ff.write("Switch Name : %s \r\n" % s_name) ff.write("Switch Type : %s \r\n" % s_type) ff.write("VF State : %s \r\n" % vf_state) ff.write("Logical Switches : %s \r\n" % ls_list) ff.write("Switch ID : %s \r\n" % switch_id) ff.write("ls and domain : %s \r\n" % ls_domain) ############################################################################### ############################################################################### #### #### loop through each switch in the fabric and collect and write the MAPS and Flow Info #### ############################################################################### for ip in fab_ip_list: tnn = anturlar.connect_tel_noparse(ip, 'root', 'password') cons_out = anturlar.fos_cmd("setcontext %s " % this_fid) m_info = anturlar.Maps() f_info = anturlar.FlowV() maps_config = anturlar.fos_cmd("mapsconfig --show") maps_policy_list = m_info.get_policies() maps_active_policy = m_info.get_active_policy() non_dflt_policy = m_info.get_nondflt_policies() flow_names = f_info.flow_names() flows_nondflt = f_info.get_nondflt_flows() flows_active = f_info.get_active_flows() #flow_cnfg = f_info.flow_config() flow_details = f_info.get_flow_details() anturlar.close_tel() ####### ####### remove line switchname FID ?? root> ####### m_no_root = s_name + ":FID" + str(this_fid) + ":root>" m = maps_config.replace(m_no_root, '') mc = m.lstrip() #### remove leading white space ####### ####### remove line switchname FID ?? root> ####### #### #### leave as capturing data for only one FID at a time #### have a switch for all fid data #### #### seperator(ff, ip) ff.write("---------------------------------------------------------------------\r\n") #ff.write("MAPS config : %s \r\n" % maps_config) ff.write("MAPS config :\r\n") ## maps config header ff.write(mc) ## write maps config ff.write("\n---------------------------------------------------------------------\r\n") ff.write("MAPS Policy List : %s \r\n" % maps_policy_list) ff.write("MAPS Active Policy : %s \r\n" % maps_active_policy) ff.write("MAPS Non Default Policy : %s \r\n" % non_dflt_policy) ff.write("---------------------------------------------------------------------\r\n") ff.write("FLOW Names list : %s \r\n" % flow_names) ff.write("FLOW non dflt Flows : %s \r\n" % flows_nondflt) ff.write("FLOWs Active : %s \r\n" % flows_active) ff.write("FLOW Details : %s \r\n" % flow_details) ff.write("---------------------------------------------------------------------\r\n") ff = liabhar.FileStuff(fname, 'a+b') ff.write("#####################################################################\r\n") ff.write("#####################################################################\r\n") ff.write("##########\r\n") ff.write("########## FABRIC SWITCHES INFO ##########\r\n") ff.write("##########\r\n") ff.write("#####################################################################\r\n") for ip in fab_ip_list: tnnn = anturlar.connect_tel_noparse(ip, 'root', 'password') firmware_ver = check_version() chass_name = m_info.chassisname() sf = "{0:18} {1:25} {2:25}" print(sf.format( str(ip), str(chass_name), str(firmware_ver) ), file=ff) ff.write("\r\n") ff.write("#####################################################################\r\n") ff.write("#####################################################################\r\n") ff.write("#####################################################################\r\n") ff.write("#####################################################################\r\n") ff.write("#####################################################################\r\n") ff.close() print("\n") print("#"*120) print("\nFind the results in logs/fabric_info_logs/fabric_info_switchtxt\n" ) print("#"*120) print("\n"*10) return(True)
def main(): global tn ####################################################################################################################### #### #### #### ####################################################################################################################### pa = parse_args(sys.argv) print(pa) #print(pa.chassis_name) print(pa.ipaddr) print(pa.quiet) print(pa.verbose) #print(pa.firmware) print(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("@"*40) #sys.exit() ########################################################################## ########################################################################## ### ### hold the ip address from the command line ### #try: # ipaddr_test = ipaddress.ip_address(pa.ipaddr) # #print (ipaddr_test) #except ValueError: # print("\nPLEASE CHECK YOUR IP ADDRESS AND TRY AGAIN") # sys.exit() if pa.ipaddr: pa.chassis_name = console_info_from_ip(pa.ipaddr, pa.chassis_name) cons_info = console_info(pa.chassis_name) console_ip = cons_info[0] console_port = cons_info[1] power_pole_info = pwr_pole_info(pa.chassis_name) usr_pass = get_user_and_pass(pa.chassis_name) user_name = usr_pass[0] usr_psswd = usr_pass[1] tn = anturlar.connect_tel_noparse(pa.ipaddr, user_name, usr_psswd) fi = anturlar.FabricInfo() si = anturlar.SwitchInfo() fcr = anturlar.FcrInfo() if pa.fabwide: ipaddr_switch = fi.ipv4_list() #print(ipaddr_switch) elif pa.csvall: ipaddr_switch = get_ip_from_file(pa.chassis_name) elif pa.fcrwide: anturlar.fos_cmd("setcontext %s" % fcr.base_check()) ipaddr_switch = fcr.fcr_fab_wide_ip() else: ipaddr_switch = [pa.ipaddr] anturlar.close_tel() #### pass ip(s)to login procedure #### and write the file for i in ipaddr_switch: try: ###New tn = anturlar.connect_tel_noparse(i, user_name, usr_psswd) except OSError: ##New print("Switch %s not available" % i) ##New nos = si.nos_check() if not nos: sw_dict = cofra.get_info_from_the_switch("restore") switch_ip = sw_dict["switch_ip"] sw_name = sw_dict["switch_name"] sw_chass_name = sw_dict["chassis_name"] sw_director_or_pizza = sw_dict["director"] sw_domains = sw_dict["domain_list"] sw_ls_list = sw_dict["ls_list"] sw_base_fid = sw_dict["base_sw"] sw_xisl = sw_dict["xisl_state"] sw_type = sw_dict["switch_type"] sw_license = sw_dict["license_list"] sw_vf_setting = sw_dict["vf_setting"] sw_fcr_enabled = sw_dict["fcr_enabled"] sw_port_list = sw_dict["port_list"] sw_ex_port_list = sw_dict["ex_ports"] print("\n" * 20) print("SWITCH IP : %s " % switch_ip) print("SWITCH NAME : %s " % sw_name) print("CHASSIS NAME : %s " % sw_chass_name) print("DIRECTOR : %s " % sw_director_or_pizza) print("SWITCH DOMAINS : %s " % sw_domains) print("LOGICAL SWITCH LIST : %s " % sw_ls_list) print("BASE FID : %s " % sw_base_fid) print("XISL STATE : %s " % sw_xisl) print("SWITCH TYPE : %s " % sw_type) print("LICENSE LIST : %s " % sw_license) print("VF SETTING : %s " % sw_vf_setting) print("FCR SETTING : %s " % sw_fcr_enabled) print("PORT LIST : %s " % sw_port_list) print("EX_PORT_LIST : %s " % sw_ex_port_list) print("@" * 40) print("CONSOLE INFO : %s " % cons_info) print("@" * 40) print("POWER POLE INFO : %s " % power_pole_info) print("@" * 40) print( "\nSwitch_Info has been written this file in logs/test/Switch_Info_%s_restore.txt\n" % switch_ip) print("@" * 40) else: print("\n" + "@" * 40) print('\nTHIS IS A NOS SWITCH> SKIPPING') print("\n" + "@" * 40) pass anturlar.close_tel() sys.exit() ############################################################################### #### #### 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 #### 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 ### later we will capture info for all fids ################################################################################################################### #### 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 -lrtthreshold 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: 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 liabhar.JustSleep(10) ################################################################################################################### ################################################################################################################### ################################################################################################################### #### #### do configupload or other test steps here #### make other changes here before configupload or other commands #### ################################################################################################################### #### #### #### pp = cofra.SwitchUpdate() ################################################################################################################### #### #### #### #### cd = cofra.cfgupload(pa.ftp_ipaddress, pa.ftp_username,pa.ftp_password,pa.config_path) liabhar.count_down(120) mc = make_changes() cdd = cofra.cfgdownload(pa.ftp_ipaddress, pa.ftp_username,pa.ftp_password,cd) liabhar.count_down(360) ################################################################################################################### #### #### #### #### #### #### #### other actions here #### #### ################################################################################################################### ################################################################################################################### ################################################################################################################### if steps_to_run == 2 or steps_to_run == 3: # liabhar.JustSleep(10) liabhar.count_down(60) 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) ################################################################################################################### #### #### disconnecting from telnet #### ################################################################################################################### anturlar.close_tel()
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 #### 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 #### #### ###################################################################################################################### ###################################################################################################################### 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 start_linux_post_3_2(h, start_cmd): db_level = 9 remote_list = [] start_pain = start_cmd ################################################################################################################### #### use catapult to capture the drives and and Volumn ID -- use this if they are Clariion to not add #### the drives with LUNZ Volumn ID since they are not target IDs #### cmdout = anturlar.traff_cmd("catapult -p") ras = re.compile('[ \d]+/dev/sd([a-z]+)\s+[:0-9]+\s+[A-Z]+\s+([A-Z]+)') remove_lunz = ras.findall(cmdout) for i in [1,2,3,4]: cmdout = anturlar.traff_cmd("bcu port --statsclr %s/0" % i, db_level) cmdout = anturlar.traff_cmd("bcu fcpim --lunlist %s/0" % i , db_level ) ras = re.compile('/dev/sd([a-z]+)') ras = ras.findall(cmdout) print("ras"*30) print(ras) print(remove_lunz) print(remote_list) print("ras"*30) for r in ras: for lunz in remove_lunz: print(r) print(lunz[0]) print(lunz[1]) if lunz[0] == r and lunz[1] != "LUNZ": if r not in remote_list: remote_list += [r] cmdout = anturlar.traff_cmd("bcu port --statsclr %s/1" % i, db_level) cmdout = anturlar.traff_cmd("bcu fcpim --lunlist %s/1" % i , db_level ) ras = re.compile('/dev/sd([a-z]+)') ras = ras.findall(cmdout) remote_list = remote_list + ras for r in ras: for lunz in remove_lunz: if lunz[0] == r and lunz[1] != "LUNZ": if r not in remote_list: remote_list += [r] print("remote port list : %s " % remote_list ) print("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA") #### put the list is the correct syntax new_list = ",".join(remote_list) print("NEW LIST IS : %s " % new_list) #### combine the command with the drive list start_pain_sd = start_pain + ' -f"/dev/sd;%s"' % new_list print("NEWEST COMMAND %s " % start_pain_sd) reg_list = [b'([\w\d]+)'] cmdout = anturlar.fos_cmd_regex(start_pain_sd , reg_list) cmdout = anturlar.traff_output() 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("@" * 40) #sys.exit() ########################################################################## ########################################################################## ### ### hold the ip address from the command line ### if pa.ipaddr: pa.chassis_name = console_info_from_ip(pa.ipaddr, pa.chassis_name) cons_info = console_info(pa.chassis_name) console_ip = cons_info[0] console_port = cons_info[1] power_pole_info = pwr_pole_info(pa.chassis_name) usr_pass = get_user_and_pass(pa.chassis_name) user_name = usr_pass[0] usr_psswd = usr_pass[1] tn = anturlar.connect_tel_noparse(pa.ipaddr, user_name, usr_psswd) fi = anturlar.FabricInfo() si = anturlar.SwitchInfo() fcr = anturlar.FcrInfo() if pa.fabwide: ipaddr_switch = fi.ipv4_list() #print(ipaddr_switch) elif pa.csvall: ipaddr_switch = get_ip_from_file(pa.chassis_name) elif pa.fcrwide: anturlar.fos_cmd("setcontext %s" % fcr.base_check()) ipaddr_switch = fcr.fcr_fab_wide_ip() else: ipaddr_switch = [pa.ipaddr] anturlar.close_tel() #### pass ip(s)to login procedure #### and write the file for i in ipaddr_switch: tn = anturlar.connect_tel_noparse(i, user_name, usr_psswd) nos = si.nos_check() if not nos: def ex_deconfig(): """ Find all EX-Ports AND VEX-Ports on either director or pizzabox and deconfigure. This parses "portcfgshow" command for any EX-Port, online or not, and deconfigures. This includes VEX ports as well. """ si = anturlar.SwitchInfo() anturlar.fos_cmd("switchdisable") portlist = si.all_ports() if si.am_i_director: for i in portlist: slot = i[0] port = i[1] pattern = re.compile(r'(?:\EX\sPort\s+)(?P<state> ON)') cmd = anturlar.fos_cmd("portcfgshow %a/%a" % (slot, port)) ex = pattern.search(cmd) if ex: anturlar.fos_cmd("portcfgexport %s/%s %s" % (slot, port, "-a 2")) anturlar.fos_cmd("portcfgvexport %s/%s %s" % (slot, port, "-a 2")) else: for i in portlist: print(i) port = i[1] pattern = re.compile(r'(?:\EX\sPort\s+)(?P<state> ON)') cmd = anturlar.fos_cmd("portcfgshow %a" % port) ex = pattern.search(cmd) if ex: anturlar.fos_cmd("portcfgexport %s %s" % (port, "-a 2")) anturlar.fos_cmd("portcfgvexport %s %s" % (port, "-a 2")) cmd_cap = anturlar.fos_cmd("switchenable") print('\n\nAll EX_ports found are now deconfigured.') #return(cmd_cap) # sw_dict = cofra.get_info_from_the_switch() # switch_ip = sw_dict["switch_ip"] # sw_name = sw_dict["switch_name"] # sw_chass_name = sw_dict["chassis_name"] # sw_director_or_pizza = sw_dict["director"] # sw_domains = sw_dict["domain_list"] # sw_ls_list = sw_dict["ls_list"] # sw_base_fid = sw_dict["base_sw"] # sw_xisl = sw_dict["xisl_state"] # sw_type = sw_dict["switch_type"] # sw_license = sw_dict["license_list"] # sw_vf_setting = sw_dict["vf_setting"] # sw_fcr_enabled = sw_dict["fcr_enabled"] # sw_port_list = sw_dict["port_list"] # # print("\n"*20) # print("SWITCH IP : %s " % switch_ip) # print("SWITCH NAME : %s " % sw_name) # print("CHASSIS NAME : %s " % sw_chass_name) # print("DIRECTOR : %s " % sw_director_or_pizza) # print("SWITCH DOMAINS : %s " % sw_domains) # print("LOGICAL SWITCH LIST : %s " % sw_ls_list) # print("BASE FID : %s " % sw_base_fid) # print("XISL STATE : %s " % sw_xisl) # print("SWITCH TYPE : %s " % sw_type) # print("LICENSE LIST : %s " % sw_license) # print("VF SETTING : %s " % sw_vf_setting) # print("FCR SETTING : %s " % sw_fcr_enabled) # print("PORT LIST : %s " % sw_port_list) # print("@"*40) # print("CONSOLE INFO : %s " % cons_info) # print("@"*40) # print("POWER POLE INFO : %s " % power_pole_info) # print("@"*40) # print("\nSwitch_Info has been written this file in logs/Switch_Info_for_playback_%s.txt\n" % switch_ip) # print("@"*40) else: print("\n" + "@" * 40) print('\nTHIS IS A NOS SWITCH> SKIPPING') print("\n" + "@" * 40) pass anturlar.close_tel() sys.exit() ############################################################################### #### #### 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) #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 main(): global tn ############################################################################### #### #### #### ############################################################################### pa = parse_args(sys.argv) #print(pa) #print(pa.chassis_name) #print(pa.ipaddr) #print(pa.quiet) #print(pa.verbose) #print(pa.firmware) #print("@"*40) #sys.exit() ########################################################################## ########################################################################## ### ### hold the ip address from the command line ### if pa.ipaddr: pa.chassis_name = console_info_from_ip(pa.ipaddr, pa.chassis_name) cons_info = console_info(pa.chassis_name) console_ip = cons_info[0] console_port = cons_info[1] power_pole_info = pwr_pole_info(pa.chassis_name) usr_pass = get_user_and_pass(pa.chassis_name) user_name = usr_pass[0] usr_psswd = usr_pass[1] tn = anturlar.connect_tel_noparse(pa.ipaddr,user_name,usr_psswd) fi = anturlar.FabricInfo() si = anturlar.SwitchInfo() fcr = anturlar.FcrInfo() if pa.fabwide: ipaddr_switch = fi.ipv4_list() #print(ipaddr_switch) elif pa.csvall: ipaddr_switch = get_ip_from_file(pa.chassis_name) elif pa.fcrwide: anturlar.fos_cmd("setcontext %s" % fcr.base_check()) ipaddr_switch = fcr.fcr_fab_wide_ip() else: ipaddr_switch = [pa.ipaddr] anturlar.close_tel() #### pass ip(s)to login procedure #### and write the file for i in ipaddr_switch: tn = anturlar.connect_tel_noparse(i,user_name,usr_psswd) nos = si.nos_check() if not nos: fi=anturlar.FcrInfo() lsanzone = anturlar.fos_cmd("lsanzoneshow -s") fcrproxy = anturlar.fos_cmd("fcrproxydevshow") fcrresource = anturlar.fos_cmd("fcrresourceshow") print(lsanzone) print(fcrproxy) print(fcrresource) f1 = "%s%s%s"%("logs/LsanZoneInfo_",pa.ipaddr,"_base.txt") a = os.path.isfile(f1) if not a: print("Not there. Capturing file now") header = "%s%s%s%s" % ("\nLsanZoneShow CAPTURE FILE \n",\ "","", "==============================\n") ff = liabhar.FileStuff(f1, 'w+b') #### open the log file for writing ff.write(header) ff.write(lsanzone) ff.write(fcrproxy) ff.write(fcrresource) sys.exit(0) else: f2 = "%s%s%s"%("logs/LsanZoneInfo_",pa.ipaddr,"_after.txt") header = "%s%s%s%s" % ("\nLsanZoneShow CAPTURE FILE \n",\ "","", "==============================\n") ff = liabhar.FileStuff(f2, 'w+b') #### open the log file for writing ff.write(header) ff.write(lsanzone) ff.write(fcrproxy) ff.write(fcrresource) #sys.exit(0) #f0 = ("logs/LsanZoneInfo_",pa.ipaddr,"_base.txt") #f1 = ("logs/LsanZoneInfo_",pa.ipaddr,"_after.txt") diff = fcr_tools.file_diff(f1,f2) print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!") print(diff) sys.exit() #sw_dict = cofra.get_info_from_the_switch() #switch_ip = sw_dict["switch_ip"] #sw_name = sw_dict["switch_name"] #sw_chass_name = sw_dict["chassis_name"] #sw_director_or_pizza = sw_dict["director"] #sw_domains = sw_dict["domain_list"] #sw_ls_list = sw_dict["ls_list"] #sw_base_fid = sw_dict["base_sw"] #sw_xisl = sw_dict["xisl_state"] #sw_type = sw_dict["switch_type"] #sw_license = sw_dict["license_list"] #sw_vf_setting = sw_dict["vf_setting"] #sw_fcr_enabled = sw_dict["fcr_enabled"] #sw_port_list = sw_dict["port_list"] # #print("\n"*20) #print("SWITCH IP : %s " % switch_ip) #print("SWITCH NAME : %s " % sw_name) #print("CHASSIS NAME : %s " % sw_chass_name) #print("DIRECTOR : %s " % sw_director_or_pizza) #print("SWITCH DOMAINS : %s " % sw_domains) #print("LOGICAL SWITCH LIST : %s " % sw_ls_list) #print("BASE FID : %s " % sw_base_fid) #print("XISL STATE : %s " % sw_xisl) #print("SWITCH TYPE : %s " % sw_type) #print("LICENSE LIST : %s " % sw_license) #print("VF SETTING : %s " % sw_vf_setting) #print("FCR SETTING : %s " % sw_fcr_enabled) #print("PORT LIST : %s " % sw_port_list) #print("@"*40) #print("CONSOLE INFO : %s " % cons_info) #print("@"*40) #print("POWER POLE INFO : %s " % power_pole_info) #print("@"*40) #print("\nSwitch_Info has been written this file in logs/Switch_Info_%s_restore.txt\n" % switch_ip) #print("@"*40) else: print("\n"+"@"*40) print('\nTHIS IS A NOS SWITCH> SKIPPING') print("\n"+"@"*40) pass anturlar.close_tel() sys.exit()
def 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 ### #try: # ipaddr_test = ipaddress.ip_address(pa.ipaddr) # #print (ipaddr_test) #except ValueError: # print("\nPLEASE CHECK YOUR IP ADDRESS AND TRY AGAIN") # sys.exit() if pa.ipaddr: pa.chassis_name = console_info_from_ip(pa.ipaddr, pa.chassis_name) cons_info = console_info(pa.chassis_name) console_ip = cons_info[0] console_port = cons_info[1] power_pole_info = pwr_pole_info(pa.chassis_name) usr_pass = get_user_and_pass(pa.chassis_name) user_name = usr_pass[0] usr_psswd = usr_pass[1] tn = anturlar.connect_tel_noparse(pa.ipaddr,user_name,usr_psswd) fi = anturlar.FabricInfo() si = anturlar.SwitchInfo() fcr = anturlar.FcrInfo() if pa.fabwide: ipaddr_switch = fi.ipv4_list() #print(ipaddr_switch) elif pa.csvall: ipaddr_switch = get_ip_from_file(pa.chassis_name) elif pa.fcrwide: anturlar.fos_cmd("setcontext %s" % fcr.base_check()) ipaddr_switch = fcr.fcr_fab_wide_ip() else: ipaddr_switch = [pa.ipaddr] anturlar.close_tel() #### pass ip(s)to login procedure #### and write the file for i in ipaddr_switch: try: ###New tn = anturlar.connect_tel_noparse(i,user_name,usr_psswd) except OSError: ##New print("Switch %s not available" % i) ##New nos = si.nos_check() if not nos: sw_dict = cofra.get_info_from_the_switch("restore") switch_ip = sw_dict["switch_ip"] sw_name = sw_dict["switch_name"] sw_chass_name = sw_dict["chassis_name"] sw_director_or_pizza = sw_dict["director"] sw_domains = sw_dict["domain_list"] sw_ls_list = sw_dict["ls_list"] sw_base_fid = sw_dict["base_sw"] sw_xisl = sw_dict["xisl_state"] sw_type = sw_dict["switch_type"] sw_license = sw_dict["license_list"] sw_vf_setting = sw_dict["vf_setting"] sw_fcr_enabled = sw_dict["fcr_enabled"] sw_port_list = sw_dict["port_list"] sw_ex_port_list = sw_dict["ex_ports"] print("\n"*20) print("SWITCH IP : %s " % switch_ip) print("SWITCH NAME : %s " % sw_name) print("CHASSIS NAME : %s " % sw_chass_name) print("DIRECTOR : %s " % sw_director_or_pizza) print("SWITCH DOMAINS : %s " % sw_domains) print("LOGICAL SWITCH LIST : %s " % sw_ls_list) print("BASE FID : %s " % sw_base_fid) print("XISL STATE : %s " % sw_xisl) print("SWITCH TYPE : %s " % sw_type) print("LICENSE LIST : %s " % sw_license) print("VF SETTING : %s " % sw_vf_setting) print("FCR SETTING : %s " % sw_fcr_enabled) print("PORT LIST : %s " % sw_port_list) print("EX_PORT_LIST : %s " % sw_ex_port_list) print("@"*40) print("CONSOLE INFO : %s " % cons_info) print("@"*40) print("POWER POLE INFO : %s " % power_pole_info) print("@"*40) print("\nSwitch_Info has been written this file in logs/test/Switch_Info_%s_restore.txt\n" % switch_ip) print("@"*40) else: print("\n"+"@"*40) print('\nTHIS IS A NOS SWITCH> SKIPPING') print("\n"+"@"*40) pass anturlar.close_tel() sys.exit() ############################################################################### #### #### 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("@"*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() su = cofra.SwitchUpdate() 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 ################################################################################################## # Manual list of switches to run suppportftp against. Entire csv list is printed out above but the # list below overwries it. # This keeps bombing on AMP switch IP (not included below). ################################################################################################## ip_no_amp = ['10.38.36.240', '10.38.36.10', '10.38.36.33', '10.38.36.158', '10.38.36.249', '10.38.36.102', '10.38.36.246', '10.38.36.250', '10.38.36.98', '10.38.36.125', '10.38.36.25', '10.38.36.24', '10.38.36.111', '10.38.36.95', '10.38.36.85', '10.38.36.112'] for i in ip_no_amp: 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: anturlar.fos_cmd("supportftp -s -h 10.39.2.171 -u ftp1 -p ftp2 -d ssaves -l ftp") anturlar.fos_cmd("supportftp -e") anturlar.fos_cmd("supportftp -t 8") anturlar.fos_cmd("tsclockserver 10.38.2.80; tstimezone America/Denver") anturlar.fos_cmd("echo Y | reboot") #anturlar.fos_cmd("tsclockserver LOCL") else: print("\n"+"@"*40) print('\nTHIS IS A NOS SWITCH> SKIPPING') print("\n"+"@"*40) pass # tn = su.reboot_reconnect() anturlar.close_tel() sys.exit()
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 ####################################################################################################################### #### #### 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("@"*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) nos = si.nos_check() if not nos: print("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") ports = fcr.all_ex_ports_with_edge_fid() devices = fcr.fcr_proxy_dev() #backbone_ip = fcr.fcr_backbone_ip() print("XXXXXXXXXXXXXXXXXXXXXXXXXXXXX") f = ('logs/EX_PortFlapper.txt') try: with open(f, 'w') as file: file.write("EX-Ports = %s\n" % str(ports)) file.write("Proxy Devices = %s\n" % str(devices)) #file.write("Backbone_IPs = %s\n" % str(backbone_ip)) except IOError: print("\n\nThere was a problem opening the file:" , f) sys.exit() file.close() 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) devices_check = fcr.fcr_proxy_dev() if devices_check != devices: 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","") sys.exit() else: print("\n"+"@"*40) print('\nTHIS IS A NOS SWITCH> SKIPPING') print("\n"+"@"*40) pass anturlar.close_tel() sys.exit()
def start_linux_pre_3_2(h, start_cmd): """ the command is passed into this procedure and the drive letters are added to the command if there are Clariion devices the LUNZ devices are skipped """ db_level = 9 remote_list = [] start_pain = start_cmd ################################################################################################################### #### use catapult to capture the drives and and Volumn ID -- use this if they are Clariion to not add #### the drives with LUNZ Volumn ID since they are not target IDs #### cmdout = anturlar.traff_cmd("catapult -p") ras = re.compile('[ \d]+/dev/sd([a-z]+)\s+[:0-9]+\s+[A-Z]+\s+([A-Z]+)') remove_lunz = ras.findall(cmdout) for i in [4,2,3,1]: cmdout = anturlar.traff_cmd("bcu port --statsclr %s/0" % i, db_level) cmdout = anturlar.traff_cmd("bcu rport --osname %s/0" % i , db_level ) ras = re.compile('/dev/sd([a-z]+)') ras = ras.findall(cmdout) print("ras"*30) print(ras) print(remove_lunz) print(remote_list) print("ras"*30) for r in ras: for lunz in remove_lunz: print(r) print(lunz[0]) print(lunz[1]) if lunz[0] == r and lunz[1] != "LUNZ": if r not in remote_list: remote_list += [r] cmdout = anturlar.traff_cmd("bcu port --statsclr %s/1" % i, db_level) cmdout = anturlar.traff_cmd("bcu rport --osname %s/1" % i , db_level ) ras = re.compile('/dev/sd([a-z]+)') ras = ras.findall(cmdout) for r in ras: for lunz in remove_lunz: if lunz[0] == r and lunz[1] != "LUNZ": if r not in remote_list: remote_list += [r] print("remote port list : %s " % remote_list ) print("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA") #### put the list is the correct syntax by adding comma new_list = ",".join(remote_list) print("NEW LIST IS : %s " % new_list) print("#"*80) #### combine the command with the drive list start_pain_sd = start_pain + ' -f"/dev/sd;%s"' % new_list print("NEWEST COMMAND %s " % start_pain_sd) reg_list = [b'([\w\d]+)'] cmdout = anturlar.fos_cmd_regex(start_pain_sd , reg_list,9) cmdout = anturlar.traff_output(9) 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("@"*40) #sys.exit() ########################################################################## ########################################################################## ### ### hold the ip address from the command line ### if pa.ipaddr: pa.chassis_name = console_info_from_ip(pa.ipaddr, pa.chassis_name) cons_info = console_info(pa.chassis_name) console_ip = cons_info[0] console_port = cons_info[1] power_pole_info = pwr_pole_info(pa.chassis_name) usr_pass = get_user_and_pass(pa.chassis_name) user_name = usr_pass[0] usr_psswd = usr_pass[1] tn = anturlar.connect_tel_noparse(pa.ipaddr,user_name,usr_psswd) fi = anturlar.FabricInfo() si = anturlar.SwitchInfo() fcr = anturlar.FcrInfo() if pa.fabwide: ipaddr_switch = fi.ipv4_list() #print(ipaddr_switch) elif pa.csvall: ipaddr_switch = get_ip_from_file(pa.chassis_name) elif pa.fcrwide: anturlar.fos_cmd("setcontext %s" % fcr.base_check()) ipaddr_switch = fcr.fcr_fab_wide_ip() else: ipaddr_switch = [pa.ipaddr] anturlar.close_tel() #### pass ip(s)to login procedure #### and write the file for i in ipaddr_switch: tn = anturlar.connect_tel_noparse(i,user_name,usr_psswd) nos = si.nos_check() if not nos: def ex_deconfig(): """ Find all EX-Ports AND VEX-Ports on either director or pizzabox and deconfigure. This parses "portcfgshow" command for any EX-Port, online or not, and deconfigures. This includes VEX ports as well. """ si = anturlar.SwitchInfo() anturlar.fos_cmd("switchdisable") portlist = si.all_ports() if si.am_i_director: for i in portlist: slot = i[0] port = i[1] pattern = re.compile(r'(?:\EX\sPort\s+)(?P<state> ON)') cmd = anturlar.fos_cmd("portcfgshow %a/%a" % (slot, port)) ex = pattern.search(cmd) if ex: anturlar.fos_cmd("portcfgexport %s/%s %s"%(slot,port,"-a 2")) anturlar.fos_cmd("portcfgvexport %s/%s %s"%(slot,port,"-a 2")) else: for i in portlist: print(i) port = i[1] pattern = re.compile(r'(?:\EX\sPort\s+)(?P<state> ON)') cmd = anturlar.fos_cmd("portcfgshow %a" % port) ex = pattern.search(cmd) if ex: anturlar.fos_cmd("portcfgexport %s %s"%(port,"-a 2")) anturlar.fos_cmd("portcfgvexport %s %s"%(port,"-a 2")) cmd_cap = anturlar.fos_cmd("switchenable") print('\n\nAll EX_ports found are now deconfigured.') #return(cmd_cap) # sw_dict = cofra.get_info_from_the_switch() # switch_ip = sw_dict["switch_ip"] # sw_name = sw_dict["switch_name"] # sw_chass_name = sw_dict["chassis_name"] # sw_director_or_pizza = sw_dict["director"] # sw_domains = sw_dict["domain_list"] # sw_ls_list = sw_dict["ls_list"] # sw_base_fid = sw_dict["base_sw"] # sw_xisl = sw_dict["xisl_state"] # sw_type = sw_dict["switch_type"] # sw_license = sw_dict["license_list"] # sw_vf_setting = sw_dict["vf_setting"] # sw_fcr_enabled = sw_dict["fcr_enabled"] # sw_port_list = sw_dict["port_list"] # # print("\n"*20) # print("SWITCH IP : %s " % switch_ip) # print("SWITCH NAME : %s " % sw_name) # print("CHASSIS NAME : %s " % sw_chass_name) # print("DIRECTOR : %s " % sw_director_or_pizza) # print("SWITCH DOMAINS : %s " % sw_domains) # print("LOGICAL SWITCH LIST : %s " % sw_ls_list) # print("BASE FID : %s " % sw_base_fid) # print("XISL STATE : %s " % sw_xisl) # print("SWITCH TYPE : %s " % sw_type) # print("LICENSE LIST : %s " % sw_license) # print("VF SETTING : %s " % sw_vf_setting) # print("FCR SETTING : %s " % sw_fcr_enabled) # print("PORT LIST : %s " % sw_port_list) # print("@"*40) # print("CONSOLE INFO : %s " % cons_info) # print("@"*40) # print("POWER POLE INFO : %s " % power_pole_info) # print("@"*40) # print("\nSwitch_Info has been written this file in logs/Switch_Info_for_playback_%s.txt\n" % switch_ip) # print("@"*40) else: print("\n"+"@"*40) print('\nTHIS IS A NOS SWITCH> SKIPPING') print("\n"+"@"*40) pass anturlar.close_tel() sys.exit() ############################################################################### #### #### 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(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) nos = si.nos_check() if not nos: #print("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") f_ports = si.f_ports() e_ports = si.e_ports() print(fports) print(eports) sys.exit() #devices = fcr.fcr_proxy_dev() print("XXXXXXXXXXXXXXXXXXXXXXXXXXXXX") fabric_check = fi.fabric_members() #print(fabric_check) 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(): ########################################################################### #### the module will start a suite of test #### #### 1. start from the command line - parse the args #### 2. determine if switch or fabric test - user input default to switch #### 3. determine which test case to run - read from a config file #### 4. start each test case in a seperate process #### 5. return the results of the complete suite -- need to wait for each #### process to exit ( each test case to complete ) #### #### ############################################################################### #### Step 1 #### parse of the command line is done when the test is started #### ############################################################################### #### confirm you are in your $HOME directory #### if not move to the user HOME directory and continue #### #### #### global tn liabhar.cls() print("@" * 80) print("@" * 80) print("@" * 80) print("@" * 80) cwd = os.getcwd() path = os.path.join(cwd, "logs") if os.path.exists(path): pass ##liabhar.count_down(1) else: print("\n\nChanging to your HOME directory\n\n") homepath = os.getenv('HOME') os.chdir(homepath) cwd = os.getcwd() print(cwd) pa = liabhar.parse_args(sys.argv) #print(pa) ########################################################################### #### if no password ask the user for the password #### ########################################################################### pw = "password" if not pa.password: pw = getpass.getpass() ############################################################################### #### Step 2 #### #### is the testing switch only or fabric wide #### #### the variable is in the parse args fabwide 0 = switch only #### ############################################################################### #print("#"*80) #print("#"*80) if pa.fabwide == False: print(" Testing in switch mode") else: print(" Testing in fabric wide mode") ############################################################################### #### Step 3 #### #### what test case do i run -- read a config file #### #### the file is in logs/config or logs still open question #### ############################################################################### #suite_name = pa.suite cw_config_file_name = "%s%s%s" % ("ini/", pa.suite, ".txt") fileIN = open(cw_config_file_name, 'rb') testcaselist = [] #print("Running the following Test Cases") #print("#"*32) for line in fileIN: line = str(line.strip(), encoding='utf8') line = line.split(" ") #for j in line: #print("list item %s "%j ) if line[0] == 'Y': testcaselist.append(line) #print("test case list \n") #print(testcaselist) #print("#"*80) #print("#"*80) ########################################################################### #### Step 4 #### #### Start the appropriate test to each switch or Fabrica Wide or #### #### or read the file for a list of IP. #### #### #### ########################################################################### #### take the testcaselist if pa.fabwide: conn_value = anturlar.connect_tel(pa, pw) si = anturlar.SwitchInfo fabi = anturlar.FabricInfo(pa.fid) fablist = fabi.ipv4_plus_fcr_list(pa.user, pw) anturlar.close_tel() time.sleep(1) liabhar.cls() print("@" * 60) print("@" * 60) print("\n FABRIC LIST OF IP TO BE TESTED : ") print("-" * 60) for ip in fablist: print(" %s" % ip) header(pa, testcaselist) user_start() for ip in fablist: #print("\n\n\n\n%s"%ip) pa.ip = ip p = Process(target=testprocess, args=(pa, testcaselist, pw)) p.daemon = False p.start() elif pa.ipfile: pass else: header(pa, testcaselist) user_start() p = Process(target=testprocess, args=(pa, testcaselist, pw)) #p.daemon = True #### use True value all child process will stop when the main process stops p.daemon = False #### this will run in the background even if this script finishes p.start() time.sleep(0.1) #print("\nprocess exit code is %s"%p.exitcode) #time.sleep(5.1) #print("\nprocess exit code is %s"%p.exitcode) print("\n\n TESTING STARTED IN ANOTHER CONNECTION ") print(" EXITING THIS CONNECTION") print("@" * 80) print("@" * 80) print("@" * 80) print("@" * 80)
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) if pa.verbose: print("@"*40) print("#"*40) print(pa) print(pa.file) print(pa.quiet) print(pa.verbose) 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 #### ####################################################################################################################### ####################################################################################################################### reg_list = get_info_from_flow_file(pa.file) if pa.verbose: print("\n\ninfo from flow reg file\n\n") print(reg_list) #### this is common steps to get the information from a csv file #### for this test we only need the chassis name and fid for i in range(0,len(reg_list),2): chass_1 = reg_list[i] target_fid = reg_list[i+1] print("chassname is %s " % chass_1) print("target fid is %s " % target_fid) #chass_1 = reg_list[0] #target_fid = reg_list[1] #cons_info = sw_matrix_tools.console_info(chass_1) #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(chass_1) usr_pass = sw_matrix_tools.get_user_and_pass(chass_1) user_name = usr_pass[0] usr_psswd = usr_pass[1] ipaddr_switch = sw_matrix_tools.get_ip_from_file(chass_1) ###################################################################################################################### ###################################################################################################################### #### #### 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 " % target_fid) #### change to the fid given on the command firmware_ver = anturlar.fos_cmd("firmwareshow") #### send any command with anturlar.fos_cmd flow = anturlar.FlowV() date_is = get_time_stamp() header = "%s" % ("\nFlow Regression Log \n") #### write a header line at top of file seperator = "%s" % ("="*80) write_to_results_file("\r\n\r\n",ipaddr_switch,date_is) write_to_results_file(header,ipaddr_switch,date_is) write_to_results_file(ipaddr_switch,ipaddr_switch,date_is) write_to_results_file(firmware_ver,ipaddr_switch,date_is) write_to_results_file(seperator,ipaddr_switch,date_is) write_to_results_file(seperator,ipaddr_switch,date_is) #### get the list of flows on the switch flow_all_fport = flow.get_flow_details() #### change the list to a string a = str(flow_all_fport) write_to_results_file(a,ipaddr_switch,date_is) liabhar.cls() ####################################################################################################################### ####################################################################################################################### #### #### ####################################################################################################################### cons_out = anturlar.fos_cmd("fosexec --fid all -cmd 'flow --deact all'") cons_out = anturlar.fos_cmd("flow --deact all") cons_out = anturlar.fos_cmd("echo y | flow --delete all -force") #### remove all flows cons_out = anturlar.fos_cmd("flow --act sys_mon_all_fports") liabhar.JustSleep(360) stats = flow.get_egr_stats("sys_mon_all_fports") liabhar.JustSleep(120) write_to_results_file(stats,ipaddr_switch,date_is) result = look_for_zero(stats) #### print the result to a file #### write_pass_fail_to_file(result,ipaddr_switch,date_is) print("@"*80) print("#"*80) print(result) print("#"*80) print("@"*80) cons_out = anturlar.fos_cmd("flow --deact all") #### find the SID DID pairs and create each monitor #### ras = re.compile('\|([0-9a-f]{1,4})\s+\|([0-9a-f]{6})\|([0-9a-f]{6})') ingr_sid_did_list = ras.findall(stats) if pa.verbose: print("LIST OF FLOWS \n") print(stats) print("regex ") print(ingr_sid_did_list) name_number = 0 for ingr_p, sid, did in ingr_sid_did_list: print(ingr_p) print(sid) print(did) print("\n") cons_out = anturlar.fos_cmd("flow --create regress_flow_a%s -fea mon -ingrport %s -srcdev %s -dstdev %s -noact " % (name_number,ingr_p,sid,did)) cons_out = anturlar.fos_cmd("flow --create regress_flow_b%s -fea mon -ingrport %s -dstdev %s -noact " % (name_number,ingr_p,did)) cons_out = anturlar.fos_cmd("flow --create regress_flow_c%s -fea mon -ingrport %s -srcdev %s -noact " % (name_number,ingr_p,sid)) cons_out = anturlar.fos_cmd("flow --create regress_flow_d%s -fea mon -ingrport %s -srcdev '*' -dstdev %s -noact " % (name_number,ingr_p,did)) cons_out = anturlar.fos_cmd("flow --create regress_flow_e%s -fea mon -ingrport %s -srcdev %s -dstdev '*' -noact " % (name_number,ingr_p,sid)) cons_out = anturlar.fos_cmd("flow --create regress_flow_f%s -fea mon -egrport %s -srcdev %s -dstdev %s -noact " % (name_number,ingr_p,did,sid)) cons_out = anturlar.fos_cmd("flow --create regress_flow_g%s -fea mon -egrport %s -srcdev %s -noact " % (name_number,ingr_p,did)) cons_out = anturlar.fos_cmd("flow --create regress_flow_h%s -fea mon -egrport %s -dstdev %s -noact " % (name_number,ingr_p,sid)) name_number += 1 flow_all = flow.get_nondflt_flows() if pa.verbose: verb_list_print(flow_all) for f in flow_all: cons_out = anturlar.fos_cmd("flow --act %s " % f) #### get the current flow #egrp_flow = flow.get_active_flows() #e = egrp_flow[0] liabhar.JustSleep(120) stats = flow.get_egr_stats(f) liabhar.JustSleep(120) write_to_results_file(stats,ipaddr_switch,date_is) result = look_for_zero(stats) #### print the result to a file #### write_pass_fail_to_file(result,ipaddr_switch,date_is) print("@"*80) print("#"*80) print(result) print("#"*80) print("@"*80) cons_out = anturlar.fos_cmd("flow --deact all") #### close the telnet session ############################# anturlar.close_tel() #### close the telnet session #liabhar.JustSleep(30) 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 ### #try: # ipaddr_test = ipaddress.ip_address(pa.ipaddr) # #print (ipaddr_test) #except ValueError: # print("\nPLEASE CHECK YOUR IP ADDRESS AND TRY AGAIN") # sys.exit() 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 ff = "" f = ("%s%s%s" % ("logs/Switch_Info_", pa.ipaddr, "_restore.txt")) #f = ("logs/Switch_Info_10.38.134.66_VF_Wedge.txt") #f = ("logs/Switch_Info_10.38.134.66_for_playback.txt") print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$") print(f) try: with open(f, 'r') as file: ff = file.read() except IOError: print("\n\nThere was a problem opening the file:", f) sys.exit() print(ff) #sys.exit() #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() # switch_ip = sw_dict["switch_ip"] # sw_name = sw_dict["switch_name"] # sw_chass_name = sw_dict["chassis_name"] # sw_director_or_pizza = sw_dict["director"] # sw_domains = sw_dict["domain_list"] # sw_ls_list = sw_dict["ls_list"] # sw_base_fid = sw_dict["base_sw"] # sw_xisl = sw_dict["xisl_state"] # sw_type = sw_dict["switch_type"] # sw_license = sw_dict["license_list"] # sw_vf_setting = sw_dict["vf_setting"] # sw_fcr_enabled = sw_dict["fcr_enabled"] # sw_port_list = sw_dict["port_list"] # # print("\n"*20) # print("SWITCH IP : %s " % switch_ip) # print("SWITCH NAME : %s " % sw_name) # print("CHASSIS NAME : %s " % sw_chass_name) # print("DIRECTOR : %s " % sw_director_or_pizza) # print("SWITCH DOMAINS : %s " % sw_domains) # print("LOGICAL SWITCH LIST : %s " % sw_ls_list) # print("BASE FID : %s " % sw_base_fid) # print("XISL STATE : %s " % sw_xisl) # print("SWITCH TYPE : %s " % sw_type) # print("LICENSE LIST : %s " % sw_license) # print("VF SETTING : %s " % sw_vf_setting) # print("FCR SETTING : %s " % sw_fcr_enabled) # print("PORT LIST : %s " % sw_port_list) # print("@"*40) # print("CONSOLE INFO : %s " % cons_info) # print("@"*40) # print("POWER POLE INFO : %s " % power_pole_info) # print("@"*40) # print("\nSwitch_Info has been written this file in logs/Switch_Info_for_playback_%s.txt\n" % switch_ip) # print("@"*40) # else: # print("\n"+"@"*40) # print('\nTHIS IS A NOS SWITCH> SKIPPING') # print("\n"+"@"*40) # pass #anturlar.close_tel() #sys.exit() ############################################################################### #### #### close telnet connection and #### connect to the console #### ############################################################################### tn = anturlar.connect_tel_noparse(pa.ipaddr, user_name, usr_psswd) 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() cons_out = cc.playback_fosconfig_fcr() tn = cc.reboot_reconnect() cons_out = anturlar.fos_cmd("switchshow") print(cons_out) anturlar.close_tel()
def switch_config_show(): """ get information for a switch for each FID """ cons_out = anturlar.fos_cmd("") swtch = anturlar.SwitchInfo() fab = anturlar.FabricInfo() #fab_ip_list = fab.ipv4_list() ip = swtch.ipaddress() this_fid = swtch.currentFID() fname = "%s%s" % ("logs/Switch_info_per_FID_" ,".txt") #### %s string %d number ff = liabhar.FileStuff(fname, 'w+b') ff.write("#############################################################\r\n") ff.close() tnn = anturlar.connect_tel_noparse(ip, 'root', 'password') ff = liabhar.FileStuff(fname, 'a+b') ls_list_fids = swtch.ls() m_info = anturlar.Maps() f_info = anturlar.FlowV() firmware_ver = check_version() s_type = m_info.switch_type() ls_list = m_info.ls() switch_id = m_info.switch_id() ls_domain = m_info.ls_and_domain() chass_name = m_info.chassisname() vf_state = m_info.vf_enabled() ff.write("Switch ipv4 : %s \r\n" % ip) ff.write("Chassis Name : %s \r\n" % chass_name) ff.write("Firmware version : %s \r\n" % firmware_ver) #ff.write("Switch Name : %s \r\n" % s_name) ff.write("Switch Type : %s \r\n" % s_type) ff.write("VF State : %s \r\n" % vf_state) ff.write("Logical Switches : %s \r\n" % ls_list) ff.write("Switch ID : %s \r\n" % switch_id) ff.write("ls and domain : %s \r\n" % ls_domain) print(ls_list_fids) for i in ls_list_fids: print(i) print("\n"*10) for ls in ls_list_fids: cons_out = anturlar.fos_cmd("setcontext %s " % ls) s_name = m_info.switch_name() maps_policy_list = m_info.get_policies() maps_active_policy = m_info.get_active_policy() non_dflt_policy = m_info.get_nondflt_policies() flow_names = f_info.flow_names() flows_nondflt = f_info.get_nondflt_flows() flows_active = f_info.get_active_flows() flow_details = f_info.get_flow_details() #flow_cnfg = f_info.flow_config() maps_config = anturlar.fos_cmd("mapsconfig --show") ####### ####### remove line switchname FID ?? root> ####### print("\n"*4) print(maps_config) print("\n"*4) m_no_root = s_name + ":FID" + str(ls) + ":root>" #m_no_name = maps_config.replace(s_name ,'') #m_no_fid = m_no_name.replace(str(this_fid), '') m = maps_config.replace(m_no_root, '') print("\n"*4) print(m) print("\n"*4) ####### ####### remove line switchname FID ?? root> ####### seperator_switch(ff, ls) ff.write("Switch Name : %s \r\n" % s_name) ff.write("---------------------------------------------------------------------\r\n") #ff.write("MAPS config : %s \r\n" % maps_config) ff.write("MAPS config : \r\n\r\n %s \r\n" % m) ## maps config ff.write("---------------------------------------------------------------------\r\n") ff.write("MAPS Policy List : %s \r\n" % maps_policy_list) ff.write("MAPS Active Policy : %s \r\n" % maps_active_policy) ff.write("MAPS Non Default Policy : %s \r\n" % non_dflt_policy) ff.write("---------------------------------------------------------------------\r\n") ff.write("FLOW Names list : %s \r\n" % flow_names) ff.write("FLOW non dflt Flows : %s \r\n" % flows_nondflt) ff.write("FLOWs Active : %s \r\n" % flows_active) ff.write("FLOW Details : %s \r\n" % flow_details) ff.write("---------------------------------------------------------------------\r\n") ff.close() anturlar.close_tel()
def main(): ########################################################################### #### the module will start a suite of test #### #### 1. start from the command line - parse the args #### 2. determine if switch or fabric test - user input default to switch #### 3. determine which test case to run - read from a config file #### 4. start each test case in a seperate process #### 5. return the results of the complete suite -- need to wait for each #### process to exit ( each test case to complete ) #### #### ############################################################################### #### Step 1 #### parse of the command line is done when the test is started #### ############################################################################### #### confirm you are in your $HOME directory #### if not move to the user HOME directory and continue #### #### #### global tn liabhar.cls() print("@"*80) print("@"*80) print("@"*80) print("@"*80) cwd = os.getcwd() path = os.path.join(cwd,"logs") if os.path.exists(path): pass ##liabhar.count_down(1) else: print("\n\nChanging to your HOME directory\n\n") homepath = os.getenv('HOME') os.chdir(homepath) cwd = os.getcwd() print(cwd) pa = liabhar.parse_args(sys.argv) #print(pa) ########################################################################### #### if no password ask the user for the password #### ########################################################################### pw = "password" if not pa.password: pw = getpass.getpass() ############################################################################### #### Step 2 #### #### is the testing switch only or fabric wide #### #### the variable is in the parse args fabwide 0 = switch only #### ############################################################################### #print("#"*80) #print("#"*80) if pa.fabwide == False: print(" Testing in switch mode") else: print(" Testing in fabric wide mode") ############################################################################### #### Step 3 #### #### what test case do i run -- read a config file #### #### the file is in logs/config or logs still open question #### ############################################################################### #suite_name = pa.suite cw_config_file_name = "%s%s%s"%("ini/",pa.suite,".txt") fileIN = open( cw_config_file_name, 'rb') testcaselist = [] #print("Running the following Test Cases") #print("#"*32) for line in fileIN: line = str(line.strip(), encoding='utf8') line = line.split(" ") #for j in line: #print("list item %s "%j ) if line[0] == 'Y': testcaselist.append(line) #print("test case list \n") #print(testcaselist) #print("#"*80) #print("#"*80) ########################################################################### #### Step 4 #### #### Start the appropriate test to each switch or Fabrica Wide or #### #### or read the file for a list of IP. #### #### #### ########################################################################### #### take the testcaselist if pa.fabwide: conn_value = anturlar.connect_tel(pa, pw ) si = anturlar.SwitchInfo fabi = anturlar.FabricInfo(pa.fid) fablist = fabi.ipv4_plus_fcr_list(pa.user,pw) anturlar.close_tel() time.sleep(1) liabhar.cls() print("@"*60) print("@"*60) print("\n FABRIC LIST OF IP TO BE TESTED : ") print("-"*60) for ip in fablist: print(" %s" % ip) header(pa, testcaselist) user_start() for ip in fablist: #print("\n\n\n\n%s"%ip) pa.ip = ip p = Process(target=testprocess, args=(pa, testcaselist, pw)) p.daemon = False p.start() elif pa.ipfile: pass else: header(pa,testcaselist) user_start() p = Process(target=testprocess, args=(pa, testcaselist, pw)) #p.daemon = True #### use True value all child process will stop when the main process stops p.daemon = False #### this will run in the background even if this script finishes p.start() time.sleep(0.1) #print("\nprocess exit code is %s"%p.exitcode) #time.sleep(5.1) #print("\nprocess exit code is %s"%p.exitcode) print("\n\n TESTING STARTED IN ANOTHER CONNECTION ") print(" EXITING THIS CONNECTION") print("@"*80) print("@"*80) print("@"*80) print("@"*80)
def main(): global tn ############################################################################### #### #### #### ############################################################################### pa = parse_args(sys.argv) #print("@"*40) #print(pa) #print(pa.chassis_name) #print(pa.ipaddr) #print(pa.quiet) #print(pa.verbose) #print(pa.firmware) #print("@"*40) #sys.exit() ########################################################################## ########################################################################## ### ### hold the ip address from the command line ### if pa.ipaddr: pa.chassis_name = console_info_from_ip(pa.ipaddr, pa.chassis_name) cons_info = console_info(pa.chassis_name) console_ip = cons_info[0] console_port = cons_info[1] power_pole_info = pwr_pole_info(pa.chassis_name) usr_pass = get_user_and_pass(pa.chassis_name) user_name = usr_pass[0] usr_psswd = usr_pass[1] tn = anturlar.connect_tel_noparse(pa.ipaddr,user_name,usr_psswd) fi = anturlar.FabricInfo() si = anturlar.SwitchInfo() fcr = anturlar.FcrInfo() if pa.fabwide: ipaddr_switch = fi.ipv4_list() #print(ipaddr_switch) elif pa.csvall: ipaddr_switch = get_ip_from_file(pa.chassis_name) elif pa.fcrwide: anturlar.fos_cmd("setcontext %s" % fcr.base_check()) ipaddr_switch = fcr.fcr_fab_wide_ip() else: ipaddr_switch = [pa.ipaddr] anturlar.close_tel() #### pass ip(s)to login procedure #### and write the file for i in ipaddr_switch: tn = anturlar.connect_tel_noparse(i,user_name,usr_psswd) nos = si.nos_check() if not nos: sw_dict = cofra.get_info_from_the_switch() switch_ip = sw_dict["switch_ip"] sw_name = sw_dict["switch_name"] sw_chass_name = sw_dict["chassis_name"] sw_director_or_pizza = sw_dict["director"] sw_domains = sw_dict["domain_list"] sw_ls_list = sw_dict["ls_list"] sw_base_fid = sw_dict["base_sw"] sw_xisl = sw_dict["xisl_state"] sw_type = sw_dict["switch_type"] sw_license = sw_dict["license_list"] sw_vf_setting = sw_dict["vf_setting"] sw_fcr_enabled = sw_dict["fcr_enabled"] sw_port_list = sw_dict["port_list"] print("\n"*20) print("SWITCH IP : %s " % switch_ip) print("SWITCH NAME : %s " % sw_name) print("CHASSIS NAME : %s " % sw_chass_name) print("DIRECTOR : %s " % sw_director_or_pizza) print("SWITCH DOMAINS : %s " % sw_domains) print("LOGICAL SWITCH LIST : %s " % sw_ls_list) print("BASE FID : %s " % sw_base_fid) print("XISL STATE : %s " % sw_xisl) print("SWITCH TYPE : %s " % sw_type) print("LICENSE LIST : %s " % sw_license) print("VF SETTING : %s " % sw_vf_setting) print("FCR SETTING : %s " % sw_fcr_enabled) print("PORT LIST : %s " % sw_port_list) print("@"*40) print("CONSOLE INFO : %s " % cons_info) print("@"*40) print("POWER POLE INFO : %s " % power_pole_info) print("@"*40) print("\nSwitch_Info has been written this file in logs/Switch_Info_for_playback_%s.txt\n" % switch_ip) print("@"*40) else: print("\n"+"@"*40) print('\nTHIS IS A NOS SWITCH> SKIPPING') print("\n"+"@"*40) pass #anturlar.close_tel() #sys.exit() ############################################################################### #### #### close telnet connection and #### connect to the console #### ############################################################################### fcrstate = fcr_state(fcr) if fcrstate is True: result = fcr_state_persist_enabled_switch_disable(fcr, si) print("RESULTFROMSWITCH_DISABLE") print(result) if result is None: print("SUCCESS") fcr_state_persist_enabled_hareboot(fcr, si) else: print("FAILED") sys.exit(0)
def switch_config_show(): """ get information for a switch for each FID """ cons_out = anturlar.fos_cmd("") swtch = anturlar.SwitchInfo() fab = anturlar.FabricInfo() #fab_ip_list = fab.ipv4_list() ip = swtch.ipaddress() this_fid = swtch.currentFID() fname = "%s%s" % ("logs/Switch_info_per_FID_", ".txt" ) #### %s string %d number ff = liabhar.FileStuff(fname, 'w+b') ff.write( "#############################################################\r\n") ff.close() tnn = anturlar.connect_tel_noparse(ip, 'root', 'password') ff = liabhar.FileStuff(fname, 'a+b') ls_list_fids = swtch.ls() m_info = anturlar.Maps() f_info = anturlar.FlowV() firmware_ver = check_version() s_type = m_info.switch_type() ls_list = m_info.ls() switch_id = m_info.switch_id() ls_domain = m_info.ls_and_domain() chass_name = m_info.chassisname() vf_state = m_info.vf_enabled() ff.write("Switch ipv4 : %s \r\n" % ip) ff.write("Chassis Name : %s \r\n" % chass_name) ff.write("Firmware version : %s \r\n" % firmware_ver) #ff.write("Switch Name : %s \r\n" % s_name) ff.write("Switch Type : %s \r\n" % s_type) ff.write("VF State : %s \r\n" % vf_state) ff.write("Logical Switches : %s \r\n" % ls_list) ff.write("Switch ID : %s \r\n" % switch_id) ff.write("ls and domain : %s \r\n" % ls_domain) print(ls_list_fids) for i in ls_list_fids: print(i) print("\n" * 10) for ls in ls_list_fids: cons_out = anturlar.fos_cmd("setcontext %s " % ls) s_name = m_info.switch_name() maps_policy_list = m_info.get_policies() maps_active_policy = m_info.get_active_policy() non_dflt_policy = m_info.get_nondflt_policies() flow_names = f_info.flow_names() flows_nondflt = f_info.get_nondflt_flows() flows_active = f_info.get_active_flows() flow_details = f_info.get_flow_details() #flow_cnfg = f_info.flow_config() maps_config = anturlar.fos_cmd("mapsconfig --show") ####### ####### remove line switchname FID ?? root> ####### print("\n" * 4) print(maps_config) print("\n" * 4) m_no_root = s_name + ":FID" + str(ls) + ":root>" #m_no_name = maps_config.replace(s_name ,'') #m_no_fid = m_no_name.replace(str(this_fid), '') m = maps_config.replace(m_no_root, '') print("\n" * 4) print(m) print("\n" * 4) ####### ####### remove line switchname FID ?? root> ####### seperator_switch(ff, ls) ff.write("Switch Name : %s \r\n" % s_name) ff.write( "---------------------------------------------------------------------\r\n" ) #ff.write("MAPS config : %s \r\n" % maps_config) ff.write("MAPS config : \r\n\r\n %s \r\n" % m) ## maps config ff.write( "---------------------------------------------------------------------\r\n" ) ff.write("MAPS Policy List : %s \r\n" % maps_policy_list) ff.write("MAPS Active Policy : %s \r\n" % maps_active_policy) ff.write("MAPS Non Default Policy : %s \r\n" % non_dflt_policy) ff.write( "---------------------------------------------------------------------\r\n" ) ff.write("FLOW Names list : %s \r\n" % flow_names) ff.write("FLOW non dflt Flows : %s \r\n" % flows_nondflt) ff.write("FLOWs Active : %s \r\n" % flows_active) ff.write("FLOW Details : %s \r\n" % flow_details) ff.write( "---------------------------------------------------------------------\r\n" ) ff.close() anturlar.close_tel()
def 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 ####################################################################################################################### ####################################################################################################################### #### #### This starts the template section 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) if pa.verbose: print("@" * 40) print("#" * 40) print(pa) print(pa.file) print(pa.quiet) print(pa.verbose) 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 #### ####################################################################################################################### ####################################################################################################################### reg_list = get_info_from_flow_file(pa.file) if pa.verbose: print("\n\ninfo from flow reg file\n\n") print(reg_list) #### this is common steps to get the information from a csv file #### for this test we only need the chassis name and fid for i in range(0, len(reg_list), 2): chass_1 = reg_list[i] target_fid = reg_list[i + 1] print("chassname is %s " % chass_1) print("target fid is %s " % target_fid) #chass_1 = reg_list[0] #target_fid = reg_list[1] #cons_info = sw_matrix_tools.console_info(chass_1) #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(chass_1) usr_pass = sw_matrix_tools.get_user_and_pass(chass_1) user_name = usr_pass[0] usr_psswd = usr_pass[1] ipaddr_switch = sw_matrix_tools.get_ip_from_file(chass_1) ###################################################################################################################### ###################################################################################################################### #### #### 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 " % target_fid) #### change to the fid given on the command firmware_ver = anturlar.fos_cmd( "firmwareshow") #### send any command with anturlar.fos_cmd flow = anturlar.FlowV() date_is = get_time_stamp() header = "%s" % ("\nFlow Regression Log \n" ) #### write a header line at top of file seperator = "%s" % ("=" * 80) write_to_results_file("\r\n\r\n", ipaddr_switch, date_is) write_to_results_file(header, ipaddr_switch, date_is) write_to_results_file(ipaddr_switch, ipaddr_switch, date_is) write_to_results_file(firmware_ver, ipaddr_switch, date_is) write_to_results_file(seperator, ipaddr_switch, date_is) write_to_results_file(seperator, ipaddr_switch, date_is) #### get the list of flows on the switch flow_all_fport = flow.get_flow_details() #### change the list to a string a = str(flow_all_fport) write_to_results_file(a, ipaddr_switch, date_is) liabhar.cls() ####################################################################################################################### ####################################################################################################################### #### #### ####################################################################################################################### cons_out = anturlar.fos_cmd( "fosexec --fid all -cmd 'flow --deact all'") cons_out = anturlar.fos_cmd("flow --deact all") cons_out = anturlar.fos_cmd( "echo y | flow --delete all -force") #### remove all flows cons_out = anturlar.fos_cmd("flow --act sys_mon_all_fports") liabhar.JustSleep(360) stats = flow.get_egr_stats("sys_mon_all_fports") liabhar.JustSleep(120) write_to_results_file(stats, ipaddr_switch, date_is) result = look_for_zero(stats) #### print the result to a file #### write_pass_fail_to_file(result, ipaddr_switch, date_is) print("@" * 80) print("#" * 80) print(result) print("#" * 80) print("@" * 80) cons_out = anturlar.fos_cmd("flow --deact all") #### find the SID DID pairs and create each monitor #### ras = re.compile('\|([0-9a-f]{1,4})\s+\|([0-9a-f]{6})\|([0-9a-f]{6})') ingr_sid_did_list = ras.findall(stats) if pa.verbose: print("LIST OF FLOWS \n") print(stats) print("regex ") print(ingr_sid_did_list) name_number = 0 for ingr_p, sid, did in ingr_sid_did_list: print(ingr_p) print(sid) print(did) print("\n") cons_out = anturlar.fos_cmd( "flow --create regress_flow_a%s -fea mon -ingrport %s -srcdev %s -dstdev %s -noact " % (name_number, ingr_p, sid, did)) cons_out = anturlar.fos_cmd( "flow --create regress_flow_b%s -fea mon -ingrport %s -dstdev %s -noact " % (name_number, ingr_p, did)) cons_out = anturlar.fos_cmd( "flow --create regress_flow_c%s -fea mon -ingrport %s -srcdev %s -noact " % (name_number, ingr_p, sid)) cons_out = anturlar.fos_cmd( "flow --create regress_flow_d%s -fea mon -ingrport %s -srcdev '*' -dstdev %s -noact " % (name_number, ingr_p, did)) cons_out = anturlar.fos_cmd( "flow --create regress_flow_e%s -fea mon -ingrport %s -srcdev %s -dstdev '*' -noact " % (name_number, ingr_p, sid)) cons_out = anturlar.fos_cmd( "flow --create regress_flow_f%s -fea mon -egrport %s -srcdev %s -dstdev %s -noact " % (name_number, ingr_p, did, sid)) cons_out = anturlar.fos_cmd( "flow --create regress_flow_g%s -fea mon -egrport %s -srcdev %s -noact " % (name_number, ingr_p, did)) cons_out = anturlar.fos_cmd( "flow --create regress_flow_h%s -fea mon -egrport %s -dstdev %s -noact " % (name_number, ingr_p, sid)) name_number += 1 flow_all = flow.get_nondflt_flows() if pa.verbose: verb_list_print(flow_all) for f in flow_all: cons_out = anturlar.fos_cmd("flow --act %s " % f) #### get the current flow #egrp_flow = flow.get_active_flows() #e = egrp_flow[0] liabhar.JustSleep(120) stats = flow.get_egr_stats(f) liabhar.JustSleep(120) write_to_results_file(stats, ipaddr_switch, date_is) result = look_for_zero(stats) #### print the result to a file #### write_pass_fail_to_file(result, ipaddr_switch, date_is) print("@" * 80) print("#" * 80) print(result) print("#" * 80) print("@" * 80) cons_out = anturlar.fos_cmd("flow --deact all") #### close the telnet session ############################# anturlar.close_tel() #### close the telnet session #liabhar.JustSleep(30) return (True)
def main(): global tn ############################################################################### #### #### #### ############################################################################### pa = parse_args(sys.argv) #print(pa) #print(pa.chassis_name) #print(pa.ipaddr) #print(pa.quiet) #print(pa.verbose) #print(pa.firmware) # print(porttype) # print("@"*40) # sys.exit() ########################################################################## ########################################################################## ### ### hold the ip address from the command line ### if pa.ipaddr: pa.chassis_name = console_info_from_ip(pa.ipaddr, pa.chassis_name) cons_info = console_info(pa.chassis_name) console_ip = cons_info[0] console_port = cons_info[1] power_pole_info = pwr_pole_info(pa.chassis_name) usr_pass = get_user_and_pass(pa.chassis_name) user_name = usr_pass[0] usr_psswd = usr_pass[1] tn = anturlar.connect_tel_noparse(pa.ipaddr,user_name,usr_psswd) fi = anturlar.FabricInfo() si = anturlar.SwitchInfo() #fcr = anturlar.FcrInfo() if pa.fabwide: ipaddr_switch = fi.ipv4_list() elif pa.csvall: ipaddr_switch = get_ip_from_file(pa.chassis_name) elif pa.fcrwide: anturlar.fos_cmd("setcontext %s" % fcr.base_check()) ipaddr_switch = fcr.fcr_fab_wide_ip() else: ipaddr_switch = [pa.ipaddr] fabric_check = fi.fabric_members() if (len(fabric_check)) < 2: print('this test requires a minimum of 2 switches in the fabric') sys.exit() trans_check = fi.zone_cfgtransshow() print(trans_check) if trans_check: print( "\n\nThere are open transaction(s). Closing them now") anturlar.fos_cmd("cfgtransabort",9) #sys.exit() all_ips = fi.ipv4_list() for item in all_ips: print(type("\n\n %s" % item)) print(item) if pa.ipaddr in all_ips: print(pa.ipaddr) all_ips = all_ips.remove(pa.ipaddr) print(all_ips) # if pa.ipaddr in all_ips: # print("Found it") # else: # print("Not there") anturlar.close_tel() sys.exit() for i in all_ips: if pa.ipaddr == i: pass else: ips = i switch1_ip = pa.ipaddr switch2_ip = all_ips[0] print(switch1_ip) print(switch2_ip) sys.exit() #print(all_ips[0]) print(ipaddr_switch) sys.exit() #ipaddr_switch = (str(ipaddr_switch)) print(type(ipaddr_switch)) print(ipaddr_switch) if ipaddr_switch in all_ips: all_ips = (all_ips.remove(ipaddr_switch)) print("222222222222222222222222") print(all_ips) anturlar.close_tel() sys.exit() #### 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) tn = anturlar.connect_tel_noparse(i,user_name,usr_psswd) #tn.set_debuglevel(9) except OSError: print("Switch %s not available" % i) nos = si.nos_check() if not nos: # all_ips = fi.ipv4_list() # print(all_ips) # fabric_check = fi.fabric_members() # if (len(fabric_check)) < 2: # print('this test requires a minimum of 2 switches in the fabric') # sys.exit() #print(fabric_check) switch1_ip = (all_ips[0]) switch2_ip = (all_ips[1]) trans_check = fi.zone_cfgtransshow() if trans_check: print( "\n\nThere are open transactions. Closing them now") anturlar.fos_cmd("cfgtransabort") anturlar.close_tel() tn = anturlar.connect_tel_noparse(i,user_name,usr_psswd) print(b) anturlar.close_tel() sys.exit() tn1 = anturlar.connect_tel_noparse(switch2_ip,user_name,usr_psswd) cfgtrans2 = anturlar.fos_cmd("cfgtransshow --opentrans") print(cfgtrans2) anturlar.close_tel(tn) anturlar.close_tel(tn1) sys.exit() #print("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") # f_ports = si.f_ports() # e_ports = si.e_ports() # print(fports) # print(eports) #sys.exit() #devices = fcr.fcr_proxy_dev() # print("XXXXXXXXXXXXXXXXXXXXXXXXXXXXX") #print(fabric_check) # 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 # 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 #### 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.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 fabric_switch_config_show(): """ document how this works here 1. Retreive a list of all of the switches in the FID passed at start of the test 2. get Flow and MAPS basic setup information 3. write to logs/fabric_info_switch.txt """ cons_out = anturlar.fos_cmd("") swtch = anturlar.SwitchInfo() fab = anturlar.FabricInfo() fab_ip_list = fab.ipv4_list() this_fid = swtch.currentFID() ############################################################################### ############################################################################### #### #### write to the file the list of IP addresses that data will be captured for #### ############################################################################### ############################################################################### fname = "%s%s" % ("logs/fabric_info_logs/fabric_info_switch", ".txt" ) #### %s string %d number ff = liabhar.FileStuff(fname, 'w+b') ff.write( "#############################################################\r\n") ff.write( "#############################################################\r\n") ff.write("\r\n") for ip in fab_ip_list: ff.write(ip) ff.write("\r\n") ff.write( "#############################################################\r\n") ff.write( "#############################################################\r\n") ff.write( "#############################################################\r\n") ff.write( "#############################################################\r\n\r\n\r\n" ) ff.close() m_info = anturlar.Maps() f_info = anturlar.FlowV() maps_config = anturlar.fos_cmd("mapsconfig --show") firmware_ver = check_version() s_name = m_info.switch_name() s_type = m_info.switch_type() ls_list = m_info.ls() switch_id = m_info.switch_id() ls_domain = m_info.ls_and_domain() chass_name = m_info.chassisname() vf_state = m_info.vf_enabled() ff = liabhar.FileStuff(fname, 'a+b') ff.write("Seed switch Info \n") ff.write( "---------------------------------------------------------------------------------\n" ) ff.write("Switch ipv4 : %s \r\n" % ip) ff.write("Chassis Name : %s \r\n" % chass_name) ff.write("Firmware version : %s \r\n" % firmware_ver) ff.write("Switch Name : %s \r\n" % s_name) ff.write("Switch Type : %s \r\n" % s_type) ff.write("VF State : %s \r\n" % vf_state) ff.write("Logical Switches : %s \r\n" % ls_list) ff.write("Switch ID : %s \r\n" % switch_id) ff.write("ls and domain : %s \r\n" % ls_domain) ############################################################################### ############################################################################### #### #### loop through each switch in the fabric and collect and write the MAPS and Flow Info #### ############################################################################### for ip in fab_ip_list: tnn = anturlar.connect_tel_noparse(ip, 'root', 'password') cons_out = anturlar.fos_cmd("setcontext %s " % this_fid) m_info = anturlar.Maps() f_info = anturlar.FlowV() maps_config = anturlar.fos_cmd("mapsconfig --show") maps_policy_list = m_info.get_policies() maps_active_policy = m_info.get_active_policy() non_dflt_policy = m_info.get_nondflt_policies() flow_names = f_info.flow_names() flows_nondflt = f_info.get_nondflt_flows() flows_active = f_info.get_active_flows() #flow_cnfg = f_info.flow_config() flow_details = f_info.get_flow_details() anturlar.close_tel() ####### ####### remove line switchname FID ?? root> ####### m_no_root = s_name + ":FID" + str(this_fid) + ":root>" m = maps_config.replace(m_no_root, '') mc = m.lstrip() #### remove leading white space ####### ####### remove line switchname FID ?? root> ####### #### #### leave as capturing data for only one FID at a time #### have a switch for all fid data #### #### seperator(ff, ip) ff.write( "---------------------------------------------------------------------\r\n" ) #ff.write("MAPS config : %s \r\n" % maps_config) ff.write( "MAPS config :\r\n") ## maps config header ff.write(mc) ## write maps config ff.write( "\n---------------------------------------------------------------------\r\n" ) ff.write("MAPS Policy List : %s \r\n" % maps_policy_list) ff.write("MAPS Active Policy : %s \r\n" % maps_active_policy) ff.write("MAPS Non Default Policy : %s \r\n" % non_dflt_policy) ff.write( "---------------------------------------------------------------------\r\n" ) ff.write("FLOW Names list : %s \r\n" % flow_names) ff.write("FLOW non dflt Flows : %s \r\n" % flows_nondflt) ff.write("FLOWs Active : %s \r\n" % flows_active) ff.write("FLOW Details : %s \r\n" % flow_details) ff.write( "---------------------------------------------------------------------\r\n" ) ff = liabhar.FileStuff(fname, 'a+b') ff.write( "#####################################################################\r\n" ) ff.write( "#####################################################################\r\n" ) ff.write("##########\r\n") ff.write( "########## FABRIC SWITCHES INFO ##########\r\n" ) ff.write("##########\r\n") ff.write( "#####################################################################\r\n" ) for ip in fab_ip_list: tnnn = anturlar.connect_tel_noparse(ip, 'root', 'password') firmware_ver = check_version() chass_name = m_info.chassisname() sf = "{0:18} {1:25} {2:25}" print(sf.format(str(ip), str(chass_name), str(firmware_ver)), file=ff) ff.write("\r\n") ff.write( "#####################################################################\r\n" ) ff.write( "#####################################################################\r\n" ) ff.write( "#####################################################################\r\n" ) ff.write( "#####################################################################\r\n" ) ff.write( "#####################################################################\r\n" ) ff.close() print("\n") print("#" * 120) print( "\nFind the results in logs/fabric_info_logs/fabric_info_switchtxt\n" ) print("#" * 120) print("\n" * 10) return (True)
def main(): global tn ####################################################################################################################### #### #### #### ####################################################################################################################### pa = parse_args(sys.argv) print(pa) #print(pa.chassis_name) print(pa.ipaddr) print(pa.quiet) print(pa.verbose) #print(pa.firmware) #print(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(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("@"*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("@"*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() su = cofra.SwitchUpdate() 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: ###New tn = anturlar.connect_tel_noparse(i, user_name, usr_psswd) except OSError: ##New print("Switch %s not available" % i) ##New nos = si.nos_check() if not nos: anturlar.fos_cmd( "supportftp -s -h 10.38.35.131 -u ftp1 -p ftp2 -d ssaves -l ftp" ) anturlar.fos_cmd("supportftp -e") anturlar.fos_cmd("supportftp -t 8") anturlar.fos_cmd( "tsclockserver 10.38.2.80; tstimezone America/Denver") #anturlar.fos_cmd("echo Y | reboot") #anturlar.fos_cmd("tsclockserver LOCL") else: print("\n" + "@" * 40) print('\nTHIS IS A NOS SWITCH> SKIPPING') print("\n" + "@" * 40) pass tn = su.reboot_reconnect() anturlar.close_tel() sys.exit()
def fabric_switch_config_show(): """ document how this works here 1. Retreive a list of all of the switches in the FID passed during start 2. get Flow and MAPS basic setup information """ cons_out = anturlar.fos_cmd("") swtch = anturlar.SwitchInfo() fab = anturlar.FabricInfo() fab_ip_list = fab.ipv4_list() this_fid = swtch.currentFID() fname = "%s%s" % ("logs/fabric_info_switch" ,".txt") #### %s string %d number ff = liabhar.FileStuff(fname, 'w+b') ff.write("#############################################################\r\n") ff.write("#############################################################\r\n") ff.write("\r\n") for ip in fab_ip_list: ff.write(ip) ff.write("\r\n") ff.write("#############################################################\r\n") ff.write("#############################################################\r\n") ff.write("#############################################################\r\n") ff.write("#############################################################\r\n\r\n\r\n") ff.close() #ff = liabhar.FileStuff(fname, 'a+b') #for ip in fab_ip_list: # tnnn = anturlar.connect_tel_noparse(ip, 'root', 'password') # firmware_ver = check_version() # # ip_firm_ver_pair = "%s %s" % ( ip,firmware_ver) # # ff.write("\r\n") # ff.write(ip_firm_ver_pair) # #ff.write("\r\n") #ff.write("#############################################################\r\n") #ff.write("#############################################################\r\n") #ff.write("#############################################################\r\n") #ff.write("#############################################################\r\n") #ff.write("#############################################################\r\n") #ff.close() m_info = anturlar.Maps() f_info = anturlar.FlowV() maps_config = anturlar.fos_cmd("mapsconfig --show") firmware_ver = check_version() s_name = m_info.switch_name() s_type = m_info.switch_type() ls_list = m_info.ls() switch_id = m_info.switch_id() ls_domain = m_info.ls_and_domain() chass_name = m_info.chassisname() vf_state = m_info.vf_enabled() ff = liabhar.FileStuff(fname, 'a+b') ff.write("Switch ipv4 : %s \r\n" % ip) ff.write("Chassis Name : %s \r\n" % chass_name) ff.write("Firmware version : %s \r\n" % firmware_ver) ff.write("Switch Name : %s \r\n" % s_name) ff.write("Switch Type : %s \r\n" % s_type) ff.write("VF State : %s \r\n" % vf_state) ff.write("Logical Switches : %s \r\n" % ls_list) ff.write("Switch ID : %s \r\n" % switch_id) ff.write("ls and domain : %s \r\n" % ls_domain) for ip in fab_ip_list: tnn = anturlar.connect_tel_noparse(ip, 'root', 'password') cons_out = anturlar.fos_cmd("setcontext %s " % this_fid) maps_policy_list = m_info.get_policies() maps_active_policy = m_info.get_active_policy() non_dflt_policy = m_info.get_nondflt_policies() flow_names = f_info.flow_names() flows_nondflt = f_info.get_nondflt_flows() flows_active = f_info.get_active_flows() #flow_cnfg = f_info.flow_config() flow_details = f_info.get_flow_details() anturlar.close_tel() ####### ####### remove line switchname FID ?? root> ####### print("\n"*4) print(maps_config) print("\n"*4) m_no_root = s_name + ":FID" + str(this_fid) + ":root>" #m_no_name = maps_config.replace(s_name ,'') #m_no_fid = m_no_name.replace(str(this_fid), '') m = maps_config.replace(m_no_root, '') print("\n"*4) print(m) print("\n"*4) ####### ####### remove line switchname FID ?? root> ####### #### #### leave as capturing data for only one FID at a time #### have a switch for all fid data #### #### seperator(ff, ip) ff.write("---------------------------------------------------------------------\r\n") #ff.write("MAPS config : %s \r\n" % maps_config) ff.write("MAPS config : \r\n %s \r\n" % m) ## maps config ff.write("---------------------------------------------------------------------\r\n") ff.write("MAPS Policy List : %s \r\n" % maps_policy_list) ff.write("MAPS Active Policy : %s \r\n" % maps_active_policy) ff.write("MAPS Non Default Policy : %s \r\n" % non_dflt_policy) ff.write("---------------------------------------------------------------------\r\n") ff.write("FLOW Names list : %s \r\n" % flow_names) ff.write("FLOW non dflt Flows : %s \r\n" % flows_nondflt) ff.write("FLOWs Active : %s \r\n" % flows_active) ff.write("FLOW Details : %s \r\n" % flow_details) ff.write("---------------------------------------------------------------------\r\n") #ff.write("FLOW CONFIG : \r\n %s \r\n" % flow_cnfg) ff = liabhar.FileStuff(fname, 'a+b') ff.write("#####################################################################\r\n") ff.write("#####################################################################\r\n") ff.write("##########\r\n") ff.write("########## FABRIC SWITCHES INFO ##########\r\n") ff.write("##########\r\n") ff.write("#####################################################################\r\n") #for ip in fab_ip_list: # tnnn = anturlar.connect_tel_noparse(ip, 'root', 'password') # firmware_ver = check_version() # m_info = anturlar.Maps() # chass_name = m_info.chassisname() # # ip_firm_ver_pair = "%s\t\t%s\t\t%s " % ( ip,chass_name,firmware_ver) # # ff.write("\r\n") # ff.write(ip_firm_ver_pair) # #ff.write("\n"*5) for ip in fab_ip_list: tnnn = anturlar.connect_tel_noparse(ip, 'root', 'password') firmware_ver = check_version() m_info = anturlar.Maps() chass_name = m_info.chassisname() sf = "{0:18} {1:25} {2:25}" print(sf.format( str(ip), str(chass_name), str(firmware_ver) ), file=ff) ff.write("\r\n") ff.write("#####################################################################\r\n") ff.write("#####################################################################\r\n") ff.write("#####################################################################\r\n") ff.write("#####################################################################\r\n") ff.write("#####################################################################\r\n") ff.close() return(True)
def main(): global tn ################################################################################################################### # # start with parsing the command line # # use the procedures parent_parser and parse_args # to determine the command line switches # ################################################################################################################### pa = parse_args() 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 start_linux_post_3_2(h, start_cmd): db_level = 9 remote_list = [] start_pain = start_cmd ################################################################################################################### #### use catapult to capture the drives and and Volumn ID -- use this if they are Clariion to not add #### the drives with LUNZ Volumn ID since they are not target IDs #### cmdout = anturlar.traff_cmd("catapult -p") ras = re.compile('[ \d]+/dev/sd([a-z]+)\s+[:0-9]+\s+[A-Z]+\s+([A-Z]+)') remove_lunz = ras.findall(cmdout) for i in [1, 2, 3, 4]: cmdout = anturlar.traff_cmd("bcu port --statsclr %s/0" % i, db_level) cmdout = anturlar.traff_cmd("bcu fcpim --lunlist %s/0" % i, db_level) ras = re.compile('/dev/sd([a-z]+)') ras = ras.findall(cmdout) print("ras" * 30) print(ras) print(remove_lunz) print(remote_list) print("ras" * 30) for r in ras: for lunz in remove_lunz: print(r) print(lunz[0]) print(lunz[1]) if lunz[0] == r and lunz[1] != "LUNZ": if r not in remote_list: remote_list += [r] cmdout = anturlar.traff_cmd("bcu port --statsclr %s/1" % i, db_level) cmdout = anturlar.traff_cmd("bcu fcpim --lunlist %s/1" % i, db_level) ras = re.compile('/dev/sd([a-z]+)') ras = ras.findall(cmdout) remote_list = remote_list + ras for r in ras: for lunz in remove_lunz: if lunz[0] == r and lunz[1] != "LUNZ": if r not in remote_list: remote_list += [r] print("remote port list : %s " % remote_list) print("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA") #### put the list is the correct syntax new_list = ",".join(remote_list) print("NEW LIST IS : %s " % new_list) #### combine the command with the drive list start_pain_sd = start_pain + ' -f"/dev/sd;%s"' % new_list print("NEWEST COMMAND %s " % start_pain_sd) reg_list = [b'([\w\d]+)'] cmdout = anturlar.fos_cmd_regex(start_pain_sd, reg_list) cmdout = anturlar.traff_output() 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 start_linux_pre_3_2(h, start_cmd): """ the command is passed into this procedure and the drive letters are added to the command if there are Clariion devices the LUNZ devices are skipped """ db_level = 9 remote_list = [] start_pain = start_cmd ################################################################################################################### #### use catapult to capture the drives and and Volumn ID -- use this if they are Clariion to not add #### the drives with LUNZ Volumn ID since they are not target IDs #### cmdout = anturlar.traff_cmd("catapult -p") ras = re.compile('[ \d]+/dev/sd([a-z]+)\s+[:0-9]+\s+[A-Z]+\s+([A-Z]+)') remove_lunz = ras.findall(cmdout) for i in [4, 2, 3, 1]: cmdout = anturlar.traff_cmd("bcu port --statsclr %s/0" % i, db_level) cmdout = anturlar.traff_cmd("bcu rport --osname %s/0" % i, db_level) ras = re.compile('/dev/sd([a-z]+)') ras = ras.findall(cmdout) print("ras" * 30) print(ras) print(remove_lunz) print(remote_list) print("ras" * 30) for r in ras: for lunz in remove_lunz: print(r) print(lunz[0]) print(lunz[1]) if lunz[0] == r and lunz[1] != "LUNZ": if r not in remote_list: remote_list += [r] cmdout = anturlar.traff_cmd("bcu port --statsclr %s/1" % i, db_level) cmdout = anturlar.traff_cmd("bcu rport --osname %s/1" % i, db_level) ras = re.compile('/dev/sd([a-z]+)') ras = ras.findall(cmdout) for r in ras: for lunz in remove_lunz: if lunz[0] == r and lunz[1] != "LUNZ": if r not in remote_list: remote_list += [r] print("remote port list : %s " % remote_list) print("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA") #### put the list is the correct syntax by adding comma new_list = ",".join(remote_list) print("NEW LIST IS : %s " % new_list) print("#" * 80) #### combine the command with the drive list start_pain_sd = start_pain + ' -f"/dev/sd;%s"' % new_list print("NEWEST COMMAND %s " % start_pain_sd) reg_list = [b'([\w\d]+)'] cmdout = anturlar.fos_cmd_regex(start_pain_sd, reg_list, 9) cmdout = anturlar.traff_output(9) 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("@"*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() su = cofra.SwitchUpdate() 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 ################################################################################################## # Manual list of switches to run suppportftp against. Entire csv list is printed out above but the # list below overwries it. # This keeps bombing on AMP switch IP (not included below). ################################################################################################## ip_no_amp = [ '10.38.36.240', '10.38.36.10', '10.38.36.33', '10.38.36.158', '10.38.36.249', '10.38.36.102', '10.38.36.246', '10.38.36.250', '10.38.36.98', '10.38.36.125', '10.38.36.25', '10.38.36.24', '10.38.36.111', '10.38.36.95', '10.38.36.85', '10.38.36.112' ] for i in ip_no_amp: 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: anturlar.fos_cmd( "supportftp -s -h 10.39.2.171 -u ftp1 -p ftp2 -d ssaves -l ftp" ) anturlar.fos_cmd("supportftp -e") anturlar.fos_cmd("supportftp -t 8") anturlar.fos_cmd( "tsclockserver 10.38.2.80; tstimezone America/Denver") anturlar.fos_cmd("echo Y | reboot") #anturlar.fos_cmd("tsclockserver LOCL") else: print("\n" + "@" * 40) print('\nTHIS IS A NOS SWITCH> SKIPPING') print("\n" + "@" * 40) pass # tn = su.reboot_reconnect() anturlar.close_tel() sys.exit()
def main(): global tn ############################################################################### #### #### #### ############################################################################### pa = parse_args(sys.argv) #print(pa) #print(pa.chassis_name) #print(pa.ipaddr) #print(pa.quiet) #print(pa.verbose) #print(pa.firmware) #print("@"*40) #sys.exit() ########################################################################## ########################################################################## ### ### hold the ip address from the command line ### if pa.ipaddr: pa.chassis_name = console_info_from_ip(pa.ipaddr, pa.chassis_name) cons_info = console_info(pa.chassis_name) console_ip = cons_info[0] console_port = cons_info[1] power_pole_info = pwr_pole_info(pa.chassis_name) usr_pass = get_user_and_pass(pa.chassis_name) user_name = usr_pass[0] usr_psswd = usr_pass[1] tn = anturlar.connect_tel_noparse(pa.ipaddr, user_name, usr_psswd) fi = anturlar.FabricInfo() si = anturlar.SwitchInfo() fcr = anturlar.FcrInfo() if pa.fabwide: ipaddr_switch = fi.ipv4_list() #print(ipaddr_switch) elif pa.csvall: ipaddr_switch = get_ip_from_file(pa.chassis_name) elif pa.fcrwide: anturlar.fos_cmd("setcontext %s" % fcr.base_check()) ipaddr_switch = fcr.fcr_fab_wide_ip() else: ipaddr_switch = [pa.ipaddr] anturlar.close_tel() #### pass ip(s)to login procedure #### and write the file for i in ipaddr_switch: tn = anturlar.connect_tel_noparse(i, user_name, usr_psswd) nos = si.nos_check() if not nos: fi = anturlar.FcrInfo() lsanzone = anturlar.fos_cmd("lsanzoneshow -s") fcrproxy = anturlar.fos_cmd("fcrproxydevshow") fcrresource = anturlar.fos_cmd("fcrresourceshow") print(lsanzone) print(fcrproxy) print(fcrresource) f1 = "%s%s%s" % ("logs/LsanZoneInfo_", pa.ipaddr, "_base.txt") a = os.path.isfile(f1) if not a: print("Not there. Capturing file now") header = "%s%s%s%s" % ("\nLsanZoneShow CAPTURE FILE \n",\ "","", "==============================\n") ff = liabhar.FileStuff( f1, 'w+b') #### open the log file for writing ff.write(header) ff.write(lsanzone) ff.write(fcrproxy) ff.write(fcrresource) sys.exit(0) else: f2 = "%s%s%s" % ("logs/LsanZoneInfo_", pa.ipaddr, "_after.txt") header = "%s%s%s%s" % ("\nLsanZoneShow CAPTURE FILE \n",\ "","", "==============================\n") ff = liabhar.FileStuff( f2, 'w+b') #### open the log file for writing ff.write(header) ff.write(lsanzone) ff.write(fcrproxy) ff.write(fcrresource) #sys.exit(0) #f0 = ("logs/LsanZoneInfo_",pa.ipaddr,"_base.txt") #f1 = ("logs/LsanZoneInfo_",pa.ipaddr,"_after.txt") diff = fcr_tools.file_diff(f1, f2) print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!") print(diff) sys.exit() #sw_dict = cofra.get_info_from_the_switch() #switch_ip = sw_dict["switch_ip"] #sw_name = sw_dict["switch_name"] #sw_chass_name = sw_dict["chassis_name"] #sw_director_or_pizza = sw_dict["director"] #sw_domains = sw_dict["domain_list"] #sw_ls_list = sw_dict["ls_list"] #sw_base_fid = sw_dict["base_sw"] #sw_xisl = sw_dict["xisl_state"] #sw_type = sw_dict["switch_type"] #sw_license = sw_dict["license_list"] #sw_vf_setting = sw_dict["vf_setting"] #sw_fcr_enabled = sw_dict["fcr_enabled"] #sw_port_list = sw_dict["port_list"] # #print("\n"*20) #print("SWITCH IP : %s " % switch_ip) #print("SWITCH NAME : %s " % sw_name) #print("CHASSIS NAME : %s " % sw_chass_name) #print("DIRECTOR : %s " % sw_director_or_pizza) #print("SWITCH DOMAINS : %s " % sw_domains) #print("LOGICAL SWITCH LIST : %s " % sw_ls_list) #print("BASE FID : %s " % sw_base_fid) #print("XISL STATE : %s " % sw_xisl) #print("SWITCH TYPE : %s " % sw_type) #print("LICENSE LIST : %s " % sw_license) #print("VF SETTING : %s " % sw_vf_setting) #print("FCR SETTING : %s " % sw_fcr_enabled) #print("PORT LIST : %s " % sw_port_list) #print("@"*40) #print("CONSOLE INFO : %s " % cons_info) #print("@"*40) #print("POWER POLE INFO : %s " % power_pole_info) #print("@"*40) #print("\nSwitch_Info has been written this file in logs/Switch_Info_%s_restore.txt\n" % switch_ip) #print("@"*40) else: print("\n" + "@" * 40) print('\nTHIS IS A NOS SWITCH> SKIPPING') print("\n" + "@" * 40) pass anturlar.close_tel() sys.exit()
def 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 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