redis 4.8.1 → 5.1.0

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 +101 -161
  4. data/lib/redis/client.rb +82 -616
  5. data/lib/redis/commands/bitmaps.rb +14 -4
  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 +21 -23
  12. data/lib/redis/commands/lists.rb +74 -25
  13. data/lib/redis/commands/pubsub.rb +28 -25
  14. data/lib/redis/commands/server.rb +15 -15
  15. data/lib/redis/commands/sets.rb +31 -40
  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 -7
  21. data/lib/redis/distributed.rb +128 -68
  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 +50 -14
  26. data/lib/redis/version.rb +1 -1
  27. data/lib/redis.rb +76 -184
  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 -68
  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: b18788ff80698e8f79fb103e7419d9ba74fb0b6a5eb55c672422cd76abff985c
4
- data.tar.gz: 1eed18a57039c677c894564ceaa1cf6bc9c0535be51501d078b09d75617a9d89
3
+ metadata.gz: ab20cee7f44b7d5f2736e1fbc7073cb950f52ceefc3dc1ff0edf9b4b778c7d8d
4
+ data.tar.gz: 76b0b6169311906b2ee634f9314c74052a1612245d7e33220aab5cb2c617af8a
5
5
  SHA512:
6
- metadata.gz: 5f2f7ce595d431f548c126a63c5ce697cc9e596e9b0eaa00f1e0186ae3853e73922c6e130b989ba9e026aec32f766a774433fdd1cff216420e837837db90659b
7
- data.tar.gz: 02fb8debb0d11f7b9d04f7616093535426f0ee5a0994992fcf3187ab00aa890dcd2fb248f14da49837508a3ccbb5756be208fc5d3b8dcd18ec6aaf0fb1bb1193
6
+ metadata.gz: 220927cf03b0ad6ab0c7340d9b32ed073e379974d054eba12cf966ad65837eba00f114d1fdeb166780ead645befcc3ee9fb3a83aab8e8cb0b1661370f401f8cb
7
+ data.tar.gz: 8f9476be4c7d4a3dd8dc1f29265b184932f67b49d524a0c79865dc95eee3ba165e9d24cb3f699ce287b886cc4f38b88574a5b33b1bab48f2fe9971597b7d2c5c
data/CHANGELOG.md CHANGED
@@ -1,5 +1,70 @@
1
1
  # Unreleased
2
2
 
