mirror of
https://github.com/hanzoai/kv.git
synced 2026-11-09 16:05:35 +00:00
`merge: upstream/unstable (-X ours, brand preserved)` resolved every conflicting
hunk in our favour. That is right for brand strings and wrong for code: it kept
our old server.h beside their new module.c, so module.c calls
commandResultSuccessListeners and reads from_call_argv off a struct that has
neither, and zslFreeLexRange lost the declarations it still has call sites for.
kvReaderFeed got a newer body calling kvReaderGetReadBuf/CommitRead grafted onto
older locals — an sds newbuf and an oom: label the new body never uses. Across
398 files nothing downstream noticed, because main has not compiled since.
That is what the Dockerfile was working around. Pulling valkey/valkey and copying
binaries out of it produced an image no matter what the source did, so a tree
that cannot build looked like a tree that builds. Now the image compiles this
source, so the build breaking is visible the moment it breaks.
src, deps and tests return to the last coherent commit. Carried forward on top:
- Two identical rdbIsVersionAccepted definitions, differing only in a
parameter name. The rename pass copied the function instead of editing it,
so this never compiled either.
- kv_strtod.h lost the #ifdef USE_FAST_FLOAT that separated its two
implementations, leaving both definitions and a stray #endif.
- extended-redis-compatibility is deleted, not defaulted off. It made the
server answer HELLO with "redis" and name itself Redis in five error
strings. A server that can be configured to lie about what it is has one
setting too many. HELLO now reports kv unconditionally.
- The redis-server and redis-cli install symlinks, on by default via
USE_REDIS_SYMLINKS?=yes. This is why a running instance answered to
redis-cli at all.
- valkeymodule.h and redismodule.h, 3094 lines of adapters mapping old
prefixes onto KVMODULE_*, included by nothing. kvmodule.h is the header.
- deps/libvalkey, one documentation file the rename stranded.
Wire contract is untouched. INFO still reports redis_version, redis_git_sha1,
redis_git_dirty and redis_build_id, and the Lua sandbox still exports
REDIS_VERSION — clients parse those field names, so they are protocol, not
branding. What we choose is what the server calls itself, and it calls itself kv.
Verified: builds clean, and a live instance answers HELLO with "server kv",
reports server_name:kv, has no extended-redis-compatibility directive, and
serves strings and lists.
893 lines
29 KiB
Tcl
893 lines
29 KiB
Tcl
source tests/support/cli.tcl
|
|
|
|
if {$::singledb} {
|
|
set ::dbnum 0
|
|
} else {
|
|
set ::dbnum 9
|
|
}
|
|
|
|
start_server {tags {"cli logreqres:skip"}} {
|
|
proc open_cli {{opts ""} {infile ""}} {
|
|
if { $opts == "" } {
|
|
set opts "-n $::dbnum"
|
|
}
|
|
set ::env(TERM) dumb
|
|
set cmdline [kvcli [srv host] [srv port] $opts]
|
|
if {$infile ne ""} {
|
|
set cmdline "$cmdline < $infile"
|
|
set mode "r"
|
|
} else {
|
|
set mode "r+"
|
|
}
|
|
set fd [open "|$cmdline" $mode]
|
|
fconfigure $fd -buffering none
|
|
fconfigure $fd -blocking false
|
|
fconfigure $fd -translation binary
|
|
set _ $fd
|
|
}
|
|
|
|
proc close_cli {fd} {
|
|
close $fd
|
|
}
|
|
|
|
proc read_cli {fd} {
|
|
set ret [read $fd]
|
|
while {[string length $ret] == 0} {
|
|
after 10
|
|
set ret [read $fd]
|
|
}
|
|
|
|
# We may have a short read, try to read some more.
|
|
set empty_reads 0
|
|
while {$empty_reads < 5} {
|
|
set buf [read $fd]
|
|
if {[string length $buf] == 0} {
|
|
after 10
|
|
incr empty_reads
|
|
} else {
|
|
append ret $buf
|
|
set empty_reads 0
|
|
}
|
|
}
|
|
return $ret
|
|
}
|
|
|
|
proc write_cli {fd buf} {
|
|
puts $fd $buf
|
|
flush $fd
|
|
}
|
|
|
|
# Helpers to run tests in interactive mode
|
|
|
|
proc format_output {output} {
|
|
set _ [string trimright $output "\n"]
|
|
}
|
|
|
|
proc run_command {fd cmd} {
|
|
write_cli $fd $cmd
|
|
after 50
|
|
set _ [format_output [read_cli $fd]]
|
|
}
|
|
|
|
proc test_interactive_cli {name code} {
|
|
set ::env(FAKETTY) 1
|
|
set fd [open_cli]
|
|
test "Interactive CLI: $name" $code
|
|
close_cli $fd
|
|
unset ::env(FAKETTY)
|
|
}
|
|
|
|
proc test_interactive_nontty_cli {name code} {
|
|
set fd [open_cli]
|
|
test "Interactive non-TTY CLI: $name" $code
|
|
close_cli $fd
|
|
}
|
|
|
|
# Helpers to run tests where stdout is not a tty
|
|
proc write_tmpfile {contents} {
|
|
set tmp [tmpfile "cli"]
|
|
set tmpfd [open $tmp "w"]
|
|
puts -nonewline $tmpfd $contents
|
|
close $tmpfd
|
|
set _ $tmp
|
|
}
|
|
|
|
proc _run_cli {host port db opts args} {
|
|
set cmd [kvcli $host $port [list -n $db {*}$args]]
|
|
foreach {key value} $opts {
|
|
if {$key eq "pipe"} {
|
|
set cmd "sh -c \"$value | $cmd\""
|
|
}
|
|
if {$key eq "path"} {
|
|
set cmd "$cmd < $value"
|
|
}
|
|
}
|
|
|
|
set fd [open "|$cmd" "r"]
|
|
fconfigure $fd -buffering none
|
|
fconfigure $fd -translation binary
|
|
set resp [read $fd 1048576]
|
|
close $fd
|
|
set _ [format_output $resp]
|
|
}
|
|
|
|
proc run_cli {args} {
|
|
_run_cli [srv host] [srv port] $::dbnum {} {*}$args
|
|
}
|
|
|
|
proc run_cli_with_input_pipe {mode cmd args} {
|
|
if {$mode == "x" } {
|
|
_run_cli [srv host] [srv port] $::dbnum [list pipe $cmd] -x {*}$args
|
|
} elseif {$mode == "X"} {
|
|
_run_cli [srv host] [srv port] $::dbnum [list pipe $cmd] -X tag {*}$args
|
|
}
|
|
}
|
|
|
|
proc run_cli_with_input_file {mode path args} {
|
|
if {$mode == "x" } {
|
|
_run_cli [srv host] [srv port] $::dbnum [list path $path] -x {*}$args
|
|
} elseif {$mode == "X"} {
|
|
_run_cli [srv host] [srv port] $::dbnum [list path $path] -X tag {*}$args
|
|
}
|
|
}
|
|
|
|
proc run_cli_host_port_db {host port db args} {
|
|
_run_cli $host $port $db {} {*}$args
|
|
}
|
|
|
|
proc test_nontty_cli {name code} {
|
|
test "Non-interactive non-TTY CLI: $name" $code
|
|
}
|
|
|
|
# Helpers to run tests where stdout is a tty (fake it)
|
|
proc test_tty_cli {name code} {
|
|
set ::env(FAKETTY) 1
|
|
test "Non-interactive TTY CLI: $name" $code
|
|
unset ::env(FAKETTY)
|
|
}
|
|
|
|
test_interactive_cli "INFO response should be printed raw" {
|
|
set lines [split [run_command $fd info] "\n"]
|
|
foreach line $lines {
|
|
# Info lines end in \r\n, so they now end in \r.
|
|
if {![regexp {^\r$|^#|^[^#:]+:} $line]} {
|
|
fail "Malformed info line: $line"
|
|
}
|
|
}
|
|
}
|
|
|
|
test_interactive_cli "Status reply" {
|
|
assert_equal "OK" [run_command $fd "set key foo"]
|
|
}
|
|
|
|
test_interactive_cli "Integer reply" {
|
|
assert_equal "(integer) 1" [run_command $fd "incr counter"]
|
|
}
|
|
|
|
test_interactive_cli "Bulk reply" {
|
|
r set key foo
|
|
assert_equal "\"foo\"" [run_command $fd "get key"]
|
|
}
|
|
|
|
test_interactive_cli "Multi-bulk reply" {
|
|
r rpush list foo
|
|
r rpush list bar
|
|
assert_equal "1) \"foo\"\n2) \"bar\"" [run_command $fd "lrange list 0 -1"]
|
|
}
|
|
|
|
test_interactive_cli "Parsing quotes" {
|
|
assert_equal "OK" [run_command $fd "set key \"bar\""]
|
|
assert_equal "bar" [r get key]
|
|
assert_equal "OK" [run_command $fd "set key \" bar \""]
|
|
assert_equal " bar " [r get key]
|
|
assert_equal "OK" [run_command $fd "set key \"\\\"bar\\\"\""]
|
|
assert_equal "\"bar\"" [r get key]
|
|
assert_equal "OK" [run_command $fd "set key \"\tbar\t\""]
|
|
assert_equal "\tbar\t" [r get key]
|
|
assert_equal "\"\\tbar\\t\"" [run_command $fd "get \"\"k'e'\"y\""]
|
|
assert_equal "OK" [run_command $fd "set key\"\" bar"]
|
|
assert_equal "bar" [r get key]
|
|
}
|
|
|
|
test_interactive_cli "Subscribed mode" {
|
|
if {$::force_resp3} {
|
|
run_command $fd "hello 3"
|
|
}
|
|
|
|
set reading "Reading messages... (press Ctrl-C to quit or any key to type command)\r"
|
|
set erase "\033\[K"; # Erases the "Reading messages..." line.
|
|
|
|
# Subscribe to some channels.
|
|
set sub1 "1) \"subscribe\"\n2) \"ch1\"\n3) (integer) 1\n"
|
|
set sub2 "1) \"subscribe\"\n2) \"ch2\"\n3) (integer) 2\n"
|
|
set sub3 "1) \"subscribe\"\n2) \"ch3\"\n3) (integer) 3\n"
|
|
assert_equal $sub1$sub2$sub3$reading \
|
|
[run_command $fd "subscribe ch1 ch2 ch3"]
|
|
|
|
# Receive pubsub message.
|
|
r publish ch2 hello
|
|
set message "1) \"message\"\n2) \"ch2\"\n3) \"hello\"\n"
|
|
assert_equal $erase$message$reading [read_cli $fd]
|
|
|
|
# Unsubscribe some.
|
|
set unsub1 "1) \"unsubscribe\"\n2) \"ch1\"\n3) (integer) 2\n"
|
|
set unsub2 "1) \"unsubscribe\"\n2) \"ch2\"\n3) (integer) 1\n"
|
|
assert_equal $erase$unsub1$unsub2$reading \
|
|
[run_command $fd "unsubscribe ch1 ch2"]
|
|
|
|
run_command $fd "hello 2"
|
|
|
|
# Command forbidden in subscribed mode (RESP2).
|
|
set err "(error) ERR Can't execute 'get': only (P|S)SUBSCRIBE / (P|S)UNSUBSCRIBE / PING / QUIT / RESET are allowed in this context\n"
|
|
assert_equal $erase$err$reading [run_command $fd "get k"]
|
|
|
|
# Command allowed in subscribed mode.
|
|
set pong "1) \"pong\"\n2) \"\"\n"
|
|
assert_equal $erase$pong$reading [run_command $fd "ping"]
|
|
|
|
# Reset exits subscribed mode.
|
|
assert_equal ${erase}RESET [run_command $fd "reset"]
|
|
assert_equal PONG [run_command $fd "ping"]
|
|
|
|
# Check TTY output of push messages in RESP3 has ")" prefix (to be changed to ">" in the future).
|
|
assert_match "1#*" [run_command $fd "hello 3"]
|
|
set sub1 "1) \"subscribe\"\n2) \"ch1\"\n3) (integer) 1\n"
|
|
assert_equal $sub1$reading \
|
|
[run_command $fd "subscribe ch1"]
|
|
}
|
|
|
|
test_interactive_nontty_cli "Subscribed mode" {
|
|
# Raw output and no "Reading messages..." info message.
|
|
# Use RESP3 in this test case.
|
|
assert_match {*proto 3*} [run_command $fd "hello 3"]
|
|
|
|
# Subscribe to some channels.
|
|
set sub1 "subscribe\nch1\n1"
|
|
set sub2 "subscribe\nch2\n2"
|
|
assert_equal $sub1\n$sub2 \
|
|
[run_command $fd "subscribe ch1 ch2"]
|
|
|
|
assert_equal OK [run_command $fd "client tracking on"]
|
|
assert_equal OK [run_command $fd "set k 42"]
|
|
assert_equal 42 [run_command $fd "get k"]
|
|
|
|
# Interleaving invalidate and pubsub messages.
|
|
r publish ch1 hello
|
|
r del k
|
|
r publish ch2 world
|
|
set message1 "message\nch1\nhello"
|
|
set invalidate "invalidate\nk"
|
|
set message2 "message\nch2\nworld"
|
|
assert_equal $message1\n$invalidate\n$message2\n [read_cli $fd]
|
|
|
|
# Unsubscribe all.
|
|
set unsub1 "unsubscribe\nch1\n1"
|
|
set unsub2 "unsubscribe\nch2\n0"
|
|
assert_equal $unsub1\n$unsub2 [run_command $fd "unsubscribe ch1 ch2"]
|
|
}
|
|
|
|
test_tty_cli "Status reply" {
|
|
assert_equal "OK" [run_cli set key bar]
|
|
assert_equal "bar" [r get key]
|
|
}
|
|
|
|
test_tty_cli "Integer reply" {
|
|
r del counter
|
|
assert_equal "(integer) 1" [run_cli incr counter]
|
|
}
|
|
|
|
test_tty_cli "Bulk reply" {
|
|
r set key "tab\tnewline\n"
|
|
assert_equal "\"tab\\tnewline\\n\"" [run_cli get key]
|
|
}
|
|
|
|
test_tty_cli "Multi-bulk reply" {
|
|
r del list
|
|
r rpush list foo
|
|
r rpush list bar
|
|
assert_equal "1) \"foo\"\n2) \"bar\"" [run_cli lrange list 0 -1]
|
|
}
|
|
|
|
test_tty_cli "Read last argument from pipe" {
|
|
assert_equal "OK" [run_cli_with_input_pipe x "echo foo" set key]
|
|
assert_equal "foo\n" [r get key]
|
|
|
|
assert_equal "OK" [run_cli_with_input_pipe X "echo foo" set key2 tag]
|
|
assert_equal "foo\n" [r get key2]
|
|
}
|
|
|
|
test_tty_cli "Read last argument from file" {
|
|
set tmpfile [write_tmpfile "from file"]
|
|
|
|
assert_equal "OK" [run_cli_with_input_file x $tmpfile set key]
|
|
assert_equal "from file" [r get key]
|
|
|
|
assert_equal "OK" [run_cli_with_input_file X $tmpfile set key2 tag]
|
|
assert_equal "from file" [r get key2]
|
|
|
|
file delete $tmpfile
|
|
}
|
|
|
|
test_tty_cli "Escape character in JSON mode" {
|
|
# reverse solidus
|
|
r hset solidus \/ \/
|
|
assert_equal \/ \/ [run_cli hgetall solidus]
|
|
set escaped_reverse_solidus \"\\"
|
|
assert_equal $escaped_reverse_solidus $escaped_reverse_solidus [run_cli --json hgetall \/]
|
|
# non printable (0xF0 in ISO-8859-1, not UTF-8(0xC3 0xB0))
|
|
set eth "\u00f0\u0065"
|
|
r hset eth test $eth
|
|
assert_equal \"\\xf0e\" [run_cli hget eth test]
|
|
assert_equal \"\u00f0e\" [run_cli --json hget eth test]
|
|
assert_equal \"\\\\xf0e\" [run_cli --quoted-json hget eth test]
|
|
# control characters
|
|
r hset control test "Hello\x00\x01\x02\x03World"
|
|
assert_equal \"Hello\\u0000\\u0001\\u0002\\u0003World" [run_cli --json hget control test]
|
|
# non-string keys
|
|
r hset numkey 1 One
|
|
assert_equal \{\"1\":\"One\"\} [run_cli --json hgetall numkey]
|
|
# non-string, non-printable keys
|
|
r hset npkey "K\u0000\u0001ey" "V\u0000\u0001alue"
|
|
assert_equal \{\"K\\u0000\\u0001ey\":\"V\\u0000\\u0001alue\"\} [run_cli --json hgetall npkey]
|
|
assert_equal \{\"K\\\\x00\\\\x01ey\":\"V\\\\x00\\\\x01alue\"\} [run_cli --quoted-json hgetall npkey]
|
|
}
|
|
|
|
test_nontty_cli "Status reply" {
|
|
assert_equal "OK" [run_cli set key bar]
|
|
assert_equal "bar" [r get key]
|
|
}
|
|
|
|
test_nontty_cli "Integer reply" {
|
|
r del counter
|
|
assert_equal "1" [run_cli incr counter]
|
|
}
|
|
|
|
test_nontty_cli "Bulk reply" {
|
|
r set key "tab\tnewline\n"
|
|
assert_equal "tab\tnewline" [run_cli get key]
|
|
}
|
|
|
|
test_nontty_cli "Multi-bulk reply" {
|
|
r del list
|
|
r rpush list foo
|
|
r rpush list bar
|
|
assert_equal "foo\nbar" [run_cli lrange list 0 -1]
|
|
}
|
|
|
|
if {!$::tls} { ;# fake_redis_node doesn't support TLS
|
|
test_nontty_cli "ASK redirect test" {
|
|
# Set up two fake nodes.
|
|
set tclsh [info nameofexecutable]
|
|
set script "tests/helpers/fake_redis_node.tcl"
|
|
set port1 [find_available_port $::baseport $::portcount]
|
|
set port2 [find_available_port $::baseport $::portcount]
|
|
set p1 [exec $tclsh $script $port1 \
|
|
"SET foo bar" "-ASK 12182 127.0.0.1:$port2" &]
|
|
set p2 [exec $tclsh $script $port2 \
|
|
"ASKING" "+OK" \
|
|
"SET foo bar" "+OK" &]
|
|
# Make sure both fake nodes have started listening
|
|
wait_for_condition 50 50 {
|
|
[catch {close [socket "127.0.0.1" $port1]}] == 0 && \
|
|
[catch {close [socket "127.0.0.1" $port2]}] == 0
|
|
} else {
|
|
fail "Failed to start fake KV nodes"
|
|
}
|
|
# Run the cli
|
|
assert_equal "OK" [run_cli_host_port_db "127.0.0.1" $port1 0 -c SET foo bar]
|
|
}
|
|
}
|
|
|
|
test_nontty_cli "Quoted input arguments" {
|
|
r set "\x00\x00" "value"
|
|
assert_equal "value" [run_cli --quoted-input get {"\x00\x00"}]
|
|
}
|
|
|
|
test_nontty_cli "No accidental unquoting of input arguments" {
|
|
run_cli --quoted-input set {"\x41\x41"} quoted-val
|
|
run_cli set {"\x41\x41"} unquoted-val
|
|
assert_equal "quoted-val" [r get AA]
|
|
assert_equal "unquoted-val" [r get {"\x41\x41"}]
|
|
}
|
|
|
|
test_nontty_cli "Invalid quoted input arguments" {
|
|
catch {run_cli --quoted-input set {"Unterminated}} err
|
|
assert_match {*exited abnormally*} $err
|
|
|
|
# A single arg that unquotes to two arguments is also not expected
|
|
catch {run_cli --quoted-input set {"arg1" "arg2"}} err
|
|
assert_match {*exited abnormally*} $err
|
|
}
|
|
|
|
test_nontty_cli "Read last argument from pipe" {
|
|
assert_equal "OK" [run_cli_with_input_pipe x "echo foo" set key]
|
|
assert_equal "foo\n" [r get key]
|
|
|
|
assert_equal "OK" [run_cli_with_input_pipe X "echo foo" set key2 tag]
|
|
assert_equal "foo\n" [r get key2]
|
|
}
|
|
|
|
test_nontty_cli "Read last argument from file" {
|
|
set tmpfile [write_tmpfile "from file"]
|
|
|
|
assert_equal "OK" [run_cli_with_input_file x $tmpfile set key]
|
|
assert_equal "from file" [r get key]
|
|
|
|
assert_equal "OK" [run_cli_with_input_file X $tmpfile set key2 tag]
|
|
assert_equal "from file" [r get key2]
|
|
|
|
file delete $tmpfile
|
|
}
|
|
|
|
test_nontty_cli "Test command-line hinting - latest server" {
|
|
# cli will connect to the running server and will use COMMAND DOCS
|
|
catch {run_cli --test_hint_file tests/assets/test_cli_hint_suite.txt} output
|
|
assert_match "*SUCCESS*" $output
|
|
}
|
|
|
|
test_nontty_cli "Test command-line hinting - no server" {
|
|
# cli will fail to connect to the server and will use the cached commands.c
|
|
catch {run_cli -p 123 --test_hint_file tests/assets/test_cli_hint_suite.txt} output
|
|
assert_match "*SUCCESS*" $output
|
|
}
|
|
|
|
test_nontty_cli "Test command-line hinting - old server" {
|
|
# cli will connect to the server but will not use COMMAND DOCS,
|
|
# and complete the missing info from the cached commands.c
|
|
r ACL setuser clitest on nopass +@all -command|docs
|
|
catch {run_cli --user clitest -a nopass --no-auth-warning --test_hint_file tests/assets/test_cli_hint_suite.txt} output
|
|
assert_match "*SUCCESS*" $output
|
|
r acl deluser clitest
|
|
}
|
|
|
|
proc test_kv_cli_rdb_dump {functions_only} {
|
|
r flushdb
|
|
r function flush
|
|
|
|
set dir [lindex [r config get dir] 1]
|
|
|
|
assert_equal "OK" [r debug populate 100000 key 1000]
|
|
assert_equal "lib1" [r function load "#!lua name=lib1\nserver.register_function('func1', function() return 123 end)"]
|
|
if {$functions_only} {
|
|
set args "--functions-rdb $dir/cli.rdb"
|
|
} else {
|
|
set args "--rdb $dir/cli.rdb"
|
|
}
|
|
catch {run_cli {*}$args} output
|
|
assert_match {*Transfer finished with success*} $output
|
|
|
|
file delete "$dir/dump.rdb"
|
|
file rename "$dir/cli.rdb" "$dir/dump.rdb"
|
|
|
|
assert_equal "OK" [r set should-not-exist 1]
|
|
assert_equal "should_not_exist_func" [r function load "#!lua name=should_not_exist_func\nserver.register_function('should_not_exist_func', function() return 456 end)"]
|
|
assert_equal "OK" [r debug reload nosave]
|
|
assert_equal {} [r get should-not-exist]
|
|
assert_equal {{library_name lib1 engine LUA functions {{name func1 description {} flags {}}}}} [r function list]
|
|
if {$functions_only} {
|
|
assert_equal 0 [r dbsize]
|
|
} else {
|
|
assert_equal 100000 [r dbsize]
|
|
}
|
|
}
|
|
|
|
foreach {functions_only} {no yes} {
|
|
|
|
test "Dumping an RDB - functions only: $functions_only" {
|
|
# Disk-based master
|
|
assert_match "OK" [r config set repl-diskless-sync no]
|
|
test_kv_cli_rdb_dump $functions_only
|
|
|
|
# Disk-less master
|
|
assert_match "OK" [r config set repl-diskless-sync yes]
|
|
assert_match "OK" [r config set repl-diskless-sync-delay 0]
|
|
test_kv_cli_rdb_dump $functions_only
|
|
} {} {needs:repl needs:debug}
|
|
|
|
} ;# foreach functions_only
|
|
|
|
test "Scan mode" {
|
|
r flushdb
|
|
populate 1000 key: 1
|
|
|
|
# basic use
|
|
assert_equal 1000 [llength [split [run_cli --scan]]]
|
|
|
|
# pattern
|
|
assert_equal {key:2} [split [run_cli --scan --pattern "*:2"]]
|
|
|
|
# pattern matching with a quoted string
|
|
assert_equal {key:2} [split [run_cli --scan --quoted-pattern {"*:\x32"}]]
|
|
}
|
|
|
|
proc test_kv_cli_repl {} {
|
|
set fd [open_cli "--replica"]
|
|
wait_for_condition 500 100 {
|
|
[string match {*slave0:*state=online*} [r info]]
|
|
} else {
|
|
fail "kv-cli --replica did not connect"
|
|
}
|
|
|
|
for {set i 0} {$i < 100} {incr i} {
|
|
r set test-key test-value-$i
|
|
}
|
|
|
|
wait_for_condition 500 100 {
|
|
[string match {*test-value-99*} [read_cli $fd]]
|
|
} else {
|
|
fail "kv-cli --replica didn't read commands"
|
|
}
|
|
|
|
fconfigure $fd -blocking true
|
|
r client kill type slave
|
|
catch { close_cli $fd } err
|
|
assert_match {*Server closed the connection*} $err
|
|
}
|
|
|
|
test "Connecting as a replica" {
|
|
# Disk-based master
|
|
assert_match "OK" [r config set repl-diskless-sync no]
|
|
test_kv_cli_repl
|
|
|
|
# Disk-less master
|
|
assert_match "OK" [r config set repl-diskless-sync yes]
|
|
assert_match "OK" [r config set repl-diskless-sync-delay 0]
|
|
test_kv_cli_repl
|
|
} {} {needs:repl}
|
|
|
|
test "Piping raw protocol" {
|
|
set cmds [tmpfile "cli_cmds"]
|
|
set cmds_fd [open $cmds "w"]
|
|
|
|
set cmds_count 2101
|
|
|
|
if {!$::singledb} {
|
|
puts $cmds_fd [formatCommand select 9]
|
|
incr cmds_count
|
|
}
|
|
puts $cmds_fd [formatCommand del test-counter]
|
|
|
|
for {set i 0} {$i < 1000} {incr i} {
|
|
puts $cmds_fd [formatCommand incr test-counter]
|
|
puts $cmds_fd [formatCommand set large-key [string repeat "x" 20000]]
|
|
}
|
|
|
|
for {set i 0} {$i < 100} {incr i} {
|
|
puts $cmds_fd [formatCommand set very-large-key [string repeat "x" 512000]]
|
|
}
|
|
close $cmds_fd
|
|
|
|
set cli_fd [open_cli "--pipe" $cmds]
|
|
fconfigure $cli_fd -blocking true
|
|
set output [read_cli $cli_fd]
|
|
|
|
assert_equal {1000} [r get test-counter]
|
|
assert_match "*All data transferred*errors: 0*replies: ${cmds_count}*" $output
|
|
|
|
file delete $cmds
|
|
}
|
|
|
|
test "Options -X with illegal argument" {
|
|
assert_error "*-x and -X are mutually exclusive*" {run_cli -x -X tag}
|
|
|
|
assert_error "*Unrecognized option or bad number*" {run_cli -X}
|
|
|
|
assert_error "*tag not match*" {run_cli_with_input_pipe X "echo foo" set key wrong_tag}
|
|
}
|
|
|
|
test "DUMP RESTORE with -x option" {
|
|
set cmdline [kvcli [srv host] [srv port]]
|
|
|
|
exec {*}$cmdline DEL set new_set
|
|
exec {*}$cmdline SADD set 1 2 3 4 5 6
|
|
assert_equal 6 [exec {*}$cmdline SCARD set]
|
|
|
|
assert_equal "OK" [exec {*}$cmdline -D "" --raw DUMP set | \
|
|
{*}$cmdline -x RESTORE new_set 0]
|
|
|
|
assert_equal 6 [exec {*}$cmdline SCARD new_set]
|
|
assert_equal "1\n2\n3\n4\n5\n6" [exec {*}$cmdline SMEMBERS new_set]
|
|
}
|
|
|
|
test "DUMP RESTORE with -X option" {
|
|
set cmdline [kvcli [srv host] [srv port]]
|
|
|
|
exec {*}$cmdline DEL zset new_zset
|
|
exec {*}$cmdline ZADD zset 1 a 2 b 3 c
|
|
assert_equal 3 [exec {*}$cmdline ZCARD zset]
|
|
|
|
assert_equal "OK" [exec {*}$cmdline -D "" --raw DUMP zset | \
|
|
{*}$cmdline -X dump_tag RESTORE new_zset 0 dump_tag REPLACE]
|
|
|
|
assert_equal 3 [exec {*}$cmdline ZCARD new_zset]
|
|
assert_equal "a\n1\nb\n2\nc\n3" [exec {*}$cmdline ZRANGE new_zset 0 -1 WITHSCORES]
|
|
}
|
|
|
|
test "kv-cli pubsub mode with single standard channel subscription" {
|
|
set fd [open_cli]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "0" $pubsub_status
|
|
|
|
write_cli $fd "SUBSCRIBE ch1"
|
|
set response [read_cli $fd]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "1" $pubsub_status
|
|
|
|
write_cli $fd "UNSUBSCRIBE ch1"
|
|
set response [read_cli $fd]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "0" $pubsub_status
|
|
|
|
close_cli $fd
|
|
}
|
|
|
|
test "kv-cli pubsub mode with multiple standard channel subscriptions" {
|
|
set fd [open_cli]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "0" $pubsub_status
|
|
|
|
write_cli $fd "SUBSCRIBE ch1 ch2 ch3"
|
|
set response [read_cli $fd]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "1" $pubsub_status
|
|
|
|
write_cli $fd "UNSUBSCRIBE"
|
|
set response [read_cli $fd]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "0" $pubsub_status
|
|
|
|
close_cli $fd
|
|
}
|
|
|
|
test "kv-cli pubsub mode with single shard channel subscription" {
|
|
set fd [open_cli]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "0" $pubsub_status
|
|
|
|
write_cli $fd "SSUBSCRIBE schannel1"
|
|
set response [read_cli $fd]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "1" $pubsub_status
|
|
|
|
write_cli $fd "SUNSUBSCRIBE schannel1"
|
|
set response [read_cli $fd]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "0" $pubsub_status
|
|
|
|
close_cli $fd
|
|
}
|
|
|
|
test "kv-cli pubsub mode with multiple shard channel subscriptions" {
|
|
set fd [open_cli]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "0" $pubsub_status
|
|
|
|
write_cli $fd "SSUBSCRIBE {schannel}1 {schannel}2 {schannel}3"
|
|
set response [read_cli $fd]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "1" $pubsub_status
|
|
|
|
write_cli $fd "SUNSUBSCRIBE"
|
|
set response [read_cli $fd]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "0" $pubsub_status
|
|
|
|
close_cli $fd
|
|
}
|
|
|
|
test "kv-cli pubsub mode with single pattern channel subscription" {
|
|
set fd [open_cli]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "0" $pubsub_status
|
|
|
|
write_cli $fd "PSUBSCRIBE pattern1*"
|
|
set response [read_cli $fd]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "1" $pubsub_status
|
|
|
|
write_cli $fd "PUNSUBSCRIBE pattern1*"
|
|
set response [read_cli $fd]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "0" $pubsub_status
|
|
|
|
close_cli $fd
|
|
}
|
|
|
|
test "kv-cli pubsub mode with multiple pattern channel subscriptions" {
|
|
set fd [open_cli]
|
|
|
|
write_cli $fd "PSUBSCRIBE pattern1* pattern2* pattern3*"
|
|
set response [read_cli $fd]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "1" $pubsub_status
|
|
|
|
write_cli $fd "PUNSUBSCRIBE"
|
|
set response [read_cli $fd]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "0" $pubsub_status
|
|
|
|
close_cli $fd
|
|
}
|
|
|
|
test "kv-cli pubsub mode when subscribing to the same channel" {
|
|
set fd [open_cli]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "0" $pubsub_status
|
|
|
|
write_cli $fd "SUBSCRIBE ch1 ch1"
|
|
set response [read_cli $fd]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "1" $pubsub_status
|
|
|
|
write_cli $fd "UNSUBSCRIBE"
|
|
set response [read_cli $fd]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "0" $pubsub_status
|
|
|
|
close_cli $fd
|
|
}
|
|
|
|
test "kv-cli pubsub mode with multiple subscription types" {
|
|
set fd [open_cli]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "0" $pubsub_status
|
|
|
|
write_cli $fd "SUBSCRIBE ch1 ch2 ch3"
|
|
set response [read_cli $fd]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "1" $pubsub_status
|
|
|
|
write_cli $fd "PSUBSCRIBE pattern*"
|
|
set response [read_cli $fd]
|
|
set lines [split $response "\n"]
|
|
assert_equal "psubscribe" [lindex $lines 0]
|
|
assert_equal "pattern*" [lindex $lines 1]
|
|
assert_equal "4" [lindex $lines 2]
|
|
|
|
write_cli $fd "SSUBSCRIBE schannel"
|
|
set response [read_cli $fd]
|
|
set lines [split $response "\n"]
|
|
assert_equal "ssubscribe" [lindex $lines 0]
|
|
assert_equal "schannel" [lindex $lines 1]
|
|
assert_equal "1" [lindex $lines 2]
|
|
|
|
write_cli $fd "PUNSUBSCRIBE pattern*"
|
|
set response [read_cli $fd]
|
|
set lines [split $response "\n"]
|
|
assert_equal "punsubscribe" [lindex $lines 0]
|
|
assert_equal "pattern*" [lindex $lines 1]
|
|
assert_equal "3" [lindex $lines 2]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "1" $pubsub_status
|
|
|
|
write_cli $fd "SUNSUBSCRIBE schannel"
|
|
set response [read_cli $fd]
|
|
set lines [split $response "\n"]
|
|
assert_equal "sunsubscribe" [lindex $lines 0]
|
|
assert_equal "schannel" [lindex $lines 1]
|
|
assert_equal "0" [lindex $lines 2]
|
|
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "1" $pubsub_status
|
|
|
|
write_cli $fd "UNSUBSCRIBE"
|
|
set response [read_cli $fd]
|
|
|
|
# Verify pubsub mode is no longer active
|
|
write_cli $fd ":get pubsub"
|
|
set pubsub_status [string trim [read_cli $fd]]
|
|
assert_equal "0" $pubsub_status
|
|
|
|
close_cli $fd
|
|
}
|
|
|
|
test "kv-cli make sure selected db survives connection drops" {
|
|
set fd [open_cli]
|
|
|
|
# Select the database
|
|
assert_equal "OK" [run_command $fd "select $::dbnum"]
|
|
|
|
# Kill all normal clients, to disconnect kv-cli client
|
|
r client kill type normal
|
|
after 10
|
|
|
|
# Trigger reconnect
|
|
write_cli $fd "ping"
|
|
|
|
assert_equal "OK" [run_command $fd "set x 1"]
|
|
assert_equal "OK" [r select $::dbnum]
|
|
assert_equal "1" [r get x]
|
|
|
|
set client_info [run_command $fd "client info"]
|
|
|
|
regexp {db=(\d+)} $client_info _ actual_db
|
|
|
|
# Validate that the selected DB matches the reported DB
|
|
assert_equal $::dbnum $actual_db
|
|
}
|
|
|
|
test "Valid Connection Scheme: redis://" {
|
|
set cmdline [kvcliuri "redis://" [srv host] [srv port]]
|
|
assert_equal {PONG} [exec {*}$cmdline PING]
|
|
}
|
|
|
|
test "Valid Connection Scheme: kv://" {
|
|
set cmdline [kvcliuri "kv://" [srv host] [srv port]]
|
|
assert_equal {PONG} [exec {*}$cmdline PING]
|
|
}
|
|
|
|
if {$::tls} {
|
|
test "Valid Connection Scheme: rediss://" {
|
|
set cmdline [kvcliuri "rediss://" [srv host] [srv port]]
|
|
assert_equal {PONG} [exec {*}$cmdline PING]
|
|
}
|
|
|
|
test "Valid Connection Scheme: kvs://" {
|
|
set cmdline [kvcliuri "kvs://" [srv host] [srv port]]
|
|
assert_equal {PONG} [exec {*}$cmdline PING]
|
|
}
|
|
}
|
|
|
|
test "kv-cli command table hint will not leak memory when COMMAND fails due to auth" {
|
|
# Enable auth of server.
|
|
set fd [open_cli]
|
|
assert_equal "OK" [run_command $fd "CONFIG SET requirepass 12345"]
|
|
|
|
# Using another client to send a command (non-AUTH command), then closing the client.
|
|
set fd2 [open_cli]
|
|
assert_match "NOAUTH*" [run_command $fd2 "PING"]
|
|
close_cli $fd2
|
|
|
|
# Disable auth of server.
|
|
assert_equal "OK" [run_command $fd "CONFIG SET requirepass \"\""]
|
|
close_cli $fd
|
|
}
|
|
}
|