Document2

proc default_zone_test { } { global cl_winhost_ip_list set wwn_list [get_device_wwns] set pid_list [get_all_device_pids] set number_remote_pid [expr [llength $pid_list] - [llength $wwn_list]]

foreach pid $pid_list { if {[convert_to_dec [get_pid_alpa $pid]] == 0} { set fport_wwn [get_pid_wwn $pid] } }

if {[cause "nszonemember $fport_wwn" "[llength $wwn_list] local zoned members"] == 0} { add_status "Proper local zoned members shown for nszonemember" 3 } else { add_status "Number of local zoned members shown is not correct" 1 }

if {[cause "nszonemember $fport_wwn" "$number_remote_pid remote zoned members:"] == 0} { add_status "Proper remote zoned members shown" 3 } else { add_status "Number of remote zoned members shown is not correct" 1 }

if {[cause "defzone --show" "committed - All Access"] != 0} { add_status "Default zone with no access allready enabled" 1 }

set cfgshow_config [get_after "cfgshow" "no configuration" 1] if {([trim_string [lindex $cfgshow_config 0]]=="defined") && ([trim_string [lindex $cfgshow_config 1]]=="in effect ")} { add_status "There is no effective or defined configuration" }

do_command "defzone --noaccess" set cfgshow_config [get_after "cfgshow" "no configuration" 1] if {([llength $cfgshow_config]==1) && ([trim_string [lindex $cfgshow_config 0]]=="in effect")} { add_status "Default zone is shown in defined configuration" } else { add_status "cfgshow doesn't display proper default zone after configuring noaccess" 1 }

if {[trim_string [get_after "defzone --show" "transaction - "]] == "No Access"} { add_status "proper transaction is shown with defzone --show option" 3 } else { add_status "proper transaction is not shown with defzone --show" 1 }

retry_command "cfgsave"

if {[get_after "defzone --show" "committed - "]!="No Access"} { add_status "Default zone show not displaying proper access" 3 }

if {[cause "cfgshow" "no configuration"] == 0} { add_status "Improper display of cfgshow" 1 } else { add_status "cfgshow on saving default zone is shown properly" 3 }

set nszone_mem [get_before "nszonemember $fport_wwn" "zoned members" 1] if {([trim_string [lindex $nszone_mem 0]]=="No local") && ([trim_string [lindex $nszone_mem 1]]=="No remote")} { add_status "Proper display of nszone membership after default no access" }

sleep 30

if {([info exists cl_winhost_ip_list])&&([lindex $cl_winhost_ip_list 0]!="")} { get_inq_device_count [lindex $cl_winhost_ip_list 0] 0 }

do_command "defzone --allaccess"

retry_command "cfgsave"

if {[cause "defzone --show" "committed - All Access"] != 0} { add_status "Default zone is not set to all access" 1 }

set cfgshow_config [get_after "cfgshow" "no configuration" 1] if {([trim_string [lindex $cfgshow_config 0]]=="defined") && ([trim_string [lindex $cfgshow_config 1]]=="in effect ")} { add_status "There is no effective or defined configuration" } }

########################################################################### ## NAME ##

transaction_test -tests zone transcation buffer property

## ## SYNOPSIS ##

transaction_test

## ## DESCRIPTION ##

Tests transcation buffer test property

## ## OPERANDS ##

NONE

## ## DEPENDENCIES ##

NONE

## ## RETURN ##

NONE

## ## USAGE ##

transaction_test

################################################################### proc transaction_test { } { do_command "zonecreate \"zone_trans\",\"239,1\"" if {[count_number "cfgshow" "zone_trans"] == 1} { add_status "Created zone with zone_trans" 3 } else { add_status "zone creation failed" 1 }

if {[cause "cfgtransshow" "Current transaction token is"] == 0} { add_status "Zoning transaction is available" 3 } else { add_status "Zoning transaction failed" 1 } set trans_size [trim_string [get_after "cfgsize" "transaction -"]]

if {$trans_size >0} { add_status "Transaction size is greater than zero its $trans_size" 3 } else { add_status "Transaction size is wrong" 1 }

if {[cause "cfgtransabort" "Zoning transaction aborted"] == 0} { add_status "zoning transaction aborted successfully" 3 } else { add_status "zoning transaction abort failed" 1 }

if {[count_number "cfgshow" "zone_trans"] == 0} { add_status "zonecreation properly aborted" 3 } else { add_status "Zone creation didn't abort" 1 } } ########################################################################### ## NAME ##

verify_zones - verify that the zone is propogated properly in the fabric

## ## SYNOPSIS ## ##

verify_zones

## DESCRIPTION ##

This procedure verifies zone configuration propogation in the fabric

## also returns the members of this zone ## ## OPERANDS ##

zone_name: name of the zone whose members needs to be checked

##

status: Checks Effective/Defined configuration based on input

##

user_ad_list: username, password and admindomain

##

ip_list: ipaddress of the fabric that needs to be checked for zone propogation

##

If nothing is specified it takes ipaddress from cl_ip_address_list

## ## DEPENDENCIES ## ## RETURN ##

member list of the zone specified

## ## USAGE ##

verify_zone zone_first Effective

##

--> {10:00:00:00:c9:2b:9d:35 22:00:00:04:cf:03:4c:fa}

## ################################################################### proc verify_zones {zone_name status {user_ad_list "admin password"} {ip_list ""}} { # Store the original ip address for login back to same spawn global cl_ip_address_list global cl_ip_address

global spawn_id set username [lindex $user_ad_list 0] set pwd [lindex $user_ad_list 1] set ad [lindex $user_ad_list 2] set orig_spawn_id $spawn_id

set orig_ip_address $cl_ip_address set status [string toupper $status] if {$ip_list==""} { set ip_list $cl_ip_address_list } # set ip_list [get_fabric_ips] foreach ip $ip_list { if {$ip!=$orig_ip_address} { if {[telnet_switch $ip $username $pwd] != 0} { add_status "Telnet to switch $ip failed" 0 } } elseif {[set_spawn_id $ip] != 0} { if {[telnet_switch $ip $username $pwd] != 0} { add_status "Telnet to switch $ip failed" 0 } }

if {$ad !=""} {

ad_select $ad }

retry_command "cfgshow" # Checks the Effective configuration for zone's if {$status=="EFFECTIVE"} { set cfgshow_output [get_command "cfgshow"] set cfgshow_string1 [regexp {Effective configuration:(.*)} $cfgshow_output cfgshow_string] } # Checks the Defined configuration for zone's if {$status =="DEFINED"} { set cfgshow_string [get_between "cfgshow" "Defined configuration:" "Effective configuration:|Type <CR> to continue "] } # Spliting the cfgshow by new line character if {$status=="EFFECTIVE"} { set cfgshow_list [split $cfgshow_string "\r\n"] set lengt [expr [llength $cfgshow_list] - 2] set cfgshow_list [lrange $cfgshow_list 0 $lengt] } else { set cfgshow_list [split $cfgshow_string "\r\n"] } # Variable that needs to be passed set members_list ""

set first_line "" for {set i 0} {$i<[llength $cfgshow_list]} {incr i} { set cfgshow_line [lindex $cfgshow_list $i] #

Search for zone expression in each of cfgshow line if {[regexp {(.*)ne:(.*)} $cfgshow_line cfgshow_zone]} { if {[lsearch $cfgshow_zone $zone_name]!=-1} { for {set j 2} {$j<[llength $cfgshow_zone]} {incr j} { append first_line [lindex $cfgshow_zone $j] } if {$first_line!=""} { lappend members_list $first_line } while {$i< [expr [llength $cfgshow_list]-1]} { incr i set cfgshow_line [lindex $cfgshow_list $i] if {[llength $cfgshow_line]==0} { continue; } #Check if next zone, alias, config has started if so exit if {[regexp {(.*)ne:(.*)|(.*)as:(.*)|(.*)fg:(.*)} $cfgshow_line kk]} { break; } lappend members_list $cfgshow_line } }

} } set members_string [join $members_list ";"] set members_list [split $members_string ";"] set final_member_list "" foreach member $members_list { set final_member [string trim $member] if {[regexp {[a-zA-Z0-9:,-_]+} $final_member t]} { lappend final_member_list $final_member } } lappend zone_list $final_member_list if {$ip!=$orig_ip_address} { end_telnet "exit" } }

#

Check whether zone is propogated properly through out the fabric through compare list set zone_member1 [lindex $zone_list 0] foreach zone_member $zone_list { set compare_result [compare_lists [lsort $zone_member1] [lsort $zone_member]] if {$compare_result != ""} {

add_status "zone configuration is not propogated properly through out fabric $compare_result" 1 } }

if {[set_spawn_id $orig_spawn_id] != 0} { if {[telnet_switch $orig_ip_address $username $pwd] != 0} { add_status "Telnet to switch $orig_ip_address failed" 0 } } return $zone_member1 }

############################################################################## ## ## NAME ##

create_zone - create zone based on key and list provided

## ## SYNOPSIS ##

create_zone

## ## DESCRIPTION ##

This procedure will create zone based on the list provided

##

with zonename as zone_$key and configuration as cfg_$key if configuration

##

argument is set then only creation of zone happens.

##

If key is given as lsan_* then zone is not appended as this is requirement

##

for FCR testing which need zones to start with lsan_*

## ## OPERANDS ##

key: string used to create zone and configuration

##

zonelist: list of devices that needs to be part of zone

##

configuration: If any value is given to this argument,

##

only zone creation gets executed, creation of zone configuration

##

and enabling is ommitted.o

## DEPENDENCIES ## ## RETURN ##

NONE

## ## USAGE ##

create_zone first {4,5 6,7}

## ################################################################### proc create_zone {key zonelist {configuration ""} {enable ""}} {

if {[regexp -nocase {^qos|^lsan} $key]} { set zone_name $key } else { set zone_name zone_$key } set cfg_name cfg_$key set zonestring [join $zonelist ";"] set zonestring [trim_string $zonestring] do_command "zonecreate \"$zone_name\", \"$zonestring\"" do_command "zoneshow"

do_command "cfgshow" do_command "cfgsave" if {$configuration == ""} { retry_command "cfgcreate \"$cfg_name\",\"$zone_name\"" do_command "zoneshow" do_command "cfgshow" retry_command "cfgsave" sleep 20 if {$enable == ""} { retry_command "cfgenable $cfg_name" } } sleep 20 } ############################################################################## ## ## NAME ##

add_zone - add members to existing zone

## ## SYNOPSIS ##

add_zone

## ## DESCRIPTION ##

This procedure will add members to existing zone

## ## OPERANDS

##

key: string used to create zone and configuration

##

zonelist: list of devices that needs to be part of zone

## ## DEPENDENCIES ## ## RETURN ##

NONE

## ## USAGE ##

add_zone first {4,5 6,7}

## ################################################################### proc add_zone {key zonelist} { if {[regexp -nocase {^qos|^lsan} $key]} { set zone_name $key } else { set zone_name zone_$key } set cfg_name cfg_$key set zonestring [join $zonelist ";"] do_command "zoneadd \"$zone_name\",\"$zonestring\"" do_command "zoneshow" do_command "cfgshow" retry_command "cfgsave" sleep 20

}

############################################################################## ## ## NAME ##

remove_zone - remove members from existing zone

## ## SYNOPSIS ##

remove_zone

## ## DESCRIPTION ##

This procedure will remove zone members from existing zone

## ## OPERANDS ##

key: string used to create zone and configuration

##

zonelist: list of devices that needs to be part of zone

## ## DEPENDENCIES ## ## RETURN ##

NONE

## ## USAGE ##

remove_zone first {4,5 6,7}

## ###################################################################

proc remove_zone {key zonelist} { if {[regexp -nocase {^qos|^lsan} $key]} { set zone_name $key } else { set zone_name zone_$key } set cfg_name cfg_$key set zonestring [join $zonelist ";"] do_command "zoneremove \"$zone_name\",\"$zonestring\"" do_command "zoneshow" do_command "cfgshow" retry_command "cfgsave" sleep 20 }

########################################################################### ## NAME ##

failover_with_zonecfg - failover of coreswitch with zone cofiguration

## ## SYNOPSIS ##

failover_with_zonecfg

## ## DESCRIPTION ##

This procedure does hafailover if switch is bladed

## else it does hareboot

## ## OPERANDS ##

NONE

## ## DEPENDENCIES ## ## RETURN ##

NONE

## ## USAGE ##

failover_with_zonecfg

###################################################################

proc failover_with_zonecfg { } { global cl_ip_address cl_zvm_build if {[info exists cl_zvm_build] && $cl_zvm_build == 1} { brcd_login $cl_ip_address do_command "hadisable" do_command "cd /fabos/bin" do_command "./zvmk-tgt -cov" 300 do_command "./zvmk-tgt -leak" 300 do_command "haenable" wait_for_ha_sync } if {[get_switch_platform] < 12000 } {

do_command "hareboot" sleep 120 close_spawn_list "exit" } else { if {[cause "hashow" "ync"] != 0} { add_status "HA State is NOT on Sync. Exiting.... " 0 } else { add_status " HA State is in Sync" } set chk1 [get_hastate] set firstroundCP [get_ActiveCP]

if {[get_ActiveCP] == 2} { do_command "hashow" add_status "HA is DISABLED on this system, exiting the script" 0 } do_command "hafailover" 180 set Timer 10 while {[cause "hashow" "ync" 30 1] != 0} { add_status "Not synchronized yet..." 3 set Timer [expr $Timer - 1] if {$Timer == 0} { add_status "CP failed to synchronize" 1 break }

sleep 30 }

if {[get_hastate] == 0} { do_command "hashow" add_status "After failover, system has only ONE cp or HA is disabled, exiting the script" 0 } } }

########################################################################### ## NAME ##

get_number_devices - get the number of devices based on zone string

## ## SYNOPSIS ##

get_number_devices

## ## DESCRIPTION ##

This procedure parses the zonestring and finds out number of

## devices(targets) participating in the zone ## ## OPERANDS ##

zone_string: zone member list that will be used to find the number of

## targets visiblie through host ##

## DEPENDENCIES ## COPA needs to be installed on the host ## ## RETURN ##

0: on success

##

-1: on failure

## ## USAGE ##

get_number_devices 1,3 3,4

##

--> 4 (4 target visible through host)

## ################################################################### proc get_number_devices {zone_string} { global array fportlist global array lportlist global cl_ip_address_list

set device_count 0 foreach dev $zone_string { foreach ip $cl_ip_address_list { if {$lportlist($ip)!=""} { if {[regexp {([0-9]+,[1-9]+)} $dev]} { set index [lsearch $lportlist($ip) $dev] if {$index!=-1} { incr device_count [llength [lindex $lportlist($ip) [expr $index +1]]]

} } else { for {set j 1} {$j<[llength $lportlist($ip)]} {incr j 2} { if {[lsearch [lindex $lportlist($ip) $j] $dev] != -1} { incr device_count } } } } } } # add_status "Device count $device_count" return $device_count }

########################################################################### ## NAME ##

get_all_remote_devices

## ## SYNOPSIS ##

get_number_devices

## # DESCRIPTION ## Get all the remote devices pids ##

## OPERANDS ## NONE ## ## DEPENDENCIES ## get_remote_devices ## ## RETURN ## Give the PID of remote devices ## ## USAGE ##

get_all_remote_devices

## ################################################################### proc get_all_remote_devices {{domain_ -1}} { set return_value "" set temp_list [get_remote_devices]

if {$domain_ < 0} { set return_value $temp_list } else { foreach item $temp_list { set item_domain [convert_to_dec [get_pid_domain [lindex $item 0]]] if {$domain_ == $item_domain} { set return_value [lappend return_value $item] }

} } return $return_value }

########################################################################### ## NAME ##

get_all_remote_device_wwns

## ## SYNOPSIS ##

get_all_remote_device_wwns

## ## DESCRIPTION ##

SDK Routine

## ## OPERANDS ## ## DEPENDENCIES ## ## RETURN ## ## USAGE ##

get_all_remote_device_wwns

## #############################################################

proc get_all_remote_device_wwns {{wwn_type_ "port"} {domain_ -1}} { set return_value ""

if {$wwn_type_ == "port"} { set wwn_type_ 1 } else { set wwn_type_ 2 }

set temp_list [get_all_remote_devices $domain_] if {$temp_list != ""} { foreach item $temp_list { set return_value [lappend return_value [lindex $item $wwn_type_]] } }

return $return_value } ########################################################################### ## NAME ##

check_device_presence - check device presence through nsshow, nscamshow

## and nsallshow ## ## SYNOPSIS ##

check_device_presence

## ## DESCRIPTION ##

This procedure does nsshow and check whether device is present

## then it telnet's to switches in the fabric, checks the devices presence ## through nscamshow ## ## OPERANDS ##

wwn_list: wwn_list that needs to be checked through nsshow and nscamshow

##

user_ad_list: username, password and admindomain

##

ip_list: List of ip address that needs to be traversed for checking nameserver

##

entries. If nothing is given it takes cl_ip_address_list as default

## ## DEPENDENCIES ## get_device_wwns # get_all_device_pids ## ## RETURN ## ## USAGE ##

check_device_presence {21:00:00:04:cf:03:10:10 21:00:00:04:cf:03:51:38}

## ################################################################### proc check_device_presence {wwn_list {user_ad_list "admin password"} {ip_list ""}} { global cl_ip_address_list cl_ip_address global spawn_id

set orig_ip_address $cl_ip_address set username [lindex $user_ad_list 0] set pwd [lindex $user_ad_list 1] set ad [lindex $user_ad_list 2] set orig_spawn_id $spawn_id

##

Checking the availability of device through nsshow

set ns_wwn_list [get_device_wwns] set pid_list [lsort [get_all_device_pids]] # add_status "PID's from nsallshow : $pid_list" 3

# add_status "wwn's got through nsshow $ns_wwn_list" 3 foreach wwn $wwn_list { if {[lsearch $ns_wwn_list $wwn]== -1} { add_status "Could not find WWN $wwn through nsshow on switch $orig_ip_address" 1 } }

# set ip_list [get_fabric_ips] if {$ip_list==""} { set ip_list $cl_ip_address_list }

## Checking the availability of device through nscamshow foreach ip $ip_list {

if {$ip!=$orig_ip_address} { if {[telnet_switch $ip $username $pwd] != 0} { add_status "Telnet to switch $ip failed" 0 } if {$ad !=""} { ad_select $ad } set ns_wwn_list [get_device_wwns] set ns_remote_wwn_list [get_all_remote_device_wwns] foreach wwn $wwn_list { if {[lsearch $ns_remote_wwn_list $wwn]== -1} { add_status "Could not find WWN $wwn through nscamshow on switch $ip" 1 } }

## Checking the nsallshow it should be same within the fabric set compare_result [compare_lists $pid_list [lsort [get_all_device_pids]]] if {$compare_result != ""} { add_status "nsallshow did not match: $compare_result" 1 } end_telnet "exit" } } if {[set_spawn_id $orig_spawn_id] != 0} { if {[telnet_switch $orig_ip_address $username $pwd] != 0} {

add_status "Telnet to switch $orig_ip_address failed" 0 } } }

########################################################################### ## NAME ##

check_device_absence - check for device absence in name server

## ## SYNOPSIS ##

check_device_absence

## ## DESCRIPTION ##

This procedure does nsshow and checks for device absence,

## then it telnet's to switches in the fabric, checks the devices ## is not shown remotly through nscamshow ## ## OPERANDS ## ## ## ##

wwn_list: wwn_list that needs to be checked through nsshow and nscamshow user_ad_list: username, password and admindomain ip_list: List of ip address that needs to be traversed for checking nameserver entries. If nothing is given it takes cl_ip_address_list as default

## ## DEPENDENCIES ## get_device_wwns

# get_all_device_pids ## ## RETURN ## ## USAGE ##

check_device_absence {21:00:00:04:cf:03:10:10 21:00:00:04:cf:03:51:38}

## ################################################################### proc check_device_absence {wwn_list {user_ad_list "admin password"} {ip_list ""}} { global cl_ip_address_list cl_ip_address global spawn_id set orig_ip_address $cl_ip_address set username [lindex $user_ad_list 0] set pwd [lindex $user_ad_list 1] set ad [lindex $user_ad_list 2] set orig_spawn_id $spawn_id

## Checking the availability of device through nsshow set ns_wwn_list [get_device_wwns] # add_status "Got wwn list is $wwn_list" 3 # add_status "wwn's got through nsshow $ns_wwn_list" 3 foreach wwn $wwn_list { if {[lsearch $ns_wwn_list $wwn]!= -1} { add_status "WWN $wwn found through nsshow on switch $orig_ip_address" 1 }

}

## Checking the availability of device through nscamshow #set ip_list [get_fabric_ips] if {$ip_list==""} { set ip_list $cl_ip_address_list }

foreach ip $ip_list { if {$ip!=$orig_ip_address} { #

if {[set_spawn_id $ip] != 0} { if {[telnet_switch $ip $username $pwd] != 0} { add_status "Telnet to switch $ip failed" 0 }

#

} if {$ad !=""} { ad_select $ad } set ns_wwn_list [get_device_wwns]

#

add_status "wwn's got through nsshow on switch $ip is $ns_wwn_list" set ns_remote_wwn_list [get_all_remote_device_wwns]

#

add_status "NS WWN List in switch $ip is $ns_remote_wwn_list" 3 foreach wwn $wwn_list { if {[lsearch $ns_remote_wwn_list $wwn]!= -1} { add_status "WWN $wwn found through nscamshow on switch $ip" 1

} } end_telnet "exit" } } if {[set_spawn_id $orig_spawn_id] != 0} { if {[telnet_switch $orig_ip_address $username $pwd] != 0} { add_status "Telnet to switch $orig_ip_address failed" 0 } } } ########################################################################### ## NAME ##

clear_zonecfg - disables and clears the zone configuration

## ## SYNOPSIS ##

clear_zonecfg

## ## DESCRIPTION ##

This procedure disables and clears all the zone confiuration

## ## OPERANDS ## NONE ## ## DEPENDENCIES

## NONE ## ## RETURN ## NONE ## ## USAGE ##

clear_zonecfg

## ############################################################################# proc clear_zonecfg { } { retry_command "cfgdisable" sleep 30 retry_command "cfgclear" retry_command "cfgsave" sleep 30 retry_command "cfgshow" }

########################################################################### ## NAME ##

reinitialize_device_array - reinitializes the device array

## ## SYNOPSIS ## ##

reinitialize_device_array

## DESCRIPTION ##

This procedure reinitializes the device array by calling nsallshow

## ## OPERANDS ##

NONE

## ## DEPENDENCIES ## get_devices -sdk routing ## ## RETURN # NONE ### ## USAGE ##

reinitialize_device_array

## ################################################################### proc reinitialize_device_array { } { global array fportlist global cl_ip_address global array lportlist set local_device_list [get_devices] set fportlist($cl_ip_address) "" set lportlist($cl_ip_address) "" for {set i 0} {$i<[llength $local_device_list]} {incr i} { set pid [lindex [lindex $local_device_list $i] 0]

