Commit cbd46317 authored by meir@redislabs.com's avatar meir@redislabs.com Committed by meir
Browse files

Redis Functions - Added redis function unit and Lua engine

Redis function unit is located inside functions.c
and contains Redis Function implementation:
1. FUNCTION commands:
  * FUNCTION CREATE
  * FCALL
  * FCALL_RO
  * FUNCTION DELETE
  * FUNCTION KILL
  * FUNCTION INFO
2. Register engine

In addition, this commit introduce the first engine
that uses the Redis Function capabilities, the
Lua engine.
parent f21dc38a
foreach is_eval {0 1} {
if {$is_eval == 1} {
proc run_script {args} {
r eval {*}$args
}
proc run_script_ro {args} {
r eval_ro {*}$args
}
proc run_script_on_connection {args} {
[lindex $args 0] eval {*}[lrange $args 1 end]
}
proc kill_script {args} {
r script kill
}
} else {
proc run_script {args} {
r function create LUA test replace [lindex $args 0]
r fcall test {*}[lrange $args 1 end]
}
proc run_script_ro {args} {
r function create LUA test replace [lindex $args 0]
r fcall_ro test {*}[lrange $args 1 end]
}
proc run_script_on_connection {args} {
set rd [lindex $args 0]
$rd function create LUA test replace [lindex $args 1]
# read the ok reply of function create
$rd read
$rd fcall test {*}[lrange $args 2 end]
}
proc kill_script {args} {
r function kill
}
}
start_server {tags {"scripting"}} {
test {EVAL - Does Lua interpreter replies to our requests?} {
r eval {return 'hello'} 0
run_script {return 'hello'} 0
} {hello}
test {EVAL - Lua integer -> Redis protocol type conversion} {
r eval {return 100.5} 0
run_script {return 100.5} 0
} {100}
test {EVAL - Lua string -> Redis protocol type conversion} {
r eval {return 'hello world'} 0
run_script {return 'hello world'} 0
} {hello world}
test {EVAL - Lua true boolean -> Redis protocol type conversion} {
r eval {return true} 0
run_script {return true} 0
} {1}
test {EVAL - Lua false boolean -> Redis protocol type conversion} {
r eval {return false} 0
run_script {return false} 0
} {}
test {EVAL - Lua status code reply -> Redis protocol type conversion} {
r eval {return {ok='fine'}} 0
run_script {return {ok='fine'}} 0
} {fine}
test {EVAL - Lua error reply -> Redis protocol type conversion} {
catch {
r eval {return {err='this is an error'}} 0
run_script {return {err='this is an error'}} 0
} e
set _ $e
} {this is an error}
test {EVAL - Lua table -> Redis protocol type conversion} {
r eval {return {1,2,3,'ciao',{1,2}}} 0
run_script {return {1,2,3,'ciao',{1,2}}} 0
} {1 2 3 ciao {1 2}}
test {EVAL - Are the KEYS and ARGV arrays populated correctly?} {
r eval {return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}} 2 a{t} b{t} c{t} d{t}
run_script {return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}} 2 a{t} b{t} c{t} d{t}
} {a{t} b{t} c{t} d{t}}
test {EVAL - is Lua able to call Redis API?} {
r set mykey myval
r eval {return redis.call('get',KEYS[1])} 1 mykey
run_script {return redis.call('get',KEYS[1])} 1 mykey
} {myval}
if {$is_eval eq 1} {
# eval sha is only relevant for is_eval Lua
test {EVALSHA - Can we call a SHA1 if already defined?} {
r evalsha fd758d1589d044dd850a6f05d52f2eefd27f033f 1 mykey
} {myval}
......@@ -60,10 +99,11 @@ start_server {tags {"scripting"}} {
catch {r evalsha ffd632c7d33e571e9f24556ebed26c3479a87130 0} e
set _ $e
} {NOSCRIPT*}
} ;# is_eval
test {EVAL - Redis integer -> Lua type conversion} {
r set x 0
r eval {
run_script {
local foo = redis.pcall('incr',KEYS[1])
return {type(foo),foo}
} 1 x
......@@ -71,7 +111,7 @@ start_server {tags {"scripting"}} {
test {EVAL - Redis bulk -> Lua type conversion} {
r set mykey myval
r eval {
run_script {
local foo = redis.pcall('get',KEYS[1])
return {type(foo),foo}
} 1 mykey
......@@ -82,14 +122,14 @@ start_server {tags {"scripting"}} {
r rpush mylist a
r rpush mylist b
r rpush mylist c
r eval {
run_script {
local foo = redis.pcall('lrange',KEYS[1],0,-1)
return {type(foo),foo[1],foo[2],foo[3],# foo}
} 1 mylist
} {table a b c 3}
test {EVAL - Redis status reply -> Lua type conversion} {
r eval {
run_script {
local foo = redis.pcall('set',KEYS[1],'myval')
return {type(foo),foo['ok']}
} 1 mykey
......@@ -97,7 +137,7 @@ start_server {tags {"scripting"}} {
test {EVAL - Redis error reply -> Lua type conversion} {
r set mykey myval
r eval {
run_script {
local foo = redis.pcall('incr',KEYS[1])
return {type(foo),foo['err']}
} 1 mykey
......@@ -105,7 +145,7 @@ start_server {tags {"scripting"}} {
test {EVAL - Redis nil bulk reply -> Lua type conversion} {
r del mykey
r eval {
run_script {
local foo = redis.pcall('get',KEYS[1])
return {type(foo),foo == false}
} 1 mykey
......@@ -115,13 +155,13 @@ start_server {tags {"scripting"}} {
r set mykey "this is DB 9"
r select 10
r set mykey "this is DB 10"
r eval {return redis.pcall('get',KEYS[1])} 1 mykey
run_script {return redis.pcall('get',KEYS[1])} 1 mykey
} {this is DB 10} {singledb:skip}
test {EVAL - SELECT inside Lua should not affect the caller} {
# here we DB 10 is selected
r set mykey "original value"
r eval {return redis.pcall('select','9')} 0
run_script {return redis.pcall('select','9')} 0
set res [r get mykey]
r select 9
set res
......@@ -131,7 +171,7 @@ start_server {tags {"scripting"}} {
test {EVAL - Script can't run more than configured time limit} {
r config set lua-time-limit 1
catch {
r eval {
run_script {
local i = 0
while true do i=i+1 end
} 0
......@@ -142,71 +182,74 @@ start_server {tags {"scripting"}} {
test {EVAL - Scripts can't run blpop command} {
set e {}
catch {r eval {return redis.pcall('blpop','x',0)} 0} e
catch {run_script {return redis.pcall('blpop','x',0)} 0} e
set e
} {*not allowed*}
test {EVAL - Scripts can't run brpop command} {
set e {}
catch {r eval {return redis.pcall('brpop','empty_list',0)} 0} e
catch {run_script {return redis.pcall('brpop','empty_list',0)} 0} e
set e
} {*not allowed*}
test {EVAL - Scripts can't run brpoplpush command} {
set e {}
catch {r eval {return redis.pcall('brpoplpush','empty_list1', 'empty_list2',0)} 0} e
catch {run_script {return redis.pcall('brpoplpush','empty_list1', 'empty_list2',0)} 0} e
set e
} {*not allowed*}
test {EVAL - Scripts can't run blmove command} {
set e {}
catch {r eval {return redis.pcall('blmove','empty_list1', 'empty_list2', 'LEFT', 'LEFT', 0)} 0} e
catch {run_script {return redis.pcall('blmove','empty_list1', 'empty_list2', 'LEFT', 'LEFT', 0)} 0} e
set e
} {*not allowed*}
test {EVAL - Scripts can't run bzpopmin command} {
set e {}
catch {r eval {return redis.pcall('bzpopmin','empty_zset', 0)} 0} e
catch {run_script {return redis.pcall('bzpopmin','empty_zset', 0)} 0} e
set e
} {*not allowed*}
test {EVAL - Scripts can't run bzpopmax command} {
set e {}
catch {r eval {return redis.pcall('bzpopmax','empty_zset', 0)} 0} e
catch {run_script {return redis.pcall('bzpopmax','empty_zset', 0)} 0} e
set e
} {*not allowed*}
test {EVAL - Scripts can't run XREAD and XREADGROUP with BLOCK option} {
r del s
r xgroup create s g $ MKSTREAM
set res [r eval {return redis.pcall('xread','STREAMS','s','$')} 1 s]
set res [run_script {return redis.pcall('xread','STREAMS','s','$')} 1 s]
assert {$res eq {}}
assert_error "*xread command is not allowed with BLOCK option from scripts" {r eval {return redis.pcall('xread','BLOCK',0,'STREAMS','s','$')} 1 s}
set res [r eval {return redis.pcall('xreadgroup','group','g','c','STREAMS','s','>')} 1 s]
assert_error "*xread command is not allowed with BLOCK option from scripts" {run_script {return redis.pcall('xread','BLOCK',0,'STREAMS','s','$')} 1 s}
set res [run_script {return redis.pcall('xreadgroup','group','g','c','STREAMS','s','>')} 1 s]
assert {$res eq {}}
assert_error "*xreadgroup command is not allowed with BLOCK option from scripts" {r eval {return redis.pcall('xreadgroup','group','g','c','BLOCK',0,'STREAMS','s','>')} 1 s}
assert_error "*xreadgroup command is not allowed with BLOCK option from scripts" {run_script {return redis.pcall('xreadgroup','group','g','c','BLOCK',0,'STREAMS','s','>')} 1 s}
}
if {$is_eval eq 1} {
# only is_eval Lua can not execute randomkey
test {EVAL - Scripts can't run certain commands} {
set e {}
r debug lua-always-replicate-commands 0
catch {
r eval "redis.pcall('randomkey'); return redis.pcall('set','x','ciao')" 0
run_script "redis.pcall('randomkey'); return redis.pcall('set','x','ciao')" 0
} e
r debug lua-always-replicate-commands 1
set e
} {*not allowed after*} {needs:debug}
} ;# is_eval
test {EVAL - No arguments to redis.call/pcall is considered an error} {
set e {}
catch {r eval {return redis.call()} 0} e
catch {run_script {return redis.call()} 0} e
set e
} {*one argument*}
test {EVAL - redis.call variant raises a Lua error on Redis cmd error (1)} {
set e {}
catch {
r eval "redis.call('nosuchcommand')" 0
run_script "redis.call('nosuchcommand')" 0
} e
set e
} {*Unknown Redis*}
......@@ -214,7 +257,7 @@ start_server {tags {"scripting"}} {
test {EVAL - redis.call variant raises a Lua error on Redis cmd error (1)} {
set e {}
catch {
r eval "redis.call('get','a','b','c')" 0
run_script "redis.call('get','a','b','c')" 0
} e
set e
} {*number of args*}
......@@ -223,7 +266,7 @@ start_server {tags {"scripting"}} {
set e {}
r set foo bar
catch {
r eval {redis.call('lpush',KEYS[1],'val')} 1 foo
run_script {redis.call('lpush',KEYS[1],'val')} 1 foo
} e
set e
} {*against a key*}
......@@ -232,7 +275,7 @@ start_server {tags {"scripting"}} {
# We must return the table as a string because otherwise
# Redis converts floats to ints and we get 0 and 1023 instead
# of 0.0003 and 1023.2 as the parsed output.
r eval {return
run_script {return
table.concat(
cjson.decode(
"[0.0, -5e3, -1, 0.3e-3, 1023.2, 0e10]"), " ")
......@@ -240,13 +283,13 @@ start_server {tags {"scripting"}} {
} {0 -5000 -1 0.0003 1023.2 0}
test {EVAL - JSON string decoding} {
r eval {local decoded = cjson.decode('{"keya": "a", "keyb": "b"}')
run_script {local decoded = cjson.decode('{"keya": "a", "keyb": "b"}')
return {decoded.keya, decoded.keyb}
} 0
} {a b}
test {EVAL - cmsgpack can pack double?} {
r eval {local encoded = cmsgpack.pack(0.1)
run_script {local encoded = cmsgpack.pack(0.1)
local h = ""
for i = 1, #encoded do
h = h .. string.format("%02x",string.byte(encoded,i))
......@@ -256,7 +299,7 @@ start_server {tags {"scripting"}} {
} {cb3fb999999999999a}
test {EVAL - cmsgpack can pack negative int64?} {
r eval {local encoded = cmsgpack.pack(-1099511627776)
run_script {local encoded = cmsgpack.pack(-1099511627776)
local h = ""
for i = 1, #encoded do
h = h .. string.format("%02x",string.byte(encoded,i))
......@@ -266,7 +309,7 @@ start_server {tags {"scripting"}} {
} {d3ffffff0000000000}
test {EVAL - cmsgpack can pack and unpack circular references?} {
r eval {local a = {x=nil,y=5}
run_script {local a = {x=nil,y=5}
local b = {x=a}
a['x'] = b
local encoded = cmsgpack.pack(a)
......@@ -298,7 +341,7 @@ start_server {tags {"scripting"}} {
} {82a17905a17881a17882a17905a17881a17882a17905a17881a17882a17905a17881a17882a17905a17881a17882a17905a17881a17882a17905a17881a17882a17905a17881a178c0 1 1}
test {EVAL - Numerical sanity check from bitop} {
r eval {assert(0x7fffffff == 2147483647, "broken hex literals");
run_script {assert(0x7fffffff == 2147483647, "broken hex literals");
assert(0xffffffff == -1 or 0xffffffff == 2^32-1,
"broken hex literals");
assert(tostring(-1) == "-1", "broken tostring()");
......@@ -309,7 +352,7 @@ start_server {tags {"scripting"}} {
} {}
test {EVAL - Verify minimal bitop functionality} {
r eval {assert(bit.tobit(1) == 1);
run_script {assert(bit.tobit(1) == 1);
assert(bit.band(1) == 1);
assert(bit.bxor(1,2) == 3);
assert(bit.bor(1,2,4,8,16,32,64,128) == 255)
......@@ -317,20 +360,22 @@ start_server {tags {"scripting"}} {
} {}
test {EVAL - Able to parse trailing comments} {
r eval {return 'hello' --trailing comment} 0
run_script {return 'hello' --trailing comment} 0
} {hello}
test {EVAL_RO - Successful case} {
r set foo bar
assert_equal bar [r eval_ro {return redis.call('get', KEYS[1]);} 1 foo]
assert_equal bar [run_script_ro {return redis.call('get', KEYS[1]);} 1 foo]
}
test {EVAL_RO - Cannot run write commands} {
r set foo bar
catch {r eval_ro {redis.call('del', KEYS[1]);} 1 foo} e
catch {run_script_ro {redis.call('del', KEYS[1]);} 1 foo} e
set e
} {*Write commands are not allowed from read-only scripts*}
if {$is_eval eq 1} {
# script command is only relevant for is_eval Lua
test {SCRIPTING FLUSH - is able to clear the scripts cache?} {
r set mykey myval
set v [r evalsha fd758d1589d044dd850a6f05d52f2eefd27f033f 1 mykey]
......@@ -361,6 +406,7 @@ start_server {tags {"scripting"}} {
[r evalsha b534286061d4b9e4026607613b95c06c06015ae8 0]
} {b534286061d4b9e4026607613b95c06c06015ae8 loaded}
# reply oredering is only relevant for is_eval Lua
test "In the context of Lua the output of random commands gets ordered" {
r debug lua-always-replicate-commands 0
r del myset
......@@ -387,19 +433,20 @@ start_server {tags {"scripting"}} {
r sadd myset a b c
r eval {return redis.call('sort',KEYS[1],'by','_','get','#','get','_:*')} 1 myset
} {a {} b {} c {}} {cluster:skip}
} ;# is_eval
test "redis.sha1hex() implementation" {
list [r eval {return redis.sha1hex('')} 0] \
[r eval {return redis.sha1hex('Pizza & Mandolino')} 0]
list [run_script {return redis.sha1hex('')} 0] \
[run_script {return redis.sha1hex('Pizza & Mandolino')} 0]
} {da39a3ee5e6b4b0d3255bfef95601890afd80709 74822d82031af7493c20eefa13bd07ec4fada82f}
test {Globals protection reading an undeclared global variable} {
catch {r eval {return a} 0} e
catch {run_script {return a} 0} e
set e
} {*ERR*attempted to access * global*}
test {Globals protection setting an undeclared global*} {
catch {r eval {a=10} 0} e
catch {run_script {a=10} 0} e
set e
} {*ERR*attempted to create global*}
......@@ -417,14 +464,16 @@ start_server {tags {"scripting"}} {
}
r set foo 5
set res {}
lappend res [r eval $decr_if_gt 1 foo 2]
lappend res [r eval $decr_if_gt 1 foo 2]
lappend res [r eval $decr_if_gt 1 foo 2]
lappend res [r eval $decr_if_gt 1 foo 2]
lappend res [r eval $decr_if_gt 1 foo 2]
lappend res [run_script $decr_if_gt 1 foo 2]
lappend res [run_script $decr_if_gt 1 foo 2]
lappend res [run_script $decr_if_gt 1 foo 2]
lappend res [run_script $decr_if_gt 1 foo 2]
lappend res [run_script $decr_if_gt 1 foo 2]
set res
} {4 3 2 2 2}
if {$is_eval eq 1} {
# random handling is only relevant for is_eval Lua
test {Scripting engine resets PRNG at every script execution} {
set rand1 [r eval {return tostring(math.random())} 0]
set rand2 [r eval {return tostring(math.random())} 0]
......@@ -444,13 +493,14 @@ start_server {tags {"scripting"}} {
assert_equal $rand1 $rand2
assert {$rand2 ne $rand3}
}
} ;# is_eval
test {EVAL does not leak in the Lua stack} {
r set x 0
# Use a non blocking client to speedup the loop.
set rd [redis_deferring_client]
for {set j 0} {$j < 10000} {incr j} {
$rd eval {return redis.call("incr",KEYS[1])} 1 x
run_script_on_connection $rd {return redis.call("incr",KEYS[1])} 1 x
}
for {set j 0} {$j < 10000} {incr j} {
$rd read
......@@ -464,9 +514,9 @@ start_server {tags {"scripting"}} {
r flushall
r config set appendonly yes
r config set aof-use-rdb-preamble no
r eval {redis.call("set",KEYS[1],"100")} 1 foo
r eval {redis.call("incr",KEYS[1])} 1 foo
r eval {redis.call("incr",KEYS[1])} 1 foo
run_script {redis.call("set",KEYS[1],"100")} 1 foo
run_script {redis.call("incr",KEYS[1])} 1 foo
run_script {redis.call("incr",KEYS[1])} 1 foo
wait_for_condition 50 100 {
[s aof_rewrite_in_progress] == 0
} else {
......@@ -481,6 +531,8 @@ start_server {tags {"scripting"}} {
set res
} {102} {external:skip}
if {$is_eval eq 1} {
# script propagation is irrelevant on functions
test {EVAL timeout from AOF} {
# generate a long running script that is propagated to the AOF as script
# make sure that the script times out during loading
......@@ -528,9 +580,11 @@ start_server {tags {"scripting"}} {
assert {[r mget a{t} b{t} c{t} d{t}] eq {1 2 3 4}}
assert {[r spop myset] eq {}}
}
} ;# is_eval
test {Call Redis command with many args from Lua (issue #1764)} {
r eval {
run_script {
local i
local x={}
redis.call('del','mylist')
......@@ -543,7 +597,7 @@ start_server {tags {"scripting"}} {
} {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100}
test {Number conversion precision test (issue #1118)} {
r eval {
run_script {
local value = 9007199254740991
redis.call("set","foo",value)
return redis.call("get","foo")
......@@ -551,19 +605,19 @@ start_server {tags {"scripting"}} {
} {9007199254740991}
test {String containing number precision test (regression of issue #1118)} {
r eval {
run_script {
redis.call("set", "key", "12039611435714932082")
return redis.call("get", "key")
} 1 key
} {12039611435714932082}
test {Verify negative arg count is error instead of crash (issue #1842)} {
catch { r eval { return "hello" } -12 } e
catch { run_script { return "hello" } -12 } e
set e
} {ERR Number of keys can't be negative}
test {Correct handling of reused argv (issue #1939)} {
r eval {
run_script {
for i = 0, 10 do
redis.call('SET', 'a{t}', '1')
redis.call('MGET', 'a{t}', 'b{t}', 'c{t}')
......@@ -576,7 +630,7 @@ start_server {tags {"scripting"}} {
test {Functions in the Redis namespace are able to report errors} {
catch {
r eval {
run_script {
redis.sha1hex()
} 0
} e
......@@ -594,22 +648,22 @@ start_server {tags {"scripting"}} {
assert_equal $res $expected_dict
# Test RESP3 client with script in both RESP2 and RESP3 modes
set res [r eval {redis.setresp(3); return redis.call('hgetall', KEYS[1])} 1 hash]
set res [run_script {redis.setresp(3); return redis.call('hgetall', KEYS[1])} 1 hash]
assert_equal $res $expected_dict
set res [r eval {redis.setresp(2); return redis.call('hgetall', KEYS[1])} 1 hash]
set res [run_script {redis.setresp(2); return redis.call('hgetall', KEYS[1])} 1 hash]
assert_equal $res $expected_list
# Test RESP2 client with script in both RESP2 and RESP3 modes
r HELLO 2
set res [r eval {redis.setresp(3); return redis.call('hgetall', KEYS[1])} 1 hash]
set res [run_script {redis.setresp(3); return redis.call('hgetall', KEYS[1])} 1 hash]
assert_equal $res $expected_list
set res [r eval {redis.setresp(2); return redis.call('hgetall', KEYS[1])} 1 hash]
set res [run_script {redis.setresp(2); return redis.call('hgetall', KEYS[1])} 1 hash]
assert_equal $res $expected_list
}
test {Script return recursive object} {
r readraw 1
set res [r eval {local a = {}; local b = {a}; a[1] = b; return a} 0]
set res [run_script {local a = {}; local b = {a}; a[1] = b; return a} 0]
# drain the response
while {true} {
if {$res == "-ERR reached lua stack limit"} {
......@@ -640,11 +694,11 @@ start_server {tags {"scripting"}} {
test {Timedout read-only scripts can be killed by SCRIPT KILL} {
set rd [redis_deferring_client]
r config set lua-time-limit 10
$rd eval {while true do end} 0
run_script_on_connection $rd {while true do end} 0
after 200
catch {r ping} e
assert_match {BUSY*} $e
r script kill
kill_script
after 200 ; # Give some time to Lua to call the hook again...
assert_equal [r ping] "PONG"
$rd close
......@@ -653,7 +707,7 @@ start_server {tags {"scripting"}} {
test {Timedout read-only scripts can be killed by SCRIPT KILL even when use pcall} {
set rd [redis_deferring_client]
r config set lua-time-limit 10
$rd eval {local f = function() while 1 do redis.call('ping') end end while 1 do pcall(f) end} 0
run_script_on_connection $rd {local f = function() while 1 do redis.call('ping') end end while 1 do pcall(f) end} 0
wait_for_condition 50 100 {
[catch {r ping} e] == 1
......@@ -663,7 +717,7 @@ start_server {tags {"scripting"}} {
catch {r ping} e
assert_match {BUSY*} $e
r script kill
kill_script
wait_for_condition 50 100 {
[catch {r ping} e] == 0
......@@ -685,8 +739,14 @@ start_server {tags {"scripting"}} {
# senging (in a pipeline):
# 1. eval "while 1 do redis.call('ping') end" 0
# 2. ping
if {$is_eval == 1} {
set buf "*3\r\n\$4\r\neval\r\n\$33\r\nwhile 1 do redis.call('ping') end\r\n\$1\r\n0\r\n"
append buf "*1\r\n\$4\r\nping\r\n"
} else {
set buf "*6\r\n\$8\r\nfunction\r\n\$6\r\ncreate\r\n\$3\r\nlua\r\n\$4\r\ntest\r\n\$7\r\nreplace\r\n\$33\r\nwhile 1 do redis.call('ping') end\r\n"
append buf "*3\r\n\$5\r\nfcall\r\n\$4\r\ntest\r\n\$1\r\n0\r\n"
append buf "*1\r\n\$4\r\nping\r\n"
}
$rd write $buf
$rd flush
......@@ -698,7 +758,7 @@ start_server {tags {"scripting"}} {
catch {r ping} e
assert_match {BUSY*} $e
r script kill
kill_script
wait_for_condition 50 100 {
[catch {r ping} e] == 0
} else {
......@@ -706,6 +766,11 @@ start_server {tags {"scripting"}} {
}
assert_equal [r ping] "PONG"
if {$is_eval == 0} {
# read the ok reply of function create
assert_match {OK} [$rd read]
}
catch {$rd read} res
assert_match {*killed by user*} $res
......@@ -717,18 +782,18 @@ start_server {tags {"scripting"}} {
test {Timedout script link is still usable after Lua returns} {
r config set lua-time-limit 10
r eval {for i=1,100000 do redis.call('ping') end return 'ok'} 0
run_script {for i=1,100000 do redis.call('ping') end return 'ok'} 0
r ping
} {PONG}
test {Timedout scripts that modified data can't be killed by SCRIPT KILL} {
set rd [redis_deferring_client]
r config set lua-time-limit 10
$rd eval {redis.call('set',KEYS[1],'y'); while true do end} 1 x
run_script_on_connection $rd {redis.call('set',KEYS[1],'y'); while true do end} 1 x
after 200
catch {r ping} e
assert_match {BUSY*} $e
catch {r script kill} e
catch {kill_script} e
assert_match {UNKILLABLE*} $e
catch {r ping} e
assert_match {BUSY*} $e
......@@ -761,11 +826,11 @@ foreach cmdrepl {0 1} {
# One with an error, but still executing a command.
# SHA is: 67164fc43fa971f76fd1aaeeaf60c1c178d25876
catch {
r eval {redis.call('incr',KEYS[1]); redis.call('nonexisting')} 1 x
run_script {redis.call('incr',KEYS[1]); redis.call('nonexisting')} 1 x
}
# One command is correct:
# SHA is: 6f5ade10a69975e903c6d07b10ea44c6382381a5
r eval {return redis.call('incr',KEYS[1])} 1 x
run_script {return redis.call('incr',KEYS[1])} 1 x
} {2}
test "Connect a replica to the master instance $rt" {
......@@ -778,6 +843,7 @@ foreach cmdrepl {0 1} {
}
}
if {$is_eval eq 1} {
test "Now use EVALSHA against the master, with both SHAs $rt" {
# The server should replicate successful and unsuccessful
# commands as EVAL instead of EVALSHA.
......@@ -794,11 +860,12 @@ foreach cmdrepl {0 1} {
fail "Expected 4 in x, but value is '[r -1 get x]'"
}
}
} ;# is_eval
test "Replication of script multiple pushes to list with BLPOP $rt" {
set rd [redis_deferring_client]
$rd brpop a 0
r eval {
run_script {
redis.call("lpush",KEYS[1],"1");
redis.call("lpush",KEYS[1],"2");
} 1 a
......@@ -812,6 +879,7 @@ foreach cmdrepl {0 1} {
set res
} {a 1}
if {$is_eval eq 1} {
test "EVALSHA replication when first call is readonly $rt" {
r del x
r eval {if tonumber(ARGV[1]) > 0 then redis.call('incr', KEYS[1]) end} 1 x 0
......@@ -823,16 +891,17 @@ foreach cmdrepl {0 1} {
fail "Expected 1 in x, but value is '[r -1 get x]'"
}
}
} ;# is_eval
test "Lua scripts using SELECT are replicated correctly $rt" {
r eval {
run_script {
redis.call("set","foo1","bar1")
redis.call("select","10")
redis.call("incr","x")
redis.call("select","11")
redis.call("incr","z")
} 0
r eval {
run_script {
redis.call("set","foo1","bar1")
redis.call("select","10")
redis.call("incr","x")
......@@ -861,6 +930,8 @@ start_server {tags {"scripting repl external:skip"}} {
}
}
if {$is_eval eq 1} {
# replicate_commands is the default on Redis Function
test "Redis.replicate_commands() must be issued before any write" {
r eval {
redis.call('set','foo','bar');
......@@ -884,11 +955,11 @@ start_server {tags {"scripting repl external:skip"}} {
r debug lua-always-replicate-commands 1
set e
} {*only after turning on*}
} ;# is_eval
test "Redis.set_repl() don't accept invalid values" {
catch {
r eval {
redis.replicate_commands();
run_script {
redis.set_repl(12345);
} 0
} e
......@@ -897,8 +968,7 @@ start_server {tags {"scripting repl external:skip"}} {
test "Test selective replication of certain Redis commands from Lua" {
r del a b c d
r eval {
redis.replicate_commands();
run_script {
redis.call('set','a','1');
redis.set_repl(redis.REPL_NONE);
redis.call('set','b','2');
......@@ -924,24 +994,37 @@ start_server {tags {"scripting repl external:skip"}} {
}
test "PRNG is seeded randomly for command replication" {
if {$is_eval eq 1} {
# on is_eval Lua we need to call redis.replicate_commands() to get real randomization
set a [
r eval {
redis.replicate_commands();
run_script {
redis.replicate_commands()
return math.random()*100000;
} 0
]
set b [
r eval {
redis.replicate_commands();
run_script {
redis.replicate_commands()
return math.random()*100000;
} 0
]
} else {
set a [
run_script {
return math.random()*100000;
} 0
]
set b [
run_script {
return math.random()*100000;
} 0
]
}
assert {$a ne $b}
}
test "Using side effects is not a problem with command replication" {
r eval {
redis.replicate_commands();
run_script {
redis.call('set','time',redis.call('time')[1])
} 0
......@@ -956,6 +1039,7 @@ start_server {tags {"scripting repl external:skip"}} {
}
}
if {$is_eval eq 1} {
start_server {tags {"scripting external:skip"}} {
r script debug sync
r eval {return 'hello'} 0
......@@ -984,12 +1068,13 @@ start_server {tags {"scripting needs:debug external:skip"}} {
r write $cmd
r flush
set ret [r read]
assert_match {*Unknown Redis command called from*} $ret
assert_match {*Unknown Redis command called from script*} $ret
# make sure the server is still ok
reconnect
assert_equal [r ping] {PONG}
}
}
} ;# is_eval
start_server {tags {"scripting resp3 needs:debug"}} {
r debug set-disable-deny-scripts 1
......@@ -999,7 +1084,7 @@ start_server {tags {"scripting resp3 needs:debug"}} {
r readraw 1
test {test resp3 big number protocol parsing} {
set ret [r eval "redis.setresp($i);return redis.call('debug', 'protocol', 'bignum')" 0]
set ret [run_script "redis.setresp($i);return redis.call('debug', 'protocol', 'bignum')" 0]
if {$client_proto == 2 || $i == 2} {
# if either Lua or the clien is RESP2 the reply will be RESP2
assert_equal $ret {$37}
......@@ -1021,7 +1106,7 @@ start_server {tags {"scripting resp3 needs:debug"}} {
}
test {test resp3 map protocol parsing} {
set ret [r eval "redis.setresp($i);return redis.call('debug', 'protocol', 'map')" 0]
set ret [run_script "redis.setresp($i);return redis.call('debug', 'protocol', 'map')" 0]
if {$client_proto == 2 || $i == 2} {
# if either Lua or the clien is RESP2 the reply will be RESP2
assert_equal $ret {*6}
......@@ -1034,7 +1119,7 @@ start_server {tags {"scripting resp3 needs:debug"}} {
}
test {test resp3 set protocol parsing} {
set ret [r eval "redis.setresp($i);return redis.call('debug', 'protocol', 'set')" 0]
set ret [run_script "redis.setresp($i);return redis.call('debug', 'protocol', 'set')" 0]
if {$client_proto == 2 || $i == 2} {
# if either Lua or the clien is RESP2 the reply will be RESP2
assert_equal $ret {*3}
......@@ -1047,7 +1132,7 @@ start_server {tags {"scripting resp3 needs:debug"}} {
}
test {test resp3 double protocol parsing} {
set ret [r eval "redis.setresp($i);return redis.call('debug', 'protocol', 'double')" 0]
set ret [run_script "redis.setresp($i);return redis.call('debug', 'protocol', 'double')" 0]
if {$client_proto == 2 || $i == 2} {
# if either Lua or the clien is RESP2 the reply will be RESP2
assert_equal $ret {$5}
......@@ -1058,7 +1143,7 @@ start_server {tags {"scripting resp3 needs:debug"}} {
}
test {test resp3 null protocol parsing} {
set ret [r eval "redis.setresp($i);return redis.call('debug', 'protocol', 'null')" 0]
set ret [run_script "redis.setresp($i);return redis.call('debug', 'protocol', 'null')" 0]
if {$client_proto == 2} {
# null is a special case in which a Lua client format does not effect the reply to the client
assert_equal $ret {$-1}
......@@ -1068,7 +1153,7 @@ start_server {tags {"scripting resp3 needs:debug"}} {
} {}
test {test resp3 verbatim protocol parsing} {
set ret [r eval "redis.setresp($i);return redis.call('debug', 'protocol', 'verbatim')" 0]
set ret [run_script "redis.setresp($i);return redis.call('debug', 'protocol', 'verbatim')" 0]
if {$client_proto == 2 || $i == 2} {
# if either Lua or the clien is RESP2 the reply will be RESP2
assert_equal $ret {$25}
......@@ -1082,7 +1167,7 @@ start_server {tags {"scripting resp3 needs:debug"}} {
}
test {test resp3 true protocol parsing} {
set ret [r eval "redis.setresp($i);return redis.call('debug', 'protocol', 'true')" 0]
set ret [run_script "redis.setresp($i);return redis.call('debug', 'protocol', 'true')" 0]
if {$client_proto == 2 || $i == 2} {
# if either Lua or the clien is RESP2 the reply will be RESP2
assert_equal $ret {:1}
......@@ -1092,7 +1177,7 @@ start_server {tags {"scripting resp3 needs:debug"}} {
}
test {test resp3 false protocol parsing} {
set ret [r eval "redis.setresp($i);return redis.call('debug', 'protocol', 'false')" 0]
set ret [run_script "redis.setresp($i);return redis.call('debug', 'protocol', 'false')" 0]
if {$client_proto == 2 || $i == 2} {
# if either Lua or the clien is RESP2 the reply will be RESP2
assert_equal $ret {:0}
......@@ -1109,8 +1194,9 @@ start_server {tags {"scripting resp3 needs:debug"}} {
test {test resp3 attribute protocol parsing} {
# attributes are not (yet) expose to the script
# So here we just check the parser handles them and they are ignored.
r eval "redis.setresp(3);return redis.call('debug', 'protocol', 'attrib')" 0
run_script "redis.setresp(3);return redis.call('debug', 'protocol', 'attrib')" 0
} {Some real reply following the attribute}
r debug set-disable-deny-scripts 0
}
} ;# foreach is_eval
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment