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 #### 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
###############################################################################
####
####
####
###############################################################################
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