set loop [string range [lindex [lindex $local_device_list $i] 0] 4 5] set domain [convert_to_dec [string range [lindex [lindex $local_device_list $i] 0] 0 1]] set dp "" if {$loop==00} { append dp $domain,[convert_to_dec [string range [lindex [lindex $local_device_list $i] 0] 2 3]] lappend fportlist($cl_ip_address) $dp lappend fportlist($cl_ip_address) [lindex [lindex $local_device_list $i] 1] } set dp "" if {$loop!=00} { set domain [convert_to_dec [string range [lindex [lindex $local_device_list $i] 0] 0 1]] append dp $domain,[convert_to_dec [string range [lindex [lindex $local_device_list $i] 0] 2 3]] lappend lportlist($cl_ip_address) [list $dp] set templist [list [lindex [lindex $local_device_list $i] 0]] set wwnlist [list [lindex [lindex $local_device_list $i] 1]] for {set j [expr $i+1]} {$j<=[llength $local_device_list]} {incr j; incr i} { set next_pid [lindex [lindex $local_device_list $j] 0] set first_domainarea [string range [lindex $templist 0] 0 3] set next_domainarea [string range $next_pid 0 3] if {$first_domainarea==$next_domainarea} { lappend templist [lindex [lindex $local_device_list $j] 0] lappend wwnlist [lindex [lindex $local_device_list $j] 1] } else { break;

} } lappend lportlist($cl_ip_address) $wwnlist } } }

########################################################################### ## NAME ##

initialize_device_array - Initialize the device array list

## ## SYNOPSIS ## initialize_device_array ## ## DESCRIPTION ## Initialize the device array using nsallshow, output is population ##

of global array fport and lport list with ipaddress as index

##

ip_list: IP's of switch whose device information needs to be gathered.

##

If not defined cl_ip_address_list is taken as default

## ## OPERANDS ## ip_list(optional) ## ## DEPENDENCIES ## get_all_devices

## get_fabricshow_info ## ## RETURN ## NONE ## ## USAGE ##

initialize_device_array

###############################################################

proc initialize_device_array {{ip_list ""} } { global array fportlist global array lportlist global cl_ip_address_list

if {$ip_list == ""} { set ip_list $cl_ip_address_list }

foreach ip $ip_list { set fportlist($ip) "" set lportlist($ip) "" }

set all_devices [get_all_devices] set fabric_info [get_fabricshow_info]

foreach switch_info $fabric_info { lappend domain_iplist [lindex $switch_info 0] lappend domain_iplist [lindex $switch_info 2] } add_status "IP Address list $domain_iplist" 3 for {set i 0} {$i<[llength $all_devices]} {incr i} { set pid [lindex [lindex $all_devices $i] 0] set loop [string range [lindex [lindex $all_devices $i] 0] 4 5] set domain [convert_to_dec [string range [lindex [lindex $all_devices $i] 0] 0 1]] set dp "" if {$loop=="00" || $loop=="c0" || $loop=="40" || $loop=="80"} { append dp $domain,[convert_to_dec [string range [lindex [lindex $all_devices $i] 0] 2 3]] set index [lsearch $domain_iplist $domain] set ip [lindex $domain_iplist [expr $index + 1]] lappend fportlist($ip) $dp lappend fportlist($ip) [lindex [lindex $all_devices $i] 1] } set dp "" if {$loop!=00} { append dp $domain,[convert_to_dec [string range [lindex [lindex $all_devices $i] 0] 2 3]] set index [lsearch $domain_iplist $domain] set ip [lindex $domain_iplist [expr $index + 1]] lappend lportlist($ip) [list $dp] set templist [list [lindex [lindex $all_devices $i] 0]] set wwnlist [list [lindex [lindex $all_devices $i] 1]]

for {set j [expr $i+1]} {$j<=[llength $all_devices]} {incr j; incr i} { set next_pid [lindex [lindex $all_devices $j] 0] set first_domainarea [string range [lindex $templist 0] 0 3] set next_domainarea [string range $next_pid 0 3] if {$first_domainarea==$next_domainarea} { lappend templist [lindex [lindex $all_devices $j] 0] lappend wwnlist [lindex [lindex $all_devices $j] 1] } else { break; } } lappend lportlist($ip) $wwnlist } } }

########################################################################### ## NAME ## initialize_pid_db ## ## SYNOPSIS ## initialize_pid_db ## ## DESCRIPTION ## initialize PID database using nsshow and nscamshow

## ## OPERANDS ##

NONE

## ## DEPENDENCIES ##

SDK Routing get_all_devices

## ## RETURN ##

NONE

## ## USAGE ##

initialize_pid_db

## ################################################################### proc initialize_pid_db {} { global array wwn_pid_list set dev_data [get_all_devices] foreach device $dev_data { set wwn_pid_list([lindex $device 1]) [lindex $device 0] } }

########################################################################### ## NAME ## get_wwn_pid_db

## ## SYNOPSIS ## get_wwn_pid_db ## ## DESCRIPTION ## get PID for give wwn through database ## ## OPERANDS ##

NONE

## ## DEPENDENCIES ##

initialize_pid_db should have been called earlier

## ## RETURN ##

NONE

## ## USAGE ##

get_wwn_pid_db

## ###################################################################

proc get_wwn_pid_db {wwn} { global array wwn_pid_list return $wwn_pid_list($wwn) }

proc check_cfg {zone} { set boolean 0 foreach tmp_zone $zone { if {$boolean == 0} { do_command "cfgcreate \"tmp_config\", \"$tmp_zone\"" set boolean 1 } else { do_command "cfgadd \"tmp_config\", \"$tmp_zone\"" } } do_command "cfgenable \"tmp_config\""

set member_list [get_zone_object_members "cfg" "tmp_config"] foreach tmp $member_list { foreach tmp_zone $zone { if {$tmp == $tmp_zone} { add_status "tmp_config was created with zone $tmp_zone" 3 } } }

set check_tmp_cfg [trim_string [get_after "cfgshow" "Effective conf(.*)cfg:"]]

if {$check_tmp_cfg == "tmp_config"} {

add_status "tmp_config is effective" } else { add_status "tmp_config was not made effective" 1 } }

proc get_alias_wwnport {wwnport_list alias_list} { set ret_list "" for {set i 0} {$i < [llength $wwnport_list]} {incr i 1} { foreach element [lindex $wwnport_list $i] { foreach tmp $alias_list { if {[lindex $element 0] == $tmp} { lappend ret_list [lindex $element 1] } } } } return $ret_list } ############################################################################## ### ## NAME ##

create_dummy_zone

## ## SYNOPSIS ##

create_dummy_zone

## ## DESCRIPTION ##

Create dummy zone as part of defined zone configuration

## ## OPERANDS ##

None.

## ## DEPENDENCIES ##

None.

## ## RETURN ##

None.

## ## USAGE ## create_dummy_zone ############################################################################## ### proc create_dummy_zone {} { for {set i 25} {$i<35} {incr i} { for {set j 0} {$j<10} {incr j} { append zone_list "21:00:00:0$j:00:00:1c:$i" " " } } set zonestring [join $zone_list ";"]

for {set i 108} {$i<118} {incr i} {

for {set j 0} {$j<10} {incr j} { append zone_list1 "$i,$j" " " } } set zonestring1 [join $zone_list1 ";"]

for {set i 1} {$i<50} {incr i} { do_command "zonecreate \"dummyzone_$i\", \"$zonestring\"" } for {set i 51} {$i<100} {incr i} { do_command "zonecreate \"dummyzone_$i\", \"$zonestring1\"" } do_command "cfgshow" retry_command "cfgsave" sleep 30 }

########################################################################### ## NAME ##

verify_zones_vf - verify that the zone is propogated properly in the fabric in LS context

## ## SYNOPSIS ##

verify_zones_vf

## ## DESCRIPTION

##

This procedure verifies zone configuration propogation in the fabric

## also returns the members of this zone ## ## OPERANDS ##

zone_name: name of the zone whose members needs to be checked

##

status: Checks Effective/Defined configuration based on input

##

fid : LS fid

##

user_ad_list: username and password

##

ip_list: ipaddress of the fabric that needs to be checked for zone propogation

##

If nothing is specified it takes ipaddress from cl_ip_address_list

## ## DEPENDENCIES ## ## RETURN ##

member list of the zone specified

## ## USAGE ##

verify_zones_vf zone_first Effective

##

--> {10:00:00:00:c9:2b:9d:35 22:00:00:04:cf:03:4c:fa}

## ################################################################### proc verify_zones_vf {zone_name status {fid "128"} {user_ad_list "root fibranne"} {ip_list ""}} { # Store the original ip address for login back to same spawn global cl_ip_address_list global cl_ip_address

global spawn_id set username [lindex $user_ad_list 0] set pwd [lindex $user_ad_list 1] set orig_spawn_id $spawn_id

set orig_ip_address $cl_ip_address set status [string toupper $status] if {$ip_list==""} { set ip_list $cl_ip_address_list } foreach ip $ip_list { if {$ip!=$orig_ip_address} { if {[telnet_switch $ip $username $pwd] != 0} { add_status "Telnet to switch $ip failed" 0 } } elseif {[set_spawn_id $ip] != 0} { if {[telnet_switch $ip $username $pwd] != 0} { add_status "Telnet to switch $ip failed" 0 } }

if {($fid != 128) && ([is_vf_enabled] == 0)} { setcontext_fid $fid } retry_command "cfgshow"

# Checks the Effective configuration for zone's if {$status=="EFFECTIVE"} { set cfgshow_output [get_command "cfgshow"] set cfgshow_string1 [regexp {Effective configuration:(.*)} $cfgshow_output cfgshow_string] set cfgshow_list [lrange [compress_list [split $cfgshow_string "\r\n"] ] 0 end-1] } # Checks the Defined configuration for zone's if {$status =="DEFINED"} { set cfgshow_string [get_between "cfgshow" "Defined configuration:" "Effective configuration:|Type <CR> to continue"] set cfgshow_list [compress_list [split $cfgshow_string "\r\n"] ] } # Variable that needs to be passed set members_list "" set first_line "" for {set i 0} {$i<[llength $cfgshow_list]} {incr i} { set cfgshow_line [lindex $cfgshow_list $i] # Search for zone expression in each of cfgshow line if {[regexp {(.*)ne:(.*)} $cfgshow_line cfgshow_zone]} { if {[lsearch $cfgshow_zone $zone_name]!=-1} { for {set j 2} {$j<[llength $cfgshow_zone]} {incr j} { append first_line [lindex $cfgshow_zone $j] } if {$first_line!=""} { lappend members_list $first_line

} while {$i< [expr [llength $cfgshow_list]-1]} { incr i set cfgshow_line [lindex $cfgshow_list $i] if {[llength $cfgshow_line]==0} { continue; } #Check if next zone, alias, config has started if so exit if {[regexp {(.*)ne:(.*)|(.*)as:(.*)|(.*)fg:(.*)} $cfgshow_line kk]} { break; } lappend members_list $cfgshow_line } } } } set members_string [join $members_list ";"] set members_list [split $members_string ";"] set final_member_list "" foreach member $members_list { set final_member [string trim $member] if {[regexp {[a-zA-Z0-9:,-_]+} $final_member t]} { lappend final_member_list $final_member } }

lappend zone_list $final_member_list if {$ip!=$orig_ip_address} { end_telnet "exit" } }

# Check whether zone is propogated properly through out the fabric through compare list set zone_member1 [lindex $zone_list 0] foreach zone_member $zone_list { set compare_result [compare_lists [lsort $zone_member1] [lsort $zone_member]] if {$compare_result != ""} { add_status "$status zone configuration is not propogated properly through out fabric $compare_result" 1 } else { add_status "$status zone configuration is propogated properly through out the fabric === $compare_result" 3 } }

if {[set_spawn_id $orig_spawn_id] != 0} { if {[telnet_switch $orig_ip_address $username $pwd] != 0} { add_status "Telnet to switch $orig_ip_address failed" 0 } } return $zone_member1 }

########################################################################### ## NAME ## check_device_status - Verifies if the particular device wwn is connected in the given port number ## ## SYNOPSIS ##

check_device_status

## ## DESCRIPTION ##

This procedure verifies portshow portWWn's of device and checks if the

## given wwn is connected to that port. ## ## OPERANDS ##

device_info_list : passed as a list of lists. 1st member should be port number

## verified.

and next member is the wwn of device which needs to be

## Eg: set device_info_list [list "9 22:00:00:04:cf:03:4c:fa" "7 10:00:00:00:c9:2b:9d:35"] ## ## DEPENDENCIES ##

NONE

## RETURN ##

NONE

## ## USAGE ##

check_device_status $device_info_list

## ################################################################### proc check_device_status {device_info_list} { set flag 0 set len [llength $device_info_list] foreach line $device_info_list { set port [lindex $line 0] set wwn [lindex $line 1] set wwn_list [trim_list_elements [lrange [compress_list [split [get_between "portshow $port" "portWwn of device" "Distance"] "\r\n"]] 1 end] "\t"] if {[lsearch $wwn_list $wwn] == -1} { add_status "Error device wwn \"$wwn\" missing in switch in port $port. Update the device list in testbed file properly" 0 } else { incr flag } } if {$flag == $len} { add_status "All devices verified successfully" 3 } }

########################################################################### ## NAME ## get_wwn_pid_nsshow - Used to return pid and wwn from nsshow output in the form of a list. ##

## SYNOPSIS ##

get_wwn_pid_nsshow

## ## DESCRIPTION ##

This procedure returns a list of list with each element consisting of

## pid and wwn of each device obtained from nsshow output. Regexp in th api can be modified ##

according to future needs.

## ## OPERANDS ##

NONE

## ## DEPENDENCIES ##

NONE

## RETURN ##

List of lists - containing pid and wwn of devices

## ## USAGE ##

get_wwn_pid_nsshow

## ################################################################### proc get_wwn_pid_nsshow {} { set return_list [list] set wwn_list [list] set pid_list [list] set output [lrange [compress_list [split [get_command "nsshow | grep '\[0-9a-fA-F\]\\{6\\}'"]

"\r\n"]] 1 end-1] add_status "$output==>" 3 foreach line $output { set temp [split $line ";"] if {[regexp {N\s+([0-9a-f]+)} [lindex $temp 0] match pid]==1} { lappend pid_list $pid if {[regexp {(([0-9a-fA-f]+:){7}[0-9a-fA-F]+)} [lindex $temp 2] match wwn ignore] ==1} { lappend wwn_list $wwn } } } lappend return_list $wwn_list $pid_list return $return_list }

proc zone_cfg_enable {cfg_name zone_name} { retry_command "cfgcreate \"$cfg_name\",\"$zone_name\"" do_command "zoneshow" do_command "cfgshow" retry_command "cfgsave" sleep 20 retry_command "cfgenable $cfg_name" sleep 20 }

###########################################################

proc get_index_given_port {port_no_list} { set index_list "" set port_list_output [get_switchport_details] foreach port_no $port_no_list { if {[regexp "/" $port_no]} { set port_temp [split $port_no "/"] set slot [lindex $port_temp 0] set port [lindex $port_temp 1] set flag 1 } else { set port $port_no set flag 0 } foreach list1 $port_list_output { set index "" if {$flag == 0} { if {[lindex $list1 1] == $port} { set index [lindex $list1 0] lappend index_list $index } } else { if {([lindex $list1 1] == $slot) && ([lindex $list1 2] == $port)} { set index [lindex $list1 0]

lappend index_list $index } } } } return $index_list }

proc get_pid {port_no} { set pid "" set port_list_output [get_switchport_details] if {[regexp "/" $port_no]} { set port_temp [split $port_no "/"] set slot [lindex $port_temp 0] set port [lindex $port_temp 1] set flag 1 } else { set port $port_no set flag 0 } foreach list1 $port_list_output { set list1 [compress_list $list1] if {$flag == 0} { if {[lindex $list1 1] == $port} { set pid [lindex $list1 2]

} } else { if {([lindex $list1 1] == $slot) && ([lindex $list1 2] == $port)} { set pid [lindex $list1 3] } } } return $pid }

proc get_slot_type { } { set slot_type "" set val [lrange [compress_list [split [get_command "slotshow -m"] "\r\n"]] 3 end] foreach line $val { set slot "" set type "" set status [regexp {([0-9]+)\s*[a-zA-Z\s]+([0-9]+)\s*[a-zA-Z0-9\-]+} $line ignore slot type] if {$status == 1} { lappend slot_type $slot $type } } return $slot_type }

proc get_slot_ports {slot} {

set port_list "" clear_buffer set val [make_matrix "switchshow" "============" ""] foreach line $val { set line [compress_list $line] set temp [lindex $line 0] if {[lindex $temp 1] == $slot} { lappend port_list [lindex $temp 2] } } return $port_list }

proc compare_switch_logs {id_1 id_2 show_command_list {file_dir ""}} { set return_value 0 if {[string length $file_dir] != 0} { set file_dir "$file_dir/" } foreach type $show_command_list { set return_list "" if {[string first "=" $type] >= 0} { if {[llength $type] >= 2} { set type [lindex $type 0] set type [string trimleft $type "="] }

}

set type [replace_string_all $type " " "_"] set type [replace_string_all $type "/" "_"] set diff_count [compare_files "$file_dir[set id_1]_$type.txt" "$file_dir[set id_2]_$type.txt"] add_status "diff_count : $diff_count" if {$diff_count != 0} { add_status "$type outputs do not match" 2 add_status "files are $file_dir[set id_1]_$type.txt and $file_dir[set id_2]_$type.txt" 3 set return_value [llength $diff_count] lappend return_list $return_value $file_dir[set id_1]_$type.txt $file_dir[set id_2]_$type.txt } else { add_status "PASSED: $type outputs match" lappend return_list $return_value } } add_status "return_list : $return_list" return $return_list }

proc get_showListcmd_output {ip_address show_list {fid 128}} { global cl_log_path cl_diff_file_dir if {[set_spawn_id $ip_address]!= 0} { if {[telnet_switch $ip_address]!= 0} { add_status "Switch: $ip_address not available" 1

} } if {$fid != "128"} { setcontext_fid $fid clear_buffer } set switch_info [log_switch_state $show_list [subst $cl_diff_file_dir]]

return $switch_info }

proc swap_ports {port1 port2} { do_command "portswapenable" do_command "portdisable $port1" do_command "portdisable $port2" set status [get_command "portswap $port1 $port2"] if {[regexp "portswap done" $status]} { add_status "Port swap done between $port1 and $port2 successfully" 3 } else { add_status "Error observed while doing port swap" 1 } do_command "portenable $port1" do_command "portenable $port2" sleep 60 }

proc check_test_mode_configuration {test_mode} { global cl_ag_ip_address_list cl_ip_address_list cl_fid_list set flag 0 foreach SUT $cl_ag_ip_address_list { if {[set_spawn_id $SUT] == 1} { if {[telnet_switch $SUT] != 0} { add_status "Switch $SUT not available" 0 } } set switch_mode [string trim [get_after "switchshow" "switchMode:"]] if {$switch_mode == "Access Gateway Mode"} { add_info "AG mode is already enabled in $SUT" add_status "Check for Disabled ports in the switch" set disabled_port_list [get_ports "Disabled"] if {$disabled_port_list != ""} { foreach port $disabled_port_list { do_command "portcfgpersistentenable $port" } sleep 50 } add_status "Required configuration exists in AG $SUT" } else { add_status "Required configuration not available" add_status "Making the necessary configurations for AG...."

incr flag } }

if {$flag != 0} { add_info "Enable AG mode in AG capable switch" source /vobs/multisite/intgtest/inc/configure_ag.inc }

set val "Scenario_$test_mode" switch $val { "Scenario_1" { set flag 0 foreach SUT $cl_ip_address_list { if {[set_spawn_id $SUT] == 1} { if {[telnet_switch $SUT] != 0} { add_status "Switch $SUT not available" 0 } } set vf_status [string trim [get_after "fosconfig --show" "Virtual Fabric:"]] if {[regexp {enabled} $vf_status] == 0} { add_info "VF is already disabled in $SUT" add_status "Check for Disabled ports in the switch" set disabled_port_list [get_ports "Disabled"] if {$disabled_port_list != ""} {

foreach port $disabled_port_list { do_command "portcfgpersistentenable $port" } sleep 50 } } else { incr flag } } if {$flag == 0} { add_status "All switches in the fabric are in Non-VF mode" #Verify whether the fabric has come up fine set SUT [lindex $cl_ip_address_list 0] if {[set_spawn_id $SUT]!= 0} { if {[telnet_switch $SUT]!= 0} { add_status "Switch: $SUT not available" 0 } } set total_no_of_switches [llength $cl_ip_address_list] set total_switches 0 set fabric_show [get_command "fabricshow"] regexp {The Fabric has ([0-9]+) switches} $fabric_show ignore total_switches if {$total_no_of_switches == $total_switches} { add_status "Fabric has come up fine" 3 add_status "configuration for Non-VF mode testing is available. Proceed with testing...." 3

} else { add_status "Fabric has not come up properly" add_info "Creating configuration for testing in Non-VF mode" source /vobs/multisite/intgtest/inc/create_nonvf_fabric.inc } close_spawn_list end_telnet "exit" } else { add_info "Creating configuration for testing in Non-VF mode" source /vobs/multisite/intgtest/inc/create_nonvf_fabric.inc } } "Scenario_2" { set flag 0 foreach SUT $cl_ip_address_list { if {[lsearch $cl_ag_ip_address_list $SUT] == -1} { if {[set_spawn_id $SUT] == 1} { if {[telnet_switch $SUT] != 0} { add_status "Switch $SUT not available" 0 } } set vf_status [string trim [get_after "fosconfig --show" "Virtual Fabric:"]] if {[regexp {enabled} $vf_status] == 1} { add_status "VF is already enabled in $SUT" set ls_list [get_logical_switch_fid]

set bs_fid [get_base_switch_fid] if {([llength $ls_list] == 2) && ($bs_fid == "")} { foreach ls $ls_list { if {[regexp "128" $ls]} { do_command "setcontext 128" set onlineport_list [get_ports "Port"] if {$onlineport_list == ""} { add_status "No online ports found in DS" } else { add_status "Online ports found in DS" incr flag } } else { setcontext_fid $ls clear_buffer set disabled_ports [get_ports "Disabled"] if {$disabled_ports != ""} { foreach port $disabled_ports { do_command "portcfgpersistentenable $port" } } sleep 50 } } } else {

incr flag } } else { incr flag } } } if {$flag == 0} { add_status "VF is enabled in all the switches in the fabric" set fabric_sw_list "" foreach switch $cl_ip_address_list { if {[lsearch $cl_ag_ip_address_list $switch] == -1} { lappend fabric_sw_list $switch } } if {[llength $fabric_sw_list] > 1} { set SUT [lindex $fabric_sw_list 0] if {[set_spawn_id $SUT]!= 0} { if {[telnet_switch $SUT]!= 0} { add_status "Switch: $SUT not available" 0 } } set lsfid [lindex $ls_list end] setcontext_fid $lsfid clear_buffer

set total_no_of_switches [llength $fabric_sw_list] set total_switches 0 set fabric_show [get_command "fabricshow"] regexp {The Fabric has ([0-9]+) switches} $fabric_show ignore total_switches if {$total_no_of_switches == $total_switches} { add_status "Fabric has come up fine" 3 add_status "configuration for VF LS mode testing is available. Proceed with testing...." 3 } else { add_status "Fabric has not come up properly" add_info "Creating configuration for testing in VF LS mode" source /vobs/multisite/intgtest/inc/create_ls_fabric.inc } close_spawn_list end_telnet "exit" } } else { add_info "Creating configuration for testing in VF LS mode" source /vobs/multisite/intgtest/inc/create_ls_fabric.inc } } "Scenario_3" { set flag 0 foreach SUT $cl_ip_address_list { if {[lsearch $cl_ag_ip_address_list $SUT] == -1} { if {[set_spawn_id $SUT] == 1} {

if {[telnet_switch $SUT] != 0} { add_status "Switch $SUT not available" 0 } } set vf_status [string trim [get_after "fosconfig --show" "Virtual Fabric:"]] if {[regexp {enabled} $vf_status] == 1} { add_status "VF is already enabled in $SUT" set ls_list [get_logical_switch_fid] set bs_fid [get_base_switch_fid] if {([llength $ls_list] == 2) && ($bs_fid != "")} { foreach ls $ls_list { if {[regexp "128" $ls]} { do_command "setcontext 128" set onlineport_list [get_ports "Port"] if {$onlineport_list == ""} { add_status "No online ports found in DS" } else { add_status "Online ports found in DS" incr flag } } else { setcontext_fid $ls clear_buffer set disabled_ports [get_ports "Disabled"] if {$disabled_ports != ""} {

foreach port $disabled_ports { do_command "portcfgpersistentenable $port" } } sleep 50 } } } else { incr flag } } else { incr flag } } } if {$flag == 0} { add_status "VF is enabled in all the switches in the fabric" set fabric_sw_list "" foreach switch $cl_ip_address_list { if {[lsearch $cl_ag_ip_address_list $switch] == -1} { lappend fabric_sw_list $switch } } if {[llength $fabric_sw_list] > 1} { set SUT [lindex $fabric_sw_list 0]

if {[set_spawn_id $SUT]!= 0} { if {[telnet_switch $SUT]!= 0} { add_status "Switch: $SUT not available" 0 } } set lsfid [lindex $ls_list end] set ls_list [list $lsfid $bs_fid] set flag1 0 foreach ls $ls_list { setcontext_fid $lsfid clear_buffer set total_no_of_switches [llength $fabric_sw_list] set total_switches 0 set fabric_show [get_command "fabricshow"] regexp {The Fabric has ([0-9]+) switches} $fabric_show ignore total_switches if {$total_no_of_switches == $total_switches} { add_status "Fabric has come up fine in $ls" 3 } else { add_status "Fabric has not come up properly" incr flag1 } } } if {$flag1 == 0} { add_status "configuration for VF LF mode testing is available. Proceed with testing...." 3

} else { add_status "Fabric has not come up properly" add_info "Creating configuration for testing in VF LF mode" source /vobs/multisite/intgtest/inc/create_lf_fabric.inc } close_spawn_list end_telnet "exit" } else { add_info "Creating configuration for testing in VF LF mode" source /vobs/multisite/intgtest/inc/create_lf_fabric.inc } } } }