3
+ # 5.1.0
4
+
5
+ - `multi` now accept a `watch` keyword argument like `redis-client`. See #1236.
6
+ - `bitcount` and `bitpos` now accept a `scale:` argument on Redis 7+. See #1242
7
+ - Added `expiretime` and `pexpiretime`. See #1248.
8
+
9
+ # 5.0.8
10
+
11
+ - Fix `Redis#without_reconnect` for sentinel clients. Fix #1212.
12
+ - Add `sentinel_username`, `sentinel_password` for sentinel clients. Bump `redis-client` to `>=0.17.0`. See #1213
13
+
14
+ # 5.0.7
15
+
16
+ - Fix compatibility with `redis-client 0.15.0` when using Redis Sentinel. Fix #1209.
17
+
18
+ # 5.0.6
19
+
20
+ - Wait for an extra `config.read_timeout` in blocking commands rather than an arbitrary 100ms. See #1175.
21
+ - Treat ReadOnlyError as ConnectionError. See #1168.
22
+
23
+ # 5.0.5
24
+
25
+ - Fix automatic disconnection when the process was forked. See #1157.
26
+
27
+ # 5.0.4
28
+
29
+ - Cast `ttl` argument to integer in `expire`, `setex` and a few others.
30
+
31
+ # 5.0.3
32
+
33
+ - Add `OutOfMemoryError` as a subclass of `CommandError`
34
+
35
+ # 5.0.2
36
+
37
+ - Fix `Redis#close` to properly reset the fork protection check.
38
+
39
+ # 5.0.1
40
+
41
+ - Added a fake `Redis::Connections.drivers` method to be compatible with older sidekiq versions.
42
+
43
+ # 5.0.0
44
+
45
+ - Default client timeout decreased from 5 seconds to 1 second.
46
+ - Eagerly and strictly cast Integer and Float parameters.
47
+ - Allow to call `subscribe`, `unsubscribe`, `psubscribe` and `punsubscribe` from a subscribed client. See #1131.
48
+ - Use `MD5` for hashing server nodes in `Redis::Distributed`. This should improve keys distribution among servers. See #1089.
49
+ - Changed `sadd` and `srem` to now always return an Integer.
50
+ - Added `sadd?` and `srem?` which always return a Boolean.
51
+ - Added support for `IDLE` paramter in `xpending`.
52
+ - Cluster support has been moved to a `redis-clustering` companion gem.
53
+ - `select` no longer record the current database. If the client has to reconnect after `select` was used, it will reconnect to the original database.
54
+ - Better support Float timeout in blocking commands. See #977.
55
+ - `Redis.new` will now raise an error if provided unknown options.
56
+ - Removed positional timeout in blocking commands (`BLPOP`, etc). Timeout now must be passed as an option: `r.blpop("key", timeout: 2.5)`
57
+ - Removed `logger` option.
58
+ - Removed `reconnect_delay_max` and `reconnect_delay`, you can pass precise sleep durations to `reconnect_attempts` instead.
59
+ - Require Ruby 2.5+.
60
+ - Removed the deprecated `queue` and `commit` methods. Use `pipelined` instead.
61
+ - Removed the deprecated `Redis::Future#==`.
62
+ - Removed the deprecated `pipelined` and `multi` signature. Commands now MUST be called on the block argument, not the original redis instance.
63
+ - Removed `Redis.current`. You shouldn't assume there is a single global Redis connection, use a connection pool instead,
64
+ and libaries using Redis should accept a Redis instance (or connection pool) as a config. E.g. `MyLibrary.redis = Redis.new(...)`.
65
+ - Removed the `synchrony` driver.
66
+ - Removed `Redis.exists_returns_integer`, it's now always enabled.
67
+
3
68
  # 4.8.1
4
69
 
5
70
  * Automatically reconnect after fork regardless of `reconnect_attempts`
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
@@ -105,85 +120,44 @@ but a few so that if one is down the client will try the next one. The client
105
120
  is able to remember the last Sentinel that was able to reply correctly and will
106
121
  use it for the next requests.
107
122
 
