redis 4.7.1 → 5.0.7

Sign up to get free protection for your applications and to get access to all the features.
Files changed (44) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +65 -0
  3. data/README.md +88 -168
  4. data/lib/redis/client.rb +84 -623
  5. data/lib/redis/commands/bitmaps.rb +4 -1
  6. data/lib/redis/commands/cluster.rb +1 -18
  7. data/lib/redis/commands/connection.rb +5 -10
  8. data/lib/redis/commands/geo.rb +3 -3
  9. data/lib/redis/commands/hashes.rb +9 -6
  10. data/lib/redis/commands/hyper_log_log.rb +1 -1
  11. data/lib/redis/commands/keys.rb +53 -27
  12. data/lib/redis/commands/lists.rb +73 -23
  13. data/lib/redis/commands/pubsub.rb +7 -25
  14. data/lib/redis/commands/server.rb +15 -15
  15. data/lib/redis/commands/sets.rb +43 -36
  16. data/lib/redis/commands/sorted_sets.rb +84 -12
  17. data/lib/redis/commands/streams.rb +39 -19
  18. data/lib/redis/commands/strings.rb +18 -17
  19. data/lib/redis/commands/transactions.rb +7 -31
  20. data/lib/redis/commands.rb +4 -9
  21. data/lib/redis/distributed.rb +128 -67
  22. data/lib/redis/errors.rb +15 -50
  23. data/lib/redis/hash_ring.rb +26 -26
  24. data/lib/redis/pipeline.rb +43 -222
  25. data/lib/redis/subscribe.rb +23 -15
  26. data/lib/redis/version.rb +1 -1
  27. data/lib/redis.rb +90 -182
  28. metadata +10 -54
  29. data/lib/redis/cluster/command.rb +0 -79
  30. data/lib/redis/cluster/command_loader.rb +0 -33
  31. data/lib/redis/cluster/key_slot_converter.rb +0 -72
  32. data/lib/redis/cluster/node.rb +0 -120
  33. data/lib/redis/cluster/node_key.rb +0 -31
  34. data/lib/redis/cluster/node_loader.rb +0 -34
  35. data/lib/redis/cluster/option.rb +0 -100
  36. data/lib/redis/cluster/slot.rb +0 -86
  37. data/lib/redis/cluster/slot_loader.rb +0 -46
  38. data/lib/redis/cluster.rb +0 -315
  39. data/lib/redis/connection/command_helper.rb +0 -41
  40. data/lib/redis/connection/hiredis.rb +0 -66
  41. data/lib/redis/connection/registry.rb +0 -13
  42. data/lib/redis/connection/ruby.rb +0 -437
  43. data/lib/redis/connection/synchrony.rb +0 -148
  44. data/lib/redis/connection.rb +0 -11
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 185ccbe36adc1e1561474af65d0e0b8d246e9c161757c9218f5ac7b6c1d24bb9
4
- data.tar.gz: 03a4203747503b971551500ea40f996cb9620e5d9a693231d7a63944a9f73bf8
3
+ metadata.gz: 1dde5fad5c2d0c73c390528b059ab36b185dd61a2c32e4f9be9512bb4516977b
4
+ data.tar.gz: cda581f3f9b0b4238f15b4b3ddf7566fb6ca02b60ee7951b903e8e195bd395cd
5
5
  SHA512:
6
- metadata.gz: 3354c910dcf3feb76b7f4ed7adb5bcce4f1cfc3ef7c58347897ba4705337a89052d2db67a8a71765f34e16f01a7ab2c8894bba60a3a89e1f36b6487f3fe0089b
7
- data.tar.gz: 0b23396f9ecf62dd952536b94107a7748bb5ee225e7c7ac1da36e813e7fffc588c5939abe1800fc440e173acc54a9ac3649037b62b3ff59aa946ffc9a3e11180
6
+ metadata.gz: 122fd647eda1a251370f32dfefb4711411b0ff9b0e9185cdb871c389c99d5b80a80d554a6b7787ed10e515291b1ebed6dceb2364f8c28021ce6fdedd3297d08e
7
+ data.tar.gz: 13aadc0709a9fc7779ad7ad1f64bb3d3b26da57eb44dd2ebd629d5ed2d34ea17c782337ce92e1047e7ae736df8b90eafb2e935e460f1b1af979621942dad772f
data/CHANGELOG.md CHANGED
@@ -1,5 +1,70 @@
1
1
  # Unreleased