proc get_WWNbasedPID_status { } { set status "" set val "" send_command "configure" expect { -re "Fabric parameters" { exp_send "y\r" exp_continue } -re {WWN Based persistent PID[^\n]+} {

exp_send "\r" set val $expect_out(0,string) exp_continue } -re ":" { exp_send "\r" exp_continue } -re ">" { } } set res [regexp {WWN Based persistent PID \(yes, y, no, n\): \[([a-zA-Z]+)\]} $val ignore status] return $status }

proc get_wwnaddress_show_output {{area ""}} { set wwn_show_output "" set wwn_show_list "" set wwn_list "" set wwn_area_list "" set wwn_show_output [split [get_command "wwnaddress --show"] "\r\n"] foreach element $wwn_show_output { if {$element != ""} { lappend wwn_show_list $element }

} set end_val [expr [llength $wwn_show_list] - 3] set wwn_show_list [lrange $wwn_show_list 3 $end_val] foreach line $wwn_show_list { set line [compress_list $line] lappend wwn_list [lindex $line 1] lappend wwn_area_list [lindex $line 1],[lindex $line 2] } if {$area == ""} { return $wwn_list } else { return $wwn_area_list } }

proc get_wwn2BoundAreaMap_file_output {ip_address {fid 128} {file ""}} { set return_list "" if {[set_spawn_id $ip_address]!= 0} { if {[telnet_switch $ip_address]!= 0} { add_status "Switch: $ip_address not available" 1 } } if {$fid != "128"} { setcontext_fid $fid

clear_buffer } if {$file == ""} { set cmd_val "" do_command "cd /etc/fabos" set cmd_val [split [get_command "ls wwn2BoundAreaMap*"] "\r\n"] set file_list "" foreach line $cmd_val { if {$line != ""} { lappend file_list $line } } set req_file [lindex $file_list end-1] } else { set req_file $file } set file_output [lrange [split [get_command "cat $req_file"] "\r\n"] 1 end-1] set file_content "" foreach line $file_output { if {$line != ""} { lappend file_content $line } } set wwn_list "" foreach line $file_content {

set line [split $line "-"] lappend wwn_list [lindex $line 0] } return $wwn_list }

proc clear_wwn2BoundAreaMap_files { } { do_command "cd /etc/fabos" do_command "rm wwn2BoundAreaMap*" set status [get_command "ls wwn2BoundAreaMap*"] if {[regexp "No such file or directory" $status]} { add_status "All existing wwn2BoundAreaMap.* files have been deleted" 3 } else { add_status "wwn2BoundAreaMap file couldn't be deleted" 1 } }

proc verify_wwnaddress_cli { } { set cmd_list [list "wwnaddress" "wwnaddress --help"] set search_pattern_list [list "wwnAddress --bind" "wwnAddress --unbind" "wwnAddress --show" "wwnAddress --findPID" "wwnAddress --help"] foreach cmd $cmd_list { set cmd_output [get_command $cmd] set count 0 foreach pattern $search_pattern_list {

if {[regexp $pattern $cmd_output]} { incr count } } if {$count == [llength $search_pattern_list]} { add_status "Usage is shown properly for $cmd" 3 } else { add_status "Usage is not shown for $cmd" 1 } } }

proc get_device_wwn_list_byPortType { {type "F-Port"}} { set port_list [get_ports $type] array set wwn "" foreach port $port_list { set wwn_list [lrange [split [get_between "portshow $port" "portWwn of device" "Distance"] "\r\n"] 1 end] set wwn_list [compress_list $wwn_list] set wwn_list [trim_list_elements $wwn_list "\t"] array set wwn [list $port $wwn_list] } return [array get wwn] }

proc enable_wwnbasedpid {ip_address {fid 128} {mapfile ""}} {

if {[set_spawn_id $ip_address]!= 0} { if {[telnet_switch $ip_address]!= 0} { add_status "Switch: $ip_address not available" 1 } } if {$fid != "128"} { setcontext_fid $fid clear_buffer } set sw_type [get_after "switchshow" "switchType:"] if {([regexp {62|77} $sw_type] == 0) || ($fid != "128")} { if {$mapfile == ""} { clear_wwn2BoundAreaMap_files } clear_buffer set status [configure_items "WWN Based persistent PID" "yes"] clear_buffer if {$status == 1} { add_status "WWN based PID assignment enabled successfully" 3 } else { add_status "Error observed while enabling WWN based PID assignment" 1 } do_command "switchdisable" sleep 20 do_command "switchenable"

sleep 50 } }

proc convert_portList_to_range {port_list} { set return_list "" set temp_list1 "" set temp [lindex $port_list 0] set count 1 foreach val1 $port_list { set val2 [lindex $port_list $count] if {[expr $val2 - $val1] == 1} { lappend temp $val2 set flag 1 } else { set temp_list2 $temp set temp $val2 set flag 0 }

if {$flag == 0} { lappend temp_list1 $temp_list2 } incr count }

foreach element $temp_list1 { if {[llength $element] > 1} { set init [lindex $element 0] set final [lindex $element end] lappend return_list $init-$final } else { lappend return_list $element } } return $return_list }

proc get_area_portAddress_show {{port_no ""}} { if {$port_no != ""} { set flag 1 if {[regexp "/" $port_no]} { set port_temp [split $port_no "/"] set slot [lindex $port_temp 0] set port [lindex $port_temp 1] set port_flag 1 } else { set port $port_no set port_flag 0 } } else {

set flag 0 set sw_type [get_after "switchshow" "switchType:"] if {[regexp {62|77} $sw_type]} { set sw_flag 1 } else { set sw_flag 0 } } set port_address_list [make_matrix "portaddress --show" "============" ""] foreach line $port_address_list { set line [compress_list $line] if {$flag == 1} { if {$port_flag == 0} { if {[lindex [lindex $line 0] 1] == $port} { set area [lindex [lindex $line 0] 2] } } else { if {([lindex [lindex $line 0] 1] == $slot) && ([lindex [lindex $line 0] 2] == $port)} { set area [lindex [lindex $line 0] 3] } } } else { if {$sw_flag == 0} { lappend area [lindex [lindex $line 0] 2] } else {

lappend area [lindex [lindex $line 0] 3] } } } return $area }

proc disable_wwnbasedpid { } { clear_buffer set status [configure_items "WWN Based persistent PID" "no"] if {$status == 1} { add_status "WWN based persistent PID disabled successfully" 3 } else { add_status "Error observed while disabling WWN based persistent PID" 1 } do_command "switchdisable" sleep 20 do_command "switchenable" sleep 50 }

proc get_random_area { } { set return_value "" set vf_status [get_after "fosconfig --show" "Virtual Fabric: "] set area_list ""

if {[regexp {enabled|Enabled} $vf_status]} { set ls_list [get_logical_switch_fid] foreach ls $ls_list { setcontext_fid $ls clear_buffer append area_list " " [get_area_portAddress_show] } } else { set area_list [get_area_portAddress_show] }

while {1} { set temp [convert_to_hex [get_random_integer 144 255]] set area "0x[append temp 00]" if {[lsearch $area_list $area] == -1} { return $area } } }

proc get_mapfile_list { } { set temp "" set temp [lrange [compress_list [split [get_command "ls /etc/fabos/wwn2BoundAreaMap.*"] "\r\n"]] 1 end] set temp [compress_list [split [lindex $temp 0] " "]] if {[regexp "No such file or directory" $temp]} {

add_status "No wwn2BoundAreaMap files are present" set temp "" } return $temp }

proc get_port_portAddress_show {area} { set port "" set ls_list "" set sw_type [get_after "switchshow" "switchType:"] if {[regexp {62|77} $sw_type]} { set flag 1 } else { set flag 0 } set vf_status [get_after "fosconfig --show" "Virtual Fabric:"] if {[regexp {enabled|Enabled} $vf_status]} { set ls_list [get_logical_switch_fid] set flag1 1 } else { set ls_list "128" set flag1 0 }

foreach ls $ls_list {

if {$flag1 == 1} { if {[regexp "128" $ls]} { set ls 128 } setcontext_fid $ls clear_buffer } set port_address_list [make_matrix "portaddress --show" "============" ""] foreach line $port_address_list { #set line [compress_list $line] if {$flag == 1} { if {[lindex [lindex $line 0] 3] == $area} { set port [lindex [lindex $line 0] 1]/[lindex [lindex $line 0] 2] return $port } } else { if {[lindex [lindex $line 0] 2] == $area} { set port [lindex [lindex $line 0] 1] return $port } } } } }

proc check_area_range { } { set sw_type [string range [trim_string [get_after "switchshow" "switchType:"]] 0 1] set switch_port_count [list 64 80 66 40 71 24] set sw_index [lsearch $switch_port_count $sw_type] set port_count [lindex $switch_port_count [expr $sw_index + 1]] set generated_area_list "" for {set i 0} {$i < $port_count} {incr i} { set temp "" set area "" set temp [convert_to_hex $i] if {[llength [split $temp ""]] == 1} { set temp 0$temp } set area "0x[append temp 00]" lappend generated_area_list $area } add_status "generated_area_list : $generated_area_list"

set actual_area_list "" set vf_status [get_after "fosconfig --show" "Virtual Fabric:"] add_status "vf_status : $vf_status" if {[regexp {enabled|Enabled} $vf_status]} { set ls_list [get_logical_switch_fid] foreach ls $ls_list {

if {[regexp 128 $ls]} { set ls 128 } setcontext_fid $ls clear_buffer set temp [get_area_portAddress_show] add_status "temp : $temp" append actual_area_list " " $temp } set ls_flag 1 } else { set ls_flag 0 set actual_area_list [get_area_portAddress_show] } add_status "actual_area_list : $actual_area_list" add_status "[get_list_disjoint $generated_area_list $actual_area_list]" if {[get_list_disjoint $generated_area_list $actual_area_list] != "" } { add_status "Some area in the switch is beyond MAX_PHY_PORTS" add_status "Unbind that area and bind a new area within the valid range" set diff_actual_list [get_list_opposite_of_intersection $generated_area_list $actual_area_list] set diff_generated_list [get_list_opposite_of_intersection $actual_area_list $generated_area_list] set port_list "" foreach val1 $diff_actual_list val2 $diff_generated_list { set port [get_port_portAddress_show $val1]

add_status "port : $port" if {$ls_flag != 0} { array set arr "" parse_lscfgshow arr set fid $arr($port) if {[regexp "128" $fid]} { set fid 128 } setcontext_fid $fid clear_buffer } do_command "portdisable $port" do_command "portaddress --unbind $port $val1" do_command "portaddress --bind $port $val2" } } else { add_status "All assigned areas are within the valid range (less than MAX_PHY_PORTS)" } } ########################################################### # windows settings #----------------------------------------------------------------# win_init - create a telnet session with Windows host # inputs:

windb - array where windows data will be stored

#

host - hostname or IP addr of Windows host

# outputs:

returns 0 if success

#

windb - loaded with windows data

#----------------------------------------------------------------proc win_init { windb index host } { global winuser global winpassword global winprompt global cl_host_user cl_host_password cl_win_prompt upvar $windb win

set win($index,host) $host if {[info exists winuser]} { set win($index,user) $winuser } else { set win($index,user) "$cl_host_user" } if {[info exists winpassword]} { set win($index,password) $winpassword } else { set win($index,password) "$cl_host_password" } if {[info exists winprompt]} { set win($index,prompt) $winprompt } else { set win($index,prompt) "$cl_win_prompt"

}

set win($index,retry) 3 set win($index,id) 0 set win($index,rc) 0 set win($index,cmd) "" set win($index,out) {} set win($index,targets) {} set win($index,targetportals) {}

win_goto_prompt win $index

return $win($index,rc) }

#----------------------------------------------------------------# win_close - close a telnet session with Windows host # inputs:

windb - win data created by win_init

# outputs:

returns nothing, telnet session is closed

#----------------------------------------------------------------proc win_close { windb index } { upvar $windb win

if {$win($index,id) != 0} { catch {

close -i $win($index,id) wait -i $win($index,id) } junk set win($index,id) 0 } set win($index,rc) 0 set win($index,out) {} }

#----------------------------------------------------------------# win_login - login to win host # inputs:

windb - win data created by win_init

# outputs:

returns 0 if success

#----------------------------------------------------------------proc win_login { windb index } { add_status "Entering login proc" global ctrl_c

upvar $windb win set rc -1 set retry $win($index,retry) set loginstate 0

if {$win($index,id) != 0} { win_close win $index

} set timeout 300 #

puts "login: telnet $linux(host)\n"

#spawn telnet $win($index,host) spawn sh -c "TERM=tty;export TERM;telnet $win($index,host)" set win($index,id) $spawn_id

while {$retry > 0} { expect { -re "\[^ \]login:" { catch {puts stderr "login: Got login prompt - send $win($index,user)\n"} send "$win($index,user)\r" exp_continue }

"password:" { if { $loginstate == 0 } { catch {puts stderr "login: Got password prompt $loginstate - send $win($index,password)\n"} send "$win($index,password)\r" incr loginstate } exp_continue }

-re "Connection closed" { catch {puts stderr "login: Connection closed by $win($index,host)\n"} set $win($index,id) 0 win_login win $index break }

-re "$win($index,prompt)" { catch {puts stderr "login: Got win prompt $loginstate done\n"} set rc 0 break exp_continue }

eof { catch {puts stderr "login: Got EOF - can't telnet to $win($index,host)\n"} win_close win $index set rc 1 break }

timeout { catch {puts stderr "login: Got timeout - failed to login\n"}

send "$ctrl_c\r" set rc 2 break } } incr retry -1 puts stderr "login: retry = $retry\n" } #

stty raw -echo

set win($index,rc) $rc return $rc }

#----------------------------------------------------------------# win_goto_prompt - make sure we are at win prompt, this func #

needs more work as required

# inputs:

windb - win data created by win_init

# outputs:

returns 0 if success

#----------------------------------------------------------------proc win_goto_prompt { windb index } { global ctrl_c

upvar $windb win set rc -1

set retry $win($index,retry)

#

puts stderr "goto: win = $win(host)\n" if { $win($index,id) == 0 } { win_login win $index } set spawn_id $win($index,id)

#

puts stderr "goto: checking $win(host)\n"

expect *

while {$retry > 0} { send "\r"

expect { -re "\[^ \]login:" { #

puts stderr "prompt: Got login prompt - need to login first\n" set rc [win_login win $index] break }

-re "$win($index,prompt)" { #

puts stderr "prompt: Got win prompt - done\n" set rc 0

break }

-re "Connection closed" { puts stderr "login: Connection closed by $win($index,host)\n" set $win($index,id) 0 win_login win $index exp_continue }

eof { #

puts stderr "prompt: Got EOF - disconnected\n" win_close win $index set rc [win_login win $index] break }

timeout { #

puts stderr "prompt: Got timeout - try again\n" send "$ctrl_c\r" } } incr retry -1 }

expect *

set win($index,rc) $rc return $rc }

#----------------------------------------------------------------# win_cmd - execute a command and return output # inputs:

windb - windows data created by win_init

#

cmd - command string

# outputs:

returns list containing output for command

#----------------------------------------------------------------proc win_cmd { windb index cmd {change_prompt 0} {prompt ""}} { upvar $windb win

global timeout

set rc -1 set buf "" set lines {} set done 0 set oldtimeout $timeout set timeout 30

set rc [win_goto_prompt win $index]

set spawn_id $win($index,id) set retry $win($index,retry) if {$change_prompt} { set win($index,prompt) "$prompt" add_status "Changed prompt as $prompt" }

if { $rc != 0 } { set timeout $oldtimeout return {} }

#

puts stderr "cmd: Sending command: $cmd\n" send "$cmd\r\n" while {$retry > 0} { expect {

#

-re "$win($index,prompt).*$cmd" {

#

puts stderr "cmd: Got cmd echo - continue\n"

#

exp_continue

#

}

-re "$win($index,prompt)" { #

puts stderr "cmd: Got win prompt - done\n" set rc 0

#

puts stderr "cmd: flushing"

set done 1 set timeout 3 append buf "$expect_out(buffer)" # break exp_continue }

-re "--More--" { #

puts stderr "cmd: Got more prompt - press enter\n" append buf "$expect_out(buffer)" send "\r\n" exp_continue } eof {

#

puts stderr "cmd: Got EOF - disconnected\n" win_close win $index set rc 1 break } full_buffer { append buf "$expect_out(buffer)" exp_continue } timeout { if {$done == 1} {

break } puts stderr "cmd: Exceeded timeout value. Exiting the procedure without receiving prompt" set rc 1 append buf "$expect_out(buffer)" }

-re ".+" { #

puts stderr "cmd: Got more lines - keep reading\n" append buf "$expect_out(buffer)" exp_continue } } incr retry -1

#

puts stderr "cmd: retry = $retry\n" }

#NM: Why appending twice?? #append buf "$expect_out(buffer)" regsub -all "\033\\\[\[0-9\]+;\[0-9\]+(\[A-Z\]|\[a-z\])" $buf "\n" tmp1 regsub -all "\015" $tmp1 "\n" tmp2 regsub -all "\010 \010" $tmp2 "\n" tmp1 regsub -all -- "--More--" $tmp1 "\n" tmp2 regsub -all ", next page: Space, next line: Return key, quit: Control-c" $tmp2 "\n" tmp1

set timeout $oldtimeout foreach line [split $tmp1 "\n"] { if { ![regexp "\^\[\t\\ \]*\$" $line junk]} { lappend lines [string trim $line] # TOM1: keep newline lappend lines [string trim $line "\t\ "] #

puts stderr "cmd: dbg: $line\n" } } set win($index,out) $lines return $lines

}

proc winhost_inquiry { winhost } {

set numdestdrives 0 set rc 0

add_status "Telnet to windows host $winhost" if {[win_init winpc 1 $winhost] != 0} { add_status "Telnet to windows host $winhost failed" 1 set rc -1 return $rc }

win_cmd winpc 1 "cd C:\\copa"

set winpc(1,out) {}

## List the drives win_cmd winpc 1 "inq.wnt"

add_status "Getting the number of drives on windows host" foreach line $winpc(1,out) { set line [string trim $line] if [regexp -nocase {^.*PHYSICALDRIVE(.*).*:SEAGATE.*} $line junk drivenum] { #Assumes **ONE** internal scsi drive. Ignore this drive. if { $drivenum == 0 } { continue } incr numdestdrives } }

add_status "Found $numdestdrives device on windows host" win_close winpc 1 return $numdestdrives }

#----------------------------------------------------------------# enable_bcu_port - To enable a given bcu port # inputs: port - Port number to be enabled in host

# outputs: 1 : Success #

-1 : Failure

#----------------------------------------------------------------proc enable_bcu_port {port} { global winuser winpassword winprompt winip set index 1 win_init win1 $index $winip set spawn_id $win1($index,id) set output [win_cmd win1 $index "bcu port --enable $port"] if {[regexp {port enabled} $output] ==1} { return 1 } else { return -1 } win_close win1 $index }

#----------------------------------------------------------------# disable_bcu_port - To disable a given bcu port # inputs: port - Port number to be disabled in host # outputs: 1 : Success #

-1 : Failure

#----------------------------------------------------------------proc disable_bcu_port {port} { global winuser winpassword winprompt winip

set index 1 win_init win1 $index $winip set spawn_id $win1($index,id) set output [win_cmd win1 $index "bcu port --disable $port"] if {[regexp {port disabled} $output] ==1} { return 1 } else { return -1 } win_close win1 $index }

#----------------------------------------------------------------# get_bcu_port - To get the bcu port number of a given wwn # inputs: wwn - wwn of the device connected # outputs: port : Port number of the given wwn #

-1 : WWN not found in bcu port list

#----------------------------------------------------------------proc get_bcu_port {wwn} { global winuser winpassword winprompt winip set index 1 win_init win1 $index $winip set spawn_id $win1($index,id) set output [win_cmd win1 $index "bcu port --list"] set port ""

foreach line $output { if {[regexp "(.*?)\[ \t]+(.*)\[ \t]+(.*)\[ \t]+$wwn.*Linkup" $line match port ig ig1 ig2] ==1 && $port!= ""} { break } } win_close win1 $index if {$port == ""} { return -1 } else { return $port } }

