2019-09-12 10:56:54 +03:00
source tests/ support/ cli.tcl
2021-06-09 15:13:24 +03:00
if { $::singledb } {
set : : dbnum 0
} else {
set : : dbnum 9
}
2025-01-12 01:02:39 +01:00
start_server { tags { " c l i l o g r e q r e s : s k i p " } } {
2021-06-09 15:13:24 +03:00
proc open_cli { { opts " " } { infile " " } } {
if { $opts == " " } {
set opts " - n $ : : d b n u m "
}
2010-08-04 14:15:52 +02:00
set : : env( TERM ) dumb
2024-04-05 16:46:33 -04:00
set cmdline [ valkeycli [ srv host] [ srv port] $opts ]
2020-07-21 14:17:14 +03:00
if { $infile ne " " } {
set cmdline " $ c m d l i n e < $ i n f i l e "
set mode " r "
} else {
set mode " r + "
}
set fd [ open " | $ c m d l i n e " $mode ]
2010-08-04 14:15:52 +02:00
fconfigure $fd - buffering none
fconfigure $fd - blocking false
fconfigure $fd - translation binary
set _ $fd
}
proc close_cli { fd } {
close $fd
}
proc read_cli { fd } {
2021-08-01 15:07:27 +03:00
set ret [ read $fd ]
while { [ string length $ret ] == 0 } {
2010-08-04 14:15:52 +02:00
after 10
2021-08-01 15:07:27 +03:00
set ret [ read $fd ]
}
# We may have a short read, try to read some more.
set empty_reads 0
while { $empty_reads < 5 } {
2010-08-04 14:15:52 +02:00
set buf [ read $fd ]
2021-08-01 15:07:27 +03:00
if { [ string length $buf ] == 0 } {
after 10
incr empty_reads
} else {
append ret $buf
set empty_reads 0
}
2010-08-04 14:15:52 +02:00
}
2021-08-01 15:07:27 +03:00
return $ret
2010-08-04 14:15:52 +02:00
}
proc write_cli { fd buf} {
puts $fd $buf
flush $fd
}
2010-08-25 14:08:32 +02:00
# Helpers to run tests in interactive mode
2020-07-10 10:25:55 +03:00
proc format_output { output } {
2023-03-19 11:56:54 +01:00
set _ [ string trimright $output " \n " ]
2020-07-10 10:25:55 +03:00
}
2010-08-04 14:15:52 +02:00
proc run_command { fd cmd} {
write_cli $fd $cmd
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
(https://github.com/valkey-io/valkey/blob/443d80f1686377ad42cbf92d98ecc6d240325ee1/.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-09 06:01:39 +03:00
after 50
2020-07-10 10:25:55 +03:00
set _ [ format_output [ read_cli $fd ] ]
2010-08-04 14:15:52 +02:00
}
proc test_interactive_cli { name code} {
2010-08-25 13:39:11 +02:00
set : : env( FAKETTY ) 1
2010-08-04 14:15:52 +02:00
set fd [ open_cli ]
test " I n t e r a c t i v e C L I : $ n a m e " $code
close_cli $fd
2010-08-25 13:39:11 +02:00
unset : : env( FAKETTY )
2010-08-04 14:15:52 +02:00
}
2023-03-19 11:56:54 +01:00
proc test_interactive_nontty_cli { name code} {
set fd [ open_cli ]
test " I n t e r a c t i v e n o n - T T Y C L I : $ n a m e " $code
close_cli $fd
}
2010-08-25 14:08:32 +02:00
# Helpers to run tests where stdout is not a tty
2010-08-25 14:48:50 +02:00
proc write_tmpfile { contents } {
set tmp [ tmpfile " c l i " ]
set tmpfd [ open $tmp " w " ]
puts - nonewline $tmpfd $contents
close $tmpfd
set _ $tmp
}
2021-08-02 19:59:08 +08:00
proc _run_cli { host port db opts args} {
2024-04-05 16:46:33 -04:00
set cmd [ valkeycli $host $port [ list - n $db { * } $args ] ]
2020-07-10 10:25:55 +03:00
foreach { key value} $opts {
2010-08-25 14:48:50 +02:00
if { $key eq " p i p e " } {
set cmd " s h - c \" $ v a l u e | $ c m d \" "
}
if { $key eq " p a t h " } {
set cmd " $ c m d < $ v a l u e "
}
}
set fd [ open " | $ c m d " " r " ]
2010-08-04 17:02:13 +02:00
fconfigure $fd - buffering none
fconfigure $fd - translation binary
set resp [ read $fd 1048576 ]
close $fd
2020-07-10 10:25:55 +03:00
set _ [ format_output $resp ]
2010-08-04 17:02:13 +02:00
}
2010-08-25 14:48:50 +02:00
proc run_cli { args } {
2021-08-02 19:59:08 +08:00
_run_cli [ srv host] [ srv port] $::dbnum { } { * } $args
2010-08-25 14:48:50 +02:00
}
2021-12-30 18:10:04 +08:00
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
}
2010-08-25 14:48:50 +02:00
}
2021-12-30 18:10:04 +08:00
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
}
2021-08-02 19:59:08 +08:00
}
proc run_cli_host_port_db { host port db args} {
_run_cli $host $port $db { } { * } $args
2010-08-25 14:48:50 +02:00
}
2010-08-04 17:16:05 +02:00
proc test_nontty_cli { name code} {
test " N o n - i n t e r a c t i v e n o n - T T Y C L I : $ n a m e " $code
}
2010-08-25 14:15:41 +02:00
# Helpers to run tests where stdout is a tty (fake it)
2010-08-04 17:16:05 +02:00
proc test_tty_cli { name code} {
2010-08-25 14:15:41 +02:00
set : : env( FAKETTY ) 1
2010-08-04 17:16:05 +02:00
test " N o n - i n t e r a c t i v e T T Y C L I : $ n a m e " $code
2010-08-25 14:15:41 +02:00
unset : : env( FAKETTY )
2010-08-04 17:02:13 +02:00
}
2010-08-04 14:15:52 +02:00
test_interactive_cli " I N F O r e s p o n s e s h o u l d b e p r i n t e d r a w " {
set lines [ split [ run_command $fd info] " \n " ]
foreach line $lines {
2023-03-19 11:56:54 +01:00
# Info lines end in \r\n, so they now end in \r.
if { ! [ regexp { ^ \ r $ | ^ # | ^ [ ^ # :]+:} $line]} {
2021-06-03 20:34:54 +03:00
fail " M a l f o r m e d i n f o l i n e : $ l i n e "
}
2010-08-04 14:15:52 +02:00
}
}
test_interactive_cli " S t a t u s r e p l y " {
assert_equal " O K " [ run_command $fd " s e t k e y f o o " ]
}
test_interactive_cli " I n t e g e r r e p l y " {
assert_equal " ( i n t e g e r ) 1 " [ run_command $fd " i n c r c o u n t e r " ]
}
test_interactive_cli " B u l k r e p l y " {
r set key foo
assert_equal " \" f o o \" " [ run_command $fd " g e t k e y " ]
}
test_interactive_cli " M u l t i - b u l k r e p l y " {
r rpush list foo
r rpush list bar
2020-07-10 10:25:55 +03:00
assert_equal " 1 ) \" f o o \" \n 2 ) \" b a r \" " [ run_command $fd " l r a n g e l i s t 0 - 1 " ]
2010-08-04 14:15:52 +02:00
}
2010-08-04 15:29:28 +02:00
test_interactive_cli " P a r s i n g q u o t e s " {
assert_equal " O K " [ run_command $fd " s e t k e y \" b a r \" " ]
assert_equal " b a r " [ r get key]
assert_equal " O K " [ run_command $fd " s e t k e y \" b a r \" " ]
assert_equal " b a r " [ r get key]
assert_equal " O K " [ run_command $fd " s e t k e y \" \\ \" b a r \\ \" \" " ]
assert_equal " \" b a r \" " [ r get key]
assert_equal " O K " [ run_command $fd " s e t k e y \" \t b a r \t \" " ]
assert_equal " \t b a r \t " [ r get key]
# invalid quotation
assert_equal " I n v a l i d a r g u m e n t ( s ) " [ run_command $fd " g e t \" \" k e y " ]
assert_equal " I n v a l i d a r g u m e n t ( s ) " [ run_command $fd " g e t \" k e y \" x " ]
# quotes after the argument are weird, but should be allowed
assert_equal " O K " [ run_command $fd " s e t k e y \" \" b a r " ]
assert_equal " b a r " [ r get key]
}
2010-08-04 17:02:13 +02:00
2023-03-19 11:56:54 +01:00
test_interactive_cli " S u b s c r i b e d m o d e " {
2023-03-20 17:58:20 +08:00
if { $::force_resp3 } {
run_command $fd " h e l l o 3 "
}
2023-03-19 11:56:54 +01:00
set reading " R e a d i n g m e s s a g e s . . . ( p r e s s C t r l - C t o q u i t o r a n y k e y t o t y p e c o m m a n d ) \r "
set erase " \033 \[ K " ; # Erases the "Reading messages..." line.
# Subscribe to some channels.
set sub1 " 1 ) \" s u b s c r i b e \" \n 2 ) \" c h 1 \" \n 3 ) ( i n t e g e r ) 1 \n "
set sub2 " 1 ) \" s u b s c r i b e \" \n 2 ) \" c h 2 \" \n 3 ) ( i n t e g e r ) 2 \n "
set sub3 " 1 ) \" s u b s c r i b e \" \n 2 ) \" c h 3 \" \n 3 ) ( i n t e g e r ) 3 \n "
assert_equal $sub1 $sub2 $sub3 $reading \
[ run_command $fd " s u b s c r i b e c h 1 c h 2 c h 3 " ]
# Receive pubsub message.
r publish ch2 hello
set message " 1 ) \" m e s s a g e \" \n 2 ) \" c h 2 \" \n 3 ) \" h e l l o \" \n "
assert_equal $erase $message $reading [ read_cli $fd ]
# Unsubscribe some.
set unsub1 " 1 ) \" u n s u b s c r i b e \" \n 2 ) \" c h 1 \" \n 3 ) ( i n t e g e r ) 2 \n "
set unsub2 " 1 ) \" u n s u b s c r i b e \" \n 2 ) \" c h 2 \" \n 3 ) ( i n t e g e r ) 1 \n "
assert_equal $erase $unsub1 $unsub2 $reading \
[ run_command $fd " u n s u b s c r i b e c h 1 c h 2 " ]
2023-03-20 17:58:20 +08:00
run_command $fd " h e l l o 2 "
2023-03-19 11:56:54 +01:00
# Command forbidden in subscribed mode (RESP2).
set err " ( e r r o r ) E R R C a n ' t e x e c u t e ' g e t ' : o n l y ( P | S ) S U B S C R I B E / ( P | S ) U N S U B S C R I B E / P I N G / Q U I T / R E S E T a r e a l l o w e d i n t h i s c o n t e x t \n "
assert_equal $erase $err $reading [ run_command $fd " g e t k " ]
# Command allowed in subscribed mode.
set pong " 1 ) \" p o n g \" \n 2 ) \" \" \n "
assert_equal $erase $pong $reading [ run_command $fd " p i n g " ]
# Reset exits subscribed mode.
assert_equal $ { erase } RESET [ run_command $fd " r e s e t " ]
assert_equal PONG [ run_command $fd " p i n g " ]
# Check TTY output of push messages in RESP3 has ")" prefix (to be changed to ">" in the future).
assert_match " 1 # * " [ run_command $fd " h e l l o 3 " ]
set sub1 " 1 ) \" s u b s c r i b e \" \n 2 ) \" c h 1 \" \n 3 ) ( i n t e g e r ) 1 \n "
assert_equal $sub1 $reading \
[ run_command $fd " s u b s c r i b e c h 1 " ]
}
test_interactive_nontty_cli " S u b s c r i b e d m o d e " {
# Raw output and no "Reading messages..." info message.
# Use RESP3 in this test case.
assert_match { * proto 3 * } [ run_command $fd " h e l l o 3 " ]
# Subscribe to some channels.
set sub1 " s u b s c r i b e \n c h 1 \n 1 "
set sub2 " s u b s c r i b e \n c h 2 \n 2 "
assert_equal $sub1 \ n$sub2 \
[ run_command $fd " s u b s c r i b e c h 1 c h 2 " ]
assert_equal OK [ run_command $fd " c l i e n t t r a c k i n g o n " ]
assert_equal OK [ run_command $fd " s e t k 4 2 " ]
assert_equal 42 [ run_command $fd " g e t k " ]
# Interleaving invalidate and pubsub messages.
r publish ch1 hello
r del k
r publish ch2 world
set message1 " m e s s a g e \n c h 1 \n h e l l o "
set invalidate " i n v a l i d a t e \n k "
set message2 " m e s s a g e \n c h 2 \n w o r l d "
assert_equal $message1 \ n$invalidate \ n$message2 \ n [ read_cli $fd ]
# Unsubscribe all.
set unsub1 " u n s u b s c r i b e \n c h 1 \n 1 "
set unsub2 " u n s u b s c r i b e \n c h 2 \n 0 "
assert_equal $unsub1 \ n$unsub2 [ run_command $fd " u n s u b s c r i b e c h 1 c h 2 " ]
}
2010-08-04 17:16:05 +02:00
test_tty_cli " S t a t u s r e p l y " {
2020-07-10 10:25:55 +03:00
assert_equal " O K " [ run_cli set key bar]
2010-08-04 17:02:13 +02:00
assert_equal " b a r " [ r get key]
}
2010-08-04 17:16:05 +02:00
test_tty_cli " I n t e g e r r e p l y " {
2010-08-04 17:02:13 +02:00
r del counter
2020-07-10 10:25:55 +03:00
assert_equal " ( i n t e g e r ) 1 " [ run_cli incr counter]
2010-08-04 17:02:13 +02:00
}
2010-08-04 17:16:05 +02:00
test_tty_cli " B u l k r e p l y " {
2010-08-04 17:02:13 +02:00
r set key " t a b \t n e w l i n e \n "
2020-07-10 10:25:55 +03:00
assert_equal " \" t a b \\ t n e w l i n e \\ n \" " [ run_cli get key]
2010-08-04 17:02:13 +02:00
}
2010-08-04 17:16:05 +02:00
test_tty_cli " M u l t i - b u l k r e p l y " {
2010-08-04 17:02:13 +02:00
r del list
r rpush list foo
r rpush list bar
2020-07-10 10:25:55 +03:00
assert_equal " 1 ) \" f o o \" \n 2 ) \" b a r \" " [ run_cli lrange list 0 - 1 ]
2010-08-04 17:02:13 +02:00
}
2010-08-04 17:46:56 +02:00
2010-08-25 14:48:50 +02:00
test_tty_cli " R e a d l a s t a r g u m e n t f r o m p i p e " {
2021-12-30 18:10:04 +08:00
assert_equal " O K " [ run_cli_with_input_pipe x " e c h o f o o " set key]
2010-08-25 14:48:50 +02:00
assert_equal " f o o \n " [ r get key]
2021-12-30 18:10:04 +08:00
assert_equal " O K " [ run_cli_with_input_pipe X " e c h o f o o " set key2 tag]
assert_equal " f o o \n " [ r get key2]
2010-08-25 14:48:50 +02:00
}
test_tty_cli " R e a d l a s t a r g u m e n t f r o m f i l e " {
set tmpfile [ write_tmpfile " f r o m f i l e " ]
2021-12-30 18:10:04 +08:00
assert_equal " O K " [ run_cli_with_input_file x $tmpfile set key]
2010-08-25 14:48:50 +02:00
assert_equal " f r o m f i l e " [ r get key]
2021-12-30 18:10:04 +08:00
assert_equal " O K " [ run_cli_with_input_file X $tmpfile set key2 tag]
assert_equal " f r o m f i l e " [ r get key2]
2020-09-09 12:30:43 +03:00
file delete $tmpfile
2010-08-25 14:48:50 +02:00
}
redis-cli: Better --json Unicode support and --quoted-json (#10286)
Normally, `redis-cli` escapes non-printable data received from Redis, using a custom scheme (which is also used to handle quoted input). When using `--json` this is not desired as it is not compatible with RFC 7159, which specifies JSON strings are assumed to be Unicode and how they should be escaped.
This commit changes `--json` to follow RFC 7159, which means that properly encoded Unicode strings in Redis will result with a valid Unicode JSON.
However, this introduces a new problem with `--json` and data that is not valid Unicode (e.g., random binary data, text that follows other encoding, etc.). To address this, we add `--quoted-json` which produces JSON strings that follow the original redis-cli quoting scheme.
For example, a value that consists of only null (0x00) bytes will show up as:
* `"\u0000\u0000\u0000"` when using `--json`
* `"\\x00\\x00\\x00"` when using `--quoted-json`
2022-03-06 04:25:52 +09:00
test_tty_cli " E s c a p e c h a r a c t e r i n J S O N m o d e " {
# 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))
2022-03-06 13:02:35 +02:00
set eth " \u 0 0 f 0 \u 0 0 6 5 "
redis-cli: Better --json Unicode support and --quoted-json (#10286)
Normally, `redis-cli` escapes non-printable data received from Redis, using a custom scheme (which is also used to handle quoted input). When using `--json` this is not desired as it is not compatible with RFC 7159, which specifies JSON strings are assumed to be Unicode and how they should be escaped.
This commit changes `--json` to follow RFC 7159, which means that properly encoded Unicode strings in Redis will result with a valid Unicode JSON.
However, this introduces a new problem with `--json` and data that is not valid Unicode (e.g., random binary data, text that follows other encoding, etc.). To address this, we add `--quoted-json` which produces JSON strings that follow the original redis-cli quoting scheme.
For example, a value that consists of only null (0x00) bytes will show up as:
* `"\u0000\u0000\u0000"` when using `--json`
* `"\\x00\\x00\\x00"` when using `--quoted-json`
2022-03-06 04:25:52 +09:00
r hset eth test $eth
assert_equal \ " \\ x f 0 e \" [ r u n _ c l i h g e t e t h t e s t ]
2022-03-06 13:02:35 +02:00
assert_equal \ " \u 0 0 f 0 e \" [ r u n _ c l i - - j s o n h g e t e t h t e s t ]
redis-cli: Better --json Unicode support and --quoted-json (#10286)
Normally, `redis-cli` escapes non-printable data received from Redis, using a custom scheme (which is also used to handle quoted input). When using `--json` this is not desired as it is not compatible with RFC 7159, which specifies JSON strings are assumed to be Unicode and how they should be escaped.
This commit changes `--json` to follow RFC 7159, which means that properly encoded Unicode strings in Redis will result with a valid Unicode JSON.
However, this introduces a new problem with `--json` and data that is not valid Unicode (e.g., random binary data, text that follows other encoding, etc.). To address this, we add `--quoted-json` which produces JSON strings that follow the original redis-cli quoting scheme.
For example, a value that consists of only null (0x00) bytes will show up as:
* `"\u0000\u0000\u0000"` when using `--json`
* `"\\x00\\x00\\x00"` when using `--quoted-json`
2022-03-06 04:25:52 +09:00
assert_equal \ " \\ \\ x f 0 e \" [ r u n _ c l i - - q u o t e d - j s o n h g e t e t h t e s t ]
# control characters
r hset control test " H e l l o \x 0 0 \x 0 1 \x 0 2 \x 0 3 W o r l d "
assert_equal \ " H e l l o \\ u 0 0 0 0 \\ u 0 0 0 1 \\ u 0 0 0 2 \\ u 0 0 0 3 W o r l d " [ run_cli - - json hget control test]
# non-string keys
r hset numkey 1 One
assert_equal \ { \ " 1 \" : \" O n e \" \} [ r u n _ c l i - - j s o n h g e t a l l n u m k e y ]
# non-string, non-printable keys
2022-03-06 13:02:35 +02:00
r hset npkey " K \u 0 0 0 0 \u 0 0 0 1 e y " " V \u 0 0 0 0 \u 0 0 0 1 a l u e "
redis-cli: Better --json Unicode support and --quoted-json (#10286)
Normally, `redis-cli` escapes non-printable data received from Redis, using a custom scheme (which is also used to handle quoted input). When using `--json` this is not desired as it is not compatible with RFC 7159, which specifies JSON strings are assumed to be Unicode and how they should be escaped.
This commit changes `--json` to follow RFC 7159, which means that properly encoded Unicode strings in Redis will result with a valid Unicode JSON.
However, this introduces a new problem with `--json` and data that is not valid Unicode (e.g., random binary data, text that follows other encoding, etc.). To address this, we add `--quoted-json` which produces JSON strings that follow the original redis-cli quoting scheme.
For example, a value that consists of only null (0x00) bytes will show up as:
* `"\u0000\u0000\u0000"` when using `--json`
* `"\\x00\\x00\\x00"` when using `--quoted-json`
2022-03-06 04:25:52 +09:00
assert_equal \ { \ " K \\ u 0 0 0 0 \\ u 0 0 0 1 e y \" : \" V \\ u 0 0 0 0 \\ u 0 0 0 1 a l u e \" \} [ r u n _ c l i - - j s o n h g e t a l l n p k e y ]
assert_equal \ { \ " K \\ \\ x 0 0 \\ \\ x 0 1 e y \" : \" V \\ \\ x 0 0 \\ \\ x 0 1 a l u e \" \} [ r u n _ c l i - - q u o t e d - j s o n h g e t a l l n p k e y ]
}
2010-08-04 17:46:56 +02:00
test_nontty_cli " S t a t u s r e p l y " {
2010-08-25 14:15:41 +02:00
assert_equal " O K " [ run_cli set key bar]
2010-08-04 17:46:56 +02:00
assert_equal " b a r " [ r get key]
}
test_nontty_cli " I n t e g e r r e p l y " {
r del counter
2010-08-25 14:15:41 +02:00
assert_equal " 1 " [ run_cli incr counter]
2010-08-04 17:46:56 +02:00
}
test_nontty_cli " B u l k r e p l y " {
r set key " t a b \t n e w l i n e \n "
2020-07-10 10:25:55 +03:00
assert_equal " t a b \t n e w l i n e " [ run_cli get key]
2010-08-04 17:46:56 +02:00
}
test_nontty_cli " M u l t i - b u l k r e p l y " {
r del list
r rpush list foo
r rpush list bar
2010-08-25 14:15:41 +02:00
assert_equal " f o o \n b a r " [ run_cli lrange list 0 - 1 ]
2010-08-04 17:46:56 +02:00
}
2010-08-25 14:48:50 +02:00
2021-08-03 23:19:03 +03:00
if { ! $::tls } { ; # fake_redis_node doesn't support TLS
2021-08-02 19:59:08 +08:00
test_nontty_cli " A S K r e d i r e c t t e s t " {
2024-04-09 01:24:03 -07:00
# Set up two fake nodes.
2021-08-02 19:59:08 +08:00
set tclsh [ info nameofexecutable]
set script " t e s t s / h e l p e r s / f a k e _ r e d i s _ n o d e . t c l "
set port1 [ find_available_port $::baseport $::portcount ]
set port2 [ find_available_port $::baseport $::portcount ]
set p1 [ exec $tclsh $script $port1 \
" S E T f o o b a r " " - A S K 1 2 1 8 2 1 2 7 . 0 . 0 . 1 : $ p o r t 2 " & ]
set p2 [ exec $tclsh $script $port2 \
" A S K I N G " " + O K " \
" S E T f o o b a r " " + O K " & ]
2021-08-05 07:20:30 +02:00
# Make sure both fake nodes have started listening
wait_for_condition 50 50 {
[ catch { close [ socket " 1 2 7 . 0 . 0 . 1 " $port1 ] } ] == 0 && \
[ catch { close [ socket " 1 2 7 . 0 . 0 . 1 " $port2 ] } ] == 0
} else {
2024-04-25 03:13:21 -04:00
fail " F a i l e d t o s t a r t f a k e V a l k e y n o d e s "
2021-08-05 07:20:30 +02:00
}
2021-08-02 19:59:08 +08:00
# Run the cli
assert_equal " O K " [ run_cli_host_port_db " 1 2 7 . 0 . 0 . 1 " $port1 0 - c SET foo bar]
}
2021-08-03 23:19:03 +03:00
}
2021-08-02 19:59:08 +08:00
2021-03-04 15:03:49 +02:00
test_nontty_cli " Q u o t e d i n p u t a r g u m e n t s " {
r set " \x 0 0 \x 0 0 " " v a l u e "
assert_equal " v a l u e " [ run_cli - - quoted-input get { " \x 0 0 \x 0 0 " } ]
}
test_nontty_cli " N o a c c i d e n t a l u n q u o t i n g o f i n p u t a r g u m e n t s " {
run_cli - - quoted-input set { " \x 4 1 \x 4 1 " } quoted-val
run_cli set { " \x 4 1 \x 4 1 " } unquoted-val
assert_equal " q u o t e d - v a l " [ r get AA]
assert_equal " u n q u o t e d - v a l " [ r get { " \x 4 1 \x 4 1 " } ]
}
test_nontty_cli " I n v a l i d q u o t e d i n p u t a r g u m e n t s " {
catch { run_cli - - quoted-input set { " U n t e r m i n a t e d } } e r r
assert_match { * exited abnormally* } $err
# A single arg that unquotes to two arguments is also not expected
catch { run_cli - - quoted-input set { " a r g 1 " " a r g 2 " } } err
assert_match { * exited abnormally* } $err
}
2010-08-25 14:48:50 +02:00
test_nontty_cli " R e a d l a s t a r g u m e n t f r o m p i p e " {
2021-12-30 18:10:04 +08:00
assert_equal " O K " [ run_cli_with_input_pipe x " e c h o f o o " set key]
2010-08-25 14:48:50 +02:00
assert_equal " f o o \n " [ r get key]
2021-12-30 18:10:04 +08:00
assert_equal " O K " [ run_cli_with_input_pipe X " e c h o f o o " set key2 tag]
assert_equal " f o o \n " [ r get key2]
2010-08-25 14:48:50 +02:00
}
test_nontty_cli " R e a d l a s t a r g u m e n t f r o m f i l e " {
set tmpfile [ write_tmpfile " f r o m f i l e " ]
2021-12-30 18:10:04 +08:00
assert_equal " O K " [ run_cli_with_input_file x $tmpfile set key]
2010-08-25 14:48:50 +02:00
assert_equal " f r o m f i l e " [ r get key]
2021-12-30 18:10:04 +08:00
assert_equal " O K " [ run_cli_with_input_file X $tmpfile set key2 tag]
assert_equal " f r o m f i l e " [ r get key2]
2020-09-09 12:30:43 +03:00
file delete $tmpfile
2010-08-25 14:48:50 +02:00
}
2020-07-10 10:25:55 +03:00
Reimplement cli hints based on command arg docs (#10515)
Now that the command argument specs are available at runtime (#9656), this PR addresses
#8084 by implementing a complete solution for command-line hinting in `redis-cli`.
It correctly handles nearly every case in Redis's complex command argument definitions, including
`BLOCK` and `ONEOF` arguments, reordering of optional arguments, and repeated arguments
(even when followed by mandatory arguments). It also validates numerically-typed arguments.
It may not correctly handle all possible combinations of those, but overall it is quite robust.
Arguments are only matched after the space bar is typed, so partial word matching is not
supported - that proved to be more confusing than helpful. When the user's current input
cannot be matched against the argument specs, hinting is disabled.
Partial support has been implemented for legacy (pre-7.0) servers that do not support
`COMMAND DOCS`, by falling back to a statically-compiled command argument table.
On startup, if the server does not support `COMMAND DOCS`, `redis-cli` will now issue
an `INFO SERVER` command to retrieve the server version (unless `HELLO` has already
been sent, in which case the server version will be extracted from the reply to `HELLO`).
The server version will be used to filter the commands and arguments in the command table,
removing those not supported by that version of the server. However, the static table only
includes core Redis commands, so with a legacy server hinting will not be supported for
module commands. The auto generated help.h and the scripts that generates it are gone.
Command and argument tables for the server and CLI use different structs, due primarily
to the need to support different runtime data. In order to generate code for both, macros
have been added to `commands.def` (previously `commands.c`) to make it possible to
configure the code generation differently for different use cases (one linked with redis-server,
and one with redis-cli).
Also adding a basic testing framework for the command hints based on new (undocumented)
command line options to `redis-cli`: `--test_hint 'INPUT'` prints out the command-line hint for
a given input string, and `--test_hint_file <filename>` runs a suite of test cases for the hinting
mechanism. The test suite is in `tests/assets/test_cli_hint_suite.txt`, and it is run from
`tests/integration/redis-cli.tcl`.
Co-authored-by: Oran Agra <oran@redislabs.com>
Co-authored-by: Viktor Söderqvist <viktor.soderqvist@est.tech>
2023-03-30 19:03:56 +03:00
test_nontty_cli " T e s t c o m m a n d - l i n e h i n t i n g - l a t e s t s e r v e r " {
# 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 " * S U C C E S S * " $output
}
test_nontty_cli " T e s t c o m m a n d - l i n e h i n t i n g - n o s e r v e r " {
# 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 " * S U C C E S S * " $output
}
test_nontty_cli " T e s t c o m m a n d - l i n e h i n t i n g - o l d s e r v e r " {
# 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 " * S U C C E S S * " $output
r acl deluser clitest
}
2024-04-24 12:01:33 -04:00
proc test_valkey_cli_rdb_dump { functions_only } {
2020-07-10 10:25:55 +03:00
r flushdb
2022-01-02 09:39:01 +02:00
r function flush
2020-07-10 10:25:55 +03:00
set dir [ lindex [ r config get dir] 1 ]
assert_equal " O K " [ r debug populate 100000 key 1000 ]
2024-06-06 16:40:55 -07:00
assert_equal " l i b 1 " [ r function load " # ! l u a n a m e = l i b 1 \n s e r v e r . r e g i s t e r _ f u n c t i o n ( ' f u n c 1 ' , f u n c t i o n ( ) r e t u r n 1 2 3 e n d ) " ]
2022-01-02 09:39:01 +02:00
if { $functions_only } {
set args " - - f u n c t i o n s - r d b $ d i r / c l i . r d b "
} else {
set args " - - r d b $ d i r / c l i . r d b "
}
catch { run_cli { * } $args } output
2020-07-10 10:25:55 +03:00
assert_match { * Transfer finished with success* } $output
file delete " $ d i r / d u m p . r d b "
file rename " $ d i r / c l i . r d b " " $ d i r / d u m p . r d b "
assert_equal " O K " [ r set should-not-exist 1 ]
2024-06-06 16:40:55 -07:00
assert_equal " s h o u l d _ n o t _ e x i s t _ f u n c " [ r function load " # ! l u a n a m e = s h o u l d _ n o t _ e x i s t _ f u n c \n s e r v e r . r e g i s t e r _ f u n c t i o n ( ' s h o u l d _ n o t _ e x i s t _ f u n c ' , f u n c t i o n ( ) r e t u r n 4 5 6 e n d ) " ]
2020-07-10 10:25:55 +03:00
assert_equal " O K " [ r debug reload nosave]
assert_equal { } [ r get should-not-exist]
2022-04-05 10:27:24 +03:00
assert_equal { { library_name lib1 engine LUA functions { { name func1 description { } flags { } } } } } [ r function list]
2022-01-02 09:39:01 +02:00
if { $functions_only } {
assert_equal 0 [ r dbsize]
} else {
assert_equal 100000 [ r dbsize]
}
2020-07-10 10:25:55 +03:00
}
2022-01-02 09:39:01 +02:00
foreach { functions_only } { no yes} {
test " D u m p i n g a n R D B - f u n c t i o n s o n l y : $ f u n c t i o n s _ o n l y " {
2020-07-10 10:25:55 +03:00
# Disk-based master
assert_match " O K " [ r config set repl-diskless-sync no]
2024-04-24 12:01:33 -04:00
test_valkey_cli_rdb_dump $functions_only
2020-07-10 10:25:55 +03:00
# Disk-less master
assert_match " O K " [ r config set repl-diskless-sync yes]
assert_match " O K " [ r config set repl-diskless-sync-delay 0 ]
2024-04-24 12:01:33 -04:00
test_valkey_cli_rdb_dump $functions_only
2021-12-19 17:41:51 +02:00
} { } { needs : repl needs:debug}
2020-07-10 10:25:55 +03:00
2022-01-02 09:39:01 +02:00
} ; # foreach functions_only
2021-03-04 15:03:49 +02:00
test " S c a n m o d e " {
r flushdb
populate 1000 key: 1
# basic use
assert_equal 1000 [ llength [ split [ run_cli - - scan] ] ]
# pattern
Replace dict with hashtable for keys, expires and pubsub channels
Instead of a dictEntry with pointers to key and value, the hashtable
has a pointer directly to the value (robj) which can hold an embedded
key and acts as a key-value in the hashtable. This minimizes the number
of pointers to follow and thus the number of memory accesses to lookup
a key-value pair.
Keys robj
hashtable
+-------+ +-----------------------+
| 0 | | type, encoding, LRU |
| 1 ------->| refcount, expire |
| 2 | | ptr |
| ... | | optional embedded key |
+-------+ | optional embedded val |
+-----------------------+
The expire timestamp (TTL) is also stored in the robj, if any. The expire
hash table points to the same robj.
Overview of changes:
* Replace dict with hashtable in kvstore (kvstore.c)
* Add functions for embedding key and expire in robj (object.c)
* When there's unused space, reserve an expire field to avoid realloting
it later if expire is added.
* Always reserve space for expire for large key names to avoid realloc
if it's set later.
* Update db functions (db.c)
* dbAdd, setKey and setExpire reallocate the object when embedding a key
* setKey does not increment the reference counter, since it would require
duplicating the object. This responsibility is moved to the caller.
* Remove logic for shared integer objects as values in the database. The keys
are now embedded in the objects, so all objects in the database need to be
unique. Thus, we can't use shared objects as values. Also delete test cases
for shared integers.
* Adjust various commands to the changes mentioned above.
* Adjust defrag code
* Improvement: Don't access the expires table before defrag has actually
reallocated the object.
* Adjust test cases that were using hard-coded sizes for dict when realloc
would happen, and some other adjustments in test cases.
* Adjust memory prefetch for new hash table implementation in IO-threading,
using new `hashtableIncrementalFind` API
* Adjust offloading of free() to IO threads: Object free to be done in main
thread while keeping obj->ptr offloading in IO-thread since the DB object is
now allocated by the main-thread and not by the IO-thread as it used to be.
* Let expireIfNeeded take an optional value, to avoid looking up the expires
table when possible.
---------
Signed-off-by: Uri Yagelnik <uriy@amazon.com>
Signed-off-by: uriyage <78144248+uriyage@users.noreply.github.com>
Signed-off-by: Viktor Söderqvist <viktor.soderqvist@est.tech>
Co-authored-by: Uri Yagelnik <uriy@amazon.com>
2024-09-11 16:24:26 +02:00
assert_equal { key : 2 } [ split [ run_cli - - scan - - pattern " * : 2 " ] ]
2021-03-04 15:03:49 +02:00
# pattern matching with a quoted string
Replace dict with hashtable for keys, expires and pubsub channels
Instead of a dictEntry with pointers to key and value, the hashtable
has a pointer directly to the value (robj) which can hold an embedded
key and acts as a key-value in the hashtable. This minimizes the number
of pointers to follow and thus the number of memory accesses to lookup
a key-value pair.
Keys robj
hashtable
+-------+ +-----------------------+
| 0 | | type, encoding, LRU |
| 1 ------->| refcount, expire |
| 2 | | ptr |
| ... | | optional embedded key |
+-------+ | optional embedded val |
+-----------------------+
The expire timestamp (TTL) is also stored in the robj, if any. The expire
hash table points to the same robj.
Overview of changes:
* Replace dict with hashtable in kvstore (kvstore.c)
* Add functions for embedding key and expire in robj (object.c)
* When there's unused space, reserve an expire field to avoid realloting
it later if expire is added.
* Always reserve space for expire for large key names to avoid realloc
if it's set later.
* Update db functions (db.c)
* dbAdd, setKey and setExpire reallocate the object when embedding a key
* setKey does not increment the reference counter, since it would require
duplicating the object. This responsibility is moved to the caller.
* Remove logic for shared integer objects as values in the database. The keys
are now embedded in the objects, so all objects in the database need to be
unique. Thus, we can't use shared objects as values. Also delete test cases
for shared integers.
* Adjust various commands to the changes mentioned above.
* Adjust defrag code
* Improvement: Don't access the expires table before defrag has actually
reallocated the object.
* Adjust test cases that were using hard-coded sizes for dict when realloc
would happen, and some other adjustments in test cases.
* Adjust memory prefetch for new hash table implementation in IO-threading,
using new `hashtableIncrementalFind` API
* Adjust offloading of free() to IO threads: Object free to be done in main
thread while keeping obj->ptr offloading in IO-thread since the DB object is
now allocated by the main-thread and not by the IO-thread as it used to be.
* Let expireIfNeeded take an optional value, to avoid looking up the expires
table when possible.
---------
Signed-off-by: Uri Yagelnik <uriy@amazon.com>
Signed-off-by: uriyage <78144248+uriyage@users.noreply.github.com>
Signed-off-by: Viktor Söderqvist <viktor.soderqvist@est.tech>
Co-authored-by: Uri Yagelnik <uriy@amazon.com>
2024-09-11 16:24:26 +02:00
assert_equal { key : 2 } [ split [ run_cli - - scan - - quoted-pattern { " * : \x 3 2 " } ] ]
2021-03-04 15:03:49 +02:00
}
2024-04-24 12:01:33 -04:00
proc test_valkey_cli_repl { } {
2020-07-10 10:25:55 +03:00
set fd [ open_cli " - - r e p l i c a " ]
2021-07-07 08:26:26 +03:00
wait_for_condition 500 100 {
2020-07-10 10:25:55 +03:00
[ string match { * slave0 : * state= online* } [ r info] ]
} else {
2024-04-24 12:01:33 -04:00
fail " v a l k e y - c l i - - r e p l i c a d i d n o t c o n n e c t "
2020-07-10 10:25:55 +03:00
}
for { set i 0 } { $i < 100 } { incr i} {
r set test-key test-value-$i
}
2021-07-07 08:26:26 +03:00
wait_for_condition 500 100 {
[ string match { * test-value-99 * } [ read_cli $fd ] ]
} else {
2024-04-24 12:01:33 -04:00
fail " v a l k e y - c l i - - r e p l i c a d i d n ' t r e a d c o m m a n d s "
2020-07-10 10:25:55 +03:00
}
2021-07-07 08:26:26 +03:00
fconfigure $fd - blocking true
r client kill type slave
catch { close_cli $fd } err
assert_match { * Server closed the connection* } $err
}
test " C o n n e c t i n g a s a r e p l i c a " {
# Disk-based master
assert_match " O K " [ r config set repl-diskless-sync no]
2024-04-24 12:01:33 -04:00
test_valkey_cli_repl
2021-07-07 08:26:26 +03:00
# Disk-less master
assert_match " O K " [ r config set repl-diskless-sync yes]
assert_match " O K " [ r config set repl-diskless-sync-delay 0 ]
2024-04-24 12:01:33 -04:00
test_valkey_cli_repl
2021-06-09 15:13:24 +03:00
} { } { needs : repl}
2020-07-10 10:25:55 +03:00
2020-07-21 14:17:14 +03:00
test " P i p i n g r a w p r o t o c o l " {
set cmds [ tmpfile " c l i _ c m d s " ]
set cmds_fd [ open $cmds " w " ]
2020-07-10 10:25:55 +03:00
2021-06-09 15:13:24 +03:00
set cmds_count 2101
if { ! $::singledb } {
puts $cmds_fd [ formatCommand select 9 ]
incr cmds_count
}
2020-07-21 14:17:14 +03:00
puts $cmds_fd [ formatCommand del test-counter]
2020-07-10 10:25:55 +03:00
2020-07-21 14:17:14 +03:00
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 ] ]
2020-07-10 10:25:55 +03:00
}
2020-07-21 14:17:14 +03:00
for { set i 0 } { $i < 100 } { incr i} {
puts $cmds_fd [ formatCommand set very-large-key [ string repeat " x " 512000 ] ]
2020-07-10 10:25:55 +03:00
}
2020-07-21 14:17:14 +03:00
close $cmds_fd
2020-07-10 10:25:55 +03:00
2020-07-21 14:17:14 +03:00
set cli_fd [ open_cli " - - p i p e " $cmds ]
fconfigure $cli_fd - blocking true
set output [ read_cli $cli_fd ]
2020-07-10 10:25:55 +03:00
2020-07-21 14:17:14 +03:00
assert_equal { 1000 } [ r get test-counter]
2021-06-09 15:13:24 +03:00
assert_match " * A l l d a t a t r a n s f e r r e d * e r r o r s : 0 * r e p l i e s : $ { c m d s _ c o u n t } * " $output
2020-07-10 10:25:55 +03:00
2020-07-21 14:17:14 +03:00
file delete $cmds
2020-07-10 10:25:55 +03:00
}
2021-12-30 18:10:04 +08:00
test " O p t i o n s - X w i t h i l l e g a l a r g u m e n t " {
assert_error " * - x a n d - X a r e m u t u a l l y e x c l u s i v e * " { run_cli - x - X tag}
assert_error " * U n r e c o g n i z e d o p t i o n o r b a d n u m b e r * " { run_cli - X}
assert_error " * t a g n o t m a t c h * " { run_cli_with_input_pipe X " e c h o f o o " set key wrong_tag}
}
2022-01-02 19:58:22 +08:00
test " D U M P R E S T O R E w i t h - x o p t i o n " {
2024-04-05 16:46:33 -04:00
set cmdline [ valkeycli [ srv host] [ srv port] ]
2022-01-02 19:58:22 +08:00
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 " O K " [ exec { * } $cmdline - D " " - - raw DUMP set | \
{ * } $cmdline -x RESTORE new_set 0 ]
assert_equal 6 [ exec { * } $cmdline SCARD new_set]
assert_equal " 1 \n 2 \n 3 \n 4 \n 5 \n 6 " [ exec { * } $cmdline SMEMBERS new_set]
}
test " D U M P R E S T O R E w i t h - X o p t i o n " {
2024-04-05 16:46:33 -04:00
set cmdline [ valkeycli [ srv host] [ srv port] ]
2022-01-02 19:58:22 +08:00
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 " O K " [ 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 \n 1 \n b \n 2 \n c \n 3 " [ exec { * } $cmdline ZRANGE new_zset 0 - 1 WITHSCORES]
}
2024-04-23 09:02:41 +08:00
2025-01-08 12:03:06 -08:00
test " v a l k e y - c l i p u b s u b m o d e w i t h s i n g l e s t a n d a r d c h a n n e l s u b s c r i p t i o n " {
set fd [ open_cli ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 0 " $pubsub_status
write_cli $fd " S U B S C R I B E c h 1 "
set response [ read_cli $fd ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 1 " $pubsub_status
write_cli $fd " U N S U B S C R I B E c h 1 "
set response [ read_cli $fd ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 0 " $pubsub_status
close_cli $fd
}
test " v a l k e y - c l i p u b s u b m o d e w i t h m u l t i p l e s t a n d a r d c h a n n e l s u b s c r i p t i o n s " {
set fd [ open_cli ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 0 " $pubsub_status
write_cli $fd " S U B S C R I B E c h 1 c h 2 c h 3 "
set response [ read_cli $fd ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 1 " $pubsub_status
write_cli $fd " U N S U B S C R I B E "
set response [ read_cli $fd ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 0 " $pubsub_status
close_cli $fd
}
test " v a l k e y - c l i p u b s u b m o d e w i t h s i n g l e s h a r d c h a n n e l s u b s c r i p t i o n " {
set fd [ open_cli ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 0 " $pubsub_status
write_cli $fd " S S U B S C R I B E s c h a n n e l 1 "
set response [ read_cli $fd ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 1 " $pubsub_status
write_cli $fd " S U N S U B S C R I B E s c h a n n e l 1 "
set response [ read_cli $fd ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 0 " $pubsub_status
close_cli $fd
}
test " v a l k e y - c l i p u b s u b m o d e w i t h m u l t i p l e s h a r d c h a n n e l s u b s c r i p t i o n s " {
set fd [ open_cli ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 0 " $pubsub_status
2025-01-09 12:21:31 +08:00
write_cli $fd " S S U B S C R I B E { s c h a n n e l } 1 { s c h a n n e l } 2 { s c h a n n e l } 3 "
2025-01-08 12:03:06 -08:00
set response [ read_cli $fd ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 1 " $pubsub_status
write_cli $fd " S U N S U B S C R I B E "
set response [ read_cli $fd ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 0 " $pubsub_status
close_cli $fd
}
test " v a l k e y - c l i p u b s u b m o d e w i t h s i n g l e p a t t e r n c h a n n e l s u b s c r i p t i o n " {
set fd [ open_cli ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 0 " $pubsub_status
write_cli $fd " P S U B S C R I B E p a t t e r n 1 * "
set response [ read_cli $fd ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 1 " $pubsub_status
write_cli $fd " P U N S U B S C R I B E p a t t e r n 1 * "
set response [ read_cli $fd ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 0 " $pubsub_status
close_cli $fd
}
test " v a l k e y - c l i p u b s u b m o d e w i t h m u l t i p l e p a t t e r n c h a n n e l s u b s c r i p t i o n s " {
set fd [ open_cli ]
write_cli $fd " P S U B S C R I B E p a t t e r n 1 * p a t t e r n 2 * p a t t e r n 3 * "
set response [ read_cli $fd ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 1 " $pubsub_status
write_cli $fd " P U N S U B S C R I B E "
set response [ read_cli $fd ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 0 " $pubsub_status
close_cli $fd
}
test " v a l k e y - c l i p u b s u b m o d e w h e n s u b s c r i b i n g t o t h e s a m e c h a n n e l " {
set fd [ open_cli ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 0 " $pubsub_status
write_cli $fd " S U B S C R I B E c h 1 c h 1 "
set response [ read_cli $fd ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 1 " $pubsub_status
write_cli $fd " U N S U B S C R I B E "
set response [ read_cli $fd ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 0 " $pubsub_status
close_cli $fd
}
test " v a l k e y - c l i p u b s u b m o d e w i t h m u l t i p l e s u b s c r i p t i o n t y p e s " {
set fd [ open_cli ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 0 " $pubsub_status
write_cli $fd " S U B S C R I B E c h 1 c h 2 c h 3 "
set response [ read_cli $fd ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 1 " $pubsub_status
write_cli $fd " P S U B S C R I B E p a t t e r n * "
set response [ read_cli $fd ]
set lines [ split $response " \n " ]
assert_equal " p s u b s c r i b e " [ lindex $lines 0 ]
assert_equal " p a t t e r n * " [ lindex $lines 1 ]
assert_equal " 4 " [ lindex $lines 2 ]
write_cli $fd " S S U B S C R I B E s c h a n n e l "
set response [ read_cli $fd ]
set lines [ split $response " \n " ]
assert_equal " s s u b s c r i b e " [ lindex $lines 0 ]
assert_equal " s c h a n n e l " [ lindex $lines 1 ]
assert_equal " 1 " [ lindex $lines 2 ]
write_cli $fd " P U N S U B S C R I B E p a t t e r n * "
set response [ read_cli $fd ]
set lines [ split $response " \n " ]
assert_equal " p u n s u b s c r i b e " [ lindex $lines 0 ]
assert_equal " p a t t e r n * " [ lindex $lines 1 ]
assert_equal " 3 " [ lindex $lines 2 ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 1 " $pubsub_status
write_cli $fd " S U N S U B S C R I B E s c h a n n e l "
set response [ read_cli $fd ]
set lines [ split $response " \n " ]
assert_equal " s u n s u b s c r i b e " [ lindex $lines 0 ]
assert_equal " s c h a n n e l " [ lindex $lines 1 ]
assert_equal " 0 " [ lindex $lines 2 ]
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 1 " $pubsub_status
write_cli $fd " U N S U B S C R I B E "
set response [ read_cli $fd ]
# Verify pubsub mode is no longer active
write_cli $fd " : g e t p u b s u b "
set pubsub_status [ string trim [ read_cli $fd ] ]
assert_equal " 0 " $pubsub_status
close_cli $fd
}
2024-04-23 09:02:41 +08:00
test " V a l i d C o n n e c t i o n S c h e m e : r e d i s : / / " {
set cmdline [ valkeycliuri " r e d i s : / / " [ srv host] [ srv port] ]
assert_equal { PONG } [ exec { * } $cmdline PING]
}
test " V a l i d C o n n e c t i o n S c h e m e : v a l k e y : / / " {
set cmdline [ valkeycliuri " v a l k e y : / / " [ srv host] [ srv port] ]
assert_equal { PONG } [ exec { * } $cmdline PING]
}
if { $::tls } {
test " V a l i d C o n n e c t i o n S c h e m e : r e d i s s : / / " {
set cmdline [ valkeycliuri " r e d i s s : / / " [ srv host] [ srv port] ]
assert_equal { PONG } [ exec { * } $cmdline PING]
}
test " V a l i d C o n n e c t i o n S c h e m e : v a l k e y s : / / " {
set cmdline [ valkeycliuri " v a l k e y s : / / " [ srv host] [ srv port] ]
assert_equal { PONG } [ exec { * } $cmdline PING]
}
}
2010-08-04 14:15:52 +02:00
}
