hiredis-client 0.13.0 → 0.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc000cc925b26584a60d6a74360cf9b39db974e718c6be6af4f19f7e4ac77051
-  data.tar.gz: f54b30ef2a1310200d60d76e310a1ea750001affe145c0994a59e262934e6865
+  metadata.gz: 3506adf6e5b2e5da54f4fc75e762a0fd4f23b9bd9ea225a468b2ae96360d0273
+  data.tar.gz: 484b29d8fb080fad9076e71f1db9a1703b9b2a3a5ae173b6a5073d5abb2bfbe6
 SHA512:
-  metadata.gz: d386889884c0a22a1e44ed346f659aa8f95e74be3363ba891b2ac372efb3b02f18bc14e6ccbe347a6e6f3daae3d48cf376dcb10793272db96574233108157177
-  data.tar.gz: e5264e89206c6d5d723cc1b814867c0e9420ec1f904ca6596a23b840bcc2a0ffe3ae5e2ff9e1069e841eb61d3040d5e916a325a8bb1b325a6b7508261a2df224
+  metadata.gz: 3e238fe1e94a808f6c1966c8c2ce1136fa173594cfa824156199c3509b3b61c8b9f97a75336458edf7c50dcddc7a7d08833358a9f34bf64f141587fb1f19fa74
+  data.tar.gz: a6ddda3ab9d41f591cd82c1319fd43fc701cbb0c515768e0d940bc095fc69c69334bbf932c860ab37944a7f73e141a5e6b25fc4a2de454fb726f4dd199fadf48

data/ext/redis_client/hiredis/extconf.rb

@@ -3,6 +3,10 @@
 require "mkmf"
 
 class HiredisConnectionExtconf
+  def initialize(debug)
+    @debug = debug
+  end
+
   def configure
     if RUBY_ENGINE == "ruby" && !RUBY_PLATFORM.match?(/mswin/)
       configure_extension
@@ -18,12 +22,16 @@ class HiredisConnectionExtconf
     have_func("rb_hash_new_capa", "ruby.h")
 
     $CFLAGS = concat_flags($CFLAGS, "-I#{hiredis_dir}", "-std=c99", "-fvisibility=hidden")
-    $CFLAGS = if ENV["EXT_PEDANTIC"]
-      concat_flags($CFLAGS, "-Werror", "-g")
+    $CFLAGS = if @debug
+      concat_flags($CFLAGS, "-Werror", "-g", RbConfig::CONFIG["debugflags"])
     else
       concat_flags($CFLAGS, "-O3")
     end
 
+    if @debug
+      $CPPFLAGS = concat_flags($CPPFLAGS, "-DRUBY_DEBUG=1")
+    end
+
     append_cflags("-Wno-declaration-after-statement") # Older compilers
     append_cflags("-Wno-compound-token-split-by-macro") # Older rubies on macos
   end
@@ -33,7 +41,7 @@ class HiredisConnectionExtconf
       "USE_SSL" => 1,
       "CFLAGS" => concat_flags(ENV["CFLAGS"], "-fvisibility=hidden"),
     }
-    env["OPTIMIZATION"] = "-g" if ENV["EXT_PEDANTIC"]
+    env["OPTIMIZATION"] = "-g" if @debug
 
     env = configure_openssl(env)
 
@@ -97,4 +105,4 @@ class HiredisConnectionExtconf
   end
 end
 
-HiredisConnectionExtconf.new.configure
+HiredisConnectionExtconf.new(ENV["EXT_PEDANTIC"]).configure

data/ext/redis_client/hiredis/hiredis_connection.c

@@ -37,8 +37,13 @@
 #include <sys/socket.h>
 #include <stdbool.h>
 #include "hiredis.h"
+#include "net.h"
 #include "hiredis_ssl.h"
 
+#if !defined(RUBY_ASSERT)
+#  define RUBY_ASSERT(condition) ((void)0)
+#endif
+
 #if !defined(HAVE_RB_HASH_NEW_CAPA)
 static inline VALUE rb_hash_new_capa(long capa)
 {
@@ -46,6 +51,16 @@ static inline VALUE rb_hash_new_capa(long capa)
 }
 #endif
 