proc online_disk {host_ip} { global winuser global winpc_user global cl_ip_address_list win_init win1 1 $host_ip win_cmd win1 1 "diskpart" win_cmd win1 1 "rescan" set oput [win_cmd win1 1 "list disk"] #set oput [split [win_cmd win1 1 "list disk"] "\r\n"] foreach line $oput { set num "" regexp -nocase {(Disk\s+\d+).*offline} $line ig num

add_status "Line: $line Disk: $num" if { $num != "" } { win_cmd win1 1 "select $num" win_cmd win1 1 "online disk" } } sleep 20 win_cmd win1 1 "list disk" win_close win1 1 } ############################################## #! /bin/sh

proc enable_vf_no_check {} {

if {[is_vf_enabled] != 0} { exp_send "fosconfig --enable vf\r" log_test_command_ "fosconfig --enable vf" expect { "]:" { exp_send "y\r" } timeout { add_status "timed out $timeout seconds waiting for affirmation of enabling vf" 0 } }

sleep 15 end_telnet "exit" return 0 } else { return 1 }

}

############################################################################## ###### ## NAME ##

return_current_ls

## ## SYNOPSIS ##

returns the current LS you are in

## ## ## DESCRIPTION ##

returns the current LS you are in

## ## OPERANDS ##

none

## ## DEPENDENCIES

## ## ## RETURN ##

-1 no current LS found after parsing switchshow

##

ls_num the number of the logical switch

## ## USAGE ## return_current_ls ## ############################################################################## ##### proc return_current_ls {} { set stuff [get_command "switchshow"] set lines [split $stuff "\n"] set lsnum -1 foreach line $lines { if {[string first "LS Attributes" $line] >= 0} { regexp "FID:\[ \t]*(\[0-9]+)," $line ignore lsnum

} } return $lsnum }

############################################################################## ###### ## NAME ##

verify_vf_enabled

## ## SYNOPSIS ##

verifies if VF is enabled

## ## ## DESCRIPTION ##

verifies if VF is enabled

## ## OPERANDS ##

none

## ## DEPENDENCIES ## ## ## RETURN ##

0 not enabled

##

1 enabled

## ## USAGE ## verify_vf_enabled ## ##############################################################################

##### proc verify_vf_enabled {} { if {[trim_string [get_after "fosconfig --show" "Virtual Fabric:"]] == "enabled"} { add_status "vf is enabled" 3 return 1 } else { add_status "vf is not enabled" 3 return 0 } }

############################################################################## ###### ## NAME ##

create_logical_switch

## ## SYNOPSIS ## creates logical switch at $fid, will retry command until it successfully completes unless it times out in 200 seconds ## this is because creation of logical switch can commonly be stalled due to FOS with the "system is not ready" response ## ## ## DESCRIPTION ##

creates logical switch without having to worry about command being accepted

## ## OPERANDS

##

the fid number

## ## DEPENDENCIES ## ## ## RETURN ##

0 failed because maximum number of switches created

##

1 passed, logical switch at $fid created

##

-1 failed, timed out, 10 tries with 20 seconds wait each

## USAGE ## create_logical_switch 29 ## ############################################################################## ##### proc create_logical_switch {fid {wait_time "180"}} { set times 0 #v7.3.0v7.3.0_pit_a_131121_1700 set version [join [lrange [regexp -inline {([0-9])\.([0-9])\.*} [get_version]] 1 end] "" ] add_status "$version : [get_version]" if { $version < "72" } { set cmd [get_command_no_wait "lscfg --create $fid" $wait_time] } else { set cmd [get_command_no_wait "lscfg --create $fid -force" $wait_time] }

while {[string first "system is not ready" $cmd] >= 0} {

sleep 20 if { $version < "72" } { set cmd [get_command_no_wait "lscfg --create $fid" $wait_time] } else { set cmd [get_command_no_wait "lscfg --create $fid -force " $wait_time] } incr times if {$times >= 10} { add_status "tried 10 times to create logical switch at $fid, but system is not ready, quitting" 1 return -1 } } if {[string first "maximum number of switches" $cmd] >= 0} { return 0 } else { return 1 } }

############################################################################## ###### ## NAME ## delete_logical_switch ## ## SYNOPSIS

## deletes logical switch at $fid, will retry command until it successfully completes unless it times out in 200 seconds ## this is because creation of logical switch can commonly be stalled due to FOS with the "system is not ready" response ## ## ## DESCRIPTION ##

deletes logical switch without having to worry about command being accepted

## ## OPERANDS ##

the fid number

## ## DEPENDENCIES ## ## ## RETURN ## ##

1 passed, logical switch at $fid created

##

-1 failed, timed out, 10 tries with 20 seconds wait each

## ## USAGE ## delete_logical_switch 29 ## ############################################################################## ##### proc delete_logical_switch {fid} { set times 0

set wait_time 120 set version [join [lrange [regexp -inline {([0-9])\.([0-9])\.*} [get_version]] 1 end] "" ] if { $version < "72" } { set cmd [get_command_no_wait "lscfg --delete $fid" $wait_time] } else { set cmd [get_command_no_wait "lscfg --delete $fid -force" $wait_time] } while {[string first "system is not ready" $cmd] >= 0} { sleep 20 if { $version < "72" } { set cmd [get_command_no_wait "lscfg --delete $fid" $wait_time] } else { set cmd [get_command_no_wait "lscfg --delete $fid -force" $wait_time] } incr times if {$times >= 10} { add_status "tried 10 times to delete logical switch at $fid, but system is not ready, quitting" 1 return -1 } } if {[string first "Unable to delete" $cmd] >=0 } { add_status "switch complaining about logical switch $fid having ports even though it does not. unable to delete, quitting" 1 return -1 }

return 1 }

############################################################################## ###### ## NAME ##

create_base_switch

## ## SYNOPSIS ## creates base switch at $fid, will retry command until it successfully completes unless it times out in 200 seconds ## this is because creation of logical switch can commonly be stalled due to FOS with the "system is not ready" response ## ## ## DESCRIPTION ##

creates base switch without having to worry about command being accepted

## ## OPERANDS ##

the fid number

## ## DEPENDENCIES ##

## ## RETURN ##

0 failed because maximum number of switches created

##

1 passed, base switch at $fid created

##

-1 timed out, 10 tries at 20 seconds wait each

## ## USAGE ## create_base_switch 29 ## ############################################################################## ##### proc create_base_switch {fid} { set wait_time 240 set times 0 set cmd [get_command_no_wait "lscfg --create $fid -b -f" $wait_time] while {[string first "system is not ready" $cmd] >= 0} { sleep 20 set cmd [get_command_no_wait "lscfg --create $fid -b -f" $wait_time] incr times if {$times >= 10} { add_status "tried 10 times to create base switch at $fid, but system is not ready, quitting" 1 return -1 } } if {[string first "maximum number of switches" $cmd] >= 0} {

return 0 } else { return 1 }

}

############################################################################## ###### ## NAME ##

enable_virtual_fabric

## ## SYNOPSIS ##

enables virtual fabric feature on the switch, requires a complete reboot

## ## ## DESCRIPTION ## enables virtual fabric feature on the switch and after a complete reboot will log back into the original spawns that existed when this routine was called ## ## OPERANDS ##

optional wait time for reboot to finish, recommended default is 250 seconds

## ## DEPENDENCIES ##

get_switch_platform

## ## RETURN ##

1: succeeded in enabling virtual fabric

##

0: no need to enable

##

-1: failed

## ## USAGE ## enable_virtual_fabric ## ############################################################################## ##### proc enable_virtual_fabric { {wait_time 250} } { set SUT [trim_string [get_after "ipaddrshow" "Ethernet IP Address:"]] add_status "The IP of the SUT is: $SUT" 3 set platform [get_switch_platform] if {[check_firmware_version] >= 62} { add_status "Virtual Fabric is supported in this Loaded FOS" 3 #set switchType [parse_real [get_after "switchShow" "switchType:"]] #set switchType [parse_integer $switchType strict] if {[check_vf_capable_platform] == 1} { add_status "Verifying VF is enabled/disabled" 3 set vf_status [trim_string [get_after "fosconfig --show" "Virtual Fabric:"]]

if {$vf_status == "enabled"} { add_status "VF is already enabled" 3 return 0 } else { slot_switch_validation add_status "Enabling the VF mode" 3 send_command "fosconfig --enable vf" expect { "\\\[Y/N]:" { exp_send "y\r" } timeout { add_status "timed out waiting for Y/N prompt after fosconfig enable vf" 2 return -1 } } sleep 60 end_telnet sleep 360 end_telnet if {[telnet_switch $SUT] != 0} { add_status "Switch not available" 0 return -1 } else { if {($platform >= 12000)} {

set xyzabc 0 while {[cause "hashow" "HA State not in sync" 5 wait] == 0} { incr xyzabc sleep 30 add_status "HA State still not in sync after Enabling VF, retrying" 3 if {$xyzabc == 10} { add_status "HA State not in sync after waiting for 5 minutes" 1 break } } } slot_switch_validation add_status "Checking VF is enabled properly" 3 set vf_status [trim_string [get_after "fosconfig --show" "Virtual Fabric:"]] add_status "value of vf is $vf_status" 3 if {$vf_status == "enabled"} { add_status "VF enabled successfully" 3 return 1 } else { add_status "Issues Observed while enabling VF" 1 return -1 }

} } } else { add_status "Platform doesn't support VF" 3 return 0 } } else { add_status "Virtual Fabric is not supported in this loaded FOS" 3 return 0 } }

#Bob:root> lscfg --show #Created switches: 128 2 #Slot

1

2

3

4

5

6

7

8

9 10 11 12

#------------------------------------------------------------------------------#Port # 0 | 128 |

|

| 128 | 128 |

|

| 128 |

| 128 |

| 128 |

# 1 | 128 |

|

| 128 | 128 |

|

| 2|

| 128 |

| 128 |

# 2 | 128 |

|

| 128 | 128 |

|

| 2|

| 128 |

| 128 |

# 3 | 128 |

|

| 128 | 128 |

|

| 2|

| 128 |

| 128 |

# 4 | 128 |

|

| 128 | 128 |

|

| 2|

| 128 |

| 128 |

# 5 | 128 |

|

| 128 | 128 |

|

| 2|

| 128 |

| 128 |

# 6 | 128 |

|

| 128 | 128 |

|

| 2|

| 128 |

| 128 |

# 7 | 128 |

|

| 128 | 128 |

|

| 2|

| 128 |

| 128 |

# 8 | 128 |

|

| 128 | 128 |

|

| 2|

| 128 |

| 128 |

# 9 | 128 |

|

| 128 | 128 |

|

| 2|

| 128 |

| 128 |

#10 | 128 |

|

| 128 | 128 |

|

| 2|

| 128 |

| 128 |

#11 | 128 |

|

| 128 | 128 |

|

| 2|

| 128 |

| 128 |

#12 | 128 |

|

| 128 | 128 |

|

| 2|

| 128 |

| 128 |

#13 | 128 |

|

| 128 | 128 |

|

| 2|

| 128 |

| 128 |

#14 | 128 |

|

| 128 | 128 |

|

| 2|

| 128 |

| 128 |

#15 | 128 |

|

| 128 | 128 |

|

| 2|

| 128 |

| 128 |

#16 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#17 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#18 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#19 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#20 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#21 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#22 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#23 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#24 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#25 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#26 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#27 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#28 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#29 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#30 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#31 | 2 |

|

|

| 128 |

|

| 2|

| 2|

| 2|

#32 |

|

|

|

|

|

|

|

|

|

|

| 2|

#33 |

|

|

|

|

|

|

|

|

|

|

| 2|

#34 |

|

|

|

|

|

|

|

|

|

|

| 2|

#35 |

|

|

|

|

|

|

|

|

|

|

| 2|

#36 |

|

|

|

|

|

|

|

|

|

|

| 2|

#37 |

|

|

|

|

|

|

|

|

|

|

| 2|

#38 |

|

|

|

|

|

|

|

|

|

|

| 2|

#39 |

|

|

|

|

|

|

|

|

|

|

| 2|

#40 |

|

|

|

|

|

|

|

|

|

|

| 2|

#41 |

|

|

|

|

|

|

|

|

|

|

| 2|

#42 |

|

|

|

|

|

|

|

|

|

|

| 2|

#43 |

|

|

|

|

|

|

|

|

|

|

| 2|

#44 |

|

|

|

|

|

|

|

|

|

|

| 2|

#45 |

|

|

|

|

|

|

|

|

|

|

| 2|

#46 |

|

|

|

|

|

|

|

|

|

|

| 2|

#47 |

|

|

|

|

|

|

|

|

|

|

| 2|

############################################################################## ###### ## NAME ## parse_lscfgshow ## ## SYNOPSIS ## parse_lscfgshow ##

## DESCRIPTION ##

Routine will parse lscfg --show, which assosciates every port on the switch

##

to a logical switch FID (fabric ID). The default logical switch FID is 128.

## ## OPERANDS ##

none

## ## DEPENDENCIES ##

none

## ## RETURN ##

-1 if error occurred

## ##

mtx(x/y) assosciative array is returned, visually

##

represented below

## ##

1 2 3 4 5 6 7 8 9 10 11 12

##

15 128 0 0 128 128 0 0 2 0 128 0 128

##

16 2 0 0 0 128 0 0 2 0 2 0 2

##

17 2 0 0 0 128 0 0 2 0 2 0 2

## ##

the X axis corresponds to the slot number

##

the Y axis corresponds to the port number

##

the value is the FID the port X/Y belongs to.

##

##

For example, if you want port 1/5 (slot 1, port 5) simply use

##

==> $mtx(1/5)

## ##

Make sure that the string between the ()'s contains no spaces

##

as this is a simiulated matrix using assosciative arrays.

## ##

For example

##

==> $mtx(1/5) NOT EQUAL TO $mtx (1 /5)

## ## ## USAGE ##

parse_lscfgshow

## ############################################################################## ##### proc parse_lscfgshow {array} { upvar $array mtx #make sure VF is enabled set output [split [get_command "lscfg --show"] "\r\n"] if {[string first "requires VF to be enabled" $output] >= 0} { add_status "Virtual Fabric is not enabled and therefore there are no partitions from lscfg --show" 1 return 0 } elseif {[string first "command not found" $output] >= 0} { add_status "Command not found, probably not an Orion or later build" 1 return 0

} set ten 0

set col 0 set row 0

set chassis "no" foreach line $output { if {[string first "Slot" $line] >= 0} { set num_slots [expr [llength $line] -1] set chassis "yes" } if {$chassis == "yes"} { if {$num_slots == 8} { set found [regexp "^ *\[0-9 ]+\\|(\[0-9 ]+)\\|(\[0-9 ]+)\\|(\[0-9 ]+)\\|(\[0-9 ]+)\\|(\[0-9 ] +)\\|(\[0-9 ]+)\\|(\[0-9 ]+)\\|(\[0-9 ]+).*$" $line ignore clm1 clm2 clm3 clm4 clm5 clm6 clm7 clm8] } else { set found [regexp "^ *\[0-9 ]+\\|(\[0-9 ]+)\\|(\[0-9 ]+)\\|(\[0-9 ]+)\\|(\[0-9 ]+)\\|(\[0-9 ] +)\\|(\[0-9 ]+)\\|(\[0-9 ]+)\\|(\[0-9 ]+)\\|(\[0-9 ]+)\\|(\[0-9 ]+)\\|(\[0-9 ]+)\\|(\[0-9 ]+).*$" $line ignore clm1 clm2 clm3 clm4 clm5 clm6 clm7 clm8 clm9 clm10 clm11 clm12] } if {$found == 1} { set col 1 for {set i 1} {$i <= $num_slots} {incr i} { set var clm$i if {[parse_integer [set $var]] == 0} {

set mtx($col/$row) -1 } else { set mtx($col/$row) [parse_integer [set $var]] }

incr col } incr row }

} else {

#Created switches: 128(ds) 10 20(bs) 30

#Port

0

1

2

3

4

5

6

7

8

9

#------------------------------------------------------------------#FID

10 | 128 | 128 | 128 | 128 | 128 | 128 | 128 | 128 | 128 |

#Port

10 11 12 13 14 15 16 17 18 19

#------------------------------------------------------------------#FID

128 | 128 | 128 | 128 | 128 | 128 | 128 | 128 | 128 | 128 |

if {[regexp "^FID\[ \t]+(\[0-9 ]+)\\|?(\[0-9 ]+)?\\|?(\[0-9 ]+)?\\|?(\[0-9 ]+)?\\|?(\[0-9 ] +)?\\|?(\[0-9 ]+)?\\|?(\[0-9 ]+)?\\|?(\[0-9 ]+)?\\|?(\[0-9 ]+)?\\|?(\[0-9 ]+)?.*$" $line ignore x0

x1 x2 x3 x4 x5 x6 x7 x8 x9] == 1} { for {set i 0} {$i < 10} {incr i} { set var x$i set index [expr $i + $ten] if {[parse_integer [set $var]] == 0} { set mtx($index) -1 } else { set mtx($index) [parse_integer [set $var]] } if {$i == 9} { set ten [expr $ten + 10] } }

}

}

}

} ########################################################################### ## NAME ## ##

clear_zonecfg - disables and clears the zone configuration

## SYNOPSIS ##

clear_zonecfg

## ## DESCRIPTION ##

This procedure disables and clears all the zone confiuration

## ## OPERANDS ## NONE ## ## DEPENDENCIES ## NONE ## ## RETURN ## NONE ## ## USAGE ##

clear_zonecfg

## ############################################################################# proc clear_zonecfg {} { while {1} { set zone_cfg [get_command "cfgshow"] set result [regexp -nocase {(.*)busy(.*)} $zone_cfg -] if {$result} { sleep 20

} else { break } } set result [regexp {([a-z0-9][a-z0-9]:)+([a-z0-9][a-z0-9])} $zone_cfg -] if {$result} { do_command "cfgshow" retry_command "cfgdisable" retry_command "cfgclear" sleep 10 retry_command "cfgsave" do_command "cfgshow" add_status "Wait for switch to stabilize" 3 sleep 30 } }

proc setcontext_mercury {ls_fid} { global cl_ip_address_list set sut [lindex $cl_ip_address_list 0] global cl_PROMPT if {$ls_fid == 128} { set cmd "setcontext chassis" send_command "setcontext fcsw 128"

} else { set cmd "setcontext fcsw $ls_fid" send_command "setcontext fcsw $ls_fid" } expect { "Use Control-C to exit" { sleep 3 exp_send "\003" expect { -re ".*>.*" { if {[string first "Please logout" $expect_out(buffer)] >= 0} { add_status "$cmd command failed, working around by using logout and re-telnet" 1 end_telnet "logout" telnet_switch $sut } else { add_status "setcontext command succeeded, no need to use logout" 3 } } } } }

clear_buffer }

########################################################################### ## NAME ## ## setcontext_fid :will set the context of a particular ls ## ## SYNOPSIS ## setcontext_fid $ls_fid ## ## DESCRIPTION ## This procudure will set the context of the fid which you will pass it as argument ## ## OPERANDS ## Fabric id of the ls of which you want to set the context ## ## DEPENDENCIES ## NONE ## ## RETURN ## NONE ## ## USAGE ##

setcontext_fid $ls_fid

## ############################################################################# proc setcontext_fid {ls_fid} {

add_status "inside setcontext in virtual_switch_fabric.lib" 3 set timeout 60 global cl_PROMPT send_command "setcontext $ls_fid" expect { "Use Control-C to exit" { sleep 3 exp_send "\003" wait_for "until password is changed." } "ethsw" { setcontext_mercury $ls_fid } -re "$cl_PROMPT" { add_status "prompt received, no password change required" 3 } "requires VF to be enabled" { add_status "FOS responded that it \"requires VF to be enabled\" while issuing setcontext $ls_fid" 2 } timeout { add_status "setcontext $ls_fid command timed out, aborting" 2 } } clear_buffer }

############################################################################## ###### ## NAME

##

delete_all_ls

## ## SYNOPSIS ##

Deletes all the LS's in the SUT

## ## ## DESCRIPTION ##

a)Moves all the ports in all the LS's including BS(Base switch) to DS(Default switch)

##

b)Deletes all the LS's and BS if all the ports are successfully moved to DS from

##

that LS instance

## ## OPERANDS ##

NONE

## ## DEPENDENCIES ##

NONE

## ## RETURN ## 0: Failed to delete all LS's ## 1: Successful deletion of all the LS's ## ## ## USAGE ## delete_all_ls ##

############################################################################## ##### proc delete_all_ls {} { add_status "You are in delete all ls procedure" 3 global timeout set f_port_trunking_status 0 set return_type 1 set ls_fids "" set ds_fid "" set other_ls_fids "" global cl_PROMPT if {[check_firmware_version] >= 62} { add_status "Virtual Fabric is supported in this Loaded FOS" 3 #set switchType [parse_real [get_after "switchShow" "switchType:"]] #set switchType [parse_integer $switchType strict] if {[check_vf_capable_platform] == 1} { add_status "Verifying VF is enabled/disabled" 3 set vf_status [trim_string [get_after "fosconfig --show" "Virtual Fabric:"]] if {$vf_status == "disabled"} { add_status "VF is already disabled" 3 } else { set ls_fids [trim_string [get_after "lscfg --show" "Created switches.*:"]] foreach fids $ls_fids { set str [regexp {\(.+?\)} $fids match] if {$str == 1 && $match == "(ds)"} { regexp {\d+} $fids ds_fid

#set ds_fid [string trimright $fids $match] } elseif {$str == 1 && $match == "(bs)"} { regexp {\d+} $fids match set other_ls_fids [linsert $other_ls_fids 0 $match] #set other_ls_fids [linsert $other_ls_fids 0 [string trimright $fids $match]] } elseif {$str == 1} { regexp {\d+} $fids match lappend other_ls_fids $match #lappend other_ls_fids [string trimright $fids $match] } else { lappend other_ls_fids $fids } } set ls_fids_len [llength $ls_fids] add_status "The total LS's are:$ls_fids; Of which DS is:$ds_fid and LS's are: $other_ls_fids" 3 if {$ls_fids_len > 1} { foreach fid $other_ls_fids { add_status "Switching to LS $fid" 3 setcontext_fid $fid sleep 10 set switchshow_output [get_command "switchshow"] set switchshow_info [split $switchshow_output "\n"] foreach line $switchshow_info { set ge_port ""