2
2
 
3
+ # 5.0.7
4
+
5
+ - Fix compatibility with `redis-client 0.15.0` when using Redis Sentinel. Fix #1209.
6
+
7
+ # 5.0.6
8
+
9
+ - Wait for an extra `config.read_timeout` in blocking commands rather than an arbitrary 100ms. See #1175.
10
+ - Treat ReadOnlyError as ConnectionError. See #1168.
11
+
12
+ # 5.0.5
13
+
14
+ - Fix automatic disconnection when the process was forked. See #1157.
15
+
16
+ # 5.0.4
17
+
18
+ - Cast `ttl` argument to integer in `expire`, `setex` and a few others.
19
+
20
+ # 5.0.3
21
+
22
+ - Add `OutOfMemoryError` as a subclass of `CommandError`
23
+
24
+ # 5.0.2
25
+
26
+ - Fix `Redis#close` to properly reset the fork protection check.
27
+
28
+ # 5.0.1
29
+
30
+ - Added a fake `Redis::Connections.drivers` method to be compatible with older sidekiq versions.
31
+
32
+ # 5.0.0
33
+
34
+ - Default client timeout decreased from 5 seconds to 1 second.
35
+ - Eagerly and strictly cast Integer and Float parameters.
36
+ - Allow to call `subscribe`, `unsubscribe`, `psubscribe` and `punsubscribe` from a subscribed client. See #1131.
37
+ - Use `MD5` for hashing server nodes in `Redis::Distributed`. This should improve keys distribution among servers. See #1089.
38
+ - Changed `sadd` and `srem` to now always return an Integer.
39
+ - Added `sadd?` and `srem?` which always return a Boolean.
40
+ - Added support for `IDLE` paramter in `xpending`.
41
+ - Cluster support has been moved to a `redis-clustering` companion gem.
42
+ - `select` no longer record the current database. If the client has to reconnect after `select` was used, it will reconnect to the original database.
43
+ - Better support Float timeout in blocking commands. See #977.
44
+ - `Redis.new` will now raise an error if provided unknown options.
45
+ - Removed positional timeout in blocking commands (`BLPOP`, etc). Timeout now must be passed as an option: `r.blpop("key", timeout: 2.5)`
46
+ - Removed `logger` option.
47
+ - Removed `reconnect_delay_max` and `reconnect_delay`, you can pass precise sleep durations to `reconnect_attempts` instead.
48
+ - Require Ruby 2.5+.
49
+ - Removed the deprecated `queue` and `commit` methods. Use `pipelined` instead.
50
+ - Removed the deprecated `Redis::Future#==`.
51
+ - Removed the deprecated `pipelined` and `multi` signature. Commands now MUST be called on the block argument, not the original redis instance.
52
+ - Removed `Redis.current`. You shouldn't assume there is a single global Redis connection, use a connection pool instead,
53
+ and libaries using Redis should accept a Redis instance (or connection pool) as a config. E.g. `MyLibrary.redis = Redis.new(...)`.
54
+ - Removed the `synchrony` driver.
55
+ - Removed `Redis.exists_returns_integer`, it's now always enabled.
56
+
57
+ # 4.8.1
58
+
59
+ * Automatically reconnect after fork regardless of `reconnect_attempts`
60
+
61
+ # 4.8.0
62
+
63
+ * Introduce `sadd?` and `srem?` as boolean returning versions of `sadd` and `srem`.
64
+ * Deprecate `sadd` and `srem` returning a boolean when called with a single argument.
65
+ To enable the redis 5.0 behavior you can set `Redis.sadd_returns_boolean = false`.
66
+ * Deprecate passing `timeout` as a positional argument in blocking commands (`brpop`, `blop`, etc).
67
+
3
68
  # 4.7.1
4
69
 
5
70
  * Gracefully handle OpenSSL 3.0 EOF Errors (`OpenSSL::SSL::SSLError: SSL_read: unexpected eof while reading`). See #1106
data/README.md CHANGED
@@ -1,7 +1,6 @@
1
- # redis-rb [![Build Status][gh-actions-image]][gh-actions-link] [![Inline docs][inchpages-image]][inchpages-link]
1
+ # redis-rb [![Build Status][gh-actions-image]][gh-actions-link] [![Inline docs][rdoc-master-image]][rdoc-master-link]
2
2
 
