set ::global_overrides {}
set ::tags {}
+set ::valgrind_errors {}
-proc error_and_quit {config_file error} {
- puts "!!COULD NOT START REDIS-SERVER\n"
- puts "CONFIGURATION:"
- puts [exec cat $config_file]
- puts "\nERROR:"
- puts [string trim $error]
- exit 1
+proc start_server_error {config_file error} {
+ set err {}
+ append err "Cant' start the Redis server\n"
+ append err "CONFIGURATION:"
+ append err [exec cat $config_file]
+ append err "\nERROR:"
+ append err [string trim $error]
+ send_data_packet $::test_server_fd err $err
}
proc check_valgrind_errors stderr {
set buf [read $fd]
close $fd
- if {![regexp -- {ERROR SUMMARY: 0 errors} $buf] ||
- ![regexp -- {definitely lost: 0 bytes} $buf]} {
- puts "*** VALGRIND ERRORS ***"
- puts $buf
- puts "--- press enter to continue ---"
- gets stdin
+ if {[regexp -- { at 0x} $buf] ||
+ (![regexp -- {definitely lost: 0 bytes} $buf] &&
+ ![regexp -- {no leaks are possible} $buf])} {
+ send_data_packet $::test_server_fd err "Valgrind error: $buf\n"
}
}
}
# kill server and wait for the process to be totally exited
+ catch {exec kill $pid}
while {[is_alive $config]} {
- if {[incr wait 10] % 1000 == 0} {
+ incr wait 10
+
+ if {$wait >= 5000} {
+ puts "Forcing process $pid to exit..."
+ catch {exec kill -KILL $pid}
+ } elseif {$wait % 1000 == 0} {
puts "Waiting for process $pid to exit..."
}
- catch {exec kill $pid}
after 10
}
}
close $fd
} e]} {
- puts "Can't PING server at $host:$port... $e"
+ if {$::verbose} {
+ puts -nonewline "."
+ }
+ } else {
+ if {$::verbose} {
+ puts -nonewline "ok"
+ }
}
return $retval
}
dict set config dir [tmpdir server]
# start every server on a different port
- dict set config port [incr ::port]
+ set ::port [find_available_port [expr {$::port+1}]]
+ dict set config port $::port
# apply overrides from global space and arguments
foreach {directive arguments} [concat $::global_overrides $overrides] {
set stderr [format "%s/%s" [dict get $config "dir"] "stderr"]
if {$::valgrind} {
- exec valgrind src/redis-server $config_file > $stdout 2> $stderr &
- after 2000
+ exec valgrind --suppressions=src/valgrind.sup --show-reachable=no --show-possibly-lost=no --leak-check=full src/redis-server $config_file > $stdout 2> $stderr &
} else {
exec src/redis-server $config_file > $stdout 2> $stderr &
- after 500
}
# check that the server actually started
- if {$code ne "undefined" && ![ping_server $::host $::port]} {
- error_and_quit $config_file [exec cat $stderr]
+ # ugly but tries to be as fast as possible...
+ if {$::valgrind} {set retrynum 1000} else {set retrynum 100}
+ set serverisup 0
+
+ if {$::verbose} {
+ puts -nonewline "=== ($tags) Starting server ${::host}:${::port} "
+ }
+
+ after 10
+ if {$code ne "undefined"} {
+ while {[incr retrynum -1]} {
+ catch {
+ if {[ping_server $::host $::port]} {
+ set serverisup 1
+ }
+ }
+ if {$serverisup} break
+ after 50
+ }
+ } else {
+ set serverisup 1
+ }
+
+ if {$::verbose} {
+ puts ""
+ }
+
+ if {!$serverisup} {
+ set err {}
+ append err [exec cat $stdout] "\n" [exec cat $stderr]
+ start_server_error $config_file $err
+ return
}
# find out the pid
while {![info exists pid]} {
- regexp {^\[(\d+)\]} [exec head -n1 $stdout] _ pid
+ regexp {\[(\d+)\]} [exec cat $stdout] _ pid
after 100
}
if {[dict exists $config port]} { set port [dict get $config port] }
# setup config dict
- dict set srv "config" $config_file
+ dict set srv "config_file" $config_file
+ dict set srv "config" $config
dict set srv "pid" $pid
dict set srv "host" $host
dict set srv "port" $port
after 10
}
- set client [redis $host $port]
- dict set srv "client" $client
-
- # select the right db when we don't have to authenticate
- if {![dict exists $config requirepass]} {
- $client select 9
- }
-
# append the server to the stack
lappend ::servers $srv
-
+
+ # connect client (after server dict is put on the stack)
+ reconnect
+
# execute provided block
- set curnum $::testnum
- if {![catch { uplevel 1 $code } err]} {
- # zero exit status is good
- unset err
+ set num_tests $::num_tests
+ if {[catch { uplevel 1 $code } error]} {
+ set backtrace $::errorInfo
+
+ # Kill the server without checking for leaks
+ dict set srv "skipleaks" 1
+ kill_server $srv
+
+ # Print warnings from log
+ puts [format "\nLogged warnings (pid %d):" [dict get $srv "pid"]]
+ set warnings [warnings_from_file [dict get $srv "stdout"]]
+ if {[string length $warnings] > 0} {
+ puts "$warnings"
+ } else {
+ puts "(none)"
+ }
+ puts ""
+
+ error $error $backtrace
}
- if {$curnum == $::testnum} {
- # don't check for leaks when no tests were executed
+ # Don't do the leak check when no tests were run
+ if {$num_tests == $::num_tests} {
dict set srv "skipleaks" 1
}
# pop the server object
set ::servers [lrange $::servers 0 end-1]
-
- # allow an exception to bubble up the call chain but still kill this
- # server, because we want to reuse the ports when the tests are re-run
- if {[info exists err]} {
- if {$err eq "exception"} {
- puts [format "Logged warnings (pid %d):" [dict get $srv "pid"]]
- set warnings [warnings_from_file [dict get $srv "stdout"]]
- if {[string length $warnings] > 0} {
- puts "$warnings"
- } else {
- puts "(none)"
- }
- # kill this server without checking for leaks
- dict set srv "skipleaks" 1
- kill_server $srv
- error "exception"
- } elseif {[string length $err] > 0} {
- puts "Error executing the suite, aborting..."
- puts $err
- exit 1
- }
- }
set ::tags [lrange $::tags 0 end-[llength $tags]]
kill_server $srv
projects / redis.git / blobdiff