if {[regexp "\[x\]*ge\[0-9\]" $line ge_port] == 1} { set slot_num [string trim [lindex $line 0]] do_command "lscfg --config $ds_fid -slot $slot_num -port $ge_port -f" } } if {[cause "porttrunkarea --show enabled" "No ports have Trunk Area enabled"] != 0} { set f_port_trunking_status 1 do_command "switchshow" add_status "Disabling f-port trunking before moving the ports; ($f_port_trunking_status)" 3 set slot_port "" #set switchType [parse_integer [parse_real [get_after "switchShow" "switchType:"]] strict] set fport_trunk_list [split [get_command "porttrunkarea --show enabled"] "\n"] if {[get_switch_platform] > 12000} { foreach fport_list $fport_trunk_list { set port_type [trim_string [lindex $fport_list 2]] if {$port_type == "F-port" || $port_type == "--"} { set slot [lindex $fport_list 0] set port [lindex $fport_list 1] lappend slot_port "$slot/$port" set area [lindex $fport_list 5] } } } else { foreach fport_list $fport_trunk_list {

set port_type [trim_string [lindex $fport_list 1]] if {$port_type == "F-port" || $port_type == "--"} { lappend slot_port [lindex $fport_list 0] set area [lindex $fport_list 4] } } } add_status "the trunking info is:- area= $area; Port list is= $slot_port" 3 do_command "switchdisable" sleep 10 do_command "porttrunkarea --disable all" sleep 10 do_command "switchenable" sleep 30 } else { add_status "No trunking links were found hence continuing" 3 } set ports_info_before "" set ports_info_before [get_ports_info] add_status "The ports information is:\n $ports_info_before" 3 set ports_info_before_len [llength $ports_info_before] set list_of_ports "" set port1 "" set port "" if {$ports_info_before_len!= 0 && [regexp "No ports found in the system!!!" $ports_info_before] != 1} {

if {[check_ha_capable_platform] == 0} { foreach port1 $ports_info_before { lappend list_of_ports [lindex $port1 1] } add_status "The list of ports in LS($fid) are:$list_of_ports" 3 set list_of_ports [convert_portList_to_range [lsort -integer $list_of_ports]] foreach port $list_of_ports { send_command "lscfg --config $ds_fid -port $port" expect { "\\\[y/n]?:" { exp_send "y\r" wait_for "Please enable your ports/switch when you are ready to continue." #

exp_continue }

#

-re "$cl_PROMPT" {

#

} timeout { add_status "Command Timed out($timeout)" 2 } } } } elseif {[get_switch_platform] > 12000} { set slots [list] foreach port1 $ports_info_before { set slot [lindex $port1 1]

set port [lindex $port1 2] if {[regexp {^[0-9]+$} $port]} { lappend slots slot_$slot lappend slot_$slot $port } }

set slots [lsort -unique $slots] foreach sl $slots { set portrange [convert_portList_to_range [lsort -integer [set $sl]]] set slot [lindex [split $sl "_"] 1] add_status "Port range - $portrange for slot $slot" foreach port $portrange { send_command "lscfg --config $ds_fid -slot $slot -port $port" expect { "\\\[y/n]?:" { exp_send "y\r" wait_for "Please enable your ports/switch when you are ready to continue." #

exp_continue }

#

-re "$cl_PROMPT" {

#

} timeout { add_status "Command Timed out($timeout)" 2 }

} } unset $sl } } } setcontext_fid $ds_fid setcontext_fid $ds_fid add_status "Deleting LS with fid $fid" 3 set version [join [lrange [regexp -inline {([0-9])\.([0-9])\.*} [get_version]] 1 end] "" ] if { $version < "72" } { send_command "lscfg --delete $fid" } else { send_command "lscfg --delete $fid -force" } if {[wait_for "Switch successfully deleted." 200] == 0} { add_status "Successfully deleted LS($fid)" 3 } else { add_status "Failed to delete LS($fid) in given time" 1 } } add_status "checking for the successful deletion of LSwitches" 3 sleep 20 set ls_fids_after [trim_string [get_after "lscfg --show" "Created switches.*:"]] set ls_fids_after_len [llength $ls_fids_after]

add_status "The LS after deletion are: $ls_fids_after; length: $ls_fids_after_len" 3 if {$ls_fids_after_len == 1} { add_status "All the LS's are successfully deleted" 3 set return_type 1 } else { add_status "The LS's [lrange $ls_fids_after 1 end] failed to be deleted" 1 set return_type 0 } ################################### # Reconfiguring the f-port truking ################################### if {$f_port_trunking_status == 1} { add_status "Reconfiguring the f-port trunking after deleting all the LS" 3 do_command "switchcfgtrunk 1" do_command "switchdisable" sleep 10 if {[check_ha_capable_platform] == 0} { foreach fport $slot_port { do_command "porttrunkarea --enable $fport -area $area" } } else { foreach fport $slot_port { do_command "porttrunkarea --enable $fport -index $area" } }

} else { add_status "No f-port trunking was enabled hence did not reconfigure" 3 do_command "switchdisable" sleep 10 } do_command "switchenable" sleep 30 if {[verify_command "switchShow" "(unconfirmed)" 20] == 0} { add_status "Switch still coming up" 3 } if {[cause "porttrunkarea --show enabled" "No ports have Trunk Area enabled"] == 0 && $f_port_trunking_status == 1} { add_status "Failed to reconfigure F-port trunking" 1 } elseif {$f_port_trunking_status == 0} { add_status "F-port trunking was not enabled initially itself" 3 } else { add_status "F-port trunking is reconfigured successfully" 3 } } else { add_status "There are no LS's created; could find only $ls_fids" 3 } } } else { add_status "Platform doesn't support VF###" 3 } } else {

add_status "Virtual Fabric is not supported in this loaded FOS" 3 } return $return_type } ############################################################################## ###### ## NAME ##

disable_virtual_fabric

## ## SYNOPSIS ##

Disables virtual fabric feature on the switch, requires a complete reboot

## ## ## DESCRIPTION ##

a)Checks if all the LS's are deleted and

##

b)Then disables VF if all the switch instances are deleted succeessfully.

## ## ## OPERANDS ##

None

## ## DEPENDENCIES ##

None

## ## RETURN ##

## ## ## USAGE ## disable_virtual_fabric ## ############################################################################## ###### proc disable_virtual_fabric {} { add_status "You are in disable virtual fabric procedure" 3 set SUT [trim_string [get_after "ipaddrshow" "Ethernet IP Address:"]] add_status "The IP of the SUT is: $SUT" 3 if {[check_firmware_version] >= 62} { add_status "Virtual Fabric is supported in this Loaded FOS" 3 add_status "Verifying VF is enabled/disabled" 3 set vf_status [trim_string [get_after "fosconfig --show" "Virtual Fabric:"]] if {$vf_status == "enabled"} { set ls_fids [trim_string [get_after "lscfg --show" "Created switches.*:"]] set ls_fids_len [llength $ls_fids] if {$ls_fids_len == 1} { add_status "No LS's detected; continuing with disabling of VF" 3 send_command "fosconfig --disable vf" puts "==>sending y" expect { "Would you like to continue" { exp_send "y\r" add_status "==>sending y"

} } sleep 60 end_telnet sleep 360 end_telnet if {[telnet_switch $SUT root fibranne] != 0} { add_status "Telnet to switch $SUT failed" 0 } add_status "Verifying for successful disabling of VF" 3 set vf_status [trim_string [get_after "fosconfig --show" "Virtual Fabric:"]] if {$vf_status == "enabled"} { add_status "Failed to disable VF" 1 return -1 } else { add_status "VF is Successfully disabled" 3 } } else { add_status "The LS's $ls_fids failed to be deleted hence failed to disable VF" 1 return -1 } } else { add_status "VF is already disabled" 3 } } else {

add_status "Virtual Fabric is not supported in this loaded FOS" 3 } return 1 } ############################################################################## ###### ## NAME ## verify_ls_presence ## ## SYNOPSIS ## verify_ls_presence ## ## DESCRIPTION ##

This procedure verifies for the presence of given LS FID by getting the list

##

of LS's created in SUT by executing lscfg --show

## ## OPERANDS ##

fid of the switch to be tested

## ## ## DEPENDENCIES ##

verify_ls_presence

## ## RETURN ##

0: if it finds the fid among the LS's present on the switch

##

1: if it fails to locate the same

## ## USAGE ##

verify_ls_presence $ls_fid

##

verify_ls_presence 12

## ############################################################################## ###### proc verify_ls_presence {fid} { set ret "" set total_ls "" set ls_fid $fid set ls_fids [trim_string [get_after "lscfg --show" "Created switches.*:"]] if {[llength $ls_fids] < 1} { sleep 10 set ls_fids [trim_string [get_after "lscfg --show" "Created switches.*:"]] } foreach fids $ls_fids { set str [regexp {\(.+\)} $fids match] if {$str == 1} { lappend total_ls [string trimright $fids $match] } else { lappend total_ls $fids } } add_status "the total ls are:$total_ls;ls_fids=$ls_fids" 3 if {[lsearch $total_ls $ls_fid] != -1} {

add_status "Successfully created LS($ls_fid)" 3 set ret 0 } else { add_status "Failed to create LS($ls_fid),Please check" 1 set ret 1 } return $ret } ############################################################################## ###### ## NAME ## move_online_port ## ## SYNOPSIS ## move_online_port ## ## DESCRIPTION ##

Moving the F-Port,L-Ports from DS to LS and E-ports from DS to BS.It takes

##

care of those f-ports with trunking (f-port trunking) enabled

## ## OPERANDS ##

The following operands had to be passed in the sequence

##

BS FID,LS FID,E-port list,F-port list,L-port list

## ## DEPENDENCIES ##

verify_ls_presence

## ## RETURN ##

0

## ## USAGE ##

move_online_port $bs_fid $ls_fid $switch_eport $switch_fport $switch_lport

## ############################################################################## ###### proc move_online_port {bs_fid1 ls_fid1 switch_eport1 switch_fport1 switch_lport1} { add_status "you are in move online port procedure" 3 proc port_movement {port_list lsfid} { add_status "you are about to move the ports" 3 set switch_port $port_list set ls_fid $lsfid set version [join [lrange [regexp -inline {([0-9])\.([0-9])\.*} [get_version]] 1 end] "" ] #set switchType [parse_integer [parse_real [get_after "switchShow" "switchType:"]] strict] set platform [get_switch_platform] foreach line $switch_port { if {$platform >= 12000} { if {[regexp "switchshow" $line] != 1} { #set status [lindex $line 6] if {[regexp "Online" $line]} { set slot [lindex $line 1] set port [lindex $line 2]

send_command "lscfg --config $ls_fid -slot $slot -port $port" expect { "\\\[y/n]?:" { exp_send "y\r" if {[wait_for "Logical Switch management operations. Please try again shortly."] == 0} { send_command "lscfg --config $ls_fid -slot $slot -port $port" exp_continue } elseif {[wait_for "Please enable your ports/switch when you are ready to continue."] == 0} { exp_continue } } } } elseif {$line == ""} { #add_status "ignore" 3 } else { add_status "Port $line is not online, Please check" 1 } } } else { if {[regexp "switchshow" $line] != 1} { #set status [lindex $line 4] if {[regexp "Online" $line]} { set port [lindex $line 1] send_command "lscfg --config $ls_fid -port $port"

expect { "\\\[y/n]?:" { exp_send "y\r" wait_for "Please enable your ports/switch when you are ready to continue." #

exp_continue } } } elseif {$line == ""} { #add_status "ignore" 3 } else { add_status "Port $line is not online, Please check" 1 } } } } } #set switchType [parse_real [get_after "switchShow" "switchType:"]] #set switchType [parse_integer $switchType strict] #add_status "switch_type is $switchType" 3 if {[check_vf_capable_platform] == 1} { add_status "It's a VF capable switch" 3 set platform [get_switch_platform] add_status "Platform is $platform" 3 set f_port_trunking_status 0 set switch_eport $switch_eport1

set switch_fport $switch_fport1 set switch_lport $switch_lport1 set ls_fids [trim_string [get_after "lscfg --show" "Created switches.*:"]] foreach fids $ls_fids { set str [regexp {\(.+?\)} $fids match] if {$str == 1 && $match == "(ds)"} { regexp {\d+} $fids ds_fid #set ds_fid [string trimright $fids $match] add_status "The DS is: $ds_fid" 3 } } set ls_fid [lindex $ls_fid1 0] if { $version < "72" } { send_command "lscfg --create $ls_fid" } else { send_command "lscfg --create $ls_fid -force" } wait_for "Switch successfully created." add_status "Checking for successful creation of the ls($ls_fid)" 3 if {[verify_ls_presence $ls_fid] != 0} { add_status "Failed to create LS($ls_fid), do consider to check" 1 } else { add_status "Successfully created LS($ls_fid)" 3 } set bs_fid [lindex $bs_fid1 0]

if { $version < "72" } { send_command "lscfg --create $bs_fid -b" } else { send_command "lscfg --create $bs_fid -b -force" } expect { "\\\[y/n]?:" { exp_send "y\r" wait_for "Switch successfully created." #

exp_continue } } do_command "switchenable" sleep 30 if {[verify_ls_presence $bs_fid] != 0} { add_status "Failed to create Base Switch($bs_fid), do consider to check" 1 } else { add_status "Successfully created Base switch($bs_fid)" 3 } ################################### # Moving E-ports ################################### set switch_eport [split $switch_eport "\n"] port_movement $switch_eport $bs_fid ###################################

# Moving F-ports ################################### if {$switch_fport != ""} { set switch_fport [split $switch_fport "\n"] #Checking for the presence of f-port trunking# add_status "checking for the presence of f-port trunking" 3 set fport_output "" set fport_output [get_command "porttrunkarea --show enabled"] if {[regexp "No ports have Trunk Area enabled" $fport_output] != 1} { set f_port_trunking_status 1 set area "" set slot_port "" do_command "switchshow" add_status "Disabling f-port trunking before moving the ports; ($f_port_trunking_status)" 3 #set switchType [parse_integer [parse_real [get_after "switchShow" "switchType:"]] strict] set fport_trunk_list [split [get_command "porttrunkarea --show enabled"] "\n"] if {[get_switch_platform] > 12000} { foreach fport_list $fport_trunk_list { set port_type [trim_string [lindex $fport_list 2]] if {$port_type == "F-port" || $port_type == "--"} { set slot [lindex $fport_list 0] set port [lindex $fport_list 1] lappend slot_port "$slot/$port" set area [lindex $fport_list 5]

} } } else { foreach fport_list $fport_trunk_list { set port_type [trim_string [lindex $fport_list 1]] if {$port_type == "F-port" || $port_type == "--"} { lappend slot_port [lindex $fport_list 0] set area [lindex $fport_list 4] } } } add_status "the trunking info is:- area= $area; Port list is= $slot_port" 3 do_command "switchdisable" sleep 10 do_command "porttrunkarea --disable all" sleep 10 do_command "switchenable" sleep 30 } else { add_status "No trunking links were found hence continuing" 3 } port_movement $switch_fport $ls_fid ################################### # Reconfiguring the f-port trunking ###################################

if {$f_port_trunking_status == 1} { add_status "Reconfiguring the f-port trunking after deleting all the LS" 3 setcontext_fid $ls_fid do_command "switchcfgtrunk 1" do_command "switchdisable" sleep 10 if {[check_ha_capable_platform] == 0} {

foreach fport $slot_port { do_command "porttrunkarea --enable $fport -area $area" } } else { foreach fport $slot_port { do_command "porttrunkarea --enable $fport -index $area" } } } else { add_status "No f-port trunking was enabled hence did not reconfigure" 3 do_command "switchdisable" sleep 5 } do_command "switchenable" sleep 30 if {[verify_command "switchShow" "(unconfirmed)" 20] == 0} { add_status "Switch still coming up" 3

} set fport_output [get_command "porttrunkarea --show enabled"] if {[regexp "No ports have Trunk Area enabled" $fport_output] == 1 && $f_port_trunking_status == 1} { add_status "Failed to reconfigure F-port trunking" 1 } elseif {$f_port_trunking_status == 0} { add_status "F-port trunking was not enabled initially itself" 3 } else { add_status "F-port trunking is reconfigured successfully" 3 } setcontext_fid $ds_fid } else { add_status "No F-port in the switch to move" 3 } ################################## # Moving L-ports ################################## if {$switch_lport != ""} { set switch_lport [split $switch_lport "\n"] port_movement $switch_lport $ls_fid } else { add_status "There are no L-port in the switch" 3 } sleep 30 } else { add_status "It's not a VF capable switch" 3

} }

############################################################################## # NAME #

delete_ls

# # SYNOPSIS #

delete_ls

# # DESCRIPTION #

Delete LS with specified FID.

# # OPERANDS #

FID: LS FID

# # DEPENDENCIES #

None

# # RETURN #

0: On successful deletion of LS

#

1: On failure to delete LS

# # USAGE

#

delete_ls 10

############################################################################## proc delete_ls {fid} { set return_value 0 set version [join [lrange [regexp -inline {([0-9])\.([0-9])\.*} [get_version]] 1 end] "" ] if { $version < "72" } { set command "lscfg --delete" } else { set command "lscfg --delete $fid -force" } if {[cause "$command" "Switch successfully deleted"] != 0} { set return_value 1 } return $return_value }

############################################################################## # NAME #

configure_lf

# # SYNOPSIS #

configure_lf

# # DESCRIPTION #

Disables or enables VF

# # OPERANDS #

lf_flag: 1 to enabled LF and 0 to disable LF.

# # DEPENDENCIES #

None

# # RETURN #

None

# # USAGE #

configure_lf 0

############################################################################## proc configure_lf {{lf_flag 1}} { global cl_PROMPT do_command "switchdisable" set timeout 1 if {$lf_flag == 0} { set str_to_send "n" } else { set str_to_send "y" } send_command "configure" expect { "Fabric parameters" {

exp_send "y\r" exp_continue } "Allow XISL Use" { exp_send "$str_to_send\r" exp_continue } "WARNING!! Disabling this parameter" { exp_send "y\r" exp_continue } -re "$cl_PROMPT" {

} default { exp_send "\r" exp_continue } } do_command "switchenable" }

############################################################################## # NAME #

get_base_switch_fid

# # SYNOPSIS #

get_base_switch_fid

# # DESCRIPTION #

Returns the FID of base switch.

# # OPERANDS #

None

# # DEPENDENCIES #

None

# # RETURN #

bs_fid: FID of base switch.

# # USAGE #

get_base_switch_fid

############################################################################## proc get_base_switch_fid {} { set bs_fid "" set created_ls [get_after "lscfg --show" "Created switches.*: "] set ls_list [split $created_ls " "] set refined_ls_list "" foreach element $ls_list {

if {$element != ""} { lappend refined_ls_list $element } } foreach ls $refined_ls_list { if {[regexp {[0-9]+\(bs\)} $ls]} { regexp {[0-9]+\(bs\)} $ls bsid set bs_fid [parse_integer $bsid] } } return $bs_fid }

############################################################################## # NAME #

get_logical_switch_fid

# # SYNOPSIS #

get_logical_switch_fid

# # DESCRIPTION #

Returns list of LS FIDs

# # OPERANDS #

None

# # DEPENDENCIES #

None

# # RETURN #

ls_fid: List of LS FIDs

# # USAGE #

get_logical_switch_fid

############################################################################## proc get_logical_switch_fid {} { set ls_fid "" set created_ls [get_after "lscfg --show" "Created switches.*: "] set ls_list [split $created_ls " "] set refined_ls_list "" foreach element $ls_list { if {$element != ""} { lappend refined_ls_list $element } } foreach ls $refined_ls_list { if {![regexp {128\(ds\)} $ls] && ([regexp {[0-9]+\(bs\)} $ls] != 1)} { if {[regexp {\d+} $ls match]} { lappend ls_fid $match }

} } return $ls_fid }

############################################################################## # NAME #

create_ls

# # SYNOPSIS #

create_ls

# # DESCRIPTION #

Created LS with specified FID.

# # OPERANDS #

fid: LS FID

#

base_attribute: Indicates whether the LS is BS

# # DEPENDENCIES #

None

# # RETURN #

0: On successful creation of LS

#

1: On failure to create LS

# # USAGE #

create_ls 10

############################################################################## proc create_ls {fid {base_attribute 0}} { set return_value 0 if {$base_attribute == 0} { if {[cause "lscfg --create $fid" "The system is not ready" 60] == 0} { set return_value 1 } } else { if {[cause "lscfg --create $fid -b -f" "The system is not ready" 60] == 0} { set return_value 1 } else { do_command "chassisenable" sleep 60 } } return $return_value }

############################################################################## # NAME # #

is_vf_enabled

# SYNOPSIS #

is_vf_enabled

# # DESCRIPTION #

Indicates whether VF is enabled or not.

# # OPERANDS #

None

# # DEPENDENCIES #

None

# # RETURN #

0: If VF is enabled

#

1: If VF is disabled

# # USAGE #

is_vf_enabled

############################################################################## proc is_vf_enabled {} { set return_value 0 set vf_status [trim_string [get_after "fosconfig --show" "Virtual Fabric:"]] if {[string first "enabled" $vf_status] == -1 } { set return_value 1 }

return $return_value }

############################################################################## # NAME #

move_port_to_ls

# # SYNOPSIS #

move_port_to_ls

# # DESCRIPTION #

Move specified ports to specified FID

# # OPERANDS #

fid: LS FID

#

port_range: Ports to be moved

#

slot_num: Slot on which ports are to be moved

# # DEPENDENCIES #

None

# # RETURN #

0: On successful port movement

#

1: On failure to move ports

#

# USAGE #

move_port_to_ls 10 0-5 3

############################################################################## proc move_port_to_ls {fid port_range {slot_num ""}} { global cl_ip_address set return_value 0 if {$slot_num == ""} { set port_move_string "-port $port_range" } else { set port_move_string "-slot $slot_num -port $port_range" } # if {[cause "lscfg --config $fid $port_move_string -f" "Configuration change successful" 300] != 0} { # #

set return_value 1 } set status [get_command "lscfg --config $fid $port_move_string -f" 100]

if {[regexp {Configuration change successful} $status] || [regexp {port is already in the current switch} $status]} { set return_value 1 } return $return_value }

############################################################################## # NAME #

verify_ge_port_movement

# # SYNOPSIS #

verify_ge_port_movement

# # DESCRIPTION #

Verified whether GE ports are successfully moved to LS

# # OPERANDS #

num_ge_ports: Number of GE ports moved

# # DEPENDENCIES #

None

# # RETURN #

0: On successful GE-Port movement

#

1: On failure to move GE-Ports

# # USAGE #

verify_ge_port_movement 1

############################################################################## proc verify_ge_port_movement {num_ge_ports} { set return_value 0 set offline_count 0 set disabled_count 0 set ge_port_count 0

if {$num_ge_ports == 1} { set expected_offline_count 8 } elseif {$num_ge_ports == 2} { set expected_offline_count 16 } set switchshow_info [get_command "switchshow"] set switchshow_info [split $switchshow_info "\n"] foreach line $switchshow_info { if {[regexp "Disabled" $line] == 1} { incr disabled_count } elseif {[regexp "Offline" $line] == 1} { incr offline_count } elseif {[regexp "FCIP" $line] == 1} { incr ge_port_count } } if {$disabled_count > 0} { set return_value 1 add_status "There are disabled GE/VE ports in in the logical switch" 3 } if {$ge_port_count != $num_ge_ports} { set return_value 1 add_status "Expected number of GE-Ports not present in the logical switch" 3 } if {$offline_count != $expected_offline_count} {

set return_value 1 add_status "Expected number of VE-channels not present in the logical switch" 3 } return $return_value }

