nginxtra 1.8.1.12 → 1.10.1.12

data/vendor/nginx/src/http/modules/ngx_http_upstream_hash_module.c

@@ -170,13 +170,16 @@ ngx_http_upstream_get_hash_peer(ngx_peer_connection_t *pc, void *data)
     uint32_t                      hash;
     ngx_int_t                     w;
     uintptr_t                     m;
-    ngx_uint_t                    i, n, p;
+    ngx_uint_t                    n, p;
     ngx_http_upstream_rr_peer_t  *peer;
 
     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
                    "get hash peer, try: %ui", pc->tries);
 
+    ngx_http_upstream_rr_peers_wlock(hp->rrp.peers);
+
     if (hp->tries > 20 || hp->rrp.peers->single) {
+        ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
         return hp->get_rr_peer(pc, &hp->rrp);
     }
 
@@ -208,20 +211,14 @@ ngx_http_upstream_get_hash_peer(ngx_peer_connection_t *pc, void *data)
         hp->hash += hash;
         hp->rehash++;
 
-        if (!hp->rrp.peers->weighted) {
-            p = hp->hash % hp->rrp.peers->number;
-
-        } else {
-            w = hp->hash % hp->rrp.peers->total_weight;
-
-            for (i = 0; i < hp->rrp.peers->number; i++) {
-                w -= hp->rrp.peers->peer[i].weight;
-                if (w < 0) {
-                    break;
-                }
-            }
+        w = hp->hash % hp->rrp.peers->total_weight;
+        peer = hp->rrp.peers->peer;
+        p = 0;
 
-            p = i;
+        while (w >= peer->weight) {
+            w -= peer->weight;
+            peer = peer->next;
+            p++;
         }
 
         n = p / (8 * sizeof(uintptr_t));
@@ -234,8 +231,6 @@ ngx_http_upstream_get_hash_peer(ngx_peer_connection_t *pc, void *data)
         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
                        "get hash peer, value:%uD, peer:%ui", hp->hash, p);
 
-        peer = &hp->rrp.peers->peer[p];
-
         if (peer->down) {
             goto next;
         }
@@ -252,20 +247,25 @@ ngx_http_upstream_get_hash_peer(ngx_peer_connection_t *pc, void *data)
     next:
 
         if (++hp->tries > 20) {
+            ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
             return hp->get_rr_peer(pc, &hp->rrp);
         }
     }
 
-    hp->rrp.current = p;
+    hp->rrp.current = peer;
 
     pc->sockaddr = peer->sockaddr;
     pc->socklen = peer->socklen;
     pc->name = &peer->name;
 
+    peer->conns++;
+
     if (now - peer->checked > peer->fail_timeout) {
         peer->checked = now;
     }
 
+    ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
+
     hp->rrp.tried[n] |= m;
 
     return NGX_OK;