+static void redis_set_error(redisContext *c, int type, const char *str) {
+    size_t len;
+
+    c->err = type;
+    len = strlen(str);
+    len = len < (sizeof(c->errstr) - 1) ? len : (sizeof(c->errstr) - 1);
+    memcpy(c->errstr, str, len);
+    c->errstr[len] = '\0';
+}
+
 static VALUE rb_eRedisClientCommandError, rb_eRedisClientConnectionError, rb_eRedisClientCannotConnectError, rb_eRedisClientProtocolError;
 static VALUE rb_eRedisClientReadTimeoutError, rb_eRedisClientWriteTimeoutError;
 static VALUE Redis_Qfalse;
@@ -60,11 +75,11 @@ typedef struct {
 #define SSL_CONTEXT(from, name) \
     hiredis_ssl_context_t *name = NULL; \
     TypedData_Get_Struct(from, hiredis_ssl_context_t, &hiredis_ssl_context_data_type, name); \
-    if(name == NULL) { \
+    if (name == NULL) { \
         rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be."); \
     }
 
-void hiredis_ssl_context_free(void *ptr) {
+static void hiredis_ssl_context_free(void *ptr) {
     hiredis_ssl_context_t *ssl_context = (hiredis_ssl_context_t *)ptr;
     if (ssl_context->context) {
         redisFreeSSLContext(ssl_context->context);
@@ -84,9 +99,6 @@ static const rb_data_type_t hiredis_ssl_context_data_type = {
         .dmark = NULL,
         .dfree = hiredis_ssl_context_free,
         .dsize = hiredis_ssl_context_memsize,
-#ifdef HAS_GC_COMPACT
-        .dcompact = NULL
-#endif
     },
     .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
@@ -120,10 +132,18 @@ static VALUE hiredis_ssl_context_init(VALUE self, VALUE ca_file, VALUE ca_path,
     return Qnil;
 }
 
+typedef struct {
+    VALUE stack;
+    int *task_index;
+} hiredis_reader_state_t;
+
 static void *reply_append(const redisReadTask *task, VALUE value) {
-    if (task && task->parent) {
-        VALUE parent = (VALUE)task->parent->obj;
+    hiredis_reader_state_t *state = (hiredis_reader_state_t *)task->privdata;
+    int task_index = *state->task_index;
 
+    if (task->parent) {
+        RUBY_ASSERT(task_index > 0);
+        VALUE parent = rb_ary_entry(state->stack, task_index - 1);
         switch (task->parent->type) {
             case REDIS_REPLY_ARRAY:
             case REDIS_REPLY_SET:
@@ -132,11 +152,10 @@ static void *reply_append(const redisReadTask *task, VALUE value) {
                 break;
             case REDIS_REPLY_MAP:
                 if (task->idx % 2) {
-                    VALUE key = (VALUE)task->parent->privdata;
-                    task->parent->privdata = NULL;
+                    VALUE key = rb_ary_pop(state->stack);
                     rb_hash_aset(parent, key, value);
                 } else {
-                    task->parent->privdata = (void*)value;
+                    rb_ary_push(state->stack, value);
                 }
                 break;
             default:
@@ -144,6 +163,7 @@ static void *reply_append(const redisReadTask *task, VALUE value) {
                 break;
         }
     }
+    rb_ary_store(state->stack, task_index, value);
     return (void*)value;
 }
 
@@ -219,13 +239,78 @@ static redisReplyObjectFunctions reply_functions = {
     reply_free,
 };
 
+typedef struct {
+    redisContext *context;
+    int return_value;
+} hiredis_buffer_read_args_t;
+
+static void *hiredis_buffer_read_safe(void *_args) {
+    hiredis_buffer_read_args_t *args = _args;
+    args->return_value = redisBufferRead(args->context);
+    return NULL;
+}
+static int hiredis_buffer_read_nogvl(redisContext *context) {
+    hiredis_buffer_read_args_t args = {
+        .context = context,
+    };
+    rb_thread_call_without_gvl(hiredis_buffer_read_safe, &args, RUBY_UBF_IO, 0);
+    return args.return_value;
+}
+
+typedef struct {
+    redisContext *context;
+    int *done;
+    int return_value;
+} hiredis_buffer_write_args_t;
+
+static void *hiredis_buffer_write_safe(void *_args) {
+    hiredis_buffer_write_args_t *args = _args;
+    args->return_value = redisBufferWrite(args->context, args->done);
+    return NULL;
+}
+static int hiredis_buffer_write_nogvl(redisContext *context, int *done) {
+    hiredis_buffer_write_args_t args = {
+        .context = context,
+        .done = done,
+    };
+    rb_thread_call_without_gvl(hiredis_buffer_write_safe, &args, RUBY_UBF_IO, 0);
+    return args.return_value;
+}
+
 #define CONNECTION(from, name) \
     hiredis_connection_t *name = NULL; \
     TypedData_Get_Struct(from, hiredis_connection_t, &hiredis_connection_data_type, name); \
-    if(name == NULL) { \
+    if (name == NULL) { \
         rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be."); \
     }
 
+typedef struct {
+    redisContext *context;
+    int return_value;
+} hiredis_reconnect_args_t;
+
+static void *hiredis_reconnect_safe(void *_args) {
+    hiredis_reconnect_args_t *args = _args;
+    args->return_value = redisReconnect(args->context);
+    return NULL;
+}
+
+static int hiredis_reconnect_nogvl(redisContext *context) {
+    hiredis_reconnect_args_t args = {
+        .context = context,
+        .return_value = 0
+    };
+    rb_thread_call_without_gvl(hiredis_reconnect_safe, &args, RUBY_UBF_IO, 0);
+    return args.return_value;
+}
+
+static void *hiredis_connect_with_options_safe(void *options) {
+    return (void *)redisConnectWithOptions(options);
+}
+
+static redisContext *hiredis_connect_with_options_nogvl(redisOptions *options) {
+    return (redisContext *)rb_thread_call_without_gvl(hiredis_connect_with_options_safe, options, RUBY_UBF_IO, 0);
+}
 
 typedef struct {
     redisContext *context;
@@ -234,42 +319,19 @@ typedef struct {
     struct timeval write_timeout;
 } hiredis_connection_t;
 
-void hiredis_connection_mark_task(redisReadTask *task) {
-    while (task) {
-        if (task->obj) { rb_gc_mark((VALUE)task->obj); }
-        if (task->privdata) { rb_gc_mark((VALUE)task->privdata); }
-        task = task->parent;
-    }
-}
-
-void hiredis_connection_mark(void *ptr) {
-    hiredis_connection_t *connection = ptr;
-    if (connection->context) {
-        redisReader *reader = connection->context->reader;
-        for (int index = 0; index < reader->tasks; index++) {
-            hiredis_connection_mark_task(reader->task[index]);
-        }
-    }
-}
-void hiredis_connection_free(void *ptr) {
+static void hiredis_connection_free(void *ptr) {
     hiredis_connection_t *connection = ptr;
     if (connection) {
          if (connection->context) {
-             redisFree(connection->context);
+           // redisFree may calls close() if we're still connected, but
+           // it shoudln't be considered a "blocking" call given we don't
+           // use any socket option that may make it a blocking operation.
+           redisFree(connection->context);
          }
          xfree(connection);
     }
 }
 
-static size_t hiredis_connection_task_memsize(redisReadTask *task) {
-    size_t size = 0;
-    while (task) {
-        size += sizeof(redisReadTask);
-        task = task->parent;
-    }
-    return size;
-}
-
 static size_t hiredis_connection_memsize(const void *ptr) {
     hiredis_connection_t *connection = (hiredis_connection_t *)ptr;
 
@@ -281,10 +343,7 @@ static size_t hiredis_connection_memsize(const void *ptr) {
             redisReader *reader = connection->context->reader;
             size += sizeof(redisReader);
             size += reader->maxbuf;
-
-            for (int index = 0; index < reader->tasks; index++) {
-                size += hiredis_connection_task_memsize(reader->task[index]);
-            }
+            size += reader->tasks * sizeof(redisReadTask);
         }
     }
 
@@ -294,14 +353,11 @@ static size_t hiredis_connection_memsize(const void *ptr) {
 static const rb_data_type_t hiredis_connection_data_type = {
     .wrap_struct_name = "redis-client:hiredis_connection",
     .function = {
-        .dmark = hiredis_connection_mark,
+        .dmark = NULL,
         .dfree = hiredis_connection_free,
         .dsize = hiredis_connection_memsize,
-#ifdef HAS_GC_COMPACT
-        .dcompact = NULL
-#endif
     },
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static VALUE hiredis_alloc(VALUE klass) {
@@ -309,7 +365,7 @@ static VALUE hiredis_alloc(VALUE klass) {
     return TypedData_Make_Struct(klass, hiredis_connection_t, &hiredis_connection_data_type, connection);
 }
 
-void redis_set_io_error(redisContext *context, int err) {
+static void redis_set_io_error(redisContext *context, int err) {
     if (err) {
         errno = err;
     }
@@ -325,10 +381,10 @@ static inline void redis_raise_error_and_disconnect(redisContext *context, VALUE
     if (context->err) {
       strncpy(errstr, context->errstr, 128);
     }
-    redisFree(context);
+    redisNetClose(context);
 
     if (!err) {
-      rb_raise(timeout_error, "Unknown Error");
+        rb_raise(timeout_error, "Unknown Error (redis_raise_error_and_disconnect)");
     }
 
     // OpenSSL bug: The SSL_ERROR_SYSCALL with errno value of 0 indicates unexpected EOF from the peer.
@@ -437,6 +493,12 @@ static int hiredis_wait_writable(int fd, const struct timeval *timeout, int *iss
 }
 
 static VALUE hiredis_connect_finish(hiredis_connection_t *connection, redisContext *context) {
+    if (connection->context && connection->context != context) {
+        redisFree(context);
+        rb_raise(rb_eRuntimeError, "HiredisConnection is already connected, must be a bug");
+    }
+    connection->context = context;
+
     if (context->err) {
         redis_raise_error_and_disconnect(context, rb_eRedisClientCannotConnectError);
     }
@@ -470,34 +532,10 @@ static VALUE hiredis_connect_finish(hiredis_connection_t *connection, redisConte
 
     context->reader->fn = &reply_functions;
     redisSetPushCallback(context, NULL);
-    connection->context = context;
     return Qtrue;
 }
 
-static VALUE hiredis_connect_tcp(VALUE self, VALUE host, VALUE port) {
-    CONNECTION(self, connection);
-    if (connection->context) {
-        redisFree(connection->context);
-        connection->context = NULL;
-    }
-    redisContext *context = redisConnectNonBlock(StringValuePtr(host), NUM2INT(port));
-    if (context) {
-        redisEnableKeepAlive(context);
-    }
-    return hiredis_connect_finish(connection, context);
-}
-
-static VALUE hiredis_connect_unix(VALUE self, VALUE path) {
-    CONNECTION(self, connection);
-    if (connection->context) {
-        redisFree(connection->context);
-        connection->context = NULL;
-    }
-    return hiredis_connect_finish(connection, redisConnectUnixNonBlock(StringValuePtr(path)));
-}
-
-static VALUE hiredis_init_ssl(VALUE self, VALUE ssl_param) {
-    CONNECTION(self, connection);
+static void hiredis_init_ssl(hiredis_connection_t *connection, VALUE ssl_param) {
     SSL_CONTEXT(ssl_param, ssl_context)
 
     if (redisInitiateSSLWithContext(connection->context, ssl_context->context) != REDIS_OK) {
@@ -505,7 +543,7 @@ static VALUE hiredis_init_ssl(VALUE self, VALUE ssl_param) {
     }
 
     redisSSL *redis_ssl = redisGetSSLSocket(connection->context);
- 
+
     if (redis_ssl->wantRead) {
         int readable = 0;
         if (hiredis_wait_readable(connection->context->fd, &connection->connect_timeout, &readable) < 0) {
@@ -513,21 +551,81 @@ static VALUE hiredis_init_ssl(VALUE self, VALUE ssl_param) {
         }
         if (!readable) {
             errno = EAGAIN;
-            hiredis_raise_error_and_disconnect(connection, rb_eRedisClientCannotConnectError);
+            redis_set_error(connection->context, REDIS_ERR_IO, "SSL Connection Timeout");
+            hiredis_raise_error_and_disconnect(connection, rb_eRedisClientReadTimeoutError);
         }
 
         if (redisInitiateSSLContinue(connection->context) != REDIS_OK) {
             hiredis_raise_error_and_disconnect(connection, rb_eRedisClientCannotConnectError);
         };
     }
+}
 
-    return Qtrue;
+static VALUE hiredis_connect(VALUE self, VALUE path, VALUE host, VALUE port, VALUE ssl_param) {
+    CONNECTION(self, connection);
+    if (connection->context) {
+        rb_raise(rb_eRuntimeError, "HiredisConnection is already connected, must be a bug");
+    }
+
+    redisOptions options = {
+        .connect_timeout = &connection->connect_timeout,
+        .options = REDIS_OPT_NONBLOCK
+    };
+    if (RTEST(path)) {
+        REDIS_OPTIONS_SET_UNIX(&options, StringValuePtr(path));
+    } else {
+        REDIS_OPTIONS_SET_TCP(&options, StringValuePtr(host), NUM2INT(port));
+    }
+
+    redisContext *context = hiredis_connect_with_options_nogvl(&options);
+    if (context && !RTEST(path)) {
+        redisEnableKeepAlive(context);
+    }
+
+    VALUE success = hiredis_connect_finish(connection, context);
+
+    if (RTEST(success) && !NIL_P(ssl_param)) {
+        hiredis_init_ssl(connection, ssl_param);
+    }
+
+    return success;
+}
+
+static VALUE hiredis_reconnect(VALUE self, VALUE unix, VALUE ssl_param) {
+    CONNECTION(self, connection);
+    if (!connection->context) {
+        return Qfalse;
+    }
+
+    hiredis_reconnect_nogvl(connection->context);
+
+    VALUE success = hiredis_connect_finish(connection, connection->context);
+
+    if (RTEST(success)) {
+        if (!RTEST(unix)) {
+            redisEnableKeepAlive(connection->context);
+        }
+
+        if (RTEST(ssl_param)) {
+            hiredis_init_ssl(connection, ssl_param);
+        }
+    }
+
+    return success;
 }
 
 static VALUE hiredis_connected_p(VALUE self) {
     CONNECTION(self, connection);
 
-    return connection->context ? Qtrue : Qfalse;
+    if (!connection->context) {
+        return Qfalse;
+    }
+
+    if (connection->context->fd == REDIS_INVALID_FD) {
+        return Qfalse;
+    }
+
+    return Qtrue;
 }
 
 static VALUE hiredis_write(VALUE self, VALUE command) {
@@ -554,44 +652,6 @@ static VALUE hiredis_write(VALUE self, VALUE command) {
     return Qnil;
 }
 
-typedef struct {
-    redisContext *context;
-    int return_value;
-} hiredis_buffer_read_args_t;
-
-void *hiredis_buffer_read_safe(void *_args) {
-    hiredis_buffer_read_args_t *args = _args;
-    args->return_value = redisBufferRead(args->context);
-    return NULL;
-}
-int hiredis_buffer_read_nogvl(redisContext *context) {
-    hiredis_buffer_read_args_t args = {
-        .context = context,
-    };
-    rb_thread_call_without_gvl(hiredis_buffer_read_safe, &args, RUBY_UBF_IO, 0);
-    return args.return_value;
-}
-
-typedef struct {
-    redisContext *context;
-    int *done;
-    int return_value;
-} hiredis_buffer_write_args_t;
-
-void *hiredis_buffer_write_safe(void *_args) {
-    hiredis_buffer_write_args_t *args = _args;
-    args->return_value = redisBufferWrite(args->context, args->done);
-    return NULL;
-}
-int hiredis_buffer_write_nogvl(redisContext *context, int *done) {
-    hiredis_buffer_write_args_t args = {
-        .context = context,
-        .done = done,
-    };
-    rb_thread_call_without_gvl(hiredis_buffer_write_safe, &args, RUBY_UBF_IO, 0);
-    return args.return_value;
-}
-
 static VALUE hiredis_flush(VALUE self) {
     CONNECTION(self, connection);
     ENSURE_CONNECTED(connection);
@@ -628,6 +688,16 @@ static int hiredis_read_internal(hiredis_connection_t *connection, VALUE *reply)
     void *redis_reply = NULL;
     int wdone = 0;
 
+    // This struct being on the stack, the GC won't move nor collect that `stack` RArray.
+    // We use that to avoid having to have a `mark` function with write barriers.
+    // Not that it would be too hard, but if we mark the response objects, we'll likely end up
+    // promoting them to the old generation which isn't desirable.
+    hiredis_reader_state_t reader_state = {
+        .stack = rb_ary_new(),
+        .task_index = &connection->context->reader->ridx,
+    };
+    connection->context->reader->privdata = &reader_state;
+
     /* Try to read pending replies */
     if (redisGetReplyFromReader(connection->context, &redis_reply) == REDIS_ERR) {
         return HIREDIS_FATAL_CONNECTION_ERROR; // Protocol error
@@ -722,18 +792,15 @@ static VALUE hiredis_read(VALUE self) {
 static VALUE hiredis_close(VALUE self) {
     CONNECTION(self, connection);
     if (connection->context) {
-        redisFree(connection->context);
-        connection->context = NULL;
+        redisNetClose(connection->context);
     }
     return Qnil;
 }
 
 RUBY_FUNC_EXPORTED void Init_hiredis_connection(void) {
-#ifdef RUBY_ASSERT
-        // Qfalse == NULL, so we can't return Qfalse in `reply_create_bool()`
-        RUBY_ASSERT((void *)Qfalse == NULL);
-        RUBY_ASSERT((void *)Qnil != NULL);
-#endif
+    // Qfalse == NULL, so we can't return Qfalse in `reply_create_bool()`
+    RUBY_ASSERT((void *)Qfalse == NULL);
+    RUBY_ASSERT((void *)Qnil != NULL);
 
     redisInitOpenSSL();
 
@@ -768,15 +835,14 @@ RUBY_FUNC_EXPORTED void Init_hiredis_connection(void) {
     rb_define_private_method(rb_cHiredisConnection, "read_timeout_us=", hiredis_set_read_timeout, 1);
     rb_define_private_method(rb_cHiredisConnection, "write_timeout_us=", hiredis_set_write_timeout, 1);
 
-    rb_define_private_method(rb_cHiredisConnection, "connect_tcp", hiredis_connect_tcp, 2);
-    rb_define_private_method(rb_cHiredisConnection, "connect_unix", hiredis_connect_unix, 1);
-    rb_define_private_method(rb_cHiredisConnection, "init_ssl", hiredis_init_ssl, 1);
+    rb_define_private_method(rb_cHiredisConnection, "_connect", hiredis_connect, 4);
+    rb_define_private_method(rb_cHiredisConnection, "_reconnect", hiredis_reconnect, 2);
     rb_define_method(rb_cHiredisConnection, "connected?", hiredis_connected_p, 0);
 
     rb_define_private_method(rb_cHiredisConnection, "_write", hiredis_write, 1);
     rb_define_private_method(rb_cHiredisConnection, "_read", hiredis_read, 0);
     rb_define_private_method(rb_cHiredisConnection, "flush", hiredis_flush, 0);
-    rb_define_method(rb_cHiredisConnection, "close", hiredis_close, 0);
+    rb_define_private_method(rb_cHiredisConnection, "_close", hiredis_close, 0);
 
     VALUE rb_cHiredisSSLContext = rb_define_class_under(rb_cHiredisConnection, "SSLContext", rb_cObject);
     rb_define_alloc_func(rb_cHiredisSSLContext, hiredis_ssl_context_alloc);

data/lib/redis_client/hiredis_connection.rb

@@ -30,27 +30,32 @@ class RedisClient
 
     def initialize(config, connect_timeout:, read_timeout:, write_timeout:)
       super()
+      @config = config
       self.connect_timeout = connect_timeout
       self.read_timeout = read_timeout
       self.write_timeout = write_timeout
+      connect
+    end
 
-      if config.path
-        begin
-          connect_unix(config.path)
-        rescue SystemCallError => error
-          raise CannotConnectError, error.message, error.backtrace
-        end
-      else
-        begin
-          connect_tcp(config.host, config.port)
-        rescue SystemCallError => error
-          error_code = error.class.name.split("::").last
-          raise CannotConnectError, "Failed to connect to #{config.host}:#{config.port} (#{error_code})"
-        end
+    def close
+      _close
+      super
+    end
+
+    def reconnect
+      reconnected = begin
+        _reconnect(@config.path, @config.ssl_context)
+      rescue SystemCallError => error
+        host = @config.path || "#{@config.host}:#{@config.port}"
+        error_code = error.class.name.split("::").last
+        raise CannotConnectError, "Failed to reconnect to #{host} (#{error_code})"
       end
 
-      if config.ssl
-        init_ssl(config.ssl_context)
+      if reconnected
+        true
+      else
+        # Reusing the hiredis connection didn't work let's create a fresh one
+        super
       end
     end
 
@@ -100,5 +105,15 @@ class RedisClient
     rescue SystemCallError, IOError => error
       raise ConnectionError, error.message
     end
+
+    private
+
+    def connect
+      _connect(@config.path, @config.host, @config.port, @config.ssl_context)
+    rescue SystemCallError => error
+      host = @config.path || "#{@config.host}:#{@config.port}"
+      error_code = error.class.name.split("::").last
+      raise CannotConnectError, "Failed to connect to #{host} (#{error_code})"
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hiredis-client
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.1
 platform: ruby
 authors:
 - Jean Boussier
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-28 00:00:00.000000000 Z
+date: 2023-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.14.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.14.1
 description:
 email:
 - jean.boussier@gmail.com