############################################################################## # NAME #

verify_lscfg_output

# # SYNOPSIS #

verify_lscfg_output

# # DESCRIPTION #

Verified lscfg --show for proper port assignment to LS

# # OPERANDS #

slot: Slot number

#

port: Port number

#

fid: LS FID

# # DEPENDENCIES #

None

# # RETURN

#

0: On successful port assignment to LS

#

1: On failed port assignment

# # USAGE #

verify_lscfg_output 10 5 10

############################################################################## proc verify_lscfg_output {slot port fid} { set return_value 0 parse_lscfgshow array if {$slot != "NONE"} { if {$array($slot/$port) != $fid} { set return_value 1 } } else { if {$array($port) != $fid} { set return_value 1 } } return $return_value }

############################################################################## # NAME # #

chassis_disable_enable

# SYNOPSIS #

chassis_disable_enable

# # DESCRIPTION #

Disables/enables chassis for removing segmentation

# # OPERANDS #

None

# # DEPENDENCIES #

None

# # RETURN #

None

# # USAGE #

chassis_disable_enable

############################################################################## proc chassis_disable_enable {} { do_command "chassisdisable" sleep 3 do_command "chassisenable" sleep 60 }

############################################################################## # NAME #

clear_defzone_cfg

# # SYNOPSIS #

clear_defzone_cfg

# # DESCRIPTION #

Clears def zone configuration

# # OPERANDS #

None

# # DEPENDENCIES #

None

# # RETURN #

None

# # USAGE #

clear_defzone_cfg

############################################################################## proc clear_defzone_cfg {} { global cl_ip_address_list foreach ip $cl_ip_address_list {

if {[set_spawn_id $ip] != 0} { if {[telnet_switch $ip] != 0} { add_status "Telnet to $ip failed" 0 } } do_command "switchdisable" default_zone "allaccess" clear_zonecfg do_command "switchenable" } sleep 60 }

############################################################################## # NAME #

get_zone_list_fid

# # SYNOPSIS #

get_zone_list_fid

# # DESCRIPTION #

Returns the zone list for specified FID from testbed file

# # OPERANDS #

fid: LS FID

# # DEPENDENCIES #

None

# # RETURN #

zone_list: Zone list for specified FID taken from testbed file

# # USAGE #

get_zone_list_fid 10

############################################################################## proc get_zone_list_fid {fid} { global cl_zone_set_$fid set zone_list "" eval set zone_list_temp $\{cl_zone_set_$fid\} set zones [split $zone_list_temp ","] set num_zones [llength $zones] for {set zone_index 0} {$zone_index < $num_zones} {incr zone_index} { if {[regexp {[0-9]*-[0-9]*} [lindex $zones $zone_index]]} { set zone [split [lindex $zones $zone_index] "-"] for {set z_index [lindex $zone 0]} {$z_index <= [lindex $zone 1]} {incr z_index} { lappend zone_list $z_index } } else { lappend zone_list [lindex $zones $zone_index] }

} return $zone_list }

############################################################################## # NAME #

get_zone_mem_info

# # SYNOPSIS #

get_zone_mem_info

# # DESCRIPTION #

Returns the zone members for specified FID from testbed file

# # OPERANDS #

fid: LS FID

# # DEPENDENCIES #

None

# # RETURN #

all_zone_list: Zone members for specified FID taken from testbed file

# # USAGE #

get_zone_mem_info 10

############################################################################## proc get_zone_mem_info {fid} { set zone_list [get_zone_list_fid $fid] foreach mem $zone_list { global cl_zone_$mem\_list } set all_zone_list "" set zone_name_mem_list "" foreach mem $zone_list { eval set zone_mem_list_temp $\{cl_zone_$mem\_list\} set zone_name [lindex $zone_mem_list_temp 0] set zone_mem "" for {set index 1} {$index < [llength $zone_mem_list_temp]} {incr index} { lappend zone_mem [lindex $zone_mem_list_temp $index] } lappend zone_name_mem_list $zone_name lappend zone_name_mem_list $zone_mem lappend all_zone_list $zone_name_mem_list set zone_name_mem_list "" } return $all_zone_list }

############################################################################## # NAME

#

config_upload_vf

# # SYNOPSIS #

config_upload_vf

# # DESCRIPTION #

Uploads configuration for specified FID

# # OPERANDS #

fid: LS FID

# # DEPENDENCIES #

upload_config

# # RETURN #

None

# # USAGE #

config_upload_vf 10

############################################################################## proc config_upload_vf {{fid "all"}} { global cl_network_path global cl_upload_file global cl_upload_passwd global cl_upload_host

global cl_upload_user

######################################################################### # Execute the configupload command. ######################################################################### add_status "Executing configupload command" 3

if {[upload_config $cl_upload_host $cl_upload_host $cl_upload_user $cl_upload_file "scp" $cl_upload_passwd $fid] == 0} { add_status "Configupload executed successfully" 3 } else { add_status "Configupload failed" 1 }

######################################################################### # Confirm configuration file is uploaded. #########################################################################

add_status "Verifying the uploaded configuration file" 3 if {[read_file $cl_network_path$cl_upload_file 1] > 0} { add_status "The Config Upload file could not be accessed using read_file" 1 } else { add_status "The configuration file uploaded was accessed successfully using

read_file" 3 } }

############################################################################## # NAME #

config_default_vf

# # SYNOPSIS #

config_default_vf

# # DESCRIPTION #

Executes configdefault -all to set configuration on all LS to factory

#

default

# # OPERANDS #

None

# # DEPENDENCIES #

None

# # RETURN #

None

# # USAGE

#

config_default_vf

############################################################################## proc config_default_vf {} { do_command "chassisdisable" do_command "configdefault -all" sleep 10 do_command "diagdisablepost" sleep 5 complete_reboot "fastboot" "480" }

############################################################################## # NAME #

config_download_vf

# # SYNOPSIS #

config_download_vf

# # DESCRIPTION #

Downloads configuration for specified FID

# # OPERANDS #

fid: LS FID

# # DEPENDENCIES

#

download_config

# # RETURN #

None

# # USAGE #

config_download_vf 10

############################################################################## proc config_download_vf {{fid "all"}} { global cl_network_path global cl_upload_file global cl_upload_passwd global cl_upload_host global cl_upload_user

do_command "chassisdisable" sleep 5 if {[download_config $cl_upload_host $cl_upload_host $cl_upload_user $cl_upload_file "scp" $cl_upload_passwd $fid] == 0} { add_status "Configdownload executed successfully" 3 } else { add_status "ConfigDownload failed" 1 } do_command "chassisenable" sleep 60 }

############################################################################## # NAME #

change_dom_id

# # SYNOPSIS #

change_dom_id

# # DESCRIPTION #

Changes domain ID on switch to specified domain ID

# # OPERANDS #

domain_id: Domain ID of switch

# # DEPENDENCIES #

None

# # RETURN #

None

# # USAGE #

change_dom_id 10

############################################################################## proc change_dom_id {domain_id} { global cl_PROMPT

do_command "switchdisable" set timeout 1 send_command "configure" expect { "Fabric parameters" { exp_send "y\r" exp_continue } "Domain:" { exp_send "$domain_id\r" exp_continue } -re "$cl_PROMPT" {

} default { exp_send "\r" exp_continue } } do_command "switchenable" sleep 20 }

########################################################################### ## NAME ##

verify_zones - verify that the zone is propogated properly in the fabric

## ## SYNOPSIS ##

verify_zones

## ## DESCRIPTION ##

This procedure verifies zone configuration propogation in the fabric

## also returns the members of this zone ## ## OPERANDS ##

zone_name: name of the zone whose members needs to be checked

##

status: Checks Effective/Defined configuration based on input

##

user_ad_list: username, password and admindomain

##

ip_list: ipaddress of the fabric that needs to be checked for zone propogation

##

If nothing is specified it takes ipaddress from cl_ip_address_list

## ## DEPENDENCIES ## ## RETURN ##

member list of the zone specified

## ## USAGE ##

verify_zone zone_first Effective

##

--> {10:00:00:00:c9:2b:9d:35 22:00:00:04:cf:03:4c:fa}

## ################################################################### proc verify_zones {zone_name status {fid "128"} {user_ad_list "root fibranne"} {ip_list ""}} { # Store the original ip address for login back to same spawn global cl_ip_address_list global cl_ip_address global spawn_id set username [lindex $user_ad_list 0] set pwd [lindex $user_ad_list 1] set ad [lindex $user_ad_list 2] set orig_spawn_id $spawn_id

set orig_ip_address $cl_ip_address set status [string toupper $status] if {$ip_list==""} { set ip_list $cl_ip_address_list } # set ip_list [get_fabric_ips] foreach ip $ip_list { if {$ip!=$orig_ip_address} { if {[telnet_switch $ip $username $pwd] != 0} { add_status "Telnet to switch $ip failed" 0 }

} elseif {[set_spawn_id $ip] != 0} { if {[telnet_switch $ip $username $pwd] != 0} { add_status "Telnet to switch $ip failed" 0 } }

if {$ad !=""} { ad_select $ad } if {($fid != 128) && ([is_vf_enabled] == 0)} { setcontext_fid $fid } retry_command "cfgshow" # Checks the Effective configuration for zone's if {$status=="EFFECTIVE"} { set cfgshow_output [get_command "cfgshow"] set cfgshow_string1 [regexp {Effective configuration:(.*)} $cfgshow_output cfgshow_string] } # Checks the Defined configuration for zone's if {$status =="DEFINED"} { set cfgshow_string [get_between "cfgshow" "Defined configuration:" "Effective configuration:|Type <CR> to continue "] } # Spliting the cfgshow by new line character

set cfgshow_list [split $cfgshow_string "\r\n"] # Variable that needs to be passed set members_list "" set first_line "" for {set i 0} {$i<[llength $cfgshow_list]} {incr i} { set cfgshow_line [lindex $cfgshow_list $i] # Search for zone expression in each of cfgshow line if {[regexp {(.*)ne:(.*)} $cfgshow_line cfgshow_zone]} { if {[lsearch $cfgshow_zone $zone_name]!=-1} { for {set j 2} {$j<[llength $cfgshow_zone]} {incr j} { append first_line [lindex $cfgshow_zone $j] } if {$first_line!=""} { lappend members_list $first_line } while {$i< [expr [llength $cfgshow_list]-1]} { incr i set cfgshow_line [lindex $cfgshow_list $i] if {[llength $cfgshow_line]==0} { continue; } #Check if next zone, alias, config has started if so exit if {[regexp {(.*)ne:(.*)|(.*)as:(.*)|(.*)fg:(.*)} $cfgshow_line kk]} { break; }

lappend members_list $cfgshow_line } } } } set members_string [join $members_list ";"] set members_list [split $members_string ";"] set final_member_list "" foreach member $members_list { set final_member [string trim $member] if {[regexp {[a-zA-Z0-9:,-_]+} $final_member t]} { lappend final_member_list $final_member } } lappend zone_list $final_member_list if {$ip!=$orig_ip_address} { end_telnet "exit" } }

# Check whether zone is propogated properly through out the fabric through compare list set zone_member1 [lindex $zone_list 0] foreach zone_member $zone_list { set compare_result [compare_lists [lsort $zone_member1] [lsort $zone_member]] if {$compare_result != ""} {

add_status "$status zone configuration is not propogated properly through out fabric $compare_result" 1 } else { add_status "$status zone configuration is propogated properly through out the fabric === $compare_result" 3 } }

if {[set_spawn_id $orig_spawn_id] != 0} { if {[telnet_switch $orig_ip_address $username $pwd] != 0} { add_status "Telnet to switch $orig_ip_address failed" 0 } } return $zone_member1 }

proc enable_disable_switch {sw_mode {ls_fid "128"} {sw_ip ""}} { global cl_ip_address_list cl_ls_fid if {$sw_mode == "switchenable"} { set sw_state "Online" set sw_status "Enabled" } else { set sw_state "Offline" set sw_status "Disabled" } if {$sw_ip == ""} {

set sw_ip $cl_ip_address_list } foreach ip $sw_ip { if {[set_spawn_id $ip]!= 0} { if {[telnet_switch $ip]!= 0} { add_status "Switch: $ip not available" 0 } } if {[is_vf_enabled] == 0} { setcontext_fid $ls_fid do_command $sw_mode sleep 20 } else { do_command $sw_mode sleep 20 } if {[string trim [get_after "switchshow" "switchState:"]] == $sw_state} { add_status "switch $ip $sw_status successfully" 3 } else { add_status "switch $ip not $sw_status successfully after $sw_mode" 1 } } }

proc get_switch_platform_type_old {} {

do_command "switchshow" set type [string trimleft [get_after "switchshow" "switchType:"] ] if {[regexp {(10|21|42|62|77)} $type]} { set sw_type 1 } else { set sw_type 0 } return $sw_type } ############################################### ############################################################################## # NAME #

validate_viking_switch

# # SYNOPSIS #

validate_viking_switch

# # DESCRIPTION #

This routine find the first valid Viking switch from the list of ip_addresses

# # OPERANDS #

ip_list : list containing IP address

# # DEPENDENCIES #

None

# RETURN #

ip_address : This is the first valid viking ip_address from the list

# # USAGE #

validate_viking_switch $cl_viking_ip_address_list

# ############################################################################## proc validate_viking_switch {viking_ip_list} { set viking_switchtype "44.0" set success_ip 0 ########################################################################## # Telnet to the viking switches specified in viking_ip_list" ########################################################################## add_status "Get the first viking switch from ip list" 3 set num_viking_switches [llength $viking_ip_list] if {[llength $viking_ip_list] == 0 } { add_status " There are no Viking switches in the list" 0 } else { foreach ip $viking_ip_list { if {[telnet_switch $ip] != 0 } { add_status "Unable to telnet to switch $ip " 0 } else { set switch_num [get_after "switchshow" "switchType:"] set switch_num [expr {floor($switch_num)}] if { [trim_string $switch_num] == $viking_switchtype } {

set success_ip 1 return $ip } end_telnet "exit"

} } if { $success_ip == 0 } { add_status " Couldn't get valid viking ip address " 0 } } } ############################################################################## # NAME #

enable_ports

# # SYNOPSIS #

enable_ports

# # DESCRIPTION #

This routine enables the range of ports on a given switch

# # OPERANDS # #

ipaddress start_port end_port

# DEPENDENCIES #

None

# RETURN #

None

# # USAGE #

enable_ports [ip_address start_port end_port]

# ##############################################################################

proc enable_ports {ip start_port end_port} {

if { [set_spawn_id $ip] != 0 } { if { [telnet_switch $ip ] != 0 } { add_status " Unable to telnet to switch $ip" 0 } } for {set index $start_port} {$index < $end_port} {incr index } { do_command "portenable $index" } } ############################################################################## # NAME # #

disable_ports

# SYNOPSIS #

disable_ports

# # DESCRIPTION #

This routine disable the range of ports on a switch and check whether

#

ports are in disabled state

# # OPERANDS #

ip_address start_port end_port

# # DEPENDENCIES #

None

# RETURN #

None

# # USAGE #

disable_ports [ip_address start_port end_port]

# ##############################################################################

proc disable_ports {ip start_port end_port} { if { [set_spawn_id $ip] != 0 } { if { [telnet_switch $ip ] != 0 } { add_status " Unable to telnet to switch $ip" 0 }

} for {set index $start_port} {$index < $end_port} {incr index } { do_command "portdisable $index" } sleep 5 set switchshowList [get_switchshow_info] set portDescriptorList [lindex $switchshowList 1] for {set index $start_port} {$index < $end_port } {incr index} { set value_to_be_compared [lindex [lindex [lindex $portDescriptorList $index] 6] 1] if {[string compare $value_to_be_compared "Disabled"] != 0 } { add_status " port $index is not Disabled " 1 } else { add_status "Port $index is disabled" } } } ############################################################################# # NAME #

convert_viking_slottoport

# # SYNOPSIS #

convert_viking_slottoport

# # DESCRIPTION #

This routine first check if the switch is viking switch then return the area

#

number directly. Otherwise convert the area number into slot/port format

# # OPERANDS #

area_number

# # DEPENDENCIES #

None

# RETURN #

return area_number if the switch is viking otherwise

#

return port_number (port is converted in slot/port format)

# USAGE #

convert_viking_slottoport area_number

# ##############################################################################

proc convert_viking_slottoport {area_number} { set viking_switchtype "44.0" set switch_num [get_after "switchshow" "switchType:"] if { [trim_string $switch_num] == $viking_switchtype } { return $area_number } else { set port [convert_to_slotport area_number] return $port } }

##################################################################

############################################################################## ###### ## NAME ## cleanup_user ## ## SYNOPSIS ##

cleanup_user [ip_list]

## ## DESCRIPTION ##

This procedure will cleanup the users within the fabric

## ## OPERANDS ##

ip_list: Description for user profile

## ## DEPENDENCIES ##

NONE

## ## RETURN ##

0 : successful creation of user

##

1 : User account already exists

##

2 : Failed to create new user due to failure

## ## USAGE

##

create_user "USER1" "user" "passwd" - Creating a user without assigning any AD

############################################################################## ###### proc cleanup_user {{ip_list ""}} { global cl_ip_address_list if {$ip_list ==""} { set ip_list $cl_ip_address_list } do_command "passwddefault" set fabric_info [get_fabric_info] foreach switch_info $fabric_info { if {[lsearch $ip_list [lindex $switch_info 2]]!=-1} { append sw_domain_list [lindex $switch_info 0] ";" } }

do_command "distribute -p pwd -d \"$sw_domain_list\"" sleep 30 } ############################################################################## ###### ## NAME ##

create_user

## ## SYNOPSIS ##

create_user user [role] [password] [AD list] [home AD] [CurrentVF] [VF List] [Description]

## ## DESCRIPTION ##

This procedure will create user with given role, password, AD members and home AD

## ## OPERANDS ##

user : name of the account

##

role : role of the account

##

admem_list: AD member list

##

adhome: Home AD

##

description: Description for user profile

## ## DEPENDENCIES ##

NONE

## ## RETURN ##

0 : successful creation of user

##

1 : User account already exists

##

2 : Failed to create new user due to failure

## ## USAGE ##

create_user "USER1" "user" "passwd" - Creating a user without assigning any AD

## create_user "USER1" "user" "passwd" "AD1 AD2 AD3" - Creatinga user with AD list "AD1 AD2 AD3" ## create_user "USER1" "user" "passwd" "AD1 AD2 AD3" "AD2" - Creating user with AD list and home AD AD2 ## create_user "USER1" "user" "passwd" "" "" "User with role user" - Creating user without AD but it has description

## create_user "USER1" "user" "passwd" "AD1 AD2 AD3" "AD2" "test" -Creating user with AD list, home and description ## ############################################################################## ##### proc create_user {user {role ""} {password ""} {admem_list ""} {adhome ""} {description ""}} { global cl_PROMPT global cl_user_password if {$role == ""} { set role admin } if {$password == ""} { set password $cl_user_password } if {$description == ""} { set description "$user creation" }

if {$admem_list!=""} { set admem_string [join $admem_list ,] }

add_status "Creating the user $user with role $role and password $password" 3 set result 0 set command_to_send ""

if {($admem_list=="")&&($adhome=="")} { set command_to_send "userConfig --add $user -r $role -l 128 -d \"$description\"" }

if {($adhome=="")&&($admem_list!="")} { set command_to_send "userConfig --add $user -r $role -a $admem_string -d \"$description\"" }

if {($adhome!="")&&($admem_list!="")} { set command_to_send "userConfig --add $user -r $role -h $adhome -a $admem_string -d \"$description\"" } send_command $command_to_send expect { "Named account already exists" { set result 1 add_status "$user account already exists" 3 exp_continue } "assword:" { sleep 1 exp_send "$password\r" exp_continue } "command not found" {

set result 2 add_status "Current user cannot create a user account" 3 exp_continue } "Maximum number of allowed accounts reached" { set result 2 add_status "Unable to create new user as maximun no. of allowed accounts reached" 1 exp_continue } "Invalid user account name" { set result 2 add_status "Invalid user account name $user" 1 exp_continue } "Invalid user account role" { set result 2 add_status "Invalid user account role $role" 1 exp_continue } "Invalid AD-ID" { # Message TBD set result 2 add_status "Invalid Admin Domain" 1 exp_continue } "Maximum AD_ID list size exceeded" { # Message TBD

set result 2 add_status "Maximum AD_ID list size exceeded" 1 exp_continue } "Home AD not present in user's AD permissions" { # Message TBD set result 2 add_status "Home AD not present in user's AD permission list" 1 exp_continue } "Invalid user account description" { set result 2 add_status "User account description exceeds maximum allowed length" 1 exp_continue } "has been successfully added" { set result 0 add_status "User account created successfully" 3 exp_continue } -re "$cl_PROMPT" { exp_continue } }

#

set show_res [verify_user_profile $user $role $admem_list $adhome $description]

set result 0 #

Need to handle AD Name now I am overlooking foreach ad $admem_list { if {($ad>=0)&&($ad<=255)} { set id 1 } else { set id 0 return 0 } } if {$admem_list==""} { set id 1 } if {$id==1} { set show_res [verify_user_profile $user $role $admem_list $adhome $description] if {($show_res!=0)} { add_status "Userconfig show doesn't show correct profile" 1 set result 2 } } return $result

} ############################################################################## ###### ############################################################################## ######

## NAME ##

create_uservf

## ## SYNOPSIS ##

create_user user [role] [password] [VF_ID list] [home VF] [Chassis Role] [Description]

## ## DESCRIPTION ##

This procedure will create user with given role, password, VF members and home VF

## ## OPERANDS ##

user

: name of the account

##

role

: role of the account

##

vflist

: VF list

##

vfhome

: Home VF

##

vfchassis : Permission for chassis cli's

##

description

: Description for user profile

## ## DEPENDENCIES ##

NONE

## ## RETURN ##

0 : successful creation of user

##

1 : User account already exists

##

2 : Failed to create new user due to failure

##

## USAGE ##

create_user "USER1" "user" "passwd" - Creating a user without assigning any FID

## create_user "USER1" "user" "passwd" "FID1 FID2 FID3" - Creatinga user with VF FID list "FID1 FID2 FID3" ## create_user "USER1" "user" "passwd" "FID1 FID2 FID3" "FID3" - Creating user with VF FID list and home FID3 ## create_user "USER1" "user" "passwd" "" "" "User with role user" - Creating user without VF List but it has description ## create_user "USER1" "user" "passwd" "FID1 FID2 FID3" "FID2" "Creating User" -Creating user with VF list,home & descri ############################################################################## ##### proc create_uservf {user {role ""} {password ""} {vflist ""} {vfhome ""} {vfchassis ""} {description ""} {passexpire ""}} { global cl_PROMPT global cl_user_password global cl_tmp_logical_switch_fid_list

if {$role == ""} { set role admin } if {$password == ""} { set password $cl_user_password } if {$description == ""} { set description "$user creation" } if {$vflist!=""} {

set vf_string [join $vflist ,] } if {$vfchassis == ""} { set vfchassis admin }

add_status "Creating the user $user with role $role and password $password and chassis role $vfchassis" 3 set result 0 set command_to_send "" if {($vflist=="")&&($vfhome=="")} { set command_to_send "userConfig --add $user -r $role -l [lindex $cl_tmp_logical_switch_fid_list 0] -h [lindex $cl_tmp_logical_switch_fid_list 0] -d \"$description\" -c $vfchassis" } if {($vflist!="")&&($vfhome!="")} { set command_to_send "userConfig --add $user -r $role -l $vf_string -h $vfhome -d \"$description\" -c $vfchassis" } if {$passexpire!=""} { append command_to_send " -x" }

send_command $command_to_send expect { "Named account already exists" { set result 1

add_status "$user account already exists" 3 exp_continue } "assword:" { sleep 1 exp_send "$password\r" exp_continue } "command not found" { set result 2 add_status "Current user cannot create a user account" 3 exp_continue } "Maximum number of allowed accounts reached" { set result 2 add_status "Unable to create new user as maximun no. of allowed accounts reached" 1 exp_continue } "Invalid user account name" { set result 2 add_status "Invalid user account name $user" 1 exp_continue } "Invalid role" { set result 2

add_status "Invalid user account role $role" 1 exp_continue } "An invalid VF_ID was specified" { set result 2 add_status "Invalid VF_ID" 1 exp_continue } "Maximum VF_ID list size exceeded" { set result 2 add_status "Maximum VF_ID list size exceeded" 1 exp_continue } "The Home VF specified is not present in the users VF permissions" { set result 2 add_status "Home AD not present in user's AD permission list" 1 exp_continue } "Invalid user account description" { set result 2 add_status "User account description exceeds maximum allowed length" 1 exp_continue } "has been successfully added" { set result 0

add_status "User account created successfully" 3 exp_continue } #

-re "$cl_PROMPT" {

#

exp_continue

#

} -re "$cl_PROMPT" { } timeout { add_status "Command Timed out($timeout)" 2 } } set result 0 return $result

} ############################################################################## ########################## ## NAME ##