@@ -277,13 +277,17 @@ ngx_http_upstream_init_chash(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us)
 {
     u_char                             *host, *port, c;
     size_t                              host_len, port_len, size;
-    uint32_t                            hash, base_hash, prev_hash;
+    uint32_t                            hash, base_hash;
     ngx_str_t                          *server;
     ngx_uint_t                          npoints, i, j;
     ngx_http_upstream_rr_peer_t        *peer;
     ngx_http_upstream_rr_peers_t       *peers;
     ngx_http_upstream_chash_points_t   *points;
     ngx_http_upstream_hash_srv_conf_t  *hcf;
+    union {
+        uint32_t                        value;
+        u_char                          byte[4];
+    } prev_hash;
 
     if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) {
         return NGX_ERROR;
@@ -304,8 +308,7 @@ ngx_http_upstream_init_chash(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us)
 
     points->number = 0;
 
-    for (i = 0; i < peers->number; i++) {
-        peer = &peers->peer[i];
+    for (peer = peers->peer; peer; peer = peer->next) {
         server = &peer->server;
 
         /*
@@ -351,20 +354,27 @@ ngx_http_upstream_init_chash(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us)
         ngx_crc32_update(&base_hash, (u_char *) "", 1);
         ngx_crc32_update(&base_hash, port, port_len);
 
-        prev_hash = 0;
+        prev_hash.value = 0;
         npoints = peer->weight * 160;
 
         for (j = 0; j < npoints; j++) {
             hash = base_hash;
 
-            ngx_crc32_update(&hash, (u_char *) &prev_hash, sizeof(uint32_t));
+            ngx_crc32_update(&hash, prev_hash.byte, 4);
             ngx_crc32_final(hash);
 
             points->point[points->number].hash = hash;
             points->point[points->number].server = server;
             points->number++;
 
-            prev_hash = hash;
+#if (NGX_HAVE_LITTLE_ENDIAN)
+            prev_hash.value = hash;
+#else
+            prev_hash.byte[0] = (u_char) (hash & 0xff);
+            prev_hash.byte[1] = (u_char) ((hash >> 8) & 0xff);
+            prev_hash.byte[2] = (u_char) ((hash >> 16) & 0xff);
+            prev_hash.byte[3] = (u_char) ((hash >> 24) & 0xff);
+#endif
         }
     }
 
@@ -458,8 +468,13 @@ ngx_http_upstream_init_chash_peer(ngx_http_request_t *r,
     hcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_hash_module);
 
     hash = ngx_crc32_long(hp->key.data, hp->key.len);
+
+    ngx_http_upstream_rr_peers_rlock(hp->rrp.peers);
+
     hp->hash = ngx_http_upstream_find_chash_point(hcf->points, hash);
 
+    ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
+
     return NGX_OK;
 }
 
@@ -473,7 +488,7 @@ ngx_http_upstream_get_chash_peer(ngx_peer_connection_t *pc, void *data)
     intptr_t                            m;
     ngx_str_t                          *server;
     ngx_int_t                           total;
-    ngx_uint_t                          i, n;
+    ngx_uint_t                          i, n, best_i;
     ngx_http_upstream_rr_peer_t        *peer, *best;
     ngx_http_upstream_chash_point_t    *point;
     ngx_http_upstream_chash_points_t   *points;
@@ -482,6 +497,8 @@ ngx_http_upstream_get_chash_peer(ngx_peer_connection_t *pc, void *data)
     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
                    "get consistent hash peer, try: %ui", pc->tries);
 
+    ngx_http_upstream_rr_peers_wlock(hp->rrp.peers);
+
     pc->cached = 0;
     pc->connection = NULL;
 
@@ -499,9 +516,13 @@ ngx_http_upstream_get_chash_peer(ngx_peer_connection_t *pc, void *data)
                        hp->hash, server);
 
         best = NULL;
+        best_i = 0;
         total = 0;
 
-        for (i = 0; i < hp->rrp.peers->number; i++) {
+        for (peer = hp->rrp.peers->peer, i = 0;
+             peer;
+             peer = peer->next, i++)
+        {
 
             n = i / (8 * sizeof(uintptr_t));
             m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));
@@ -510,8 +531,6 @@ ngx_http_upstream_get_chash_peer(ngx_peer_connection_t *pc, void *data)
                 continue;
             }
 
-            peer = &hp->rrp.peers->peer[i];
-
             if (peer->down) {
                 continue;
             }
@@ -539,39 +558,46 @@ ngx_http_upstream_get_chash_peer(ngx_peer_connection_t *pc, void *data)
 
             if (best == NULL || peer->current_weight > best->current_weight) {
                 best = peer;
+                best_i = i;
             }
         }
 
         if (best) {
             best->current_weight -= total;
-
-            i = best - &hp->rrp.peers->peer[0];
-
-            hp->rrp.current = i;
-
-            n = i / (8 * sizeof(uintptr_t));
-            m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));
-
-            hp->rrp.tried[n] |= m;
-
-            if (now - best->checked > best->fail_timeout) {
-                best->checked = now;
-            }
-
-            pc->sockaddr = best->sockaddr;
-            pc->socklen = best->socklen;
-            pc->name = &best->name;
-
-            return NGX_OK;
+            goto found;
         }
 
         hp->hash++;
         hp->tries++;
 
         if (hp->tries >= points->number) {
+            ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
             return NGX_BUSY;
         }
     }
+
+found:
+
+    hp->rrp.current = best;
+
+    pc->sockaddr = best->sockaddr;
+    pc->socklen = best->socklen;
+    pc->name = &best->name;
+
+    best->conns++;
+
+    if (now - best->checked > best->fail_timeout) {
+        best->checked = now;
+    }
+
+    ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
+
+    n = best_i / (8 * sizeof(uintptr_t));
+    m = (uintptr_t) 1 << best_i % (8 * sizeof(uintptr_t));
+
+    hp->rrp.tried[n] |= m;
+
+    return NGX_OK;
 }
 
 

data/vendor/nginx/src/http/modules/ngx_http_upstream_ip_hash_module.c

@@ -161,7 +161,10 @@ ngx_http_upstream_get_ip_hash_peer(ngx_peer_connection_t *pc, void *data)
 
     /* TODO: cached */
 
+    ngx_http_upstream_rr_peers_wlock(iphp->rrp.peers);
+
     if (iphp->tries > 20 || iphp->rrp.peers->single) {
+        ngx_http_upstream_rr_peers_unlock(iphp->rrp.peers);
         return iphp->get_rr_peer(pc, &iphp->rrp);
     }
 
@@ -178,20 +181,14 @@ ngx_http_upstream_get_ip_hash_peer(ngx_peer_connection_t *pc, void *data)
             hash = (hash * 113 + iphp->addr[i]) % 6271;
         }
 
-        if (!iphp->rrp.peers->weighted) {
-            p = hash % iphp->rrp.peers->number;
-
-        } else {
-            w = hash % iphp->rrp.peers->total_weight;
-
-            for (i = 0; i < iphp->rrp.peers->number; i++) {
-                w -= iphp->rrp.peers->peer[i].weight;
-                if (w < 0) {
-                    break;
-                }
-            }
+        w = hash % iphp->rrp.peers->total_weight;
+        peer = iphp->rrp.peers->peer;
+        p = 0;
 
-            p = i;
+        while (w >= peer->weight) {
+            w -= peer->weight;
+            peer = peer->next;
+            p++;
         }
 
         n = p / (8 * sizeof(uintptr_t));
@@ -202,51 +199,42 @@ ngx_http_upstream_get_ip_hash_peer(ngx_peer_connection_t *pc, void *data)
         }
 
         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
-                       "get ip hash peer, hash: %ui %04XA", p, m);
-
-        peer = &iphp->rrp.peers->peer[p];
-
-        /* ngx_lock_mutex(iphp->rrp.peers->mutex); */
+                       "get ip hash peer, hash: %ui %04XL", p, (uint64_t) m);
 
         if (peer->down) {
-            goto next_try;
+            goto next;
         }
 
         if (peer->max_fails
             && peer->fails >= peer->max_fails
             && now - peer->checked <= peer->fail_timeout)
         {
-            goto next_try;
+            goto next;
         }
 
         break;
 
