648 lines
22 KiB
Plaintext
648 lines
22 KiB
Plaintext
# This file is a library of useful utilities designed to help automatic
|
|
# OS installation. It was written by Jerry Wei and modified by Jason
|
|
# Hunter.
|
|
|
|
# expect script file contains all expect procedures available for target
|
|
# specific installation script
|
|
|
|
global timeout
|
|
global inprom
|
|
global cmd_out server path
|
|
#global ip_dist mach_dist
|
|
|
|
#############################################################################
|
|
# different states of target machine during installation
|
|
#----------------------------------------------------------------------------
|
|
# p_mon in prom command monitor
|
|
# p_menu in prom menu
|
|
# u_root in unix logined as root
|
|
# u_user in unix logined other than root
|
|
# u_login in unix waiting for login
|
|
# i_top in inst top menu
|
|
# i_intr in inst interrupted menu
|
|
# i_adm in inst admin menu
|
|
# i_quit in inst waiting for confirmation of quit
|
|
# u_res in unix, finished inst waiting for confirmation to restart
|
|
# system
|
|
# u_rec in unix, during bootup ask for automatic system reconfigura-
|
|
# tion
|
|
#############################################################################
|
|
|
|
|
|
# trap interrupt in interact on the inst process
|
|
proc intr_intr {} {
|
|
send "\003"
|
|
trap {intr_intr} 2
|
|
}
|
|
|
|
# use interrupt to start interact on the inst process
|
|
proc intr {} {
|
|
global timeout
|
|
send_error "\ninterract with inst process directly\n"
|
|
send_error "use '^' to get back to expect, in expect use inter_return\n"
|
|
send_error "command to continue script execution\n"
|
|
set stimeout $timeout
|
|
trap {intr_intr} 2
|
|
interact ^
|
|
trap {intr} 2
|
|
set timeout $stimeout
|
|
}
|
|
|
|
# inst error
|
|
proc inst_go_err {} {
|
|
send_error "\007\ninst detect error, direct interact with inst\n"
|
|
send_error "after go again, use ^ to get back to expect, then type\n"
|
|
send_error "inter_return to continue\n"
|
|
trap {intr_intr} 2
|
|
interact ^
|
|
trap {intr} 2
|
|
# expect -re "Inst> $" {send"\r"} \
|
|
# timeout {send_error "install default failed"}
|
|
}
|
|
|
|
# change state, from u_login to u_root
|
|
proc u_login2u_root {} {
|
|
set timeout 300
|
|
send "root\r"
|
|
expect -re "# $" {send "\r"} \
|
|
"TERM = " {send "\r"} \
|
|
"TERM=" {send "\r"} \
|
|
timeout {send_error "timeout in u_login2u_root\n"; intr; send "\r"}
|
|
}
|
|
|
|
# change state, from p_menu to p_mon
|
|
proc p_menu2p_mon {} {
|
|
send "5\r"
|
|
expect -re ">> $" { } \
|
|
timeout {send_error "timeout in p_menu2p_mon\n"; intr; send "\r"}
|
|
}
|
|
|
|
# change state, from i_intr to i_top by stop command in interrupted menu
|
|
# to get into state in unix logined as root
|
|
# modified to handle failed autoboot's "Hit Enter to continue."
|
|
proc 2u_root {} {
|
|
global timeout
|
|
send "\r"
|
|
set timeout 900
|
|
for {} {1} {} {
|
|
expect {
|
|
-re "# $" {send "\r"; break}
|
|
-re "ogin: $" {u_login2u_root; set timeout 300}
|
|
"assword:" {send "\r"}
|
|
-re "% $" {send "exit\r"}
|
|
-re ">> $" {send "\003"}
|
|
-re "Inst> $" {send "q\r"}
|
|
"<Enter> to continue" {send "\r"}
|
|
"Option\\? \007\012" {send "1\r"}
|
|
"Option\\? \007" {send "1\r"}
|
|
"Option\\? $" {send "1\r"}
|
|
-ex "Restart? { (y)es, (n)o, (sh)ell, (h)elp }: " {send "y\r"}
|
|
-re "Restart\\? \\\[y, n] $" {send "y\r"}
|
|
-re "restart.$" {send "\r"}
|
|
-re "start\\? $" {send "y\r"}
|
|
"system (y or n)\\? " {send "y\r"}
|
|
-re "quit\\? $" {send "y\r"}
|
|
"2. Quit now" {send "2\r"}
|
|
-re ": \\\[y] $" {send "y\r"}
|
|
"Press <Enter> to continue" {send "\r"}
|
|
"Hit Enter to continue." {send "\r"}
|
|
"sash: " {send "\$OSLoadPartition\$OSLoadFilename\r"}
|
|
"PENDING INSTALATION " {inst_go_err}
|
|
"INCOMPATIBLE SUBSYSTEMS INSTALLED" {inst_go_err}
|
|
"Interrupt> " {send "1\r"}
|
|
timeout {send_user "timeout in 2U_root\n"; intr; send "\r"}
|
|
}
|
|
}
|
|
}
|
|
|
|
proc i_top2u_root {} {
|
|
send "\r"
|
|
set timeout 1800
|
|
for {} {1} {} {
|
|
expect {
|
|
-re "# $" {send "\r"; break}
|
|
-re "ogin: $" {u_login2u_root; set timeout 300}
|
|
-re "Inst> $" {send "q\r"}
|
|
-ex "Restart? { (y)es, (n)o, (sh)ell, (h)elp }: " {send "y\r"}
|
|
-re "Restart\\? \\\[y, n] $" {send "y\r"}
|
|
-re "restart.$" {send "\r"}
|
|
-re "start\\? $" {send "y\r"}
|
|
"system (y or n)\\? " {send "y\r"}
|
|
-re "quit\\? $" {send "y\r"}
|
|
"2. Quit now" {send "2\r"}
|
|
-re ": \\\[y] $" {send "y\r"}
|
|
"Press <Enter> to continue" {send "\r"}
|
|
"sash: " {send "\$OSLoadPartition\$OSLoadFilename\r"}
|
|
"PENDING INSTALATION " {inst_go_err}
|
|
"INCOMPATIBLE SUBSYSTEMS INSTALLED" {inst_go_err}
|
|
"Interrupt> " {send "1\r"}
|
|
timeout {send_user "timeout in i_top2u_root\n"; intr; send "\r"}
|
|
}
|
|
}
|
|
}
|
|
|
|
proc reboot {} {
|
|
send "reboot\r"
|
|
set timeout 600
|
|
for {} {1} {} {
|
|
expect {
|
|
-re "login: $" {u_login2u_root; break}
|
|
-re "Enter Reason for Shutdown.*>> $" {send "4\r" }
|
|
"Press <Enter> to continue" {send "\r"}
|
|
"sash: " {send "\$OSLoadPartition\$OSLoadFilename\r"}
|
|
timeout {send_error "timeout in reboot\n"; intr; send "\r"}
|
|
}
|
|
}
|
|
}
|
|
|
|
# to get into state in prom command monitor
|
|
proc u_root2p_mon {} {
|
|
send "\r"
|
|
expect {#\ } {set timeout 600; send "sync;sync;init 0\r"}
|
|
for {} {1} {} {
|
|
expect {
|
|
-re "restart.$" {send "\033"}
|
|
"<Esc>" {send "\033\033"}
|
|
"<Enter> to continue" {send "\r"}
|
|
"Option? \007\012" {send "5\r"; set timout 500}
|
|
"Option? " {send "5\r"}
|
|
-re "Enter Reason for Shutdown.*>> $" {send "4\r"}
|
|
-re ">> $" {break}
|
|
timeout {send_error "timeout in u_root2p_mon\n"; intr; send "\r"}
|
|
}
|
|
}
|
|
}
|
|
|
|
# to get into single user mode
|
|
proc u_root2u_s {} {
|
|
send "\r"
|
|
expect {#\ } {set timeout 600; send "sync;sync;init 1\r"}
|
|
for {} {1} {} {
|
|
expect {
|
|
"Single User Mode): " {send "\r"}
|
|
"TERM = " {send "\r"; break}
|
|
timeout {send_error "timeout in u_root2u_s\n"; intr; send "\r"}
|
|
}
|
|
}
|
|
}
|
|
|
|
# from single user mode to multi user mode
|
|
proc u_s2u_login {} {
|
|
send "\r"
|
|
expect {#\ } {set timeout 600; send "init 3\r"}
|
|
for {} {1} {} {
|
|
expect {
|
|
"login: " {break}
|
|
timeout {send_error "timeout in u_s2u_login; intr; send "\r"}
|
|
}
|
|
}
|
|
}
|
|
|
|
# execute acceptance test
|
|
proc exec_accept acceptcmd {
|
|
set timeout 5400
|
|
send "$acceptcmd \r"
|
|
for {} {1} {} {
|
|
expect {
|
|
" ,default y: " {send "n\r"}
|
|
-re "# $" {break}
|
|
-timestamp timeout {
|
|
send_error "acceptance timeout $expect_out(seconds) seconds\n";
|
|
intr; send "\r"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# execute a root shell command
|
|
proc sh_root_cmd shcmd {
|
|
global timeout
|
|
if {[string compare [lindex $shcmd 0] "TimeOut"] == 0} {
|
|
set timeout [lindex $shcmd 1]; return
|
|
}
|
|
if {[string match "*acceptance" [lindex $shcmd 0]] } {
|
|
exec_accept $shcmd ; return
|
|
}
|
|
|
|
send "$shcmd \r"
|
|
for {} {1} {} {
|
|
expect {
|
|
"more? " {send " "}
|
|
-re "# $" {break }
|
|
-re "Inst> $" {break}
|
|
-re "> $" {break}
|
|
-timestamp timeout {
|
|
send_error "sh_root_cmd $expect_out(seconds) seconds\n";
|
|
send_error "timeout in sh_root_cmd $shcmd\n"; intr; send "\r"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# to run a command in shell and get the output to return
|
|
proc sh_cmd_out shcmd {
|
|
send "$shcmd \r"
|
|
for {} {1} {} {
|
|
expect {
|
|
-re "\n(.*)# " {
|
|
if {[string first $shcmd $expect_out(buffer)] >= 0} {
|
|
break
|
|
} else {
|
|
continue
|
|
}
|
|
}
|
|
-timestamp timeout {
|
|
send_error "sh_cmd_out $expect_out(seconds) seconds\n";
|
|
send_error "timeout in sh_cmd_out $shcmd\n"; intr; send "\r"
|
|
}
|
|
}
|
|
}
|
|
# get cmd_out as in expect_out buffer after shcmd and before last newline
|
|
set s_last [expr [string last "\n" $expect_out(0,string)] -2]
|
|
set s_first [string first $shcmd $expect_out(0,string)]
|
|
if {$s_first >= 0} {
|
|
set s_first [expr $s_first + [string length $shcmd] + 3]
|
|
} else {
|
|
set s_first 1
|
|
}
|
|
set cmd_out [string range $expect_out(0,string) $s_first $s_last]
|
|
return "$cmd_out"
|
|
}
|
|
|
|
# execute a prom monitor command
|
|
proc prom_cmd promcmd {
|
|
send "$promcmd \r"
|
|
expect -re ">> $" { } \
|
|
timeout {send_error "timeout in prom_cmd $promcmd\n"; intr; send "\r"}
|
|
}
|
|
|
|
# execute a inst command in i_top
|
|
proc inst_cmd instcmd {
|
|
send "$instcmd \r"
|
|
set timeout 1800
|
|
for {} {1} {} {
|
|
expect {
|
|
-re "Inst> $" {break}
|
|
-re "# $" {break}
|
|
"more? " {send " "}
|
|
-ex {more? (h=help)} {send " "}
|
|
timeout {send_error "timeout in inst_cmd $instcmd\n"; intr; send "\r"}
|
|
}
|
|
}
|
|
}
|
|
|
|
# set root disk in p_mon
|
|
proc set_rdisk rdisk {
|
|
send "setenv root $rdisk \r"
|
|
expect -re ">> $" {send "init\r"}
|
|
p_menu2p_mon
|
|
}
|
|
|
|
# load miniroot in p_mon state to get in i_top state from remote disk
|
|
# modified by jhunter to read global targmach and targaddr
|
|
# XXX it should be passed these!
|
|
#set mach_dist dist
|
|
#set ip_dist 192.26.80.118
|
|
proc load_mr_rdisk {mrloc distmach distaddr targmach targaddr platform} {
|
|
# global distmach distaddr targmach targaddr
|
|
|
|
puts "===$distmach===$distaddr==="
|
|
send "\r"
|
|
# if { !([ string compare $platform "IP17" ]) } {
|
|
# expect -re ">> $" {send "setenv tapedevice bootp()$mrloc/sa.IP17\r"}
|
|
# } else {
|
|
expect -re ">> $" {send "setenv tapedevice bootp()$mrloc/sa\r"}
|
|
# }
|
|
if { !([ string compare $platform "IP19" ]) || \
|
|
!([ string compare $platform "IP20" ]) || \
|
|
!([ string compare $platform "IP22" ]) } {
|
|
expect -re ">> $" {send "boot -f \$tapedevice(sashARCS) --m\r"}
|
|
} elseif { !([ string compare $platform "IP10" ]) } {
|
|
expect -re ">> $" {send "boot -f \$tapedevice(sash.IP6) --m\r"}
|
|
} elseif { !([ string compare $platform "IP21" ]) || \
|
|
!([ string compare $platform "IP26" ]) } {
|
|
expect -re ">> $" {send "boot -f \$tapedevice(sash64) --m\r"}
|
|
} else {
|
|
expect -re ">> $" {send "boot -f \$tapedevice(sash.$platform) --m\r"} }
|
|
set timeout 2000
|
|
for {} {1} {} {
|
|
expect {
|
|
"Inst> " {set timeout 60; break}
|
|
"execute this script" {send "y\r"}
|
|
"ready to continue." {send "\r"}
|
|
"more? " {send " "}
|
|
"ENTER (c, r, or a) " {send "r\r"}
|
|
-ex {enter a choice [1]:} {send "2\r"}
|
|
-ex {(yes/no) [yes] } {send "\r"}
|
|
-ex {(yes/no) [no] } {send "\r"}
|
|
-ex {(yes/no)[no] :} {send "\r"}
|
|
"address of IRIS? " {send "$targaddr\r"}
|
|
[format "address of %s? " $targmach] {send "$targaddr\r"}
|
|
"hostname of this machine?" {send "$targmach\r"}
|
|
[format "address of %s? " $distmach] {send "$distaddr\r"}
|
|
-timestamp timeout {
|
|
send_error "load_mr_rdisk $expect_out(seconds) seconds\n";
|
|
send_error " $expect_out(seconds_total) total\n";
|
|
send_error "timeout in load_mr_rdisk\n"; intr; send "\r"}
|
|
}
|
|
}
|
|
}
|
|
|
|
# clean_inst, go to admin then mkfs
|
|
# modified by jhunter to take optional fstype; default to xfs
|
|
# also modified to handle inst core-dumping (Restart/more/choice)
|
|
# we should find a way to report errors like this!
|
|
proc clean_inst {args} {
|
|
# args holds fstype
|
|
if {[string match $args "efs"] == 1} {
|
|
set fstype "efs"
|
|
} else {
|
|
set fstype "xfs"
|
|
}
|
|
send "\r"
|
|
expect -re "Inst> $" {send "admin\r"}
|
|
expect -re "Admin> $" {send "mkfs\r"}
|
|
set timeout 600
|
|
for {} {1} {} {
|
|
expect {
|
|
-re "s0\\? |s6\\? |usr\\? |dev\\? $" {send "yes\r"}
|
|
"want to clean your disks ?" {send "yes\r"}
|
|
-ex {[efs/xfs]: } {send "$fstype\r"}
|
|
-ex "s0? " {send "yes\r"}
|
|
-ex "s6? " {send "yes\r"}
|
|
-ex "usr? " {send "yes\r"}
|
|
-ex "dev? " {send "yes\r"}
|
|
-re "Admin> $" {send "return\r"}
|
|
-re "Inst> $" {set timeout 20; break}
|
|
-ex "Restart? { (y)es, (n)o, (sh)ell, (h)elp }: " {send "n\r"}
|
|
"more? " {send " "}
|
|
-ex {enter a choice [1]:} {send "2\r"}
|
|
timeout {send_error "timeout in clean_inst\n"; intr; send "\r"}
|
|
}
|
|
}
|
|
}
|
|
|
|
# from_dist, specify distribution source with from command in inst
|
|
proc from_dist {distpath distmach distaddr targmach targaddr} {
|
|
send "from ${distpath} \r"
|
|
set timeout 600
|
|
for {} {1} {} {
|
|
expect {
|
|
"No route to host*Inst> " {sleep 5; send "from ${distpath} \r"}
|
|
-re "Inst> $" {break}
|
|
"CD-ROM drive\\?*n, y\] " {send "n\r"}
|
|
"execute this script" {send "y\r"}
|
|
-ex {more? (h=help)} {send " "}
|
|
-ex {enter a choice [1]:} {send "2\r"}
|
|
-ex {(yes/no) [yes] } {send "\r"}
|
|
-ex {(yes/no) [no] } {send "\r"}
|
|
-ex {(yes/no)[no] :} {send "\r"}
|
|
[format " %s? " $distmach] {send "$distaddr\r"}
|
|
"hostname of this machine?" {send "$targmach\r"}
|
|
"more\\? " {send " "}
|
|
"press ENTER to continue $" {send "\r"}
|
|
timeout {send_error "timeout in from_dist\n"; intr; send "\r"}
|
|
}
|
|
}
|
|
}
|
|
|
|
# live_inst, specify distribution source
|
|
proc live_inst distfrom {
|
|
send "inst -f $distfrom\r"
|
|
set timeout 120
|
|
for {} {1} {} {
|
|
expect {
|
|
-re "Inst> $" {break}
|
|
-ex {enter a choice [1]:} {send "2\r"}
|
|
"execute this script" {send "y\r"}
|
|
-ex {more? (h=help)} {send " "}
|
|
-ex {(yes/no) [yes] } {send "\r"}
|
|
-ex {(yes/no) [no] } {send "\r"}
|
|
-ex {(yes/no)[no] :} {send "\r"}
|
|
"more\\? " {send " "}
|
|
-re "press ENTER to continue $" {send "\r"}
|
|
timeout { expect * {puts "==<$expect_out(buffer)>"}; send_error "timeout in live_inst: \n"; intr; send "\r"}
|
|
}
|
|
}
|
|
}
|
|
|
|
# expect after go in inst
|
|
# If there are conflicts the logic we follow is to repeatedly resolve
|
|
# the conflicts with choice "1b" unless we see that 1b is "not on current
|
|
# distrubution". The coding to handle this is very ugly. The trick is to
|
|
# find the sentinel value which indicates that you have seen all of the
|
|
# possible solutions for "conflict 1". Since I cannot think of a better
|
|
# way, the method I use to do this is to use 1c as the sentinel if we see
|
|
# 1c. Otherwise use 2a if it exists, and otherwise to just eat to EOF.
|
|
# We look for the keyword "current" to indicate that there is the message
|
|
# "not on current distribution" was present. Due to line breaks we can't
|
|
# search for the whole string sequence.
|
|
#
|
|
proc wait_inst {} {
|
|
set timeout 36000
|
|
set corrupt_retries 0 ;# number of corrupt retries
|
|
for {} {1} {} {
|
|
expect {
|
|
eof {send_user "inst finished\n"; exit}
|
|
"Archive*corrupt*Interrupt>" {if {[incr corrupt_retries] <= 3} {
|
|
send "1\r" } else {
|
|
inst_go_err} }
|
|
"OLDER VERSIONS REQUESTED" {inst_go_err}
|
|
"INCOMPATIBLE SYSTEM" {inst_go_err}
|
|
"NOT ENOUGH DISK SPACE" {inst_go_err}
|
|
"MISSING PREREQUISITES" {inst_go_err}
|
|
"Installation failed." {inst_go_err}
|
|
"can't proceed with installation" {inst_go_err}
|
|
"What is the network address of" {inst_go_err}
|
|
-re "\r\n 1a\..*\r\n 1c\." {
|
|
if {[string match "*current*" $expect_out(0,string)]} {
|
|
set choice "conflicts 1a\r"
|
|
} else {
|
|
set choice "conflicts 1b\r"
|
|
}
|
|
}
|
|
-re "\r\n 1a\..*\r\n 2a\." {
|
|
if {[string match "*current*" $expect_out(0,string)]} {
|
|
set choice "conflicts 1a\r"
|
|
} else {
|
|
set choice "conflicts 1b\r"
|
|
}
|
|
}
|
|
-re " 1a\..*\r\nResolve conflicts" {
|
|
if {[string match "*current*" $expect_out(0,string)]} {
|
|
set choice "conflicts 1a\r"
|
|
} else {
|
|
set choice "conflicts 1b\r"
|
|
}
|
|
}
|
|
-re "conflicts choice choice.*Inst> $" {send "$choice"}
|
|
-re "No conflicts.*Inst> $" {send "go\r"}
|
|
"more\? " {send " "}
|
|
"2. Quit now" {send "2\r"; set timeout 900; break}
|
|
-re "Error extracting file .*Interrupt> " {send "1\r"}
|
|
"Installations and removals were successful" {set timeout 900;break}
|
|
-re "Interrupt> $" {inst_go_err}
|
|
-re "Inst> $" {set timeout 900; break}
|
|
timeout {send_error "install failed with timeout"; inst_go_err}
|
|
}
|
|
}
|
|
}
|
|
|
|
# default_inst, install default
|
|
proc default_inst {} {
|
|
send "\r"
|
|
expect -re "Inst> $" {send "install default\r"}
|
|
expect -re "Inst> $" {send "go\r"}
|
|
wait_inst
|
|
}
|
|
|
|
# all_inst, install all
|
|
proc all_inst {} {
|
|
send "\r"
|
|
expect -re "Inst> $" {send "install *\r"}
|
|
expect -re "Inst> $" {send "go\r"}
|
|
wait_inst
|
|
}
|
|
|
|
# update_inst, install
|
|
proc update_inst {} {
|
|
send "\r"
|
|
expect -re "Inst> $" {send "keep install\r"}
|
|
expect -re "Inst> $" {send "install keep\r"}
|
|
expect -re "Inst> $" {send "go\r"}
|
|
wait_inst
|
|
}
|
|
|
|
# choice_inst, installation based on install commands
|
|
proc choice_inst {} {
|
|
send "\r"
|
|
expect -re "Inst> $" {send "go\r"}
|
|
wait_inst
|
|
}
|
|
|
|
# check if machine in prom mode, it might not need to go back to unix to
|
|
# start mini-root installation
|
|
proc checkinprom {} {
|
|
global timeout inprom
|
|
set stimeout $timeout
|
|
set timeout 5
|
|
send "\r"
|
|
for {} {1} {} {
|
|
expect {
|
|
-re ">> $" { set inprom 1; break}
|
|
"Option? " {send "5\r"}
|
|
timeout { set inprom -1; break}
|
|
}
|
|
}
|
|
}
|
|
|
|
# add sybtcl part to query adhoc for inst server for a alpha number
|
|
set env(DSQUERY) SGIBASE_CORP_1001_B
|
|
set env(SYBASE) /usr/local/lib/pv+
|
|
|
|
proc curdist alpha_num {
|
|
global server path
|
|
if {[catch {set connection [sybconnect adhoc_dbo gamma1]}] != 0} {
|
|
puts "sybconnect failed, try again"
|
|
} else {
|
|
set sybcmd "select server,path from AH_Product_alpha where alpha = $alpha_num"
|
|
if {[catch {sybsql $connection $sybcmd} errmsg] != 0} {
|
|
puts "sybsql failed due to:"
|
|
puts $errmsg
|
|
} else {
|
|
catch {sybnext $connection} row
|
|
scan $row "%s %s" server path
|
|
}
|
|
sybclose $connection
|
|
}
|
|
}
|
|
|
|
# procedure to send mail in the begining of testing
|
|
proc send_bmail {t_name t_case prod p_ver os alpha owner rid} {
|
|
sh_root_cmd " echo \"$t_name,$t_case,$prod,$p_ver,-1,,\" > /tmp/iNsT.tMp "
|
|
sh_root_cmd { echo "----------" >> /tmp/iNsT.tMp }
|
|
sh_root_cmd { hinv -c graphics >> /tmp/iNsT.tMp }
|
|
sh_root_cmd { echo "----------" >> /tmp/iNsT.tMp }
|
|
sh_root_cmd { /bin/sh -c "if [ -x /usr/gfx/gfxinfo ]; then /usr/gfx/gfxinfo; fi" >> /tmp/iNsT.tMp }
|
|
sh_root_cmd { echo "----------" >> /tmp/iNsT.tMp }
|
|
sh_root_cmd { hinv -c processor | grep -v MIPS >> /tmp/iNsT.tMp }
|
|
sh_root_cmd { echo "----------" >> /tmp/iNsT.tMp }
|
|
sh_root_cmd " echo $os >> /tmp/iNsT.tMp "
|
|
sh_root_cmd { echo "----------" >> /tmp/iNsT.tMp }
|
|
sh_root_cmd " echo $alpha >> /tmp/iNsT.tMp "
|
|
sh_root_cmd { echo "----------" >> /tmp/iNsT.tMp }
|
|
sh_root_cmd " echo $owner >> /tmp/iNsT.tMp "
|
|
sh_root_cmd { echo "----------" >> /tmp/iNsT.tMp }
|
|
sh_root_cmd { date "+%R %D" >> /tmp/iNsT.tMp }
|
|
sh_root_cmd { echo "----------" >> /tmp/iNsT.tMp }
|
|
sh_root_cmd { nvram netaddr >> /tmp/iNsT.tMp }
|
|
sh_root_cmd { echo "----------" >> /tmp/iNsT.tMp }
|
|
sh_root_cmd { echo >> /tmp/iNsT.tMp }
|
|
sh_root_cmd { echo "----------" >> /tmp/iNsT.tMp }
|
|
sh_root_cmd " echo $rid >> /tmp/iNsT.tMp "
|
|
sh_root_cmd { Mail -s "new-adhoc-testresult : inst" testec@tao.engr < /tmp/iNsT.tMp }
|
|
}
|
|
|
|
# procedure directly insert AH_Testresult_n for begining of test instead of
|
|
# using send_bmail
|
|
proc testr_b {t_name t_case prod p_ver os alpha owner rid} {
|
|
if {[catch {set connection [sybconnect adhoc_dbo gamma1]}] != 0} {
|
|
puts "sybconnect failed, try again"
|
|
} else {
|
|
# set gfx_str [sh_cmd_out { hinv -c graphics; /bin/sh -c "if [ -x /usr/gfx/gfxinfo ]; then /usr/gfx/gfxinfo; fi" }]
|
|
# set gfx [exec /usr/people/sybase/adhoc/bin/gfx.pl << $gfx_str]
|
|
# set cpu_str [sh_cmd_out {hinv -c processor | grep -v MIPS}]
|
|
# set cpu [exec /usr/people/sybase/adhoc/bin/cpu.pl << $cpu_str]
|
|
|
|
set mach_str [sh_cmd_out { hinv -c graphics; echo "-----"; /bin/sh -c "if [ -x /usr/gfx/gfxinfo ]; then /usr/gfx/gfxinfo; fi"; echo "-----"; hinv -c processor | grep -v MIPS }]
|
|
set mach [exec /usr/people/sybase/adhoc/bin/mach.pl << $mach_str]
|
|
#puts "MACHSTR: $mach_str :MACHSTR"
|
|
set gfx [string range $mach 0 [expr [string first "===" $mach] -1]]
|
|
set cpu [string range $mach [expr [string first "===" $mach] +3] end]
|
|
|
|
set date [exec date "+%R %D"]
|
|
set ipaddr [sh_cmd_out {nvram netaddr}]
|
|
set sybcmd "insert AH_Testresult_n values ($rid,'$t_name','$t_case',\
|
|
'$cpu','$gfx','$os',$alpha,'$prod','$p_ver',-1,-1,-1,'$ipaddr',\
|
|
NULL,'$owner','$date')"
|
|
if {[catch {sybsql $connection $sybcmd} errmsg] != 0} {
|
|
puts "insert AH_Testresult_n : $errmsg"
|
|
puts "$sybcmd"
|
|
}
|
|
puts "DONE: $sybcmd"
|
|
sybclose $connection
|
|
}
|
|
}
|
|
|
|
# procedure to send mail in the completion of testing
|
|
proc send_cmail {t_pass t_total t_val os descrip owner rid} {
|
|
set alpha [sh_cmd_out { versions -n eoe.sw.unix | fgrep eoe.sw.unix | nawk '{print $3;exit}' }]
|
|
set os [sh_cmd_out { uname -r | cut -f1 -d- }]
|
|
sh_root_cmd " echo ,,,,$t_pass,$t_total,$t_val,,,$os,$alpha,$owner,`date \"+%R %D\"`,`nvram netaddr`,,$rid > /tmp/iNsT.tMp "
|
|
sh_root_cmd { Mail -s "new-adhoc-testresult : inst" testec@tao.engr < /tmp/iNsT.tMp }
|
|
}
|
|
|
|
# procedure directly update AH_Testresult_n for completion of testing instead
|
|
# of using send_cmail
|
|
proc testr_c {t_pass t_total t_val os descrip owner rid} {
|
|
if {[catch {set connection [sybconnect adhoc_dbo gamma1]}] != 0} {
|
|
puts "sybconnect failed, try again"
|
|
} else {
|
|
set alpha [sh_cmd_out { versions -n eoe.sw.unix | fgrep eoe.sw.unix | nawk '{print $3;exit}' }]
|
|
set os [sh_cmd_out { uname -r | cut -f1 -d- }]
|
|
set date [exec date "+%R %D"]
|
|
set sybcmd "update AH_Testresult_n set test_pass=$t_pass,\
|
|
test_total=$t_total,test_val=$t_val,date='$date',\
|
|
descrip='$descrip',owner='$owner' where ID = $rid"
|
|
if {[catch {sybsql $connection $sybcmd} errmsg] != 0} {
|
|
puts "update AH_Testresult_n : $errmsg"
|
|
puts "$sybcmd"
|
|
}
|
|
puts "DONE: $sybcmd"
|
|
sybclose $connection
|
|
}
|
|
}
|
|
|
|
|
|
trap {intr} 2
|