3
- A Ruby client that tries to match [Redis][redis-home]' API one-to-one, while still
4
- providing an idiomatic interface.
3
+ A Ruby client that tries to match [Redis][redis-home]' API one-to-one, while still providing an idiomatic interface.
5
4
 
6
5
  See [RubyDoc.info][rubydoc] for the API docs of the latest published gem.
7
6
 
@@ -38,10 +37,6 @@ redis = Redis.new(url: "redis://:p4ssw0rd@10.0.1.1:6380/15")
38
37
  The client expects passwords with special chracters to be URL-encoded (i.e.
39
38
  `CGI.escape(password)`).
40
39
 
41
- By default, the client will try to read the `REDIS_URL` environment variable
42
- and use that as URL to connect to. The above statement is therefore equivalent
43
- to setting this environment variable and calling `Redis.new` without arguments.
44
-
45
40
  To connect to Redis listening on a Unix socket, try:
46
41
 
47
42
  ```ruby
@@ -76,6 +71,26 @@ redis.get("mykey")
76
71
  All commands, their arguments, and return values are documented and
77
72
  available on [RubyDoc.info][rubydoc].
78
73
 
74
+ ## Connection Pooling and Thread safety
75
+
76
+ The client does not provide connection pooling. Each `Redis` instance
77
+ has one and only one connection to the server, and use of this connection
78
+ is protected by a mutex.
79
+
80
+ As such it is heavilly recommended to use the [`connection_pool` gem](https://github.com/mperham/connection_pool), e.g.:
81
+
82
+ ```ruby
83
+ module MyApp
84
+ def self.redis
85
+ @redis ||= ConnectionPool::Wrapper.new do
86
+ Redis.new(url: ENV["REDIS_URL"])
87
+ end
88
+ end
89
+ end
90
+
91
+ MyApp.redis.incr("some-counter")
92
+ ```
93
+
79
94
  ## Sentinel support
80
95
 
81
96
  The client is able to perform automatic failover by using [Redis
@@ -88,7 +103,7 @@ To connect using Sentinel, use:
88
103
  SENTINELS = [{ host: "127.0.0.1", port: 26380 },
89
104
  { host: "127.0.0.1", port: 26381 }]
90
105
 
91
- redis = Redis.new(url: "redis://mymaster", sentinels: SENTINELS, role: :master)
106
+ redis = Redis.new(name: "mymaster", sentinels: SENTINELS, role: :master)
92
107
  ```
93
108
 
94
109
  * The master name identifies a group of Redis instances composed of a master
