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
###############################################################################
####
####
####
###############################################################################
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 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 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("@"*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 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
###############################################################################
####
####
####
###############################################################################
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
###
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():
###########################################################################
#### 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 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
###############################################################################
####
####
####
###############################################################################
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("@"*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
#######################################################################################################################
####
#### start with parsing the command line
####
#### use the procedures parent_parser and parse_args
#### to determine the command line switches
####
#######################################################################################################################
pa = parse_args(sys.argv)
print(pa)
print(pa.ipaddr)
print(pa.quiet)
print(pa.verbose)
print(pa.cmdprompt)
print(pa.iterations)
#print(pa.zone_name_size)
print("@" * 40)
print("@" * 40)
#sys.exit()
#######################################################################################################################
#######################################################################################################################
####
#### if user enter ip address then get the chassisname from the
#### SwitchMatrix file
####
#### then get the info from the SwitchMatrix file using the Chassis Name
####
####
#### Type,Chassisname,IP Address,Username,Password,Console1 IP,Console1 Port,Console2 IP,Console2 Port,
#### Power1 IP,Power1 Port,Power2 IP,Power2 Port,Power3 IP,Power3 Port,Power4 IP,Power4 Port,
#### KVM IP,KVM Port,Web Username,Web Password,Admin Password
####
#######################################################################################################################
#######################################################################################################################
if pa.ipaddr:
print("do IP steps")
pa.chassis_name = sw_matrix_tools.console_info_from_ip(pa.ipaddr)
cons_info = sw_matrix_tools.console_info(pa.chassis_name)
console_ip = cons_info[0]
console_port = cons_info[1]
console_ip_bkup = cons_info[2]
console_port_bkup = cons_info[3]
power_pole_info = sw_matrix_tools.pwr_pole_info(pa.chassis_name)
usr_pass = sw_matrix_tools.get_user_and_pass(pa.chassis_name)
user_name = usr_pass[0]
usr_psswd = usr_pass[1]
ipaddr_switch = sw_matrix_tools.get_ip_from_file(pa.chassis_name)
######################################################################################################################
######################################################################################################################
####
#### connect via telnet:
#### if you want to connect to the console it is available in anturlar and an example is available below
####
####
######################################################################################################################
######################################################################################################################
#### Config_up_down_compare.main()
#cons_out = anturlar.fos_cmd("firmwareshow") #### send any command with anturlar.fos_cmd
#print("\r\n")
#liabhar.JustSleep(5) #### sleep without printing anything
#print(cons_out)
# print("now closing telnet session ")
# #anturlar.close_tel() #### close the telnet session
#######################################################################################################################
#######################################################################################################################
####
#### connect via console example and other "send command" commands
####
####
#######################################################################################################################
#######################################################################################################################
#tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,usr_psswd) #### connect to console w/o parser info
#cons_out = anturlar.fos_cmd("firmwareshow")
#cons_out = anturlar.fos_cmd("setcontext %s " % pa.fid) #### change to the fid given on the command
#tn = anturlar.connect_console(console_ip,console_port) #### use the console ip and console port info
#cons_out = anturlar.fos_cmd("switchshow") #### send a command via the console
#cons_out = cofra.power_cycle(power_pole_info) #### powercycle switch via switchmatrix.csv file
#liabhar.JustSleep(30) #### wait for the switch to boot
#cons_out = anturlar.send_cmd_console("\r\n") #### send some commands to the console
#cons_out = anturlar.send_cmd_console("setcontext %s " % pa.fid) #### send some commands to the console
#cons_out = anturlar.send_cmd_console("firmwareshow") #### send some commands to the console
#capture = cofra.cfgupload("10.38.35.131", "ftp1", "ftp2") #### send a cfgupload file to a ftp server
#liabhar.count_down(5) #### set and observe a count down timer
#######################################################################################################################
#######################################################################################################################
####
#### This starts the template for configshow output comparison (after some type of switch operation).
#### First snippet of code simply opens a connection, changes to requested fid, sends output of configshow to a file.
####
#######################################################################################################################
#######################################################################################################################
tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, usr_psswd)
cons_out = anturlar.fos_cmd("setcontext %s " % pa.fid)
dt = liabhar.dateTimeStuff(
) #### create the object for date and time stuff
date_is = dt.current_no_dash_at_end(
) #### get the current time for file naming purposes
#print("\n\nDate is %s" % date_is)
liabhar.count_down(3) #### count down to the next command
#configup_cmd = ("configupload -all -p ftp %s,%s,/configs/%s.txt,%s") % ("10.38.35.131","ftp1", ipaddr_switch, "ftp2")
f = "%s%s%s%s" % ("logs/CLITIZoneOperations_test_case_file",
"_" + ipaddr_switch + "_", date_is, ".txt")
ff = liabhar.FileStuff(f, 'w+b') #### open the log file for writing
#header = "%s%s%s%s" % ("\nNAMESERVER CAPTURE FILE \n", " sw_info ipaddr ",ipaddr_switch,"\n==============================\n\n") #### write a header line at top of file
header = "%s%s%s%s" % ("\nCLITIZoneOperations CAPTURE FILE \n",
" sw_info ipaddr ", ipaddr_switch,
"\n==============================\n\n")
ff.write(header)
ff.write(anturlar.fos_cmd("nsshow"))
ff.write(anturlar.fos_cmd("nsallshow"))
ff.close()
g = open(f, "r")
lines = g.readlines()
g.close()
ff = liabhar.FileStuff(f, 'w+b')
for l in lines:
if " date = " not in l:
ff.write(l)
ff.close() #### close this file for comparison later
#######################################################################################################################
#######################################################################################################################
####
#### do anything else you want to try (small sample of examples):
#### anturlar.fos_cmd("tsclockserver 10.38.2.80; tstimezone America/Denver")
#### anturlar.fos_cmd("cfgenable")
#### anturlar.fos_cmd("switchdisable")
#### anturlar.fos_cmd("switchenable")
####
#### In the below snippet we run tsclockerver: anturlar.fos_cmd("tsclockserver 10.38.2.80; tstimezone America/Denver")
#### Then grab output of configshow, drop into a file and compare that with original
####
#######################################################################################################################
#######################################################################################################################
# tn = cofra.clear_stats()
# print(pa.porttype)
# #sys.exit()
# porttype = pa.porttype
# print(porttype)
# PortFlapper.main(porttype)
#############################################################################################
si = anturlar.SwitchInfo()
fi = anturlar.FabricInfo()
# fabric_check = fi.fabric_members()
cfgsz = anturlar.fos_cmd("cfgsize")
# cfgshow = anturlar.fos_cmd("cfgshow")
cfgtransshow = anturlar.fos_cmd("cfgtransshow")
if "token" in cfgtransshow:
print("Outstanding transaction in progress. Use cfgtransshow to view.")
sys.exit()
# print(fabric_check)
# print(cfgsz)
# print(cfgshow)
# print(cfgtransshow)
character = "$-^_"
characters = ["$", "-", "^", "_"]
size = random.randint(0, 61)
ti_zonename = (''.join(
random.choice(string.ascii_letters + string.digits + character)
for _ in range(size)) + "_TI")
ti_zonename = "$" + ti_zonename
print(ti_zonename)
while ti_zonename[0] in character:
print("Can't have special characters at the beginning of a zone name")
ti_zonename = (''.join(
random.choice(string.ascii_letters + string.digits + character)
for _ in range(size)) + "_TI")
print(ti_zonename)
sys.exit()
# a = ("time zone --create -t ti %s -p \"1,1:2,2\"" % ti_zonename)
# print(a)
anturlar.fos_cmd("zone --create -t ti %s -p \"1,1;2,2\"" % ti_zonename)
#anturlar.fos_cmd("echo Y | cfgsave")
# anturlar.fos_cmd("echo Y | cfgsave")
# anturlar.fos_cmd("cfgshow")
sys.exit()
# f_ports = si.f_ports()
# e_ports = si.e_ports()
# print("\n\n\n\n")
# print(f_ports)
# print(e_ports)
# print("\n\n\n\n")
# if pa.porttype == "eports":
# ports = e_ports
# else:
# ports = f_ports
# i = ipaddr_switch
# try:
# tn = anturlar.connect_tel_noparse(i,user_name,usr_psswd)
# except OSError:
# print("Switch %s not available" % i)
nos = si.nos_check()
if not nos:
for i in ports:
slot = i[0]
port = i[1]
if slot:
anturlar.fos_cmd("portdisable %s/%s" % (slot, port))
liabhar.count_down(15)
anturlar.fos_cmd("portenable %s/%s" % (slot, port))
liabhar.count_down(15)
else:
anturlar.fos_cmd("portdisable %s" % (port))
liabhar.count_down(15)
anturlar.fos_cmd("portenable %s" % (port))
liabhar.count_down(15)
fabric_check1 = fi.fabric_members()
if fabric_check != fabric_check1:
print("WTF")
#email_sender_html(you, me, subj, html_to_send, htmlfile_path = "" )
liabhar.email_sender_html("*****@*****.**",
"*****@*****.**",
"NS_portflapper failed",
"NS_portflapper failed", "")
sys.exit()
anturlar.close_tel()
#return(True)
else:
print("\n" + "@" * 40)
print('\nTHIS IS A NOS SWITCH> SKIPPING')
print("\n" + "@" * 40)
pass
#anturlar.close_tel()
####################################################################################################################
#anturlar.fos_cmd("tsclockserver 10.38.2.80; tstimezone America/Denver")
#tn = cofra.ha_failover(pa.iterations)
#tn = cofra.power_cycle_iterations(power_pole_info, pa.iterations)
tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, usr_psswd)
cons_out = anturlar.fos_cmd("setcontext %s " % pa.fid)
date_is = dt.current_no_dash_at_end()
f1 = "%s%s%s%s" % ("logs/NameServer_test_case_file",
"_" + ipaddr_switch + "_", date_is, ".txt")
ff = liabhar.FileStuff(f1, 'w+b') #### reset the log file
#header = "%s%s%s%s" % ("\NAMESERVER CAPTURE FILE \n", " sw_info ipaddr ",ipaddr_switch,"\n==============================\n\n")
#header = "%s%s%s%s" % ("\nCONFIGUPLOAD CAPTURE FILE \n", " sw_info ipaddr ",ipaddr_switch, "\n==============================\n\n")
header = "%s%s%s%s" % ("\nNAMESERVER CAPTURE FILE \n",
" sw_info ipaddr ", ipaddr_switch,
"\n==============================\n\n")
ff.write(header)
ff.write(anturlar.fos_cmd("nsshow"))
ff.write(anturlar.fos_cmd("nsallshow"))
ff.close()
g = open(f1, "r")
lines = g.readlines()
g.close()
ff = liabhar.FileStuff(f1, 'w+b')
for l in lines:
if " date = " not in l:
ff.write(l)
ff.close()
diff_f = liabhar.file_diff(f, f1)
print("#" * 80)
print("#" * 80)
print("#" * 80)
print("#" * 80)
print("Result ")
print(diff_f)
liabhar.email_sender_html("*****@*****.**", "*****@*****.**",
"NS_portflapper passed", "NS_portflapper passed",
"")
return (True)
def flow_to_each_SIM():
"""
find all the SIM ports in the fabric and create a flow
from each SIM port to all the Other SIM ports
Since this test case finds all the switches in the
fabric it might not be good to run in fabric mode
steps
1. get the ip list of switches in the fabric
2. for each switch get a list of SIM ports
3. create a flow for each SIMport to all other SIM ports
4. start all of the flows if not started
5. if there are only 2 switches only send to the other switch
if there are more than 2 switches then send to a random port which
could also be on the same switch
"""
sw_info = anturlar.SwitchInfo()
fid_now = sw_info.ls_now()
cons_out = anturlar.fos_cmd(" ")
#sw_ip = sw_info.ipaddress()
f = anturlar.FabricInfo(fid_now)
ip_list = f.ipv4_list()
ip_count = len(ip_list)
ip_c = ip_count
combine_port_list = []
list_for_j = []
list_for_i = []
temp_list = []
for ip in ip_list:
anturlar.connect_tel_noparse(ip, 'root', 'password')
s = anturlar.SwitchInfo()
cons_out = anturlar.fos_cmd(" ")
cons_out = anturlar.fos_cmd("setcontext %s" % (fid_now))
ports = s.sim_ports(False)
#print("\n\n\n",ports, "\n\n\n")
#combine_port_list.append(ports)
combine_port_list = combine_port_list + ports
if ip_c == 2:
list_for_i = ports
#print("\n\n\nI list \n")
#print(list_for_i)
liabhar.count_down(10)
ip_c = 1
if ip_c == 1:
list_for_j = ports
#print("\n\n\nJ list \n")
#print(list_for_j)
liabhar.count_down(10)
flow_name_base = "Send_to_each_"
count = 0
#### need index address for simport
#### now create a flow to each simport
#print(combine_port_list)
for ip in ip_list:
anturlar.connect_tel_noparse(ip, 'root', 'password')
s = anturlar.SwitchInfo()
cons_out = anturlar.fos_cmd(" ")
cons_out = anturlar.fos_cmd("setcontext %s " % (fid_now))
cons_out = anturlar.fos_cmd(
"flow --deact sys_gen_all_simports -fea all")
#### randomize the list
#combine_port_list = liabhar.randomList(combine_port_list)
random.shuffle(combine_port_list)
j_port_list = combine_port_list
#print("\n\n\nPORT LIST RANDOMIZED \n", combine_port_list)
#print("\n\n\nNEW LIST RANDOMIZED \n", new_combine_port_list)
if len(ip_list) == 2:
#print("\n\n\nyes only two switches\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n")
liabhar.count_down(10)
random.shuffle(list_for_i)
#print("start I list ")
for i in list_for_i:
random.shuffle(list_for_j)
generate_port = i[0]
generate_addr = i[1]
#print("\n\ngenerator port and address %s %s \n\n" %(generate_port, generate_addr))
#### this loops on the same list of combined port list
#### one idea was to select a random element from the list each time
####
for j in list_for_j:
target_port = j[0]
target_addr = j[1]
#print("\n\ntarget port and address %s %s \n\n" %( target_port, target_addr))
if generate_port not in target_port:
flow_name = ("%s%s" % (flow_name_base, count))
count += 1
#print(flow_name, " " , generate_port," ", generate_addr, "to this port " ,target_port," ", target_addr)
cmd_create = "flow --create %s -srcdev %s -dstdev %s -ingrport %s -fea gen,mon" % (
flow_name, generate_addr, target_addr,
generate_port)
cons_out = anturlar.fos_cmd(cmd_create)
if "maximum limit" in cons_out:
count -= 1
break
if "Port does not" in cons_out:
break
if "PID or WWN do not" in cons_out:
break
if "Exceeds maximum flow limit" in cons_out:
count -= 1
break
temp_list = list_for_i
list_for_i = list_for_j
list_for_j = temp_list
else:
for i in combine_port_list:
random.shuffle(j_port_list)
generate_port = i[0]
generate_addr = i[1]
#### this loops on the same list of combined port list
#### one idea was to select a random element from the list each time
####
for j in j_port_list:
target_port = j[0]
target_addr = j[1]
if generate_port not in target_port:
flow_name = ("%s%s" % (flow_name_base, count))
count += 1
print(flow_name, " ", generate_port, " ",
generate_addr, "to this port ", target_port,
" ", target_addr)
cmd_create = "flow --create %s -srcdev %s -dstdev %s -ingrport %s -fea gen,mon" % (
flow_name, generate_addr, target_addr,
generate_port)
cons_out = anturlar.fos_cmd(cmd_create)
if "maximum limit" in cons_out:
count -= 1
break
if "Port does not" in cons_out:
break
if "PID or WWN do not" in cons_out:
break
if "Exceeds maximum flow limit" in cons_out:
count -= 1
break
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
###################################################################################################################
#
# start with parsing the command line
#
# use the procedures parent_parser and parse_args
# to determine the command line switches
#
###################################################################################################################
pa = parse_args()
print(pa)
print(pa.ipaddr)
print(pa.quiet)
print(pa.verbose)
print(pa.cmdprompt)
print(pa.iterations)
print(pa.porttype)
print(pa.email)
print("@" * 40)
print("@" * 40)
# sys.exit()
###################################################################################################################
###################################################################################################################
#
# if user enter ip address then get the chassisname from the
# SwitchMatrix file
#
# then get the info from the SwitchMatrix file using the Chassis Name
#
#
# Type,Chassisname,IP Address,Username,Password,Console1 IP,Console1 Port,Console2 IP,Console2 Port,
# Power1 IP,Power1 Port,Power2 IP,Power2 Port,Power3 IP,Power3 Port,Power4 IP,Power4 Port,
# KVM IP,KVM Port,Web Username,Web Password,Admin Password
#
###################################################################################################################
###################################################################################################################
if pa.ipaddr:
print("do IP steps")
pa.chassis_name = sw_matrix_tools.console_info_from_ip(pa.ipaddr)
# cons_info = sw_matrix_tools.console_info(pa.chassis_name)
# console_ip = cons_info[0]
# console_port = cons_info[1]
# console_ip_bkup = cons_info[2]
# console_port_bkup = cons_info[3]
# power_pole_info = sw_matrix_tools.pwr_pole_info(pa.chassis_name)
usr_pass = sw_matrix_tools.get_user_and_pass(pa.chassis_name)
user_name = usr_pass[0]
usr_psswd = usr_pass[1]
ipaddr_switch = sw_matrix_tools.get_ip_from_file(pa.chassis_name)
###################################################################################################################
#
# connect via telnet:
# if you want to connect to the console it is available in anturlar and an example is available below
#
#
###################################################################################################################
# Config_up_down_compare.main()
# cons_out = anturlar.fos_cmd("firmwareshow") # send any command with anturlar.fos_cmd
# print("\r\n")
# liabhar.JustSleep(5) # sleep without printing anything
# print(cons_out)
# print("now closing telnet session ")
# #anturlar.close_tel() #### close the telnet session
###################################################################################################################
#
# connect via console example and other "send command" commands
#
#
###################################################################################################################
# tn = anturlar.connect_tel_noparse(ipaddr_switch,user_name,usr_psswd) # connect to console w/o parser info
# cons_out = anturlar.fos_cmd("firmwareshow")
# cons_out = anturlar.fos_cmd("setcontext %s " % pa.fid) # hange to the fid given on the command
# tn = anturlar.connect_console(console_ip,console_port) # use the console ip and console port info
# cons_out = anturlar.fos_cmd("switchshow") # send a command via the console
# cons_out = cofra.power_cycle(power_pole_info) # powercycle switch w switchmatrix.csv file
# liabhar.JustSleep(30) # wait for the switch to boot
# cons_out = anturlar.send_cmd_console("\r\n") # end some commands to the console
# cons_out = anturlar.send_cmd_console("setcontext %s " % pa.fid) # send some commands to the console
# cons_out = anturlar.send_cmd_console("firmwareshow") # send some commands to the console
# capture = cofra.cfgupload("10.38.35.131", "ftp1", "ftp2") # send a cfgupload file to a ftp server
# liabhar.count_down(5) #### set and observe a count down timer
###################################################################################################################
###################################################################################################################
#
# This starts the template for configshow output comparison (after some type of switch operation).
# First snippet of code simply opens a connection, changes to requested fid, sends output of configshow to a
# file
###################################################################################################################
###################################################################################################################
tn = anturlar.connect_tel_noparse(ipaddr_switch, user_name, usr_psswd)
# cons_out = anturlar.fos_cmd("setcontext %s " % pa.fid)
dt = liabhar.dateTimeStuff() # create the object for date and time stuff
date_is = dt.current_no_dash_at_end() # get the current time for file naming purposes
# print("\n\nDate is %s" % date_is)
liabhar.count_down(3) # count down to the next command
# configup_cmd = ("configupload -all -p ftp %s,%s,/configs/%s.txt,%s") % ("172.16.114.67","ftp1",/
# ipaddr_switch,"ftp2")
f = "%s%s%s%s" % ("logs/Configupload_test_case_file_ORIG", "_" + ipaddr_switch + "_", date_is, ".txt")
ff = liabhar.FileStuff(f, 'w+b') # open the log file for writing
header = "%s%s%s%s" % ("\nCONFIGUPLOAD CAPTURE FILE \n", " sw_info ipaddr ", ipaddr_switch,
"\n==============================\n\n") # write a header line at top of file
ff.write(header)
ff.write(anturlar.fos_cmd("configshow"))
# ff.write("THE END")
ff.close() # close this file for comparison later
# g = open(f, "r")
# lines = g.readlines()
# g.close()
# ff = liabhar.FileStuff(f, 'w+b')
# for l in lines:
# if " date = " not in l:
# ff.write(l)
# ff.close()
##################################################################################################################
##################################################################################################################
#
# do anything else you want to try (small sample of examples):
# anturlar.fos_cmd("tsclockserver 10.38.2.80; tstimezone America/Denver")
# anturlar.fos_cmd("cfgenable")
# anturlar.fos_cmd("switchdisable")
# anturlar.fos_cmd("switchenable")
#
# In the below snippet we run tsclockerver: anturlar.fos_cmd("tsclockserver 10.38.2.80;\
# tstimezone America/Denver")
# Then grab output of configshow, drop into a file and compare that with original
#
##################################################################################################################
##################################################################################################################
# tn = cofra.clear_stats()
# print(pa.porttype)
# #sys.exit()
# porttype = pa.porttype
# print(porttype)
# PortFlapper.main(porttype)
#############################################################################################
si = anturlar.SwitchInfo()
fi = anturlar.FabricInfo()
fabric_check = fi.fabric_members()
f_ports = si.f_ports()
e_ports = si.e_ports()
print("\n\n\n\n")
print(f_ports)
print(e_ports)
print("\n\n\n\n")
if pa.porttype == "eports":
ports = e_ports
else:
ports = f_ports
# try:
# tn = anturlar.connect_tel_noparse(i,user_name,usr_psswd)
# except OSError:
# print("Switch %s not available" % i)
g = pa.iterations
while g > 0:
for i in ports:
slot = i[0]
port = i[1]
if slot:
anturlar.fos_cmd("portdisable %s/%s" % (slot, port))
liabhar.count_down(15)
anturlar.fos_cmd("portenable %s/%s" % (slot, port))
liabhar.count_down(15)
else:
anturlar.fos_cmd("portdisable %s" % port)
liabhar.count_down(15)
anturlar.fos_cmd("portenable %s" % port)
liabhar.count_down(15)
fabric_check1 = fi.fabric_members()
if fabric_check != fabric_check1:
print("WTF")
# email_sender_html(you, me, subj, html_to_send, htmlfile_path = "" )
liabhar.email_sender_html(pa.email, pa.email, "portflapper failed",
"portflapper failed", "")
anturlar.close_tel()
sys.exit(0)
else:
c = "%s%s%s%s" % ("logs/Configupload_test_case_file_COMPARE", "_" + ipaddr_switch + "_", date_is, ".txt")
cc = liabhar.FileStuff(c, 'w+b') # open the log file for writing
header = "%s%s%s%s" % ("\nCONFIGUPLOAD CAPTURE FILE \n", " sw_info ipaddr ", ipaddr_switch,
"\n==============================\n\n") # write a header line at top of file
cc.write(header)
cc.write(anturlar.fos_cmd("configshow"))
# ff.write("THE END")
cc.close()
# x = open(c, "r")
# lines = x.readlines()
# x.close()
# cc = liabhar.FileStuff(f, 'w+b')
# for l in lines:
# if " date = " not in l:
# cc.write(l)
# cc.close()
diff_f = liabhar.file_diff(f, c)
print(diff_f)
g = g - 1
print(g)
if not diff_f:
liabhar.email_sender_html(pa.email, pa.email,
"PF_configshow_compare failed a checkpoint", "PF_configshow_compare failed"
"a checkpoint. Support Save and trace dump transferred", "")
cofra.DoSupportsave("172.16.114.67", "ftp1", "ftp2", pa.chassis_name)
anturlar.close_tel()
sys.exit(0)
# diff_f = liabhar.file_diff(f, f1)
print("#" * 80)
print("#" * 80)
print("#" * 80)
print("#" * 80)
print("Result ")
print(diff_f)
liabhar.email_sender_html(pa.email, pa.email, "PF_configshow_compare passed", "PF_configshow_compare passed",
"")
return True
def main():
global tn
###############################################################################
####
####
####
###############################################################################
pa = parse_args(sys.argv)
#print(pa)
#print(pa.chassis_name)
#print(pa.ipaddr)
#print(pa.quiet)
#print(pa.verbose)
#print(pa.firmware)
#print("@"*40)
#sys.exit()
##########################################################################
##########################################################################
###
### hold the ip address from the command line
###
#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 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 chck_a():
#global tn
si = anturlar.SwitchInfo()
does_allow_xisl = si.allow_xisl()
show_all_ports = si.all_ports()
show_all_ports_fc = si.all_ports_fc_only()
base_y_n = si.base_check()
blade_8G = si.blade_search_8GB()
blades = si.blades()
blade_blank = si.blank_type()
fid_now = si.currentFID()
chass_name = si.chassisname()
dport = si.d_ports()
dflt_switch = si.default_switch()
dir_y_n = si.director()
disbled_ports = si.disabled_ports()
eports = si.e_ports()
exports = si.ex_ports()
vexports = si.vex_ports()
fports = si.f_ports()
fans = si.fan_count()
fcr_y_n = si.fcr_enabled()
gports = si.g_ports()
lic_lst = si.getLicense()
sw_ip = si.ipaddress()
lport = si.loopback()
ls_lst = si.ls()
ls_crnt = si.ls_now()
nports = si.n_ports()
pdports = si.persistent_disabled_ports()
sensors_lst_t = si.sensor_t_f_ps("t")
sensors_lst_t = si.sensor_t_f_ps("f")
sensors_lst_t = si.sensor_t_f_ps("ps")
sfpinfo = si.sfp_info()
sports = si.sim_ports()
swstate = si.switch_state()
sw_id = si.switch_id()
sw_name = si.switch_name()
sw_status = si.switch_status() ### fcr info
sw_type = si.switch_type()
sw_sync = si.synchronized()
sw_tmp = si.temp_sensors()
vf_y_n = si.vf_enabled()
#### Fabric
fi = anturlar.FabricInfo()
sid_nums = fi.sid_numbers()
sw_cnt = fi.switch_count()
ipv4_lst = fi.ipv4_list()
print("$" * 80)
print(ipv4_lst)
print("@" * 80)
ipv4_fcr = fi.ipv4_plus_fcr_list('root', 'password')
print("$" * 80)
print(ipv4_fcr)
print("@" * 80)
fab_name = fi.name()
fab_all = fi.all_info()
fab_memb = fi.fabric_members()
fab_zone = fi.zone_info()
##### FCIP info
#
fc = anturlar.FcipInfo()
fc_ge_ports = fc.all_online_ge_ports()
fc_ge_ports_dble = fc.all_ge_port_disabled()
fc_vex_ports = fc.vex_ports()
fc_ex_ports = fc.ex_ports()
fc_ge_ports = fc.ge_ports()
#### DATE TIME STUFF
####
dt = liabhar.dateTimeStuff()
crrnt_date = dt.current()
time_stamp = dt.stamp()
time_simple = dt.simple()
#### other stuff
print("\r\n" * 5)
print(crrnt_date)
print(time_stamp)
print(time_simple)
liabhar.cls()
liabhar.count_down(3)
some_string_0 = "this is to compare different text strings"
some_string_1 = "this is to compare diff erent text strings"
some_string_2 = "this is to compare different text strings"
case_1_diff = liabhar.diff_compare(some_string_0, some_string_1)
case_2_diff = liabhar.diff_compare(some_string_0, some_string_2)
print("result of case 1 diff test %s " % case_1_diff)
print("result of case 2 diff test %s " % case_2_diff)
this_pltfrm_is = liabhar.platform()
print("this platform is %s " % this_pltfrm_is)
print(liabhar.random_number())
print(liabhar.random_number_int(23))
#### COFRA
bld_port_map_info = cofra.bladeportmap_Info(3)
port_stats_0 = cofra.PortStats()
fid_to_check = "24"
fids_0 = cofra.fids_check(fid_to_check)
print("THIS IS FID CHECK %s is on the switch %s " %
(fid_to_check, fids_0))
print("Blade Port Map Info ")
print(bld_port_map_info)
print("PORT STATS ")
print(port_stats_0)
clr_stats = cofra.clear_stats()
