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  #### 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)
예제 #3
0
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()
예제 #4
0
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","")
예제 #5
0
파일: birlinn.py 프로젝트: gsquire1/Python
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)
예제 #6
0
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)
예제 #7
0
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)
예제 #8
0
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()
예제 #9
0
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", "")
예제 #10
0
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)
예제 #11
0
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", "")
예제 #12
0
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)
예제 #13
0
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()