user_passwd_failure

## ## SYNOPSIS ## user_passwd_failure param user [role] [password] [AD list] [home AD] [Description] ## ## DESCRIPTION ## ##

This procedure will handle invalid passwords passed for creating a user

## OPERANDS ##

param : password feature for which invalid scenarios have to be taken care

##

user : name of the account

##

role : role of the account

##

admem_list: AD member list

##

adhome: Home AD

##

description: Description for user profile

## ## DEPENDENCIES ##

NONE

## ## RETURN ##

0 : successful creation of user

##

1 : User account already exists

##

2 : Failed to create new user due to failure

## ## USAGE ## user_passwd_failure "repeat" "USER1" "user" "passwd" ## ############################################################################## ##### proc user_passwd_failure { param user {role ""} {password ""} {admem_list ""} {adhome ""} {description ""} } { global cl_PROMPT global cl_user_password set count 0

if {$role == ""} { set role admin } if {$password == ""} { set password $cl_user_password } if {$description == ""} { set description "$user creation" } if {$admem_list!=""} { set admem_string [join $admem_list ,] } add_status "Creating the user $user with role $role and password $password" 3 set result 0 set command_to_send ""

if {($admem_list=="")&&($adhome=="")} { set command_to_send "userConfig --add $user -r $role -d \"$description\"" } if {($adhome=="")&&($admem_list!="")} { set command_to_send "userConfig --add $user -r $role -a $admem_string -d \"$description\"" }

if {($adhome!="")&&($admem_list!="")} {

set command_to_send "userConfig --add $user -r $role -h $adhome -a $admem_string -d \"$description\"" } send_command $command_to_send switch $param { "repeat" { expect { "Enter new password:" { exp_send "$password\r" incr count exp_continue

} "Password contains more repeated characters than allowed" { add_status "Password contains more repeated characters than allowed string " 3 exp_continue } "Password must be between 8 and 40 characters long." { add_status " Password supplied must be satisfying the basic conditions " 1 } "Failed to get user account password" { if {$count != 3 } { add_status "Account creation successful eventhough it violates passwd policy" 1 } else { add_status "Account creation Unsuccessful " 3 }

} } } "sequence" { expect { "Enter new password:" { exp_send "$password\r" incr count exp_continue

} "Password contains more character sequences than allowed" { add_status "Password contains more characters in sequence than allowed " 3 exp_continue } "Password must be between 8 and 40 characters long." { add_status " Password supplied must be satisfying the basic conditions " 1 } "Failed to get user account password" { if {$count != 3 } { add_status "Account creation successful eventhough it violates passwd policy" 1 } else { add_status "Account creation Unsuccessful " 3 } }

} } } } ############################################################################## ###### ## NAME ##

remove_user

## ## SYNOPSIS ##

remove_user user

## ## DESCRIPTION ##

This procedure will remove user $user account from the switch

## ## OPERANDS ##

user

## ## DEPENDENCIES ##

NONE

## ## RETURN ##

0 : success

##

1 : failed to remove the user from the switch

## ## USAGE

##

remove_user "USER1"

## ############################################################################## ##### proc remove_user {user} { add_status "Removing user account $user from the switch" 3 if {[do_command "userconfig --delete $user"] != 0} { add_status "Unable to delete the account $user form the switch" 1 return 1 } return 0 }

############################################################################## ###### ## NAME ##

verify_user_profile

## ## SYNOPSIS ##

verify_user_profile user [role] [ad_list] [home_ad] [description]

## ## DESCRIPTION ##

This procedure will check whether user was created successfully with

##

role, home AD, AD list. These are passed as argument

## ## OPERANDS

##

user : name of the account

##

role : role of the account

##

ad_list: AD member list

##

home_ad: Home AD

##

description: Description for user profile

## ## DEPENDENCIES ##

NONE

## ## RETURN ##

0 : User profile verification passed

##

1 : User profile verification failed

## ## USAGE ##

verify_user_profile "USER1" "admin" "1 3" 1 "User Check"

## ############################################################################## ##### proc verify_user_profile {user {role ""} {ad_list ""} {home_ad ""} {description ""}} { # Verifying whether the user is created successfully add_status "Verifying profile of user $user" 3 set userconf_list [get_command "userconfig --show $user" 10] set ad_list [lsort -integer $ad_list] if {[regexp "Account name: $user" $userconf_list] != 1} { add_status "User $user profile doesnot exists" 1 return 1

} if {$role !=""} { if {[regexp "Role: $role" $userconf_list] != 1} { add_status "User not created with role $role " 1 return 1 } } if {$ad_list!=""} { set parameter "AD membership: " set parameter1 "Home AD" if {[regexp ($parameter)(.*)($parameter1) $userconf_list expression expression1 user_ad]} { foreach ad $user_ad { if {[regexp {([0-9]+)-([0-9]+)} $ad]} { set ad_range [split $ad -] for {set i [lindex $ad_range 0]} {$i<=[lindex $ad_range 1]} {incr i} { append user_ad_list $i " " } } else { append user_ad_list $ad " " } } } set compare_result [compare_lists [lsort $user_ad_list] [lsort $ad_list]] if {$compare_result != ""} {

add_status "There is variation in AD list configured $ad_list and shown $user_ad_list" 1 } }

if {$home_ad!=""} { if {[regexp "Home AD: $home_ad" $userconf_list] != 1} { add_status "Home AD is wrong" 1 return 1 } } if {$description!=""} { if {[regexp "Description: $description" $userconf_list] != 1} { add_status "Description for user is wrong" 1 return 1 } } return 0 }

############################################################################## ###### ## NAME ##

verify_user_admember

## ## SYNOPSIS

##

verify_user_admember user AD_list

## ## DESCRIPTION ##

This procedure will check whether the user has the ad members specified.

## ## OPERANDS ##

user : name of the account

##

ad_list : AD member list

## ## DEPENDENCIES ##

NONE

## ## RETURN ##

0 : AD member present for this particular user

##

1 : AD memeber is not part of this particular user

## ## USAGE ##

verify_user_admember "USER1" "1 3 4"

## ############################################################################## ##### proc verify_user_admember {user ad_list} { # Verifying whether ad_memeber is present set return_value 0 set userconf_list [get_command "userconfig --show $user"] set ad_list [lsort -integer $ad_list]

set parameter "AD membership: " set parameter1 "Home AD"

if {[regexp ($parameter)(.*)($parameter1) $userconf_list expression expression1 user_ad]} { foreach ad $user_ad { if {[regexp {([0-9]+)-([0-9]+)} $ad]} { set ad_range [split $ad -] for {set i [lindex $ad_range 0]} {$i<=[lindex $ad_range 1]} {incr i} { append user_ad_list $i " " } } else { append user_ad_list $ad " " } } }

foreach ad $ad_list { if {[lsearch $user_ad_list $ad] == -1} { set return_value 1 } } return $return_value }

##############################################################################

###### ## NAME ##

verify_user_adhome

## ## SYNOPSIS ##

verify_user_adhome user ad

## ## DESCRIPTION ##

This procedure will check whether the user has specified AD as its home AD.

## ## OPERANDS ##

user : name of the account

##

ad : AD

## ## DEPENDENCIES ##

NONE

## ## RETURN ##

0 : AD is home AD for this particular user

##

1 : AD is not home AD for this particular user

## ## USAGE ##

verify_user_adhome "USER1" "3"

## ############################################################################## #####

proc verify_user_adhome {user ad} { # Verifying whether Home AD is the given AD set return_value 0 set userconf_list [get_command "userconfig --show $user"] if {[regexp {(Home AD: )(.*)} $userconf_list i j ad_home] == 1} { if {$ad_home!=$ad} { set return_value 1 } } return $return_value } ############################################################################## ###### ## NAME ##

verify_passwd_configuration

## ## SYNOPSIS ##

verify_passwd_configuration parameter value

## ## DESCRIPTION ##

This routine will try to verify if the correct password attribute is set

## ## OPERANDS ## parameter: password configuration parameter (example: repeat,sequence etc) ## ##

value: value that needs to verified for that particular password parameter

## DEPENDENCIES ##

NONE

## ## RETURN ## 0 - Success ##

1 - Failure

## ## USAGE ##

verify_passwd_configuration "repeat" "3"

## ############################################################################## ##### proc verify_passwd_configuration {parameter value} { set parameter [string tolower $parameter] set passwd_configuration passwdcfg.$parameter: set parameter_value [trim_string [get_after "passwdcfg --show" $passwd_configuration]] if {$value==$parameter_value} { return 0 } else { return 1 } }

############################################################################## ###### ## NAME

##

add_ad_to_user

## ## SYNOPSIS ##

add_ad_to_user user ad_list [ad_home]

## ## DESCRIPTION ##

This routine is used to add AD/homeAD to the user

## ## OPERANDS ## ## ##

user : name of the account ad_list : List of AD's that needs to be added ad_home: Home AD that will be modified

## ## ## DEPENDENCIES ##

NONE

## ## RETURN ##

0 : successful additon of AD to user

##

1 : failed to add AD to the user

## ## USAGE ##

add_ad_to_user "USER1" "AD1 AD2 AD3" "AD2" - Adding AD and Home AD

## add_ad_to_user "USER1" "AD1 AD2 AD3" modifying the Home AD ##

- Adding only the AD memebers not

############################################################################## ##### proc add_ad_to_user {user admem_list {adhome ""}} { global cl_PROMPT

set admem_string [join $admem_list ,] add_status "Adding ad $admem_list to user $user" 3 set result 0 set command_to_send ""

if {($adhome=="")} { set command_to_send "userConfig --addad $user -a $admem_string" }

if {($adhome!="")} { set command_to_send "userConfig --addad $user -h $adhome -a $admem_string" }

send_command $command_to_send expect { "command not found" { set result 1 add_status "Current user cannot create a user account" 3 exp_continue } "Maximum number of allowed accounts reached" {

set result 1 add_status "Unable to create new user as maximun no. of allowed accounts reached" 1 exp_continue } "Invalid user account name" { set result 1 add_status "Invalid user account name $user" 1 exp_continue } "Invalid AD-ID" { # Message TBD set result 1 add_status "Invalid Admin Domain" 1 exp_continue } "Maximum AD_ID list size exceeded" { # Message TBD set result 1 add_status "Maximum AD_ID list size exceeded" 1 exp_continue } "Home AD not present in user's AD permissions" { # Message TBD set result 1 add_status "Home AD not present in user's AD permission list" 1 exp_continue } "New Ads for account $user has been successfully added" {

set result 0 add_status "AD added successfully" 3 exp_continue } -re "$cl_PROMPT" { exp_continue } } set show_res [verify_user_admember $user $admem_list] if {$show_res != 0} { add_status "userconfig show doesn't show the added AD memeber $admem_list" 1 set result 2 } if {$adhome!=""} { set show_res [verify_user_adhome $user $adhome] if {$show_res != 0} { add_status "userconfig show doesn't show the added home AD memeber" 1 set result 2 } } return $result }

############################################################################## ######

## NAME ##

delete_ad_from_user

## ## SYNOPSIS ##

delete_ad_from_user user ad_list [ad_home]

## ## DESCRIPTION ##

This routine is used to delete AD/home AD from the user

## ## OPERANDS ## ## ##

user : name of the account ad_list : List of AD's that needs to be added ad_home: Home AD that will be modified

## ## ## DEPENDENCIES ##

NONE

## ## RETURN ##

0 : successful deletion of AD to user

##

1 : failed to delete AD from the user

## ## USAGE ##

delete_ad_from_user "USER1" "AD1 AD2 AD3" "AD2" - deleting AD and Home AD

##

delete_ad_from_user "USER1" "AD1 AD2 AD3"

- deleting only the AD memebers

## ############################################################################## ##### proc delete_ad_from_user {user admem_list {adhome ""}} { global cl_PROMPT

set admem_string [join $admem_list ,] add_status "Deleting ad $admem_list from user $user" 3 set result 0 set command_to_send ""

if {($adhome=="")} { set command_to_send "userConfig --deletead $user -a $admem_string" }

if {($adhome!="")} { set command_to_send "userConfig --deletead $user -h $adhome -a $admem_string" }

send_command $command_to_send expect { "command not found" { set result 1 add_status "Current user cannot create a user account" 3 exp_continue }

"Maximum number of allowed accounts reached" { set result 1 add_status "Unable to create new user as maximun no. of allowed accounts reached" 1 exp_continue } "Invalid user account name" { set result 1 add_status "Invalid user account name $user" 1 exp_continue } "Invalid AD-ID" { # Message TBD set result 1 add_status "Invalid Admin Domain" 1 exp_continue } "Maximum AD_ID list size exceeded" { # Message TBD set result 1 add_status "Maximum AD_ID list size exceeded" 1 exp_continue } "Home AD not present in user's AD permissions" { # Message TBD set result 1 add_status "Home AD not present in user's AD permission list" 1 exp_continue }

"New Ads for account $user has been successfully deleted" { set result 0 add_status "AD added successfully" 3 exp_continue } -re "$cl_PROMPT" { exp_continue } } set show_res [verify_user_admember $user $admem_list] if {$show_res != 1} { add_status "userconfig show displays the deleted AD memeber" 1 set result 2 } if {$adhome!=""} { set show_res [verify_user_adhome $user $adhome] if {$show_res != 1} { add_status "userconfig show displays the deleted home AD memeber" 1 set result 2 } } return $result }

############################################################################## ######

## NAME ##

login_user

## ## SYNOPSIS ##

login_user ip_address user passwd

## ## DESCRIPTION ##

This procedure will login as user, and stores the spawn_id as

##

two dimension spawn_user_id array

##

Example: spawn_user_id(10.32.247.51,user1)

## ## OPERANDS ## ## ##

ip_address : IP address of the switch user : User name to login the switch passwd : Password of the user

## ## DEPENDENCIES ##

global two dimenstional array should be present in the main program

## Example: set spawn_user_id(10.32.247.51,user1) "" ## ## ## RETURN ##

None

## ## USAGE

##

login_user 10.32.247.41 user1 password

## ############################################################################## ##### proc login_user {ip_address user passwd} { global array spawn_user_id global spawn_id if {[set_spawn_id $spawn_user_id($ip_address,$user)] != 0} { if {[telnet_switch $ip_address $user $passwd] != 0} { add_status "Telnet to switch $ip_address failed" 0 } } set spawn_user_id($ip_address,$user) $spawn_id }

############################################################################## ###### ## NAME ## verify_failure_nondist_cfgdownload ## ## SYNOPSIS ## verify_failure_nondist_cfgdownload ## ## DESCRIPTION ## This routine will try to download the configuration filter parameter to the switch and verify that configuration \ ##

parameters cannot be downloaded when switch is enabled

## ## OPERANDS ## NONE ## ## DEPENDENCIES ##

NONE

## ## RETURN ##

NONE

## ## USAGE ## verify_failure_nondist_cfgdownload param "value" ## ############################################################################## #####

proc verify_failure_nondist_cfgdownload { } {

global cl_upload_host global cl_upload_user global cl_upload_file global cl_upload_passwd set protocol ftp set return_value 0 set timeout 300 exp_send "configDownload\r"

expect { "may not be executed" { add_status "Switch must be disabled first." 1 } "erver Name " { exp_send "$cl_upload_host\n" exp_continue } "ser Name " {

exp_send "$cl_upload_user\n" exp_continue } "ile Name " { exp_send "$cl_upload_file\n" exp_continue } "rotocol (" { exp_send "\n" exp_continue } "assword:" { exp_send "$cl_upload_passwd\n" exp_continue }

"Do you want to continue" { exp_send "y\n" exp_continue } "ogin incorrect." { add_status "config_download failed. Login incorrect." 1 } "ermission denied." { add_status "config_download failed. Permission denied." 1 } "load failed" { add_status "config_download failed. (Incorrect host / user / password ?)" 1 } "load complete" { add_status "Config download performed even when switch was not disabled " 1 set return_value 1 } "configDownload not permitted" { add_status " Verified that Configuration file cannot be downloaded to the switch without disabling it" 3 set return_value 0 } "Can only execute this command on the Primary FCS switch" { add_status " Verified that Configuration file cannot be downloaded to the backup FCS switch without disabling it" 3 set return_value 0

}

timeout { add_status "configDownload timed out." 1 } } clear_buffer return $return_value }

proc verify_success_nondist_cfgdownload { } {

global cl_upload_host global cl_upload_user global cl_upload_file global cl_upload_passwd set protocol ftp set return_value 0 set timeout 300 exp_send "configDownload\r" expect { "may not be executed" { add_status "Switch must be disabled first." 1 } "erver Name " {

exp_send "$cl_upload_host\n" exp_continue } "ser Name " {

exp_send "$cl_upload_user\n" exp_continue } "ile Name " { exp_send "$cl_upload_file\n" exp_continue } "rotocol (" { exp_send "\n" exp_continue } "assword:" { exp_send "$cl_upload_passwd\n" exp_continue } "Do you want to continue" { exp_send "y\n" exp_continue } "ogin incorrect." {

add_status "config_download failed. Login incorrect." 1 } "ermission denied." { add_status "config_download failed. Permission denied." 1 } "load failed" { add_status "config_download failed. (Incorrect host / user / password ?)" 1 } "load complete" { add_status "Config download performed even when Primary FCS switch was not disabled "3 set return_value 1 } "configDownload not permitted" { add_status " Configuration file cannot be downloaded to the switch without disabling it" 1 set return_value 0 } "Can only execute this command on the Primary FCS switch" { add_status "Current Switch is a Primary FCS Switch" 1 set return_value 0 }

timeout { add_status "configDownload timed out." 1 }

} clear_buffer return $return_value }

##################################################### ################### ## NAME ##

verify_required_index - verifies if the minimum required

##

index is in a list

## ## SYNOPSIS ##

verify_required_index list min_index [error_level]

## ## DESCRIPTION ##

Verifies if the minimum required index is in a list

## ## OPERANDS ##

list:

##

min_index: The minimum required index. The default

## ## ## ##

A list for verifying required index.

ist set to 1 if not specified. error_level: Error level for add_status. The default is set to 0 if not specified.

## DEPENDENCIES ##

none

## ## RETURN ##

<index>: returns 0 if required number of index is in the list,

##

else will return the number of indexes needed to reach the

##

required number.

## ## USAGE ##

set index [verify_required_index $ip_list $min_ip $error_level]

##

