# This is in api.1 so that it happens after all the tests in api.0.
# If some API function does not unlock the database then the server
# (whichs runs through all api tests) will still have it locked, and
# these tests will fail.
load_lib lib.t
api_exit
if { $RPC } {
return
}
send_user "UNTESTED: lock: DAL changes broke locking code (see MIT RT ticket 3201)\n"
untested "lock: DAL changes broke locking code (see MIT RT ticket 3201)"
return
set locktest $LOCKTEST
set lockfile $env(K5ROOT)/kdb5.kadm5.lock
# The lock tests use the program lock-test in the unit test
# directory. The basic idea is that lock-test can be told to acquire
# various kinds of locks and then wait for input before proceeding;
# this is necessary because otherwise we'd have no way to test locking
# interactions without a race condition.
#
# lock_test_start and lock_test_continue work together to give a crude
# form of continuations. lock_test_continue expects a list of
# commands for lock-test (passed on the command line) and responses
# (read from stdout). When it gets to a command of "wait",
# lock_test_continue returns, and its return value is a list of the
# arguments that it should be passed to continue processing that
# particular list of commands for that particular lock-test after
# whatever that requried lock-test to wait has been completed.
#
# lock_test is simply a wrapper for tests that do not involve wait.
proc lock_test_setup {test cmds} {
global locktest spawn_id
verbose "test $test"
set cmdline ""
foreach cmdpair $cmds {
if {[lindex $cmdpair 0] == "eof"} {
break
}
set cmdline "$cmdline [lindex $cmdpair 0]"
}
verbose "spawning $locktest $cmdline"
eval "spawn $locktest $cmdline"
}
proc lock_test {test cmds} {
global spawn_id
lock_test_setup $test $cmds
set lockany [lock_test_continue $test $spawn_id 0 "" 0 $cmds]
while {$lockany != {}} {
set lockany [eval lock_test_continue $lockany]
}
}
proc lock_test_start {test cmds} {
global spawn_id
lock_test_setup $test $cmds
return [lock_test_continue $test $spawn_id 0 "" 0 $cmds]
}
proc lock_test_continue {test my_spawn_id test_failed fail_output cont cmds} {
global wait_error_index wait_errno_index wait_status_index
global spawn_id
set spawn_id $my_spawn_id
if {$cont == 1} {
send -i $spawn_id "\n"
}
while {[llength $cmds] > 0} {
set cmdpair [lindex $cmds 0]
set cmds [lrange $cmds 1 end]
set cmd [lindex $cmdpair 0]
set output [lindex $cmdpair 1]
verbose "test $test: command: $cmd"
if {$cmd == "wait"} {
# ah, for continuations...
return [list $test $spawn_id $test_failed $fail_output 1 $cmds]
}
if {$cmd == "eof"} {
set status $output
set output "doesnotmatchanything"
}
expect {
-i $spawn_id
-re "$output" { verbose "test $test: read: $output" }
timeout {
set test_failed 1
set fail_output "timeout while waiting for $output"
}
eof {
if {$cmd != "eof"} {
set test_failed 1
set fail_output "eof while waiting for $output"
}
}
}
if {$test_failed == 1} { break }
}
# In timeout cases, the process may not be dead yet.
catch { exec kill -9 [exp_pid -i $spawn_id] } x
set ret [wait -i $spawn_id]
verbose "% Exit $ret" 2
if {$test_failed == 0} {
if {[lindex $ret $wait_error_index] == -1} {
set test_failed 1
set fail_output "wait returned error [lindex $ret $wait_errno_index]"
} else {
if { [lindex $ret $wait_status_index] == $status ||
(($status<0) && ([lindex $ret $wait_status_index] == ($status+256))) } {
verbose "test $test: status $status"
} else {
set test_failed 1
set fail_output "unexpected return status [lindex $ret $wait_status_index], should be $status"
}
}
}
if {$test_failed == 0} {
pass $test
} else {
fail "$test: $fail_output"
}
return {}
}
set lock1 [lock_test_start 1 [list \
[list shared "shared"] \
[list release "released"] \
[list wait ""] \
[list eof 0]]]
eval lock_test_continue $lock1
set lock2 [lock_test_start 2 [list \
[list exclusive exclusive] \
[list release released] \
[list wait ""] \
[list eof 0]]]
eval lock_test_continue $lock2
set lock3 [lock_test_start 5 [list \
[list permanent permanent] \
[list release released] \
[list wait ""] \
[list eof 0]]]
eval lock_test_continue $lock3
set lock4 [lock_test_start 4 [list \
[list release "Database not locked"] \
[list wait ""] \
[list eof 0]]]
eval lock_test_continue $lock4
set lock5 [lock_test_start 5 [list \
[list shared shared] \
[list wait ""] \
[list eof 0]]]
set lock5_1 [lock_test_start 5.1 [list \
[list shared shared] \
[list wait ""] \
[list eof 0]]]
eval lock_test_continue $lock5_1
eval lock_test_continue $lock5
set lock6 [lock_test_start 6 [list \
[list exclusive exclusive] \
[list wait ""] \
[list eof 0]]]
set lock6_1 [lock_test_start 6.1 [list \
[list shared "Cannot lock database"] \
[list wait ""] \
[list eof 0]]]
eval lock_test_continue $lock6_1
eval lock_test_continue $lock6
set lock7 [lock_test_start 7 [list \
[list shared shared] \
[list wait ""] \
[list eof 0]]]
set lock7_1 [lock_test_start 7.1 [list \
[list exclusive "Cannot lock database"] \
[list wait ""] \
[list eof 0]]]
eval lock_test_continue $lock7_1
eval lock_test_continue $lock7
set lock8 [lock_test_start 8 [list \
[list permanent permanent] \
[list wait ""] \
[list release "released" ] \
[list wait ""] \
[list eof 0]]]
set lock8_1 [lock_test_start 8.1 [list \
[list "" "administration database lock file missing while opening database" ] \
[list wait ""] \
[list eof 1]]]
eval lock_test_continue $lock8_1
eval set lock8 \[lock_test_continue $lock8\]
eval lock_test_continue $lock8
set lock9 [lock_test_start 9 [list \
[list exclusive exclusive] \
[list release released] \
[list wait ""] \
[list exclusive "database lock file missing while getting exclusive"] \
[list wait ""] \
[list eof 0]]]
set lock9_1 [lock_test_start 9.1 [list \
[list permanent permanent] \
[list wait ""] \
[list release released] \
[list wait ""] \
[list eof 0]]]
eval set lock9 \[lock_test_continue $lock9\]
eval lock_test_continue $lock9
eval set lock9_1 \[lock_test_continue $lock9_1\]
eval lock_test_continue $lock9_1
if {! [file exists $lockfile]} {
perror "lock file missing before test 10"
}
set lock10 [lock_test_start 10 [list \
[list permanent permanent] \
[list wait ""] \
[list release released] \
[list wait ""] \
[list eof 0]]]
if {[file exists $lockfile]} {
fail "test 10: lock file exists"
}
eval set lock10 \[lock_test_continue $lock10\]
eval lock_test_continue $lock10
if {[file exists $lockfile]} {
pass "test 11: lock file exists"
} else {
fail "test 11: lock file does not exist"
}
set lock12 [lock_test_start 12 [list \
[list shared shared] \
[list wait ""] \
[list eof 0]]]
set lock12_1 [lock_test_start 12.1 [list \
[list "get test-pol" retrieved] \
[list wait ""] \
[list eof 0]]]
eval lock_test_continue $lock12_1
eval lock_test_continue $lock12
set lock13 [lock_test_start 13 [list \
[list "get lock13" "Principal or policy does not exist"] \
[list wait ""] \
[list "get lock13" retrieved] \
[list wait ""] \
[list eof 0]]]
set test13_spawn_id $spawn_id
# create_policy could call api_exit immediately when it starts up.
# If it does, and the spawn ID in $spawn_id is ours rather than its,
# it'll close our spawn ID. So, we call api_start to give it something
# to close.
api_start
create_policy lock13
set api_spawn_id $spawn_id
set spawn_id $test13_spawn_id
eval set lock13 \[lock_test_continue $lock13\]
eval lock_test_continue $lock13
set spawn_id $api_spawn_id
delete_policy lock13