hiredis-client 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 002d836b8dec0059c6dd1bfe640f613594b34bb625a724b1a72183e321ebc98f
-  data.tar.gz: 96ea371a99e2091712fb01366f00bff21398f0e08039b573d677c8157ef41af6
+  metadata.gz: ba60e75acf78441a3ee79cc33c7dd02be25481a229e6c3a697f6595864da50f5
+  data.tar.gz: 8e850b60219abce73e320a42b610fadfec522ab0f926c429a98f6c51dcfd862f
 SHA512:
-  metadata.gz: fc7b1a377d1531936f3456ca54dfe07d99e0a9e7c7adb72cfbdd4126ea1ca0f8ce206ded1338a78f6e43ebcaa5b976a08bdf0849a976cf57690ae61da4b5bd39
-  data.tar.gz: 4ee028ab34699d2301a8bd6b23ae02c9056ab1b049548a945a9a83b0a55c5eb3dcd33472fefc83d125be451709a7a5bfb722f7d9cca64e507213e7fe2d234d96
+  metadata.gz: 86f117da17118c442f127d11eec64d9dea91fb3da1070a111e2be1611815056e4443bcc2904d8e709bd3a4095e1704f9c32a47fb6a09688670c9f4d9221f4635
+  data.tar.gz: fa1896db0cf13d0d33ad812659f381968de920e1516fc05aa1467e1c302fd958b3fbfa9919171f6bdaff63a44e8d21c13de9fb8efd1b56524d6f84d1961d865a

data/ext/redis_client/hiredis/hiredis_connection.c

@@ -31,6 +31,7 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "ruby.h"
+#include "ruby/thread.h"
 #include "ruby/encoding.h"
 #include <errno.h>
 #include <sys/socket.h>
@@ -45,8 +46,8 @@ static inline VALUE rb_hash_new_capa(long capa)
 }
 #endif
 