if {$index != 0} {

##

add_status "this list needs $index more indexes to reach its

## ##

required index." }

##

proc verify_required_index {list_ {min_index_ 1} {error_level_ 0}} { set return_value 0 if {[llength $list_] < $min_index_} { add_status "Missing index(es), need at least $min_index_ in this list" $error_level_ set return_value [expr $min_index_ - [llength $list_]] } return $return_value }

################### ## NAME ##

login_all_ips - login to all ip addresses

## ## SYNOPSIS ##

login_all_ips ip_list min_ip [error_level]

## ## DESCRIPTION ##

Verifies if the minimum required ip addresses is in

##

the ip list and login to all ip addresses.

## ## OPERANDS ##

ip_list:

##

min_ip:

## ##

A list of ip addresses to login.

The minimum required ip addresses. The Default

is set to 1 if nothing is specified. error_level: Error level for add_status. The default is set

##

to 0 if nothing is specified.

## ## DEPENDENCIES ##

verify_required_index

## ## RETURN ##

<index>: If verification succeeds, returns 0 if all ip address

##

logins are successful, else will return the number of

##

logins that weren't successful.

##

If verification fails, returns the number of ip's

##

needed to reach the required number.

## ## USAGE ##

if {[login_all_ips $ip_list] == 0} {

## ##

add_status "All ip logins are successful" } else {

## ##

add_status "not all ip logins are successful" }

##

proc login_all_ips {ip_list_ {min_ip_ 1} {error_level_ 0}} { set return_value 0

set index [verify_required_index $ip_list_ $min_ip_ $error_level_] if {$index != 0} { set return_value $index } else { for {set count 0} {$count < [llength $ip_list_]} {incr count 1} { if {[telnet_switch [lindex $ip_list_ $count]] == 1} { add_status "Switch [lindex $ip_list_ $count] not available" $error_level_ incr return_value 1 } } }

return $return_value }

################### ## NAME ##

get_list_intersection - gets the intersection of two lists

## ## SYNOPSIS ##

get_list_intersection element list

## ## DESCRIPTION ##

Gets the intersection of two lists.

## ## OPERANDS ##

list1

##

list2

## ## DEPENDENCIES ##

none

## ## RETURN ##

<list_intersection>: returns the intersection of two lists, else

## ## ## USAGE

will return "" if nothing is found.

##

set intersection [get_list_intersection $list1 $list2]

##

proc get_list_intersection {list1_ list2_} { set return_list "" foreach tmp1 $list2_ { foreach tmp2 $list1_ { if {$tmp1 == $tmp2} { lappend return_list $tmp1 } } } return $return_list }

################### ## NAME ##

get_list_opposite_of_intersection - gets the opposite of

##

intersection of two lists

## ## SYNOPSIS ##

get_list_opposite_of_intersection element list

## ## DESCRIPTION ##

Gets the opposite of intersection of two lists.

## ## OPERANDS ##

list1

##

list2

## ## DEPENDENCIES ##

none

## ## RETURN ##

<list_intersection>: returns the opposite of intersection of

##

two lists, else will return "" if

##

nothing is found.

## ## USAGE ##

set var [get_list_opposite_of_intersection $list1 $list2]

##

proc get_list_opposite_of_intersection {list1_ list2_} { set return_list "" foreach tmp1 $list2_ { set boolean 0 foreach tmp2 $list1_ { if {$tmp1 == $tmp2} { set boolean 1 break

} } if {$boolean == 0} { lappend return_list $tmp1 } } return $return_list }

################### ## NAME ##

reboot_host - reboots a sun host

## ## SYNOPSIS ##

get_list_opposite_of_intersection element list

## ## DESCRIPTION ##

Reboots a sun hust with the "reboot -- -r" command

## ## OPERANDS ##

host_ip: host ip address

##

host_user: host username

##

host_pass: host password

##

wait_for: For logging back into the host to ensure it is back

##

up from a reboot. Will sleep for specified seconds

##

and then ensure host is back up. If value given

##

is 0, it will skip the verification completely.

##

Will default to 60 if nothing is specified.

## ## DEPENDENCIES ##

none

## ## RETURN ##

<return>: returns 0 if host successfully rebooted, or a value

##

greater than 0 if not.

## ## USAGE ##

if {[reboot_host $host_ip] == 0} {

## ##

add_status "host has been successfully rebooted" }

##

#proc reboot_host {host_ip_ {host_user_ ""} {host_pass_ ""} {wait_for_ 60}} { #

global cl_PROMPT

#

global cl_HOST_PROMPT

#

global cl_is_last_command

#

global spawn_id

# # #

if {$host_user_ == ""} { global cl_host_name

#

set host_user_ $cl_host_name

#

}

#

if {$host_pass_ == ""} {

#

global cl_host_pass

#

set host_pass_ $cl_host_pass

#

}

#

if {($host_user_ == "") || ($host_pass_ == "")} {

# #

return 1 }

# #

set orig_prompt $cl_PROMPT

#

set orig_spawn_id $spawn_id

#

set orig_ilc $cl_is_last_command

# #

set cl_PROMPT $cl_HOST_PROMPT

#

telnet_switch $host_ip_ $host_user_ $host_pass_

#

set cl_is_last_command 1

#

set return_value [do_command "reboot -- -r"]

# #

if {$wait_for_ > 0} {

#

sleep $wait_for_

#

set cl_PROMPT $cl_HOST_PROMPT

#

set return_value [telnet_switch $host_ip_ $host_user_ $host_pass_]

#

if {$return_value == 0} {

#

end_telnet "exit"

# #

} }

# #

set cl_PROMPT $orig_prompt

#

set spawn_id $orig_spawn_id

#

set cl_is_last_command $orig_ilc

#

return $return_value

#}

proc reboot_host { args } { global cl_ERROR

set argc [llength $args]

if {$argc == 1} { set spawn_id [lindex $args 0] } elseif {$argc == 3} { set system_name [lindex $args 0] set user [lindex $args 1] set password [lindex $args 2] if {[telnet_host $system_name $user $password] != -1} { add_status "$system_name is up successfully; reboot it!" } else { add_status "$system_name is not up successfully, cannot reboot it." 1 return $cl_ERROR

} }

set system [get_uname]

if {$system == "HP-UX"} { send -- "shutdown -r now\r" sleep 300 puts "system rebooted!" return 0 } else { send -- "reboot -- -r\r" expect -exact "Connection closed by foreign host." { sleep 120 } puts "system rebooted!" return 0 }

} #############################################

################### ## NAME ##

verify_fabric_io - Verifies traffic throughout a fabric.

## ## SYNOPSIS

##

verify_fabric_io ip_list [target_list] [performance]

## ## DESCRIPTION ##

Verifies traffic on each device port in a fabric.

##

Note, traffic is verified by comparing the average

##

portperfshow to a performance limit (in bytes).

## ## OPERANDS ##

ip_list:

List of IP addresses of the switches that traffic is

##

desired to be verified. There must be connections

##

already open to the switches and available by spawn_id.

##

target_list: List of targets by WWN or Domain/Port format that

##

specifies which targets are desired for traffic

##

verification. The default is all targets if no list

##

is specified.

##

performance: An integer that represents the least amount of

##

performance (in bytes) that is acceptable for traffic

##

to be verified on a port. The default is 150000 bytes

##

if nothing is specified.

## ## DEPENDENCIES ##

verify_switch_io: verifies traffic for each switch

## ## RETURN ##

<failure_number>: returns 0 if traffic on all switches in the fabric

##

was successfully verified, else will return the

##

number of switches that failed verification.

## ## USAGE ##

if {[verify_fabric_io $cl_ip_address_list $target_list] > 0} {

## ##

add_status "traffic was not verified" 1 } else {

## ##

add_status "traffic was successfully verified" 3 }

##

proc verify_fabric_io {ip_list_ {target_list_ ""} {performance_ 150000}} { global spawn_id

set return_value 0 set original_spawn_id $spawn_id foreach ip $ip_list_ { if {[set_spawn_id $ip] == 0} { if {[verify_switch_io $target_list_ $performance_] > 0} { incr return_value 1 } } } set spawn_id $original_spawn_id return $return_value

}

################### ## NAME ##

verify_switch_io - Verifies traffic on a switch.

## ## SYNOPSIS ##

verify_switch_io [target_list] [performance]

## ## DESCRIPTION ##

Verifies traffic on each device port in a switch.

##

Note, traffic is verified by comparing the average

##

portperfshow to a performance limit (in bytes).

## ## OPERANDS ##

target_list: List of targets by WWN or Domain/Port format that

##

specifies which targets are desired for traffic

##

verification. The default is all targets if no list

##

is specified.

##

performance: An integer that represents the least amount of

##

performance (in bytes) that is acceptable for traffic

##

to be verified on a port. The default is 150000 bytes

##

if nothing is specified.

## ## DEPENDENCIES

##

get_switch_platform

##

get_device_areas

##

convert_to_slotport

##

get_avg_switch_perf

##

get_avg_port_perf

##

extract_port_perf

## ## RETURN ##

<failure_number>: returns 0 if traffic on all ports in the switch

##

was successfully verified, else will return the

##

number of ports that failed verification.

## ## USAGE ##

if {[verify_switch_io $target_list_ $performance_] > 0} {

## ##

add_status "traffic was not verified" 1 } else {

## ##

add_status "traffic was successfully verified" 3 }

##

proc verify_switch_io {{target_list_ ""} {performance_ 150000}} { set switch_type [get_switch_platform] set target_list_ [get_device_areas $target_list_] set return_value 0

foreach target $target_list_ { if {$switch_type > 4100} { set target [convert_to_slotport $target] } if {$switch_type == 3900} { set tmp_matrix [get_avg_switch_perf 50] set tmp_perf [extract_port_perf $tmp_matrix $target] } else { set tmp_perf [get_avg_port_perf $target 50] } if {$tmp_perf < 0} { set tmp_perf [expr $tmp_perf * -1] } if {$tmp_perf < $performance_} { add_status "The throughput on port $target is less than $performance_!!" 1 add_status "The throughput was $tmp_perf" incr return_value 1 } else { add_status "Traffic on port $target is confirmed!!" 3 add_status "The throughput was $tmp_perf" } clear_buffer } return $return_value }

###################

## NAME ##

get_device_areas - Gets the Pid areas all devices

## ## SYNOPSIS ##

get_device_areas [device_list]

## ## DESCRIPTION ##

Converts local devices into Pid area format.

##

Note, there is still an outstanding issue with legacy and core

##

Pid differentiation. This function assumes all Pids are in

##

core Pid format.

## ## OPERANDS ##

device_list: List of devices by WWN or Domain/Port format that

##

specifies which devices are desired to be converted

##

into Pid area format. The default is all devices

##

if no list is specified.

## ## DEPENDENCIES ##

get_device_pids

##

get_pid_port

##

get_devices

##

convert_to_dec

##

convert_to_domain_port

##

lappend_unique

##

replace_string

## ## RETURN ##

<area_list>: returns a list of all Pid areas found. Will return

##

"" if nothing was found.

## ## USAGE ##

set target_list [get_device_areas $target_list_]

##

proc get_device_areas {{device_list_ ""}} { set return_value "" set temp_list [get_device_pids]

if {$device_list_ == ""} { if {$temp_list != ""} { foreach single_pid $temp_list { set pid_area [convert_to_dec [get_pid_port $single_pid]] set return_value [lappend_unique $return_value $pid_area] } } } else { set local_devices [get_devices] foreach member $device_list_ { # if it is in "domain,port" format, change to "domain port"

set member [replace_string $member "," " "] set member [string tolower $member] foreach local_device $local_devices { set new_member "" if {([string first $member $local_device] >= 0) || ([convert_to_domain_port [lindex $local_device 0]] == $member)} { set new_member [convert_to_dec [get_pid_port [lindex $local_device 0]]] set return_value [lappend_unique $return_value $new_member] } } } }

return $return_value } ################################################### ############################################################################## ###### ## NAME ##

get_ti_zone_show

## ## SYNOPSIS ##

get_ti_zone_show

## ## DESCRIPTION

##

This routine will give the list of port members, status and failover from TI zone

## ## OPERANDS ## Name - Name of the zone ## ## ## DEPENDENCIES ##

NONE

## ## RETURN: ## List containing: ## port_list ## status ## failover ## ## USAGE ##

get_ti_zone_show zone1

## ############################################################################## #####

proc get_ti_zone_show {name} { set firmware_version [get_version] regexp {v[0-9]+.[0-9]+} $firmware_version version_string set zone_show_output [get_command "zone --show $name"] set zone_show_list [lrange [split $zone_show_output "\n"] 0 end-1]

if {[string compare $version_string "v6.1"] == 0} { foreach elem $zone_show_list { set elem [trim_string $elem] if {[regexp {(Port List:)(.*)} $elem i j k] == 1} { set port_list "" set port_list [trim_string $k] } if {[regexp {(Status:)(.*)(Failover:)} $elem i j k] == 1} { set status [trim_string $k] } if {[regexp {(Failover:)(.*)} $elem i j k] == 1} { set failover [trim_string $k] } } set port_list [split $port_list ";"] foreach port $port_list { set port [trim_string $port] if {$port!=""} { append port_list1 $port " " } } set zone_show_list "{$port_list1} $status $failover" return $zone_show_list } else { foreach elem $zone_show_list {

set elem [trim_string $elem] if {[regexp {(Port List:)(.*)} $elem i j k] == 1} { set port_list "" set port_list [trim_string $k] } elseif {![regexp {Configured|Enabled} $elem]} { append port_list $elem add_status "Ari:port list is $port_list" } if {[regexp {(Configured Status:)(.*)(/ Failover-)} $elem i j k] == 1} { add_status "Stats is $i, $j, $k" set status [trim_string $k] } if {[regexp {(Failover-)(.*)} $elem i j k] == 1} { add_status "failover is $i, $j, $k" set failover [trim_string $k] } } set port_list [split $port_list ";"] foreach port $port_list { set port [trim_string $port] if {$port!=""} { append port_list1 $port " " } } add_status "list1 $port_list1"

set zone_show_list "{$port_list1} $status $failover" return $zone_show_list } } ############################################################################## ###### ## NAME ##

ti_zone_create

## ## SYNOPSIS ##

ti_zone_create

## ## DESCRIPTION ##

This routine will create ti zone with port members

## ## OPERANDS ## Name - Name of the zone ## port_list - List of ports(D,P) ## ## DEPENDENCIES ##

NONE

## ## RETURN ## ## USAGE ##

To create TI zone with list of parameters

##

ti_zone_create zone1 {1,1 1,3}

## ############################################################################## #####

proc ti_zone_create {name member_list {failover ""} {activate ""}} {

set i 0 foreach member $member_list { if {$i!=0} { append member_string ";" } incr i append member_string [join $member ";"] } set member_string \"$member_string\" if {($failover=="")&&($activate=="")} { do_command "zone --create -t ti $name -p $member_string" } if {($failover=="")&&($activate!="")} { do_command "zone --create -t ti -o d $name -p $member_string" } if {($failover!="")&&($activate=="")} { do_command "zone --create -t ti -o n $name -p $member_string" } if {($failover!="")&&($activate!="")} {

do_command "zone --create -t ti -o dn $name -p $member_string" } }

############################################################################## ###### ## NAME ##

ti_zone_add

## ## SYNOPSIS ##

ti_zone_add

## ## DESCRIPTION ##

This routine will add port members to ti zone

## ## OPERANDS ## Name - Name of the zone ## port_list - List of ports(D,P) ## failover- f(failover enable) ##

n(failover disable)

## activate- a(activate) ##

d(deactivate)

## ## DEPENDENCIES ## ##

NONE

## RETURN ## ## USAGE ##

To add TI zone with list of parameters

##

ti_zone_add zone1 {1,1 1,3}

## ############################################################################## #####

proc ti_zone_add {name member_list {failover ""} {activate ""}} { set member_string "" set i 0 foreach member $member_list { if {$i!=0} { append member_string ";" } incr i append member_string [join $member ";"] } set member_string \"$member_string\" if {($failover=="")&&($activate=="")} { do_command "zone --add $name -p $member_string" } if {($failover=="")&&($activate!="")} { do_command "zone --add -o d $name -p $member_string" }

if {($failover!="")&&($activate=="")} { do_command "zone --add -o an $name -p $member_string" } if {($failover!="")&&($activate!="")} { do_command "zone --add -o dn $name -p $member_string" } }

############################################################################## ###### ## NAME ##

ti_zone_remove

## ## SYNOPSIS ##

ti_zone_remove

## ## DESCRIPTION ##

This routine will remove port members from TI zone

## ## OPERANDS ## Name - Name of the zone ## port_list - List of ports(D,P) ## ## DEPENDENCIES ##

NONE

## ## RETURN ## ## USAGE ##

To remove the port members from TI zone

##

ti_zone_add zone1 {1,1 1,3}

## ############################################################################## #####

proc ti_zone_remove {name member_list} {

set i 0 foreach member $member_list { if {$i!=0} { append member_string ";" } incr i append member_string [join $member ";"] } set member_string \"$member_string\" do_command "zone --remove $name -p $member_string" }

############################################################################## ######

## NAME ##

verify_ti_zone_show

## ## SYNOPSIS ##

verify_ti_zone_show

## ## DESCRIPTION ##

This routine will verify the ti zone show with portlist, status and failover

## ## OPERANDS ## Name - Name of the zone ## port_list - list of ports participating in the zone ## state - State of TI zone activated or non activated state ## failover - status whether failover is enabled or disabled ## ## DEPENDENCIES ##

get_ti_zone_show

## ## RETURN: ## NONE ## ## ## USAGE ## ##

verify_ti_zone_show zone1 {1,1 1,2 1,3} Activated Enabled

############################################################################## #####

proc verify_ti_zone_show {name port_list {state ""} {failover ""}} { set ti_zone_show [get_ti_zone_show $name] set got_port_list [lindex $ti_zone_show 0] add_status "got_port is $got_port_list and $port_list" foreach port $port_list { if {[lsearch $got_port_list $port] == -1} { add_status "port $port is not in the zone show list" 1 } } if {$state!=""} { if {$state !=[lindex $ti_zone_show 1]} { add_status "State of TI zone $name doesn't match: expected $state, found [lindex $ti_zone_show 1]" 1 } } if {$failover!=""} { if {$failover !=[lindex $ti_zone_show 2]} { add_status "Failover status of TI zone $name doesn't match: expected $failover, found [lindex $ti_zone_show 2]" 1 } } }

############################################################################## ###### ## NAME ##

get_ti_zone_state

## ## SYNOPSIS ##

get_ti_zone_state

## ## DESCRIPTION ##

This routine will return the state of specified TI zone

## ## OPERANDS ## Name - Name of the zone ## ## ## DEPENDENCIES ##

get_ti_zone_show

## ## RETURN: ## status ## ## ## USAGE ##

get_ti_zone_state zone1

## ##############################################################################

#####

proc get_ti_zone_state {name} { set ti_zone_show_list [get_ti_zone_show $name] return [lindex $ti_zone_show_list 1] }

############################################################################## ###### ## NAME ##

get_ti_zone_failover

## ## SYNOPSIS ##

get_ti_zone_failover

## ## DESCRIPTION ##

This routine will return the failover status of specified TI zone

## ## OPERANDS ## Name - Name of the zone ## ## DEPENDENCIES ##

get_ti_zone_state

## ## RETURN: ## failover state(Enabled or Disabled)

## ## ## USAGE ##

get_ti_zone_failover zone1

## ############################################################################## #####

proc get_ti_zone_failover {name} { set ti_zone_show [get_ti_zone_show $name] return [lindex $ti_zone_show 2] }

proc get_route_domain {in_port domain} { set return_value ""

set raw_data [make_matrix "urouteshow [convert_area_slotport $in_port] $domain" "----------" "" 6] set in_port_blob "" set in_port_current "" foreach line $raw_data { set in_port [lindex $line 0] scan [lindex $line 1] "%d %d %d %d %s %d,%d" domain_ out_port_ metric_ hops_ flags_ remote_domain_ remote_port_ if {$in_port != ""} { if {$in_port_blob != ""} {

lappend return_value [list $in_port_current $in_port_blob] set in_port_current $in_port set in_port_blob [list "$domain_ $out_port_ $metric_ $hops_ $flags_ $remote_domain_ $remote_port_"] } else { set in_port_current $in_port lappend in_port_blob [list $domain_ $out_port_ $metric_ $hops_ $flags_ $remote_domain_ $remote_port_] } } else { lappend in_port_blob [list $domain_ $out_port_ $metric_ $hops_ $flags_ $remote_domain_ $remote_port_] } } lappend return_value [list $in_port_current $in_port_blob] return $return_value } proc get_out_next_dp {in_port domain} {

set route_list [get_route_domain $in_port $domain] set local_domain [trim_string [parse_integer [get_after "switchshow" "switchDomain:"]]] set out_route_list [lindex [lindex $route_list 0] 1] foreach route $out_route_list { set dom [lindex $route 5] set out_port [lindex $route 1] set next_port [lindex $route 6] set ndp "$dom,$next_port"

set odp "$local_domain,$out_port" append dp_list $odp " " $ndp " " } return $dp_list }

proc verify_no_route {in_port domain} { set route_list [get_route_domain $in_port $domain] set routes [lindex $route_list 0] foreach route $routes { if {$route!=""} { add_status "Routes are not empty" 1 } } } ########################################### proc telnet_SW {} { global cl_SWITCH global cl_EXPECTED_VERSION

release_term_console

if {[telnet_switch $cl_SWITCH] != 0} { add_status "Unable to connect to $cl_SWITCH" 0; }

send_command "auto" expect { "Booting" { add_status "waiting.." 1 sleep 60 end_telnet "exit" if {[telnet_switch $cl_SWITCH] != 0} { add_status "Unable to connect to $cl_SWITCH" 0; } } } set_spawn_id $cl_SWITCH do_command "version" if {[verify_version $cl_EXPECTED_VERSION] == 1} { add_status "Incorrect version. Firmwaredownload failed" 0 } }

proc reboot_SW {} {

global cl_SWITCH

# Reboot switch

set_spawn_id $cl_SWITCH puts "SWITCH GOING FOR FASTBOOT.." set cl_login_pause 200 do_command "fastboot" wait_for "Enabling switch..." 120:w }

proc release_term_console {} { global cl_SWITCH global cl_PROMPT

# find console ip ports set loc [string first " " $cl_SWITCH] set console [string range $cl_SWITCH 0 $loc]

set loc [expr $loc + 3] set port1 [string range $cl_SWITCH $loc end] if {[string index $port1 0] == 0} { set port1 [string index $port1 1] }

set old_PROMPT $cl_PROMPT set cl_PROMPT "> "

if {[telnet_switch $console "root" "pass"] != 0} { add_status "Unable to connect to $console" 0; }

add_status "sending command" do_command "user logout port$port1" end_telnet "quit"

sleep 5

set $cl_PROMPT $old_PROMPT } ####################################################### puts "

########################## temp library ##########################"

# type 26 should be 3850 # type 22 should be 3016 # type 21 should be 24000 # type 23 should be production model number for Pulsar-24 # type 32 should be production model number for Pulsar-32 proc get_switch_platform {} { set switch_version 0

set switch_type [parse_real [get_after "switchShow" "switchType:"]] set switch_type [parse_integer $switch_type strict]

# set chassis_config [parse_real [get_after "chassisconfig" "Current Option:"]] # set chassis_config [parse_integer $chassis_config strict] if {$switch_type < "1"} { set switch_type [parse_real [get_after "agswitchshow" "switchType:"]] set switch_type [parse_integer $switch_type strict] if {$switch_type < "1"} { # The line below is needed to handle the case of a standby switch # which does not support the switchShow command to return a switchType set switch_version 12000 } else { set switch_version 3900 } } elseif {$switch_type == "32"} { set switch_version 3900 } elseif {$switch_type == "26"} { set switch_version 3900 } elseif {$switch_type == "27"} { set switch_version 3900 } elseif {$switch_type == "23"} { set switch_version 3900 } elseif {$switch_type == "22"} { set switch_version 3900 } elseif {$switch_type == "29"} { set switch_version 3900 } elseif {$switch_type == "21"} {

set chassis_config [parse_real [get_after "chassisconfig" "Current Option:"]] set chassis_config [parse_integer $chassis_config strict] if {$chassis_config == "2"} { set switch_version 12000 } else { set switch_version 12128 } } elseif {$switch_type == "17"} { set switch_version 3600 } elseif {$switch_type == "16"} { set switch_version 3200 } elseif {$switch_type == "12"} { set switch_version 3900 } elseif {$switch_type == "10"} { set switch_version 12000 } elseif {$switch_type == "9"} { set switch_version 3800 } elseif {$switch_type <= "8"} { set switch_version 2000 } elseif {$switch_type == "42"} { set switch_version 12128 } elseif {$switch_type == "33"} { set switch_version 3900 } elseif {$switch_type == "34"} { set switch_version 3900

} elseif {$switch_type == "44"} { set switch_version 3900 } elseif {$switch_type == "46"} { set switch_version 3900 } elseif {$switch_type == "37"} { set switch_version 3900 } elseif {$switch_type == "58"} { set switch_version 3900 } elseif {$switch_type == "55"} { set switch_version 3900 } elseif {$switch_type == "62"} { set switch_version 96000 } elseif {$switch_type == "120"} { set switch_version 96000 } elseif {$switch_type == "64"} { set switch_version 3900 } elseif {$switch_type == "66"} { set switch_version 3900 } elseif {$switch_type == "71"} { set switch_version 3900 } elseif {$switch_type == "67"} { set switch_version 3900 } elseif {$switch_type == "76"} { set switch_version 3900 } elseif {$switch_type == "77"} {

set switch_version 68000 } elseif {$switch_type == "121"} { set switch_version 68000 } elseif {$switch_type == "83"} { set switch_version 5000 } elseif {$switch_type == "109"} { set switch_version 6510 }

return $switch_version }