gvsafronov/futriix
1
0
Fork 0
Code Issues Pull Requests Actions 8 Packages Projects Releases Wiki Activity
futriix/tests/unit/pubsub.tcl
uriyage bbfd041895
Async IO threads (#758) 
This PR is 1 of 3 PRs intended to achieve the goal of 1 million requests
per second, as detailed by [dan touitou](https://github.com/touitou-dan)
in https://github.com/valkey-io/valkey/issues/22. This PR modifies the
IO threads to be fully asynchronous, which is a first and necessary step
to allow more work offloading and better utilization of the IO threads.

### Current IO threads state:

Valkey IO threads were introduced in Redis 6.0 to allow better
utilization of multi-core machines. Before this, Redis was
single-threaded and could only use one CPU core for network and command
processing. The introduction of IO threads helps in offloading the IO
operations to multiple threads.

**Current IO Threads flow:**

1. Initialization: When Redis starts, it initializes a specified number
of IO threads. These threads are in addition to the main thread, each
thread starts with an empty list, the main thread will populate that
list in each event-loop with pending-read-clients or
pending-write-clients.
2. Read Phase: The main thread accepts incoming connections and reads
requests from clients. The reading of requests are offloaded to IO
threads. The main thread puts the clients ready-to-read in a list and
set the global io_threads_op to IO_THREADS_OP_READ, the IO threads pick
the clients up, perform the read operation and parse the first incoming
command.
3. Command Processing: After reading the requests, command processing is
still single-threaded and handled by the main thread.
4. Write Phase: Similar to the read phase, the write phase is also be
offloaded to IO threads. The main thread prepares the response in the
clients’ output buffer then the main thread puts the client in the list,
and sets the global io_threads_op to the IO_THREADS_OP_WRITE. The IO
threads then pick the clients up and perform the write operation to send
the responses back to clients.
5. Synchronization: The main-thread communicate with the threads on how
many jobs left per each thread with atomic counter. The main-thread
doesn’t access the clients while being handled by the IO threads.

**Issues with current implementation:**

* Underutilized Cores: The current implementation of IO-threads leads to
the underutilization of CPU cores.
* The main thread remains responsible for a significant portion of
IO-related tasks that could be offloaded to IO-threads.
* When the main-thread is processing client’s commands, the IO threads
are idle for a considerable amount of time.
* Notably, the main thread's performance during the IO-related tasks is
constrained by the speed of the slowest IO-thread.
* Limited Offloading: Currently, Since the Main-threads waits
synchronously for the IO threads, the Threads perform only read-parse,
and write operations, with parsing done only for the first command. If
the threads can do work asynchronously we may offload more work to the
threads reducing the load from the main-thread.
* TLS: Currently, we don't support IO threads with TLS (where offloading
IO would be more beneficial) since TLS read/write operations are not
thread-safe with the current implementation.

### Suggested change

Non-blocking main thread - The main thread and IO threads will operate
in parallel to maximize efficiency. The main thread will not be blocked
by IO operations. It will continue to process commands independently of
the IO thread's activities.

**Implementation details**

**Inter-thread communication.**

* We use a static, lock-free ring buffer of fixed size (2048 jobs) for
the main thread to send jobs and for the IO to receive them. If the ring
buffer fills up, the main thread will handle the task itself, acting as
back pressure (in case IO operations are more expensive than command
processing). A static ring buffer is a better candidate than a dynamic
job queue as it eliminates the need for allocation/freeing per job.
* An IO job will be in the format: ` [void* function-call-back | void
*data] `where data is either a client to read/write from and the
function-ptr is the function to be called with the data for example
readQueryFromClient using this format we can use it later to offload
other types of works to the IO threads.
* The Ring buffer is one way from the main-thread to the IO thread, Upon
read/write event the main thread will send a read/write job then in
before sleep it will iterate over the pending read/write clients to
checking for each client if the IO threads has already finished handling
it. The IO thread signals it has finished handling a client read/write
by toggling an atomic flag read_state / write_state on the client
struct.

**Thread Safety**

As suggested in this solution, the IO threads are reading from and
writing to the clients' buffers while the main thread may access those
clients.
We must ensure no race conditions or unsafe access occurs while keeping
the Valkey code simple and lock free.

Minimal Action in the IO Threads
The main change is to limit the IO thread operations to the bare
minimum. The IO thread will access only the client's struct and only the
necessary fields in this struct.
The IO threads will be responsible for the following:

* Read Operation: The IO thread will only read and parse a single
command. It will not update the server stats, handle read errors, or
parsing errors. These tasks will be taken care of by the main thread.
* Write Operation: The IO thread will only write the available data. It
will not free the client's replies, handle write errors, or update the
server statistics.


To achieve this without code duplication, the read/write code has been
refactored into smaller, independent components:

* Functions that perform only the read/parse/write calls.
* Functions that handle the read/parse/write results.

This refactor accounts for the majority of the modifications in this PR.

**Client Struct Safe Access**

As we ensure that the IO threads access memory only within the client
struct, we need to ensure thread safety only for the client's struct's
shared fields.

* Query Buffer 
* Command parsing - The main thread will not try to parse a command from
the query buffer when a client is offloaded to the IO thread.
* Client's memory checks in client-cron - The main thread will not
access the client query buffer if it is offloaded and will handle the
querybuf grow/shrink when the client is back.
* CLIENT LIST command - The main thread will busy-wait for the IO thread
to finish handling the client, falling back to the current behavior
where the main thread waits for the IO thread to finish their
processing.
* Output Buffer 
* The IO thread will not change the client's bufpos and won't free the
client's reply lists. These actions will be done by the main thread on
the client's return from the IO thread.
* bufpos / block→used: As the main thread may change the bufpos, the
reply-block→used, or add/delete blocks to the reply list while the IO
thread writes, we add two fields to the client struct: io_last_bufpos
and io_last_reply_block. The IO thread will write until the
io_last_bufpos, which was set by the main-thread before sending the
client to the IO thread. If more data has been added to the cob in
between, it will be written in the next write-job. In addition, the main
thread will not trim or merge reply blocks while the client is
offloaded.
* Parsing Fields 
    * Client's cmd, argc, argv, reqtype, etc., are set during parsing.
* The main thread will indicate to the IO thread not to parse a cmd if
the client is not reset. In this case, the IO thread will only read from
the network and won't attempt to parse a new command.
* The main thread won't access the c→cmd/c→argv in the CLIENT LIST
command as stated before it will busy wait for the IO threads.
* Client Flags 
* c→flags, which may be changed by the main thread in multiple places,
won't be accessed by the IO thread. Instead, the main thread will set
the c→io_flags with the information necessary for the IO thread to know
the client's state.
* Client Close 
* On freeClient, the main thread will busy wait for the IO thread to
finish processing the client's read/write before proceeding to free the
client.
* Client's Memory Limits 
* The IO thread won't handle the qb/cob limits. In case a client crosses
the qb limit, the IO thread will stop reading for it, letting the main
thread know that the client crossed the limit.

**TLS**

TLS is currently not supported with IO threads for the following
reasons:

1. Pending reads - If SSL has pending data that has already been read
from the socket, there is a risk of not calling the read handler again.
To handle this, a list is used to hold the pending clients. With IO
threads, multiple threads can access the list concurrently.
2. Event loop modification - Currently, the TLS code
registers/unregisters the file descriptor from the event loop depending
on the read/write results. With IO threads, multiple threads can modify
the event loop struct simultaneously.
3. The same client can be sent to 2 different threads concurrently
(https://github.com/redis/redis/issues/12540).

Those issues were handled in the current PR:

1. The IO thread only performs the read operation. The main thread will
check for pending reads after the client returns from the IO thread and
will be the only one to access the pending list.
2. The registering/unregistering of events will be similarly postponed
and handled by the main thread only.
3. Each client is being sent to the same dedicated thread (c→id %
num_of_threads).


**Sending Replies Immediately with IO threads.**

Currently, after processing a command, we add the client to the
pending_writes_list. Only after processing all the clients do we send
all the replies. Since the IO threads are now working asynchronously, we
can send the reply immediately after processing the client’s requests,
reducing the command latency. However, if we are using AOF=always, we
must wait for the AOF buffer to be written, in which case we revert to
the current behavior.

**IO threads dynamic adjustment**

Currently, we use an all-or-nothing approach when activating the IO
threads. The current logic is as follows: if the number of pending write
clients is greater than twice the number of threads (including the main
thread), we enable all threads; otherwise, we enable none. For example,
if 8 IO threads are defined, we enable all 8 threads if there are 16
pending clients; else, we enable none.
It makes more sense to enable partial activation of the IO threads. If
we have 10 pending clients, we will enable 5 threads, and so on. This
approach allows for a more granular and efficient allocation of
resources based on the current workload.

In addition, the user will now be able to change the number of I/O
threads at runtime. For example, when decreasing the number of threads
from 4 to 2, threads 3 and 4 will be closed after flushing their job
queues.

**Tests**

Currently, we run the io-threads tests with 4 IO threads
(443d80f168/.github/workflows/daily.yml (L353)).
This means that we will not activate the IO threads unless there are 8
(threads * 2) pending write clients per single loop, which is unlikely
to happened in most of tests, meaning the IO threads are not currently
being tested.

To enforce the main thread to always offload work to the IO threads,
regardless of the number of pending events, we add an
events-per-io-thread configuration with a default value of 2. When set
to 0, this configuration will force the main thread to always offload
work to the IO threads.

When we offload every single read/write operation to the IO threads, the
IO-threads are running with 100% CPU when running multiple tests
concurrently some tests fail as a result of larger than expected command
latencies. To address this issue, we have to add some after or wait_for
calls to some of the tests to ensure they pass with IO threads as well.

Signed-off-by: Uri Yagelnik <uriy@amazon.com>
2024-07-08 20:01:39 -07:00

519 lines
18 KiB
Tcl
Raw Blame History

start_server {tags {"pubsub network"}} {
if {$::singledb} {
set db 0
} else {
set db 9
}
foreach resp {2 3} {
set rd1 [valkey_deferring_client]
if {[lsearch $::denytags "resp3"] >= 0} {
if {$resp == 3} {continue}
} elseif {$::force_resp3} {
if {$resp == 2} {continue}
}
$rd1 hello $resp
$rd1 read
test "Pub/Sub PING on RESP$resp" {
subscribe $rd1 somechannel
# While subscribed to non-zero channels PING works in Pub/Sub mode.
$rd1 ping
$rd1 ping "foo"
# In RESP3, the SUBSCRIBEd client can issue any command and get a reply, so the PINGs are standard
# In RESP2, only a handful of commands are allowed after a client is SUBSCRIBED (PING is one of them).
# For some reason, the reply in that case is an array with two elements: "pong" and argv[1] or an empty string
# God knows why. Done in commit 2264b981
if {$resp == 3} {
assert_equal {PONG} [$rd1 read]
assert_equal {foo} [$rd1 read]
} else {
assert_equal {pong {}} [$rd1 read]
assert_equal {pong foo} [$rd1 read]
}
unsubscribe $rd1 somechannel
# Now we are unsubscribed, PING should just return PONG.
$rd1 ping
assert_equal {PONG} [$rd1 read]
}
$rd1 close
}
test "PUBLISH/SUBSCRIBE basics" {
set rd1 [valkey_deferring_client]
# subscribe to two channels
assert_equal {1 2} [subscribe $rd1 {chan1 chan2}]
assert_equal 1 [r publish chan1 hello]
assert_equal 1 [r publish chan2 world]
assert_equal {message chan1 hello} [$rd1 read]
assert_equal {message chan2 world} [$rd1 read]
# unsubscribe from one of the channels
unsubscribe $rd1 {chan1}
assert_equal 0 [r publish chan1 hello]
assert_equal 1 [r publish chan2 world]
assert_equal {message chan2 world} [$rd1 read]
# unsubscribe from the remaining channel
unsubscribe $rd1 {chan2}
assert_equal 0 [r publish chan1 hello]
assert_equal 0 [r publish chan2 world]
# clean up clients
$rd1 close
}
test "PUBLISH/SUBSCRIBE with two clients" {
set rd1 [valkey_deferring_client]
set rd2 [valkey_deferring_client]
assert_equal {1} [subscribe $rd1 {chan1}]
assert_equal {1} [subscribe $rd2 {chan1}]
assert_equal 2 [r publish chan1 hello]
assert_equal {message chan1 hello} [$rd1 read]
assert_equal {message chan1 hello} [$rd2 read]
# clean up clients
$rd1 close
$rd2 close
}
test "PUBLISH/SUBSCRIBE after UNSUBSCRIBE without arguments" {
set rd1 [valkey_deferring_client]
assert_equal {1 2 3} [subscribe $rd1 {chan1 chan2 chan3}]
unsubscribe $rd1
# wait for the unsubscribe to take effect
wait_for_condition 50 100 {
[r publish chan1 hello] eq 0
} else {
fail "unsubscribe did not take effect"
}
assert_equal 0 [r publish chan1 hello]
assert_equal 0 [r publish chan2 hello]
assert_equal 0 [r publish chan3 hello]
# clean up clients
$rd1 close
}
test "SUBSCRIBE to one channel more than once" {
set rd1 [valkey_deferring_client]
assert_equal {1 1 1} [subscribe $rd1 {chan1 chan1 chan1}]
assert_equal 1 [r publish chan1 hello]
assert_equal {message chan1 hello} [$rd1 read]
# clean up clients
$rd1 close
}
test "UNSUBSCRIBE from non-subscribed channels" {
set rd1 [valkey_deferring_client]
assert_equal {0 0 0} [unsubscribe $rd1 {foo bar quux}]
# clean up clients
$rd1 close
}
test "PUBLISH/PSUBSCRIBE basics" {
set rd1 [valkey_deferring_client]
# subscribe to two patterns
assert_equal {1 2} [psubscribe $rd1 {foo.* bar.*}]
assert_equal 1 [r publish foo.1 hello]
assert_equal 1 [r publish bar.1 hello]
assert_equal 0 [r publish foo1 hello]
assert_equal 0 [r publish barfoo.1 hello]
assert_equal 0 [r publish qux.1 hello]
assert_equal {pmessage foo.* foo.1 hello} [$rd1 read]
assert_equal {pmessage bar.* bar.1 hello} [$rd1 read]
# unsubscribe from one of the patterns
assert_equal {1} [punsubscribe $rd1 {foo.*}]
assert_equal 0 [r publish foo.1 hello]
assert_equal 1 [r publish bar.1 hello]
assert_equal {pmessage bar.* bar.1 hello} [$rd1 read]
# unsubscribe from the remaining pattern
assert_equal {0} [punsubscribe $rd1 {bar.*}]
assert_equal 0 [r publish foo.1 hello]
assert_equal 0 [r publish bar.1 hello]
# clean up clients
$rd1 close
}
test "PUBLISH/PSUBSCRIBE with two clients" {
set rd1 [valkey_deferring_client]
set rd2 [valkey_deferring_client]
assert_equal {1} [psubscribe $rd1 {chan.*}]
assert_equal {1} [psubscribe $rd2 {chan.*}]
assert_equal 2 [r publish chan.foo hello]
assert_equal {pmessage chan.* chan.foo hello} [$rd1 read]
assert_equal {pmessage chan.* chan.foo hello} [$rd2 read]
# clean up clients
$rd1 close
$rd2 close
}
test "PUBLISH/PSUBSCRIBE after PUNSUBSCRIBE without arguments" {
set rd1 [valkey_deferring_client]
assert_equal {1 2 3} [psubscribe $rd1 {chan1.* chan2.* chan3.*}]
punsubscribe $rd1
# wait for the unsubscribe to take effect
wait_for_condition 50 100 {
[r publish chan1.hi hello] eq 0
} else {
fail "unsubscribe did not take effect"
}
assert_equal 0 [r publish chan1.hi hello]
assert_equal 0 [r publish chan2.hi hello]
assert_equal 0 [r publish chan3.hi hello]
# clean up clients
$rd1 close
}
test "PubSub messages with CLIENT REPLY OFF" {
set rd [valkey_deferring_client]
$rd hello 3
$rd read ;# Discard the hello reply
# Test that the subscribe/psubscribe notification is ok
$rd client reply off
assert_equal {1} [subscribe $rd channel]
assert_equal {2} [psubscribe $rd ch*]
# Test that the publish notification is ok
$rd client reply off
assert_equal 2 [r publish channel hello]
assert_equal {message channel hello} [$rd read]
assert_equal {pmessage ch* channel hello} [$rd read]
# Test that the unsubscribe/punsubscribe notification is ok
$rd client reply off
assert_equal {1} [unsubscribe $rd channel]
assert_equal {0} [punsubscribe $rd ch*]
$rd close
} {0} {resp3}
test "PUNSUBSCRIBE from non-subscribed channels" {
set rd1 [valkey_deferring_client]
assert_equal {0 0 0} [punsubscribe $rd1 {foo.* bar.* quux.*}]
# clean up clients
$rd1 close
}
test "NUMSUB returns numbers, not strings (#1561)" {
r pubsub numsub abc def
} {abc 0 def 0}
test "NUMPATs returns the number of unique patterns" {
set rd1 [valkey_deferring_client]
set rd2 [valkey_deferring_client]
# Three unique patterns and one that overlaps
psubscribe $rd1 "foo*"
psubscribe $rd2 "foo*"
psubscribe $rd1 "bar*"
psubscribe $rd2 "baz*"
set patterns [r pubsub numpat]
# clean up clients
punsubscribe $rd1
punsubscribe $rd2
assert_equal 3 $patterns
$rd1 close
$rd2 close
}
test "Mix SUBSCRIBE and PSUBSCRIBE" {
set rd1 [valkey_deferring_client]
assert_equal {1} [subscribe $rd1 {foo.bar}]
assert_equal {2} [psubscribe $rd1 {foo.*}]
assert_equal 2 [r publish foo.bar hello]
assert_equal {message foo.bar hello} [$rd1 read]
assert_equal {pmessage foo.* foo.bar hello} [$rd1 read]
# clean up clients
$rd1 close
}
test "PUNSUBSCRIBE and UNSUBSCRIBE should always reply" {
# Make sure we are not subscribed to any channel at all.
r punsubscribe
r unsubscribe
# Now check if the commands still reply correctly.
set reply1 [r punsubscribe]
set reply2 [r unsubscribe]
concat $reply1 $reply2
} {punsubscribe {} 0 unsubscribe {} 0}
### Keyspace events notification tests
test "Keyspace notifications: we receive keyspace notifications" {
r config set notify-keyspace-events KA
set rd1 [valkey_deferring_client]
$rd1 CLIENT REPLY OFF ;# Make sure it works even if replies are silenced
assert_equal {1} [psubscribe $rd1 *]
r set foo bar
assert_equal "pmessage * __keyspace@${db}__:foo set" [$rd1 read]
$rd1 close
}
test "Keyspace notifications: we receive keyevent notifications" {
r config set notify-keyspace-events EA
set rd1 [valkey_deferring_client]
$rd1 CLIENT REPLY SKIP ;# Make sure it works even if replies are silenced
assert_equal {1} [psubscribe $rd1 *]
r set foo bar
assert_equal "pmessage * __keyevent@${db}__:set foo" [$rd1 read]
$rd1 close
}
test "Keyspace notifications: we can receive both kind of events" {
r config set notify-keyspace-events KEA
set rd1 [valkey_deferring_client]
$rd1 CLIENT REPLY ON ;# Just coverage
assert_equal {OK} [$rd1 read]
assert_equal {1} [psubscribe $rd1 *]
r set foo bar
assert_equal "pmessage * __keyspace@${db}__:foo set" [$rd1 read]
assert_equal "pmessage * __keyevent@${db}__:set foo" [$rd1 read]
$rd1 close
}
test "Keyspace notifications: we are able to mask events" {
r config set notify-keyspace-events KEl
r del mylist
set rd1 [valkey_deferring_client]
assert_equal {1} [psubscribe $rd1 *]
r set foo bar
r lpush mylist a
# No notification for set, because only list commands are enabled.
assert_equal "pmessage * __keyspace@${db}__:mylist lpush" [$rd1 read]
assert_equal "pmessage * __keyevent@${db}__:lpush mylist" [$rd1 read]
$rd1 close
}
test "Keyspace notifications: general events test" {
r config set notify-keyspace-events KEg
set rd1 [valkey_deferring_client]
assert_equal {1} [psubscribe $rd1 *]
r set foo bar
r expire foo 1
r del foo
assert_equal "pmessage * __keyspace@${db}__:foo expire" [$rd1 read]
assert_equal "pmessage * __keyevent@${db}__:expire foo" [$rd1 read]
assert_equal "pmessage * __keyspace@${db}__:foo del" [$rd1 read]
assert_equal "pmessage * __keyevent@${db}__:del foo" [$rd1 read]
$rd1 close
}
test "Keyspace notifications: list events test" {
r config set notify-keyspace-events KEl
r del mylist
set rd1 [valkey_deferring_client]
assert_equal {1} [psubscribe $rd1 *]
r lpush mylist a
r rpush mylist a
r rpop mylist
assert_equal "pmessage * __keyspace@${db}__:mylist lpush" [$rd1 read]
assert_equal "pmessage * __keyevent@${db}__:lpush mylist" [$rd1 read]
assert_equal "pmessage * __keyspace@${db}__:mylist rpush" [$rd1 read]
assert_equal "pmessage * __keyevent@${db}__:rpush mylist" [$rd1 read]
assert_equal "pmessage * __keyspace@${db}__:mylist rpop" [$rd1 read]
assert_equal "pmessage * __keyevent@${db}__:rpop mylist" [$rd1 read]
$rd1 close
}
test "Keyspace notifications: set events test" {
r config set notify-keyspace-events Ks
r del myset
set rd1 [valkey_deferring_client]
assert_equal {1} [psubscribe $rd1 *]
r sadd myset a b c d
r srem myset x
r sadd myset x y z
r srem myset x
assert_equal "pmessage * __keyspace@${db}__:myset sadd" [$rd1 read]
assert_equal "pmessage * __keyspace@${db}__:myset sadd" [$rd1 read]
assert_equal "pmessage * __keyspace@${db}__:myset srem" [$rd1 read]
$rd1 close
}
test "Keyspace notifications: zset events test" {
r config set notify-keyspace-events Kz
r del myzset
set rd1 [valkey_deferring_client]
assert_equal {1} [psubscribe $rd1 *]
r zadd myzset 1 a 2 b
r zrem myzset x
r zadd myzset 3 x 4 y 5 z
r zrem myzset x
assert_equal "pmessage * __keyspace@${db}__:myzset zadd" [$rd1 read]
assert_equal "pmessage * __keyspace@${db}__:myzset zadd" [$rd1 read]
assert_equal "pmessage * __keyspace@${db}__:myzset zrem" [$rd1 read]
$rd1 close
}
test "Keyspace notifications: hash events test" {
r config set notify-keyspace-events Kh
r del myhash
set rd1 [valkey_deferring_client]
assert_equal {1} [psubscribe $rd1 *]
r hmset myhash yes 1 no 0
r hincrby myhash yes 10
assert_equal "pmessage * __keyspace@${db}__:myhash hset" [$rd1 read]
assert_equal "pmessage * __keyspace@${db}__:myhash hincrby" [$rd1 read]
$rd1 close
}
test "Keyspace notifications: stream events test" {
r config set notify-keyspace-events Kt
r del mystream
set rd1 [valkey_deferring_client]
assert_equal {1} [psubscribe $rd1 *]
r xgroup create mystream mygroup $ mkstream
r xgroup createconsumer mystream mygroup Bob
set id [r xadd mystream 1 field1 A]
r xreadgroup group mygroup Alice STREAMS mystream >
r xclaim mystream mygroup Mike 0 $id force
# Not notify because of "Lee" not exists.
r xgroup delconsumer mystream mygroup Lee
# Not notify because of "Bob" exists.
r xautoclaim mystream mygroup Bob 0 $id
r xgroup delconsumer mystream mygroup Bob
assert_equal "pmessage * __keyspace@${db}__:mystream xgroup-create" [$rd1 read]
assert_equal "pmessage * __keyspace@${db}__:mystream xgroup-createconsumer" [$rd1 read]
assert_equal "pmessage * __keyspace@${db}__:mystream xadd" [$rd1 read]
assert_equal "pmessage * __keyspace@${db}__:mystream xgroup-createconsumer" [$rd1 read]
assert_equal "pmessage * __keyspace@${db}__:mystream xgroup-createconsumer" [$rd1 read]
assert_equal "pmessage * __keyspace@${db}__:mystream xgroup-delconsumer" [$rd1 read]
$rd1 close
}
test "Keyspace notifications: expired events (triggered expire)" {
r config set notify-keyspace-events Ex
r del foo
set rd1 [valkey_deferring_client]
assert_equal {1} [psubscribe $rd1 *]
r psetex foo 100 1
wait_for_condition 50 100 {
[r exists foo] == 0
} else {
fail "Key does not expire?!"
}
assert_equal "pmessage * __keyevent@${db}__:expired foo" [$rd1 read]
$rd1 close
}
test "Keyspace notifications: expired events (background expire)" {
r config set notify-keyspace-events Ex
r del foo
set rd1 [valkey_deferring_client]
assert_equal {1} [psubscribe $rd1 *]
r psetex foo 100 1
assert_equal "pmessage * __keyevent@${db}__:expired foo" [$rd1 read]
$rd1 close
}
test "Keyspace notifications: evicted events" {
r config set notify-keyspace-events Ee
r config set maxmemory-policy allkeys-lru
r flushdb
set rd1 [valkey_deferring_client]
assert_equal {1} [psubscribe $rd1 *]
r set foo bar
r config set maxmemory 1
assert_equal "pmessage * __keyevent@${db}__:evicted foo" [$rd1 read]
r config set maxmemory 0
$rd1 close
r config set maxmemory-policy noeviction
} {OK} {needs:config-maxmemory}
test "Keyspace notifications: test CONFIG GET/SET of event flags" {
r config set notify-keyspace-events gKE
assert_equal {gKE} [lindex [r config get notify-keyspace-events] 1]
r config set notify-keyspace-events {$lshzxeKE}
assert_equal {$lshzxeKE} [lindex [r config get notify-keyspace-events] 1]
r config set notify-keyspace-events KA
assert_equal {AK} [lindex [r config get notify-keyspace-events] 1]
r config set notify-keyspace-events EA
assert_equal {AE} [lindex [r config get notify-keyspace-events] 1]
}
test "Keyspace notifications: new key test" {
r config set notify-keyspace-events En
set rd1 [valkey_deferring_client]
assert_equal {1} [psubscribe $rd1 *]
r set foo bar
# second set of foo should not cause a 'new' event
r set foo baz
r set bar bar
assert_equal "pmessage * __keyevent@${db}__:new foo" [$rd1 read]
assert_equal "pmessage * __keyevent@${db}__:new bar" [$rd1 read]
$rd1 close
}
test "publish to self inside multi" {
r hello 3
r subscribe foo
r multi
r ping abc
r publish foo bar
r publish foo vaz
r ping def
assert_equal [r exec] {abc 1 1 def}
assert_equal [r read] {message foo bar}
assert_equal [r read] {message foo vaz}
} {} {resp3}
test "publish to self inside script" {
r hello 3
r subscribe foo
set res [r eval {
redis.call("ping","abc")
redis.call("publish","foo","bar")
redis.call("publish","foo","vaz")
redis.call("ping","def")
return "bla"} 0]
assert_equal $res {bla}
assert_equal [r read] {message foo bar}
assert_equal [r read] {message foo vaz}
} {} {resp3}
test "unsubscribe inside multi, and publish to self" {
r hello 3
# Note: SUBSCRIBE and UNSUBSCRIBE with multiple channels in the same command,
# breaks the multi response, see Redis OSS issue: https://github.com/redis/redis/issues/12207
# this is just a temporary sanity test to detect unintended breakage.
# subscribe for 3 channels actually emits 3 "responses"
assert_equal "subscribe foo 1" [r subscribe foo bar baz]
assert_equal "subscribe bar 2" [r read]
assert_equal "subscribe baz 3" [r read]
r multi
r ping abc
r unsubscribe bar
r unsubscribe baz
r ping def
assert_equal [r exec] {abc {unsubscribe bar 2} {unsubscribe baz 1} def}
# published message comes after the publish command's response.
assert_equal [r publish foo vaz] {1}
assert_equal [r read] {message foo vaz}
} {} {resp3}
}
Reference in New Issue View Git Blame Copy Permalink