Persistent connections for cluster and possible crash fix

Author: michael-grunder

cluster_library.c

@@ -650,7 +650,7 @@ cluster_node_create(redisCluster *c, char *host, size_t host_len,
 
     // Attach socket
     node->sock = redis_sock_create(host, host_len, port, c->timeout,
-        0, NULL, 0, 1);
+        c->persistent, NULL, 0, 1);
 
     return node;
 }
@@ -799,7 +799,7 @@ static void ht_free_node(void *data) {
 
 /* Construct a redisCluster object */
 PHP_REDIS_API redisCluster *cluster_create(double timeout, double read_timeout,
-                                           int failover)
+                                           int failover, int persistent)
 {
     redisCluster *c;
 
@@ -813,6 +813,7 @@ PHP_REDIS_API redisCluster *cluster_create(double timeout, double read_timeout,
     c->timeout = timeout;
     c->read_timeout = read_timeout;
     c->failover = failover;
+    c->persistent = persistent;
 
     /* Set up our waitms based on timeout */
     c->waitms  = (long)(1000 * timeout);
@@ -877,7 +878,8 @@ cluster_init_seeds(redisCluster *cluster, HashTable *ht_seeds) {
 
         // Allocate a structure for this seed
         redis_sock = redis_sock_create(str, psep-str,
-            (unsigned short)atoi(psep+1),cluster->timeout,0,NULL,0,0);
+            (unsigned short)atoi(psep+1), cluster->timeout,
+            cluster->persistent, NULL, 0, 0);
 
         // Index this seed by host/port
         key_len = snprintf(key, sizeof(key), "%s:%u", redis_sock->host,

cluster_library.h

@@ -180,6 +180,9 @@ typedef struct redisCluster {
     double timeout;
     double read_timeout;
 
+    /* Are we using persistent connections */
+    int persistent;
+
     /* How long in milliseconds should we wait when being bounced around */
     long waitms;
 
@@ -359,7 +362,7 @@ PHP_REDIS_API int cluster_send_slot(redisCluster *c, short slot, char *cmd,
     int cmd_len, REDIS_REPLY_TYPE rtype TSRMLS_DC);
 
 PHP_REDIS_API redisCluster *cluster_create(double timeout, double read_timeout,
-    int failover);
+    int failover, int persistent);
 PHP_REDIS_API void cluster_free(redisCluster *c);
 PHP_REDIS_API int cluster_init_seeds(redisCluster *c, HashTable *ht_seeds);
 PHP_REDIS_API int cluster_map_keyspace(redisCluster *c TSRMLS_DC);

redis_cluster.c

@@ -264,7 +264,6 @@ zend_object_value
 create_cluster_context(zend_class_entry *class_type TSRMLS_DC) {
     zend_object_value retval;
     redisCluster *cluster;
-    struct timeval t1;
 
     // Allocate our actual struct
     cluster = emalloc(sizeof(redisCluster));
@@ -333,7 +332,7 @@ void free_cluster_context(void *object TSRMLS_DC) {
 
 /* Attempt to connect to a Redis cluster provided seeds and timeout options */
 void redis_cluster_init(redisCluster *c, HashTable *ht_seeds, double timeout,
-                        double read_timeout TSRMLS_DC)
+                        double read_timeout, int persistent TSRMLS_DC)
 {
     // Validate timeout
     if(timeout < 0L || timeout > INT_MAX) {
@@ -357,6 +356,9 @@ void redis_cluster_init(redisCluster *c, HashTable *ht_seeds, double timeout,
      * socket type operations */
     c->timeout = timeout;
     c->read_timeout = read_timeout;
+    
+    /* Set our option to use or not use persistent connections */
+    c->persistent = persistent;
 
     /* Calculate the number of miliseconds we will wait when bouncing around,
      * (e.g. a node goes down), which is not the same as a standard timeout. */
@@ -371,9 +373,10 @@ void redis_cluster_init(redisCluster *c, HashTable *ht_seeds, double timeout,
 
 /* Attempt to load a named cluster configured in php.ini */
 void redis_cluster_load(redisCluster *c, char *name, int name_len TSRMLS_DC) {
-    zval *z_seeds, *z_timeout, *z_read_timeout, **z_value;
+    zval *z_seeds, *z_timeout, *z_read_timeout, *z_persistent, **z_value;
     char *iptr;
     double timeout=0, read_timeout=0;
+    int persistent = 0;
     HashTable *ht_seeds = NULL;
 
     /* Seeds */
@@ -415,8 +418,21 @@ void redis_cluster_load(redisCluster *c, char *name, int name_len TSRMLS_DC) {
         }
     }
 
+    /* Persistent connections */
+    MAKE_STD_ZVAL(z_persistent);
+    array_init(z_persistent);
+    iptr = estrdup(INI_STR("redis.clusters.persistent"));
+    sapi_module.treat_data(PARSE_STRING, iptr, z_persistent TSRMLS_CC);
+    if (zend_hash_find(Z_ARRVAL_P(z_persistent), name, name_len+1, (void**)&z_value) != FAILURE) {
+        if (Z_TYPE_PP(z_value) == IS_STRING) {
+            persistent = atoi(Z_STRVAL_PP(z_value));
+        } else if (Z_TYPE_PP(z_value) == IS_LONG) {
+            persistent = Z_LVAL_PP(z_value);
+        }
+    }
+
     /* Attempt to create/connect to the cluster */
-    redis_cluster_init(c, ht_seeds, timeout, read_timeout TSRMLS_CC);    
+    redis_cluster_init(c, ht_seeds, timeout, read_timeout, persistent TSRMLS_CC);    
 
     /* Clean up our arrays */
     zval_dtor(z_seeds);
@@ -437,13 +453,14 @@ PHP_METHOD(RedisCluster, __construct) {
     char *name;
     long name_len;
     double timeout = 0.0, read_timeout = 0.0;
+    zend_bool persistent = 0;
     redisCluster *context = GET_CONTEXT();
 
     // Parse arguments
     if(zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(),
-                                    "Os|add", &object, redis_cluster_ce, &name,
+                                    "Os|addb", &object, redis_cluster_ce, &name,
                                     &name_len, &z_seeds, &timeout,
-                                    &read_timeout)==FAILURE)
+                                    &read_timeout, &persistent)==FAILURE)
     {
         RETURN_FALSE;
     }
@@ -458,8 +475,8 @@ PHP_METHOD(RedisCluster, __construct) {
     /* If we've been passed only one argument, the user is attempting to connect
      * to a named cluster, stored in php.ini, otherwise we'll need manual seeds */
     if (ZEND_NUM_ARGS() > 1) {
-        redis_cluster_init(context, Z_ARRVAL_P(z_seeds), timeout, read_timeout
-            TSRMLS_CC);
+        redis_cluster_init(context, Z_ARRVAL_P(z_seeds), timeout, read_timeout,
+            persistent TSRMLS_CC);
     } else {
         redis_cluster_load(context, name, name_len TSRMLS_CC);
     }

redis_session.c

@@ -497,6 +497,7 @@ PS_OPEN_FUNC(rediscluster) {
     zval *z_conf, **z_val;
     HashTable *ht_conf, *ht_seeds;
     double timeout = 0, read_timeout = 0;
+    int persistent = 0;
     int retval, prefix_len, failover = REDIS_FAILOVER_NONE;
     char *prefix;
 
@@ -554,7 +555,14 @@ PS_OPEN_FUNC(rediscluster) {
         }
     }
 
-    c = cluster_create(timeout, read_timeout, failover);
+    /* Check for persistent option */
+    if (zend_hash_find(ht_conf, "persistent", sizeof("persistent"), (void **)&z_val) == SUCCESS &&
+        Z_TYPE_PP(z_val) == IS_STRING)
+    {
+        persistent = atoi(z_val);
+    }
+
+    c = cluster_create(timeout, read_timeout, failover, persistent);
     if (!cluster_init_seeds(c, ht_seeds) && !cluster_map_keyspace(c TSRMLS_CC)) {
         /* Set up our prefix */
         c->flags->prefix = estrndup(prefix, prefix_len);
@@ -671,7 +679,6 @@ PS_DESTROY_FUNC(rediscluster) {
 
     /* Attempt to send command */
     if (cluster_send_command(c,slot,cmd,cmdlen TSRMLS_CC)<0 || c->err) {
-        if (reply) cluster_free_reply(reply, 1);
         efree(cmd);
         return FAILURE;
     }