-    next_try:
-
-        iphp->rrp.tried[n] |= m;
-
-        /* ngx_unlock_mutex(iphp->rrp.peers->mutex); */
-
-        pc->tries--;
-
     next:
 
         if (++iphp->tries > 20) {
+            ngx_http_upstream_rr_peers_unlock(iphp->rrp.peers);
             return iphp->get_rr_peer(pc, &iphp->rrp);
         }
     }
 
-    iphp->rrp.current = p;
+    iphp->rrp.current = peer;
 
     pc->sockaddr = peer->sockaddr;
     pc->socklen = peer->socklen;
     pc->name = &peer->name;
 
+    peer->conns++;
+
     if (now - peer->checked > peer->fail_timeout) {
         peer->checked = now;
     }
 
-    /* ngx_unlock_mutex(iphp->rrp.peers->mutex); */
+    ngx_http_upstream_rr_peers_unlock(iphp->rrp.peers);
 
     iphp->rrp.tried[n] |= m;
     iphp->hash = hash;

data/vendor/nginx/src/http/modules/ngx_http_upstream_keepalive_module.c

@@ -22,6 +22,18 @@ typedef struct {
 } ngx_http_upstream_keepalive_srv_conf_t;
 
 
+typedef struct {
+    ngx_http_upstream_keepalive_srv_conf_t  *conf;
+
+    ngx_queue_t                        queue;
+    ngx_connection_t                  *connection;
+
+    socklen_t                          socklen;
+    u_char                             sockaddr[NGX_SOCKADDRLEN];
+
+} ngx_http_upstream_keepalive_cache_t;
+
+
 typedef struct {
     ngx_http_upstream_keepalive_srv_conf_t  *conf;
 
@@ -40,18 +52,6 @@ typedef struct {
 } ngx_http_upstream_keepalive_peer_data_t;
 
 
-typedef struct {
-    ngx_http_upstream_keepalive_srv_conf_t  *conf;
-
-    ngx_queue_t                        queue;
-    ngx_connection_t                  *connection;
-
-    socklen_t                          socklen;
-    u_char                             sockaddr[NGX_SOCKADDRLEN];
-
-} ngx_http_upstream_keepalive_cache_t;
-
-
 static ngx_int_t ngx_http_upstream_init_keepalive_peer(ngx_http_request_t *r,
     ngx_http_upstream_srv_conf_t *us);
 static ngx_int_t ngx_http_upstream_get_keepalive_peer(ngx_peer_connection_t *pc,
@@ -63,7 +63,6 @@ static void ngx_http_upstream_keepalive_dummy_handler(ngx_event_t *ev);
 static void ngx_http_upstream_keepalive_close_handler(ngx_event_t *ev);
 static void ngx_http_upstream_keepalive_close(ngx_connection_t *c);
 
-
 #if (NGX_HTTP_SSL)
 static ngx_int_t ngx_http_upstream_keepalive_set_session(
     ngx_peer_connection_t *pc, void *data);
@@ -244,24 +243,28 @@ ngx_http_upstream_get_keepalive_peer(ngx_peer_connection_t *pc, void *data)
             ngx_queue_remove(q);
             ngx_queue_insert_head(&kp->conf->free, q);
 
-            ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
-                           "get keepalive peer: using connection %p", c);
-
-            c->idle = 0;
-            c->sent = 0;
-            c->log = pc->log;
-            c->read->log = pc->log;
-            c->write->log = pc->log;
-            c->pool->log = pc->log;
-
-            pc->connection = c;
-            pc->cached = 1;
-
-            return NGX_DONE;
+            goto found;
         }
     }
 
     return NGX_OK;