108
- If you want to [authenticate](https://redis.io/topics/sentinel#configuring-sentinel-instances-with-authentication) Sentinel itself, you must specify the `password` option per instance.
109
-
110
- ```ruby
111
- SENTINELS = [{ host: '127.0.0.1', port: 26380, password: 'mysecret' },
112
- { host: '127.0.0.1', port: 26381, password: 'mysecret' }]
113
-
114
- redis = Redis.new(host: 'mymaster', sentinels: SENTINELS, role: :master)
115
- ```
116
-
117
- ## Cluster support
118
-
119
- `redis-rb` supports [clustering](https://redis.io/topics/cluster-spec).
123
+ To [authenticate](https://redis.io/docs/management/sentinel/#configuring-sentinel-instances-with-authentication) Sentinel itself, you can specify the `sentinel_username` and `sentinel_password`. Exclude the `sentinel_username` option if you're using password-only authentication.
120
124
 
121
125
  ```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)
126
+ SENTINELS = [{ host: '127.0.0.1', port: 26380},
127
+ { host: '127.0.0.1', port: 26381}]
125
128
 
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 } }
129
+ redis = Redis.new(name: 'mymaster', sentinels: SENTINELS, sentinel_username: 'appuser', sentinel_password: 'mysecret', role: :master)
128
130
  ```
129
131
 
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.
132
+ If you specify a username and/or password at the top level for your main Redis instance, Sentinel *will not* using thouse credentials
131
133
 
132
134
  ```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.
135
+ # Use 'mysecret' to authenticate against the mymaster instance, but skip authentication for the sentinels:
136
+ SENTINELS = [{ host: '127.0.0.1', port: 26380 },
137
+ { host: '127.0.0.1', port: 26381 }]
137
138
 
138
- ```ruby
139
- Redis.new(cluster: nodes, replica: true)
139
+ redis = Redis.new(name: 'mymaster', sentinels: SENTINELS, role: :master, password: 'mysecret')
140
140
  ```
141
141
 
142
- The calling code is responsible for [avoiding cross slot commands](https://redis.io/topics/cluster-spec#keys-distribution-model).
142
+ So you have to provide Sentinel credential and Redis explictly even they are the same
143
143
 
144
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)
145
+ # Use 'mysecret' to authenticate against the mymaster instance and sentinel
146
+ SENTINELS = [{ host: '127.0.0.1', port: 26380 },
147
+ { host: '127.0.0.1', port: 26381 }]
149
148
 
150
- redis.mget('{key}1', '{key}2')
151
- #=> [nil, nil]
149
+ redis = Redis.new(name: 'mymaster', sentinels: SENTINELS, role: :master, password: 'mysecret', sentinel_password: 'mysecret')
152
150
  ```
153
151
 
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:
152
+ Also the `name`, `password`, `username` and `db` for Redis instance can be passed as an url:
160
153
 
161
154
  ```ruby
162
- Redis.new(cluster: %w[rediss://foo.example.com:6379])
155
+ redis = Redis.new(url: "redis://appuser:mysecret@mymaster/10", sentinels: SENTINELS, role: :master)
163
156
  ```
164
157
 
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
158
+ ## Cluster support
183
159
 
184
- JSON.parse(redis.get("foo"))
185
- # => [1, 2, 3]
186
- ```
160
+ [Clustering](https://redis.io/topics/cluster-spec). is supported via the [`redis-clustering` gem](cluster/).
187
161
 
188
162
  ## Pipelining
189
163
 
@@ -206,6 +180,17 @@ end
206
180
  # => ["OK", 1]
207
181
  ```
208
182
 
183
+ Commands must be called on the yielded objects. If you call methods
184
+ on the original client objects from inside a pipeline, they will be sent immediately:
185
+
186
+ ```ruby
187
+ redis.pipelined do |pipeline|
188
+ pipeline.set "foo", "bar"
189
+ redis.incr "baz" # => 1
190
+ end
191
+ # => ["OK"]
192
+ ```
193
+
209
194
  ### Executing commands atomically
210
195
 
211
196
  You can use `MULTI/EXEC` to run a number of commands in an atomic
@@ -225,21 +210,22 @@ end
225
210
  ### Futures
226
211
 
227
212
  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
213
+ emit. All calls on the pipeline object return a
229
214
  `Future` object, which responds to the `#value` method. When the
230
215
  pipeline has successfully executed, all futures are assigned their
231
216
  respective replies and can be used.
232
217
 
233
218
  ```ruby
219
+ set = incr = nil
234
220
  redis.pipelined do |pipeline|
235
- @set = pipeline.set "foo", "bar"
236
- @incr = pipeline.incr "baz"
221
+ set = pipeline.set "foo", "bar"
222
+ incr = pipeline.incr "baz"
237
223
  end
238
224
 
239
- @set.value
225
+ set.value
240
226
  # => "OK"
241
227
 
242
- @incr.value
228
+ incr.value
243
229
  # => 1
244
230
  ```
245
231
 
@@ -251,7 +237,7 @@ it can't connect to the server a `Redis::CannotConnectError` error will be raise
251
237
  ```ruby
252
238
  begin
253
239
  redis.ping
254
- rescue StandardError => e
240
+ rescue Redis::BaseError => e
255
241
  e.inspect
256
242
  # => #<Redis::CannotConnectError: Timed out connecting to Redis on 10.0.1.1:6380>
257
243
 
@@ -298,55 +284,37 @@ If no message is received after 5 seconds, the client will unsubscribe.
298
284
 
299
285
  ## Reconnections
300
286
 
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`.
287
+ **By default**, this gem will only **retry a connection once** and then fail, but
288
+ the client allows you to configure how many `reconnect_attempts` it should
289
+ complete before declaring a connection as failed.
305
290
 
306
291
  ```ruby
307
- Redis.new(
308
- :reconnect_attempts => 10,
309
- :reconnect_delay => 1.5,
310
- :reconnect_delay_max => 10.0,
311
- )
292
+ Redis.new(reconnect_attempts: 0)
293
+ Redis.new(reconnect_attempts: 3)
312
294
  ```
313
295
 
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:
296
+ If you wish to wait between reconnection attempts, you can instead pass a list
297
+ of durations:
319
298
 
320
299
  ```ruby
321
- attempt_wait_time = [(reconnect_delay * 2**(attempt-1)), reconnect_delay_max].min
300
+ Redis.new(reconnect_attempts: [
301
+ 0, # retry immediately
302
+ 0.25, # retry a second time after 250ms
303
+ 1, # retry a third and final time after another 1s
304
+ ])
322
305
  ```
323
306
 
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`.
307
+ If you wish to disable reconnection only for some commands, you can use
308
+ `disable_reconnection`:
344
309
 
345
- ## SSL/TLS Support
310
+ ```ruby
311
+ redis.get("some-key") # this may be retried
312
+ redis.disable_reconnection do
313
+ redis.incr("some-counter") # this won't be retried.
314
+ end
315
+ ```
346
316
 
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].
317
+ ## SSL/TLS Support
350
318
 
351
319
  To enable SSL support, pass the `:ssl => true` option when configuring the
352
320
  Redis client, or pass in `:url => "rediss://..."` (like HTTPS for Redis).
@@ -381,13 +349,7 @@ redis = Redis.new(
381
349
  )
382
350
  ```
383
351
 
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
-
352
+ [OpenSSL::SSL::SSLContext documentation]: http://ruby-doc.org/stdlib-2.5.0/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html
391
353
 
392
354
  ## Expert-Mode Options
393
355
 
@@ -401,17 +363,9 @@ redis = Redis.new(
401
363
  Improper use of `inherit_socket` will result in corrupted and/or incorrect
402
364
  responses.
403
365
 
404
- ## Alternate drivers
366
+ ## hiredis binding
405
367
 
406
368
  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
369
 
416
370
  The hiredis driver uses the connection facility of hiredis-rb. In turn,
417
371
  hiredis-rb is a binding to the official hiredis client library. It
@@ -421,41 +375,27 @@ extension, JRuby is not supported (by default).
421
375
  It is best to use hiredis when you have large replies (for example:
422
376
  `LRANGE`, `SMEMBERS`, `ZRANGE`, etc.) and/or use big pipelines.
423
377
 
424
- In your Gemfile, include hiredis:
378
+ In your Gemfile, include `hiredis-client`:
425
379
 
426
380
  ```ruby
427
- gem "redis", "~> 3.0.1"
428
- gem "hiredis", "~> 0.4.5"
381
+ gem "redis"
382
+ gem "hiredis-client"
429
383
  ```
430
384
 
431
- When instantiating the client object, specify hiredis:
385
+ If your application doesn't call `Bundler.require`, you may have
386
+ to require it explictly:
432
387
 
433
388
  ```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.
444
-
445
- [em-synchrony]: https://github.com/igrigorik/em-synchrony
389
+ require "hiredis-client"
390
+ ````
446
391
 
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
- ```
392
+ This makes the hiredis driver the default.
454
393
 
455
- When instantiating the client object, specify synchrony:
394
+ If you want to be certain hiredis is being used, when instantiating
395
+ the client object, specify hiredis:
456
396
 
457
397
  ```ruby
458
- redis = Redis.new(:driver => :synchrony)
398
+ redis = Redis.new(driver: :hiredis)
459
399
  ```
460
400
 
461
401
  ## Testing
@@ -480,11 +420,11 @@ client and evangelized Redis in Rubyland. Thank you, Ezra.
480
420
  requests.
481
421
 
482
422
 
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
423
+ [rdoc-master-image]: https://img.shields.io/badge/docs-rdoc.info-blue.svg
424
+ [rdoc-master-link]: https://rubydoc.info/github/redis/redis-rb
425
+ [redis-commands]: https://redis.io/commands
426
+ [redis-home]: https://redis.io
427
+ [redis-url]: https://www.iana.org/assignments/uri-schemes/prov/redis
428
+ [gh-actions-image]: https://github.com/redis/redis-rb/workflows/Test/badge.svg
429
+ [gh-actions-link]: https://github.com/redis/redis-rb/actions
430
+ [rubydoc]: https://rubydoc.info/gems/redis