-static VALUE rb_cSet, rb_eRedisClientCommandError, rb_eRedisClientConnectionError;
-static VALUE rb_eRedisClientConnectTimeoutError, rb_eRedisClientReadTimeoutError, rb_eRedisClientWriteTimeoutError;
+static VALUE rb_eRedisClientCommandError, rb_eRedisClientConnectionError, rb_eRedisClientCannotConnectError, rb_eRedisClientProtocolError;
+static VALUE rb_eRedisClientReadTimeoutError, rb_eRedisClientWriteTimeoutError;
 static ID id_parse, id_add, id_new;
 
 typedef struct {
@@ -150,6 +151,12 @@ static void *reply_append(const redisReadTask *task, VALUE value) {
 }
 
 static void *reply_create_string(const redisReadTask *task, char *cstr, size_t len) {
+    if (len >= 4 && task->type == REDIS_REPLY_VERB) {
+        // Skip 4 bytes of verbatim type header.
+        cstr += 4;
+        len -= 4;
+    }
+
     VALUE string = rb_external_str_new(cstr, len);
     if (rb_enc_str_coderange(string) == ENC_CODERANGE_BROKEN) {
         rb_enc_associate(string, rb_ascii8bit_encoding());
@@ -170,14 +177,12 @@ static void *reply_create_array(const redisReadTask *task, size_t elements) {
     switch (task->type) {
         case REDIS_REPLY_PUSH:
         case REDIS_REPLY_ARRAY:
+        case REDIS_REPLY_SET:
             value = rb_ary_new_capa(elements);
             break;
         case REDIS_REPLY_MAP:
             value = rb_hash_new_capa(elements / 2);
             break;
-        case REDIS_REPLY_SET:
-            value = rb_funcallv(rb_cSet, id_new, 0, NULL);
-            break;
         default:
             rb_bug("[hiredis] Unexpected create array type %d", task->parent->type);
             break;
@@ -325,6 +330,8 @@ static inline void redis_raise_error_and_disconnect(redisContext *context, VALUE
     case REDIS_ERR_IO:
         rb_sys_fail(0);
         break;
+    case REDIS_ERR_PROTOCOL:
+        rb_raise(rb_eRedisClientProtocolError, "%s", errstr);
     default:
         /* Raise something else */
         rb_raise(rb_eRedisClientConnectionError, "%s", errstr);
@@ -420,7 +427,7 @@ 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 (context->err) {
-        redis_raise_error_and_disconnect(context, rb_eRedisClientConnectTimeoutError);
+        redis_raise_error_and_disconnect(context, rb_eRedisClientCannotConnectError);
     }
 
     int writable = 0;
@@ -429,23 +436,23 @@ static VALUE hiredis_connect_finish(hiredis_connection_t *connection, redisConte
 
     /* Wait for socket to become writable */
     if (hiredis_wait_writable(context->fd, &connection->connect_timeout, &writable) < 0) {
-        redis_raise_error_and_disconnect(context, rb_eRedisClientConnectTimeoutError);
+        redis_raise_error_and_disconnect(context, rb_eRedisClientCannotConnectError);
     }
 
     if (!writable) {
         errno = ETIMEDOUT;
-        redis_raise_error_and_disconnect(context, rb_eRedisClientConnectTimeoutError);
+        redis_raise_error_and_disconnect(context, rb_eRedisClientCannotConnectError);
     }
 
     /* Check for socket error */
     if (getsockopt(context->fd, SOL_SOCKET, SO_ERROR, &optval, &optlen) < 0) {
         context->err = REDIS_ERR_IO;
-        redis_raise_error_and_disconnect(context, rb_eRedisClientConnectTimeoutError);
+        redis_raise_error_and_disconnect(context, rb_eRedisClientCannotConnectError);
     }
 
     if (optval) {
         errno = optval;
-        redis_raise_error_and_disconnect(context, rb_eRedisClientConnectTimeoutError);
+        redis_raise_error_and_disconnect(context, rb_eRedisClientCannotConnectError);
     }
 
     context->reader->fn = &reply_functions;
@@ -477,7 +484,7 @@ static VALUE hiredis_init_ssl(VALUE self, VALUE ssl_param) {
     SSL_CONTEXT(ssl_param, ssl_context)
 
     if (redisInitiateSSLWithContext(connection->context, ssl_context->context) != REDIS_OK) {
-        hiredis_raise_error_and_disconnect(connection, rb_eRedisClientConnectTimeoutError);
+        hiredis_raise_error_and_disconnect(connection, rb_eRedisClientCannotConnectError);
     }
 
     redisSSL *redis_ssl = redisGetSSLSocket(connection->context);
@@ -485,15 +492,15 @@ static VALUE hiredis_init_ssl(VALUE self, VALUE ssl_param) {
     if (redis_ssl->wantRead) {
         int readable = 0;
         if (hiredis_wait_readable(connection->context->fd, &connection->connect_timeout, &readable) < 0) {
-            hiredis_raise_error_and_disconnect(connection, rb_eRedisClientConnectTimeoutError);
+            hiredis_raise_error_and_disconnect(connection, rb_eRedisClientCannotConnectError);
         }
         if (!readable) {
             errno = EAGAIN;
-            hiredis_raise_error_and_disconnect(connection, rb_eRedisClientConnectTimeoutError);
+            hiredis_raise_error_and_disconnect(connection, rb_eRedisClientCannotConnectError);
         }
 
         if (redisInitiateSSLContinue(connection->context) != REDIS_OK) {
-            hiredis_raise_error_and_disconnect(connection, rb_eRedisClientConnectTimeoutError);
+            hiredis_raise_error_and_disconnect(connection, rb_eRedisClientCannotConnectError);
         };
     }
 
@@ -530,6 +537,44 @@ 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);
@@ -537,7 +582,7 @@ static VALUE hiredis_flush(VALUE self) {
     int wdone = 0;
     while (!wdone) {
         errno = 0;
-        if (redisBufferWrite(connection->context, &wdone) == REDIS_ERR) {
+        if (hiredis_buffer_write_nogvl(connection->context, &wdone) == REDIS_ERR) {
             if (errno == EAGAIN) {
                 int writable = 0;
 
@@ -573,7 +618,7 @@ static int hiredis_read_internal(hiredis_connection_t *connection, VALUE *reply)
         while (!wdone) {
             errno = 0;
 
-            if (redisBufferWrite(connection->context, &wdone) == REDIS_ERR) {
+            if (hiredis_buffer_write_nogvl(connection->context, &wdone) == REDIS_ERR) {
                 /* Socket error */
                 return -1;
             }
@@ -596,7 +641,7 @@ static int hiredis_read_internal(hiredis_connection_t *connection, VALUE *reply)
         while (redis_reply == NULL) {
             errno = 0;
 
-            if (redisBufferRead(connection->context) == REDIS_ERR) {
+            if (hiredis_buffer_read_nogvl(connection->context) == REDIS_ERR) {
                 /* Socket error */
                 return -1;
             }
@@ -665,9 +710,6 @@ void Init_hiredis_connection(void) {
     id_add = rb_intern("add");
     id_new = rb_intern("new");
 
-    rb_cSet = rb_const_get(rb_cObject, rb_intern("Set"));
-    rb_global_variable(&rb_cSet);
-
     VALUE rb_cRedisClient = rb_const_get(rb_cObject, rb_intern("RedisClient"));
 
     rb_eRedisClientCommandError = rb_const_get(rb_cRedisClient, rb_intern("CommandError"));
@@ -676,8 +718,11 @@ void Init_hiredis_connection(void) {
     rb_eRedisClientConnectionError = rb_const_get(rb_cRedisClient, rb_intern("ConnectionError"));
     rb_global_variable(&rb_eRedisClientConnectionError);
 
-    rb_eRedisClientConnectTimeoutError = rb_const_get(rb_cRedisClient, rb_intern("ConnectTimeoutError"));
-    rb_global_variable(&rb_eRedisClientConnectTimeoutError);
+    rb_eRedisClientCannotConnectError = rb_const_get(rb_cRedisClient, rb_intern("CannotConnectError"));
+    rb_global_variable(&rb_eRedisClientCannotConnectError);
+
+    rb_eRedisClientProtocolError = rb_const_get(rb_cRedisClient, rb_intern("ProtocolError"));
+    rb_global_variable(&rb_eRedisClientProtocolError);
 
     rb_eRedisClientReadTimeoutError = rb_const_get(rb_cRedisClient, rb_intern("ReadTimeoutError"));
     rb_global_variable(&rb_eRedisClientReadTimeoutError);

data/lib/redis_client/hiredis_connection.rb

@@ -34,7 +34,11 @@ class RedisClient
       self.write_timeout = write_timeout
 
       if config.path
-        connect_unix(config.path)
+        begin
+          connect_unix(config.path)
+        rescue SystemCallError => error
+          raise CannotConnectError, error.message, error.backtrace
+        end
       else
         connect_tcp(config.host, config.port)
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hiredis-client
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Jean Boussier
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-06 00:00:00.000000000 Z
+date: 2022-08-16 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.4.0
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.6.0
 description:
 email:
 - jean.boussier@gmail.com