+
+found:
+
+    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
+                   "get keepalive peer: using connection %p", c);
+
+    c->idle = 0;
+    c->sent = 0;
+    c->log = pc->log;
+    c->read->log = pc->log;
+    c->write->log = pc->log;
+    c->pool->log = pc->log;
+
+    pc->connection = c;
+    pc->cached = 1;
+
+    return NGX_DONE;
 }
 
 
@@ -299,6 +302,14 @@ ngx_http_upstream_free_keepalive_peer(ngx_peer_connection_t *pc, void *data,
         goto invalid;
     }
 
+    if (!u->request_body_sent) {
+        goto invalid;
+    }
+
+    if (ngx_terminate || ngx_exiting) {
+        goto invalid;
+    }
+
     if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
         goto invalid;
     }
@@ -322,9 +333,10 @@ ngx_http_upstream_free_keepalive_peer(ngx_peer_connection_t *pc, void *data,
         item = ngx_queue_data(q, ngx_http_upstream_keepalive_cache_t, queue);
     }
 
-    item->connection = c;
     ngx_queue_insert_head(&kp->conf->cache, q);
 
+    item->connection = c;
+
     pc->connection = NULL;
 
     if (c->read->timer_set) {
@@ -470,10 +482,9 @@ ngx_http_upstream_keepalive_create_conf(ngx_conf_t *cf)
      *
      *     conf->original_init_upstream = NULL;
      *     conf->original_init_peer = NULL;
+     *     conf->max_cached = 0;
      */
 
-    conf->max_cached = 1;
-
     return conf;
 }
 
@@ -487,18 +498,10 @@ ngx_http_upstream_keepalive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
     ngx_int_t    n;
     ngx_str_t   *value;
 
-    uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);
-
-    if (kcf->original_init_upstream) {
+    if (kcf->max_cached) {
         return "is duplicate";
     }
 
-    kcf->original_init_upstream = uscf->peer.init_upstream
-                                  ? uscf->peer.init_upstream
-                                  : ngx_http_upstream_init_round_robin;
-
-    uscf->peer.init_upstream = ngx_http_upstream_init_keepalive;
-
     /* read options */
 
     value = cf->args->elts;
@@ -514,5 +517,13 @@ ngx_http_upstream_keepalive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 
     kcf->max_cached = n;
 
+    uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);
+
+    kcf->original_init_upstream = uscf->peer.init_upstream
+                                  ? uscf->peer.init_upstream
+                                  : ngx_http_upstream_init_round_robin;
+
+    uscf->peer.init_upstream = ngx_http_upstream_init_keepalive;
+
     return NGX_CONF_OK;
 }