mirror of
https://codeberg.org/redict/redict.git
synced 2025-01-23 08:38:27 -05:00
2a2954086a
Deleting a stream while a client is blocked XREADGROUP should unblock the client. The idea is that if a client is blocked via XREADGROUP is different from any other blocking type in the sense that it depends on the existence of both the key and the group. Even if the key is deleted and then revived with XADD it won't help any clients blocked on XREADGROUP because the group no longer exist, so they would fail with -NOGROUP anyway. The conclusion is that it's better to unblock these clients (with error) upon the deletion of the key, rather than waiting for the first XADD. Other changes: 1. Slightly optimize all `serveClientsBlockedOn*` functions by checking `server.blocked_clients_by_type` 2. All `serveClientsBlockedOn*` functions now use a list iterator rather than looking at `listFirst`, relying on `unblockClient` to delete the head of the list. Before this commit, only `serveClientsBlockedOnStreams` used to work like that. 3. bugfix: CLIENT UNBLOCK ERROR should work even if the command doesn't have a timeout_callback (only relevant to module commands)
272 lines
8.2 KiB
Tcl
272 lines
8.2 KiB
Tcl
set testmodule [file normalize tests/modules/blockonkeys.so]
|
|
|
|
start_server {tags {"modules"}} {
|
|
r module load $testmodule
|
|
|
|
test "Module client blocked on keys: Circular BPOPPUSH" {
|
|
set rd1 [redis_deferring_client]
|
|
set rd2 [redis_deferring_client]
|
|
|
|
r del src dst
|
|
|
|
$rd1 fsl.bpoppush src dst 0
|
|
$rd2 fsl.bpoppush dst src 0
|
|
;# wait until clients are actually blocked
|
|
wait_for_condition 50 100 {
|
|
[s 0 blocked_clients] eq {2}
|
|
} else {
|
|
fail "Clients are not blocked"
|
|
}
|
|
|
|
r fsl.push src 42
|
|
|
|
assert_equal {42} [r fsl.getall src]
|
|
assert_equal {} [r fsl.getall dst]
|
|
}
|
|
|
|
test "Module client blocked on keys: Self-referential BPOPPUSH" {
|
|
set rd1 [redis_deferring_client]
|
|
|
|
r del src
|
|
|
|
$rd1 fsl.bpoppush src src 0
|
|
;# wait until clients are actually blocked
|
|
wait_for_condition 50 100 {
|
|
[s 0 blocked_clients] eq {1}
|
|
} else {
|
|
fail "Clients are not blocked"
|
|
}
|
|
r fsl.push src 42
|
|
|
|
assert_equal {42} [r fsl.getall src]
|
|
}
|
|
|
|
test {Module client blocked on keys (no metadata): No block} {
|
|
r del k
|
|
r fsl.push k 33
|
|
r fsl.push k 34
|
|
r fsl.bpop k 0
|
|
} {34}
|
|
|
|
test {Module client blocked on keys (no metadata): Timeout} {
|
|
r del k
|
|
set rd [redis_deferring_client]
|
|
$rd fsl.bpop k 1
|
|
assert_equal {Request timedout} [$rd read]
|
|
}
|
|
|
|
test {Module client blocked on keys (no metadata): Blocked} {
|
|
r del k
|
|
set rd [redis_deferring_client]
|
|
$rd fsl.bpop k 0
|
|
;# wait until clients are actually blocked
|
|
wait_for_condition 50 100 {
|
|
[s 0 blocked_clients] eq {1}
|
|
} else {
|
|
fail "Clients are not blocked"
|
|
}
|
|
r fsl.push k 34
|
|
assert_equal {34} [$rd read]
|
|
}
|
|
|
|
test {Module client blocked on keys (with metadata): No block} {
|
|
r del k
|
|
r fsl.push k 34
|
|
r fsl.bpopgt k 30 0
|
|
} {34}
|
|
|
|
test {Module client blocked on keys (with metadata): Timeout} {
|
|
r del k
|
|
set rd [redis_deferring_client]
|
|
$rd client id
|
|
set cid [$rd read]
|
|
r fsl.push k 33
|
|
$rd fsl.bpopgt k 35 1
|
|
assert_equal {Request timedout} [$rd read]
|
|
r client kill id $cid ;# try to smoke-out client-related memory leak
|
|
}
|
|
|
|
test {Module client blocked on keys (with metadata): Blocked, case 1} {
|
|
r del k
|
|
set rd [redis_deferring_client]
|
|
$rd client id
|
|
set cid [$rd read]
|
|
r fsl.push k 33
|
|
$rd fsl.bpopgt k 33 0
|
|
;# wait until clients are actually blocked
|
|
wait_for_condition 50 100 {
|
|
[s 0 blocked_clients] eq {1}
|
|
} else {
|
|
fail "Clients are not blocked"
|
|
}
|
|
r fsl.push k 34
|
|
assert_equal {34} [$rd read]
|
|
r client kill id $cid ;# try to smoke-out client-related memory leak
|
|
}
|
|
|
|
test {Module client blocked on keys (with metadata): Blocked, case 2} {
|
|
r del k
|
|
set rd [redis_deferring_client]
|
|
$rd fsl.bpopgt k 35 0
|
|
;# wait until clients are actually blocked
|
|
wait_for_condition 50 100 {
|
|
[s 0 blocked_clients] eq {1}
|
|
} else {
|
|
fail "Clients are not blocked"
|
|
}
|
|
r fsl.push k 33
|
|
r fsl.push k 34
|
|
r fsl.push k 35
|
|
r fsl.push k 36
|
|
assert_equal {36} [$rd read]
|
|
}
|
|
|
|
test {Module client blocked on keys (with metadata): Blocked, CLIENT KILL} {
|
|
r del k
|
|
set rd [redis_deferring_client]
|
|
$rd client id
|
|
set cid [$rd read]
|
|
$rd fsl.bpopgt k 35 0
|
|
;# wait until clients are actually blocked
|
|
wait_for_condition 50 100 {
|
|
[s 0 blocked_clients] eq {1}
|
|
} else {
|
|
fail "Clients are not blocked"
|
|
}
|
|
r client kill id $cid ;# try to smoke-out client-related memory leak
|
|
}
|
|
|
|
test {Module client blocked on keys (with metadata): Blocked, CLIENT UNBLOCK TIMEOUT} {
|
|
r del k
|
|
set rd [redis_deferring_client]
|
|
$rd client id
|
|
set cid [$rd read]
|
|
$rd fsl.bpopgt k 35 0
|
|
;# wait until clients are actually blocked
|
|
wait_for_condition 50 100 {
|
|
[s 0 blocked_clients] eq {1}
|
|
} else {
|
|
fail "Clients are not blocked"
|
|
}
|
|
r client unblock $cid timeout ;# try to smoke-out client-related memory leak
|
|
assert_equal {Request timedout} [$rd read]
|
|
}
|
|
|
|
test {Module client blocked on keys (with metadata): Blocked, CLIENT UNBLOCK ERROR} {
|
|
r del k
|
|
set rd [redis_deferring_client]
|
|
$rd client id
|
|
set cid [$rd read]
|
|
$rd fsl.bpopgt k 35 0
|
|
;# wait until clients are actually blocked
|
|
wait_for_condition 50 100 {
|
|
[s 0 blocked_clients] eq {1}
|
|
} else {
|
|
fail "Clients are not blocked"
|
|
}
|
|
r client unblock $cid error ;# try to smoke-out client-related memory leak
|
|
assert_error "*unblocked*" {$rd read}
|
|
}
|
|
|
|
test {Module client blocked on keys, no timeout CB, CLIENT UNBLOCK TIMEOUT} {
|
|
r del k
|
|
set rd [redis_deferring_client]
|
|
$rd client id
|
|
set cid [$rd read]
|
|
$rd fsl.bpop k 0 NO_TO_CB
|
|
;# wait until clients are actually blocked
|
|
wait_for_condition 50 100 {
|
|
[s 0 blocked_clients] eq {1}
|
|
} else {
|
|
fail "Clients are not blocked"
|
|
}
|
|
assert_equal [r client unblock $cid timeout] {0}
|
|
$rd close
|
|
}
|
|
|
|
test {Module client blocked on keys, no timeout CB, CLIENT UNBLOCK ERROR} {
|
|
r del k
|
|
set rd [redis_deferring_client]
|
|
$rd client id
|
|
set cid [$rd read]
|
|
$rd fsl.bpop k 0 NO_TO_CB
|
|
;# wait until clients are actually blocked
|
|
wait_for_condition 50 100 {
|
|
[s 0 blocked_clients] eq {1}
|
|
} else {
|
|
fail "Clients are not blocked"
|
|
}
|
|
assert_equal [r client unblock $cid error] {0}
|
|
$rd close
|
|
}
|
|
|
|
test {Module client re-blocked on keys after woke up on wrong type} {
|
|
r del k
|
|
set rd [redis_deferring_client]
|
|
$rd fsl.bpop k 0
|
|
;# wait until clients are actually blocked
|
|
wait_for_condition 50 100 {
|
|
[s 0 blocked_clients] eq {1}
|
|
} else {
|
|
fail "Clients are not blocked"
|
|
}
|
|
r lpush k 12
|
|
r lpush k 13
|
|
r lpush k 14
|
|
r del k
|
|
r fsl.push k 34
|
|
assert_equal {34} [$rd read]
|
|
assert_equal {1} [r get fsl_wrong_type] ;# first lpush caused one wrong-type wake-up
|
|
}
|
|
|
|
test {Module client blocked on keys woken up by LPUSH} {
|
|
r del k
|
|
set rd [redis_deferring_client]
|
|
$rd blockonkeys.popall k
|
|
# wait until client is actually blocked
|
|
wait_for_condition 50 100 {
|
|
[s 0 blocked_clients] eq {1}
|
|
} else {
|
|
fail "Client is not blocked"
|
|
}
|
|
r lpush k 42 squirrel banana
|
|
assert_equal {banana squirrel 42} [$rd read]
|
|
$rd close
|
|
}
|
|
|
|
test {Module client unblocks BLPOP} {
|
|
r del k
|
|
set rd [redis_deferring_client]
|
|
$rd blpop k 3
|
|
# wait until client is actually blocked
|
|
wait_for_condition 50 100 {
|
|
[s 0 blocked_clients] eq {1}
|
|
} else {
|
|
fail "Client is not blocked"
|
|
}
|
|
r blockonkeys.lpush k 42
|
|
assert_equal {k 42} [$rd read]
|
|
$rd close
|
|
}
|
|
|
|
test {Module unblocks module blocked on non-empty list} {
|
|
r del k
|
|
r lpush k aa
|
|
# Module client blocks to pop 5 elements from list
|
|
set rd [redis_deferring_client]
|
|
$rd blockonkeys.blpopn k 5
|
|
# Wait until client is actually blocked
|
|
wait_for_condition 50 100 {
|
|
[s 0 blocked_clients] eq {1}
|
|
} else {
|
|
fail "Client is not blocked"
|
|
}
|
|
# Check that RM_SignalKeyAsReady() can wake up BLPOPN
|
|
r blockonkeys.lpush_unblock k bb cc ;# Not enough elements for BLPOPN
|
|
r lpush k dd ee ff ;# Doesn't unblock module
|
|
r blockonkeys.lpush_unblock k gg ;# Unblocks module
|
|
assert_equal {gg ff ee dd cc} [$rd read]
|
|
$rd close
|
|
}
|
|
}
|