@@ -111,79 +126,18 @@ If you want to [authenticate](https://redis.io/topics/sentinel#configuring-senti
111
126
  SENTINELS = [{ host: '127.0.0.1', port: 26380, password: 'mysecret' },
112
127
  { host: '127.0.0.1', port: 26381, password: 'mysecret' }]
113
128
 
114
- redis = Redis.new(host: 'mymaster', sentinels: SENTINELS, role: :master)
129
+ redis = Redis.new(name: 'mymaster', sentinels: SENTINELS, role: :master)
115
130
  ```
116
131
 
117
- ## Cluster support
118
-
119
- `redis-rb` supports [clustering](https://redis.io/topics/cluster-spec).
132
+ Also the name can be passed as an url:
120
133
 
121
134
  ```ruby
122
- # Nodes can be passed to the client as an array of connection URLs.
123
- nodes = (7000..7005).map { |port| "redis://127.0.0.1:#{port}" }
124
- redis = Redis.new(cluster: nodes)
125
-
126
- # You can also specify the options as a Hash. The options are the same as for a single server connection.
127
- (7000..7005).map { |port| { host: '127.0.0.1', port: port } }
135
+ redis = Redis.new(name: "redis://mymaster", sentinels: SENTINELS, role: :master)
128
136
  ```
129
137
 
130
- You can also specify only a subset of the nodes, and the client will discover the missing ones using the [CLUSTER NODES](https://redis.io/commands/cluster-nodes) command.
131
-
132
- ```ruby
133
- Redis.new(cluster: %w[redis://127.0.0.1:7000])
134
- ```
135
-
136
- If you want [the connection to be able to read from any replica](https://redis.io/commands/readonly), you must pass the `replica: true`. Note that this connection won't be usable to write keys.
137
-
138
- ```ruby
139
- Redis.new(cluster: nodes, replica: true)
140
- ```
141
-
142
- The calling code is responsible for [avoiding cross slot commands](https://redis.io/topics/cluster-spec#keys-distribution-model).
143
-
144
- ```ruby
145
- redis = Redis.new(cluster: %w[redis://127.0.0.1:7000])
146
-
147
- redis.mget('key1', 'key2')
148
- #=> Redis::CommandError (CROSSSLOT Keys in request don't hash to the same slot)
149
-
150
- redis.mget('{key}1', '{key}2')
151
- #=> [nil, nil]
152
- ```
153
-
154
- * The client automatically reconnects after a failover occurred, but the caller is responsible for handling errors while it is happening.
155
- * The client support permanent node failures, and will reroute requests to promoted slaves.
156
- * The client supports `MOVED` and `ASK` redirections transparently.
157
-
158
- ## Cluster mode with SSL/TLS
159
- Since Redis can return FQDN of nodes in reply to client since `7.*` with CLUSTER commands, we can use cluster feature with SSL/TLS connection like this:
160
-
161
- ```ruby
162
- Redis.new(cluster: %w[rediss://foo.example.com:6379])
163
- ```
164
-
165
- On the other hand, in Redis versions prior to `6.*`, you can specify options like the following if cluster mode is enabled and client has to connect to nodes via single endpoint with SSL/TLS.
166
-
167
- ```ruby
168
- Redis.new(cluster: %w[rediss://foo-endpoint.example.com:6379], fixed_hostname: 'foo-endpoint.example.com')
169
- ```
170
-
171
- In case of the above architecture, if you don't pass the `fixed_hostname` option to the client and servers return IP addresses of nodes, the client may fail to verify certificates.
172
-
173
- ## Storing objects
174
-
175
- Redis "string" types can be used to store serialized Ruby objects, for
176
- example with JSON:
177
-
178
- ```ruby
179
- require "json"
180
-
181
- redis.set "foo", [1, 2, 3].to_json
182
- # => OK
138
+ ## Cluster support
183
139
 
184
- JSON.parse(redis.get("foo"))
185
- # => [1, 2, 3]
186
- ```
140
+ [Clustering](https://redis.io/topics/cluster-spec). is supported via the [`redis-clustering` gem](cluster/).
187
141
 
188
142
  ## Pipelining
189
143
 
@@ -206,6 +160,17 @@ end
206
160
  # => ["OK", 1]
207
161
  ```
208
162
 
163
+ Commands must be called on the yielded objects. If you call methods
164
+ on the original client objects from inside a pipeline, they will be sent immediately:
165
+
166
+ ```ruby
167
+ redis.pipelined do |pipeline|
168
+ pipeline.set "foo", "bar"
169
+ redis.incr "baz" # => 1
170
+ end
171
+ # => ["OK"]
172
+ ```
173
+
209
174
  ### Executing commands atomically
210
175
 
211
176
  You can use `MULTI/EXEC` to run a number of commands in an atomic
@@ -225,21 +190,22 @@ end
225
190
  ### Futures
226
191
 
227
192
  Replies to commands in a pipeline can be accessed via the *futures* they
228
- emit (since redis-rb 3.0). All calls on the pipeline object return a
193
+ emit. All calls on the pipeline object return a
229
194
  `Future` object, which responds to the `#value` method. When the
230
195
  pipeline has successfully executed, all futures are assigned their
231
196
  respective replies and can be used.
232
197
 
233
198
  ```ruby
199
+ set = incr = nil
234
200
  redis.pipelined do |pipeline|
235
- @set = pipeline.set "foo", "bar"
236
- @incr = pipeline.incr "baz"
201
+ set = pipeline.set "foo", "bar"
202
+ incr = pipeline.incr "baz"
237
203
  end
238
204
 
239
- @set.value
205
+ set.value
240
206
  # => "OK"
241
207
 
242
- @incr.value
208
+ incr.value
243
209
  # => 1
244
210
  ```
245
211
 
@@ -251,7 +217,7 @@ it can't connect to the server a `Redis::CannotConnectError` error will be raise
251
217
  ```ruby
252
218
  begin
253
219
  redis.ping
254
- rescue StandardError => e
220
+ rescue Redis::BaseError => e
255
221
  e.inspect
256
222
  # => #<Redis::CannotConnectError: Timed out connecting to Redis on 10.0.1.1:6380>
257
223
 
@@ -298,55 +264,37 @@ If no message is received after 5 seconds, the client will unsubscribe.
298
264
 
299
265
  ## Reconnections
300
266
 
301
- The client allows you to configure how many `reconnect_attempts` it should
302
- complete before declaring a connection as failed. Furthermore, you may want
303
- to control the maximum duration between reconnection attempts with
304
- `reconnect_delay` and `reconnect_delay_max`.
267
+ **By default**, this gem will only **retry a connection once** and then fail, but
268
+ the client allows you to configure how many `reconnect_attempts` it should
269
+ complete before declaring a connection as failed.
305
270
 
306
271
  ```ruby
307
- Redis.new(
308
- :reconnect_attempts => 10,
309
- :reconnect_delay => 1.5,
310
- :reconnect_delay_max => 10.0,
311
- )
272
+ Redis.new(reconnect_attempts: 0)
273
+ Redis.new(reconnect_attempts: 3)
312
274
  ```
313
275
 
314
- The delay values are specified in seconds. With the above configuration, the
315
- client would attempt 10 reconnections, exponentially increasing the duration
316
- between each attempt but it never waits longer than `reconnect_delay_max`.
317
-
318
- This is the retry algorithm:
276
+ If you wish to wait between reconnection attempts, you can instead pass a list
277
+ of durations:
319
278
 
320
279
  ```ruby
321
- attempt_wait_time = [(reconnect_delay * 2**(attempt-1)), reconnect_delay_max].min
280
+ Redis.new(reconnect_attempts: [
281
+ 0, # retry immediately
282
+ 0.25, # retry a second time after 250ms
283
+ 1, # retry a third and final time after another 1s
284
+ ])
322
285
  ```
323
286
 
324
- **By default**, this gem will only **retry a connection once** and then fail, but with the
325
- above configuration the reconnection attempt would look like this:
326
-
327
- #|Attempt wait time|Total wait time
328
- :-:|:-:|:-:
329
- 1|1.5s|1.5s
330
- 2|3.0s|4.5s
331
- 3|6.0s|10.5s
332
- 4|10.0s|20.5s
333
- 5|10.0s|30.5s
334
- 6|10.0s|40.5s
335
- 7|10.0s|50.5s
336
- 8|10.0s|60.5s
337
- 9|10.0s|70.5s
338
- 10|10.0s|80.5s
339
-
340
- So if the reconnection attempt #10 succeeds 70 seconds have elapsed trying
341
- to reconnect, this is likely fine in long-running background processes, but if
342
- you use Redis to drive your website you might want to have a lower
343
- `reconnect_delay_max` or have less `reconnect_attempts`.
287
+ If you wish to disable reconnection only for some commands, you can use
288
+ `disable_reconnection`:
344
289
 
345
- ## SSL/TLS Support
290
+ ```ruby
291
+ redis.get("some-key") # this may be retried
292
+ redis.disable_reconnection do
293
+ redis.incr("some-counter") # this won't be retried.
294
+ end
295
+ ```
346
296
 
347
- This library supports natively terminating client side SSL/TLS connections
348
- when talking to Redis via a server-side proxy such as [stunnel], [hitch],
349
- or [ghostunnel].
297
+ ## SSL/TLS Support
350
298
 
351
299
  To enable SSL support, pass the `:ssl => true` option when configuring the
352
300
  Redis client, or pass in `:url => "rediss://..."` (like HTTPS for Redis).
@@ -381,13 +329,7 @@ redis = Redis.new(
381
329
  )
382
330
  ```
383
331
 
384
- [stunnel]: https://www.stunnel.org/
385
- [hitch]: https://hitch-tls.org/
386
- [ghostunnel]: https://github.com/square/ghostunnel
387
- [OpenSSL::SSL::SSLContext documentation]: http://ruby-doc.org/stdlib-2.3.0/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html
388
-
389
- *NOTE:* SSL is only supported by the default "Ruby" driver
390
-
332
+ [OpenSSL::SSL::SSLContext documentation]: http://ruby-doc.org/stdlib-2.5.0/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html
391
333
 
392
334
  ## Expert-Mode Options
393
335
 
@@ -401,17 +343,9 @@ redis = Redis.new(
401
343
  Improper use of `inherit_socket` will result in corrupted and/or incorrect
402
344
  responses.
403
345
 
404
- ## Alternate drivers
346
+ ## hiredis binding
405
347
 
406
348
  By default, redis-rb uses Ruby's socket library to talk with Redis.
407
- To use an alternative connection driver it should be specified as option
408
- when instantiating the client object. These instructions are only valid
409
- for **redis-rb 3.0**. For instructions on how to use alternate drivers from
410
- **redis-rb 2.2**, please refer to an [older README][readme-2.2.2].
411
-
412
- [readme-2.2.2]: https://github.com/redis/redis-rb/blob/v2.2.2/README.md
413
-
414
- ### hiredis
415
349
 
416
350
  The hiredis driver uses the connection facility of hiredis-rb. In turn,
417
351
  hiredis-rb is a binding to the official hiredis client library. It
@@ -421,41 +355,27 @@ extension, JRuby is not supported (by default).
421
355
  It is best to use hiredis when you have large replies (for example:
422
356
  `LRANGE`, `SMEMBERS`, `ZRANGE`, etc.) and/or use big pipelines.
423
357
 
424
- In your Gemfile, include hiredis:
358
+ In your Gemfile, include `hiredis-client`:
425
359
 
426
360
  ```ruby
427
- gem "redis", "~> 3.0.1"
428
- gem "hiredis", "~> 0.4.5"
361
+ gem "redis"
362
+ gem "hiredis-client"
429
363
  ```
430
364
 
431
- When instantiating the client object, specify hiredis:
365
+ If your application doesn't call `Bundler.require`, you may have
366
+ to require it explictly:
432
367
 
433
368
  ```ruby
434
- redis = Redis.new(:driver => :hiredis)
435
- ```
436
-
437
- ### synchrony
438
-
439
- The synchrony driver adds support for [em-synchrony][em-synchrony].
440
- This makes redis-rb work with EventMachine's asynchronous I/O, while not
441
- changing the exposed API. The hiredis gem needs to be available as
442
- well, because the synchrony driver uses hiredis for parsing the Redis
443
- protocol.
369
+ require "hiredis-client"
370
+ ````
444
371
 
445
- [em-synchrony]: https://github.com/igrigorik/em-synchrony
446
-
447
- In your Gemfile, include em-synchrony and hiredis:
448
-
449
- ```ruby
450
- gem "redis", "~> 3.0.1"
451
- gem "hiredis", "~> 0.4.5"
452
- gem "em-synchrony"
453
- ```
372
+ This makes the hiredis driver the default.
454
373
 
455
- When instantiating the client object, specify synchrony:
374
+ If you want to be certain hiredis is being used, when instantiating
375
+ the client object, specify hiredis:
456
376
 
457
377
  ```ruby
458
- redis = Redis.new(:driver => :synchrony)
378
+ redis = Redis.new(driver: :hiredis)
459
379
  ```
460
380
 
461
381
  ## Testing
@@ -480,11 +400,11 @@ client and evangelized Redis in Rubyland. Thank you, Ezra.
480
400
  requests.
481
401
 
482
402
 
483
- [inchpages-image]: https://inch-ci.org/github/redis/redis-rb.svg
484
- [inchpages-link]: https://inch-ci.org/github/redis/redis-rb
485
- [redis-commands]: https://redis.io/commands
486
- [redis-home]: https://redis.io
487
- [redis-url]: http://www.iana.org/assignments/uri-schemes/prov/redis
488
- [gh-actions-image]: https://github.com/redis/redis-rb/workflows/Test/badge.svg
489
- [gh-actions-link]: https://github.com/redis/redis-rb/actions
490
- [rubydoc]: http://www.rubydoc.info/gems/redis
403
+ [rdoc-master-image]: https://img.shields.io/badge/docs-rdoc.info-blue.svg
404
+ [rdoc-master-link]: https://rubydoc.info/github/redis/redis-rb
405
+ [redis-commands]: https://redis.io/commands
406
+ [redis-home]: https://redis.io
407
+ [redis-url]: https://www.iana.org/assignments/uri-schemes/prov/redis
408
+ [gh-actions-image]: https://github.com/redis/redis-rb/workflows/Test/badge.svg
409
+ [gh-actions-link]: https://github.com/redis/redis-rb/actions
410
+ [rubydoc]: https://rubydoc.info/gems/redis