nginxtra 1.8.1.12 → 1.10.1.12

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

@@ -10,29 +10,10 @@
 #include <ngx_http.h>
 
 
-typedef struct {
-    ngx_uint_t                        *conns;
-} ngx_http_upstream_least_conn_conf_t;
-
-
-typedef struct {
-    /* the round robin data must be first */
-    ngx_http_upstream_rr_peer_data_t   rrp;
-
-    ngx_uint_t                        *conns;
-
-    ngx_event_get_peer_pt              get_rr_peer;
-    ngx_event_free_peer_pt             free_rr_peer;
-} ngx_http_upstream_lc_peer_data_t;
-
-
 static ngx_int_t ngx_http_upstream_init_least_conn_peer(ngx_http_request_t *r,
     ngx_http_upstream_srv_conf_t *us);
 static ngx_int_t ngx_http_upstream_get_least_conn_peer(
     ngx_peer_connection_t *pc, void *data);
-static void ngx_http_upstream_free_least_conn_peer(ngx_peer_connection_t *pc,
-    void *data, ngx_uint_t state);
-static void *ngx_http_upstream_least_conn_create_conf(ngx_conf_t *cf);
 static char *ngx_http_upstream_least_conn(ngx_conf_t *cf, ngx_command_t *cmd,
     void *conf);
 
@@ -57,7 +38,7 @@ static ngx_http_module_t  ngx_http_upstream_least_conn_module_ctx = {
     NULL,                                  /* create main configuration */
     NULL,                                  /* init main configuration */
 
-    ngx_http_upstream_least_conn_create_conf, /* create server configuration */
+    NULL,                                  /* create server configuration */
     NULL,                                  /* merge server configuration */
 
     NULL,                                  /* create location configuration */
@@ -85,10 +66,6 @@ static ngx_int_t
 ngx_http_upstream_init_least_conn(ngx_conf_t *cf,
     ngx_http_upstream_srv_conf_t *us)
 {
-    ngx_uint_t                            n;
-    ngx_http_upstream_rr_peers_t         *peers;
-    ngx_http_upstream_least_conn_conf_t  *lcf;
-
     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0,
                    "init least conn");
 
@@ -96,22 +73,6 @@ ngx_http_upstream_init_least_conn(ngx_conf_t *cf,
         return NGX_ERROR;
     }
 
-    peers = us->peer.data;
-
-    n = peers->number;
-
-    if (peers->next) {
-        n += peers->next->number;
-    }
-
-    lcf = ngx_http_conf_upstream_srv_conf(us,
-                                          ngx_http_upstream_least_conn_module);
-
-    lcf->conns = ngx_pcalloc(cf->pool, sizeof(ngx_uint_t) * n);
-    if (lcf->conns == NULL) {
-        return NGX_ERROR;
-    }
-
     us->peer.init = ngx_http_upstream_init_least_conn_peer;
 
     return NGX_OK;
@@ -122,33 +83,14 @@ static ngx_int_t
 ngx_http_upstream_init_least_conn_peer(ngx_http_request_t *r,
     ngx_http_upstream_srv_conf_t *us)
 {
-    ngx_http_upstream_lc_peer_data_t     *lcp;
-    ngx_http_upstream_least_conn_conf_t  *lcf;
-
     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                    "init least conn peer");
 
-    lcf = ngx_http_conf_upstream_srv_conf(us,
-                                          ngx_http_upstream_least_conn_module);
-
-    lcp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_lc_peer_data_t));
-    if (lcp == NULL) {
-        return NGX_ERROR;
-    }
-
-    lcp->conns = lcf->conns;
-
-    r->upstream->peer.data = &lcp->rrp;
-
     if (ngx_http_upstream_init_round_robin_peer(r, us) != NGX_OK) {
         return NGX_ERROR;
     }
 
     r->upstream->peer.get = ngx_http_upstream_get_least_conn_peer;
-    r->upstream->peer.free = ngx_http_upstream_free_least_conn_peer;
-
-    lcp->get_rr_peer = ngx_http_upstream_get_round_robin_peer;
-    lcp->free_rr_peer = ngx_http_upstream_free_round_robin_peer;
 
     return NGX_OK;
 }
@@ -157,7 +99,7 @@ ngx_http_upstream_init_least_conn_peer(ngx_http_request_t *r,
 static ngx_int_t
 ngx_http_upstream_get_least_conn_peer(ngx_peer_connection_t *pc, void *data)
 {
-    ngx_http_upstream_lc_peer_data_t  *lcp = data;
+    ngx_http_upstream_rr_peer_data_t  *rrp = data;
 
     time_t                         now;
     uintptr_t                      m;
@@ -169,8 +111,8 @@ ngx_http_upstream_get_least_conn_peer(ngx_peer_connection_t *pc, void *data)
     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
                    "get least conn peer, try: %ui", pc->tries);
 
-    if (lcp->rrp.peers->single) {
-        return lcp->get_rr_peer(pc, &lcp->rrp);
+    if (rrp->peers->single) {
+        return ngx_http_upstream_get_round_robin_peer(pc, rrp);
     }
 
     pc->cached = 0;
@@ -178,7 +120,9 @@ ngx_http_upstream_get_least_conn_peer(ngx_peer_connection_t *pc, void *data)
 
     now = ngx_time();
 
-    peers = lcp->rrp.peers;
+    peers = rrp->peers;
+
+    ngx_http_upstream_rr_peers_wlock(peers);
 
     best = NULL;
     total = 0;
@@ -188,17 +132,18 @@ ngx_http_upstream_get_least_conn_peer(ngx_peer_connection_t *pc, void *data)
     p = 0;
 #endif
 
-    for (i = 0; i < peers->number; i++) {
+    for (peer = peers->peer, i = 0;
+         peer;
+         peer = peer->next, i++)
+    {
 
         n = i / (8 * sizeof(uintptr_t));
         m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));
 
-        if (lcp->rrp.tried[n] & m) {
+        if (rrp->tried[n] & m) {
             continue;
         }
 
-        peer = &peers->peer[i];
-
         if (peer->down) {
             continue;
         }
@@ -217,15 +162,13 @@ ngx_http_upstream_get_least_conn_peer(ngx_peer_connection_t *pc, void *data)
          */
 
         if (best == NULL
-            || lcp->conns[i] * best->weight < lcp->conns[p] * peer->weight)
+            || peer->conns * best->weight < best->conns * peer->weight)
         {
             best = peer;
             many = 0;
             p = i;
 
-        } else if (lcp->conns[i] * best->weight
-                   == lcp->conns[p] * peer->weight)
-        {
+        } else if (peer->conns * best->weight == best->conns * peer->weight) {
             many = 1;
         }
     }
@@ -241,22 +184,22 @@ ngx_http_upstream_get_least_conn_peer(ngx_peer_connection_t *pc, void *data)
         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
                        "get least conn peer, many");
 
-        for (i = p; i < peers->number; i++) {
-
+        for (peer = best, i = p;
+             peer;
+             peer = peer->next, i++)
+        {
             n = i / (8 * sizeof(uintptr_t));
             m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));
 
-            if (lcp->rrp.tried[n] & m) {
+            if (rrp->tried[n] & m) {
                 continue;
             }
 
-            peer = &peers->peer[i];
-
             if (peer->down) {
                 continue;
             }
 
-            if (lcp->conns[i] * best->weight != lcp->conns[p] * peer->weight) {
+            if (peer->conns * best->weight != best->conns * peer->weight) {
                 continue;
             }
 
@@ -291,13 +234,16 @@ ngx_http_upstream_get_least_conn_peer(ngx_peer_connection_t *pc, void *data)
     pc->socklen = best->socklen;
     pc->name = &best->name;
 
-    lcp->rrp.current = p;
+    best->conns++;
+
+    rrp->current = best;
 
     n = p / (8 * sizeof(uintptr_t));
     m = (uintptr_t) 1 << p % (8 * sizeof(uintptr_t));
 
-    lcp->rrp.tried[n] |= m;
-    lcp->conns[p]++;
+    rrp->tried[n] |= m;
+
+    ngx_http_upstream_rr_peers_unlock(peers);
 
     return NGX_OK;
 
@@ -307,77 +253,40 @@ failed:
         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
                        "get least conn peer, backup servers");
 
-        lcp->conns += peers->number;
-
-        lcp->rrp.peers = peers->next;
+        rrp->peers = peers->next;
 
-        n = (lcp->rrp.peers->number + (8 * sizeof(uintptr_t) - 1))
+        n = (rrp->peers->number + (8 * sizeof(uintptr_t) - 1))
                 / (8 * sizeof(uintptr_t));
 
         for (i = 0; i < n; i++) {
-             lcp->rrp.tried[i] = 0;
+            rrp->tried[i] = 0;
         }
 
-        rc = ngx_http_upstream_get_least_conn_peer(pc, lcp);
+        ngx_http_upstream_rr_peers_unlock(peers);
+
+        rc = ngx_http_upstream_get_least_conn_peer(pc, rrp);
 
         if (rc != NGX_BUSY) {
             return rc;
         }
+
+        ngx_http_upstream_rr_peers_wlock(peers);
     }
 
     /* all peers failed, mark them as live for quick recovery */
 
-    for (i = 0; i < peers->number; i++) {
-        peers->peer[i].fails = 0;
+    for (peer = peers->peer; peer; peer = peer->next) {
+        peer->fails = 0;
     }
 
+    ngx_http_upstream_rr_peers_unlock(peers);
+
     pc->name = peers->name;
 
     return NGX_BUSY;
 }
 
 
-static void
-ngx_http_upstream_free_least_conn_peer(ngx_peer_connection_t *pc,
-    void *data, ngx_uint_t state)
-{
-    ngx_http_upstream_lc_peer_data_t  *lcp = data;
-
-    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
-                   "free least conn peer %ui %ui", pc->tries, state);
-
-    if (lcp->rrp.peers->single) {
-        lcp->free_rr_peer(pc, &lcp->rrp, state);
-        return;
-    }
-
-    lcp->conns[lcp->rrp.current]--;
-
-    lcp->free_rr_peer(pc, &lcp->rrp, state);
-}
-
-
-static void *
-ngx_http_upstream_least_conn_create_conf(ngx_conf_t *cf)
-{
-    ngx_http_upstream_least_conn_conf_t  *conf;
-
-    conf = ngx_pcalloc(cf->pool,
-                       sizeof(ngx_http_upstream_least_conn_conf_t));
-    if (conf == NULL) {
-        return NULL;
-    }
-
-    /*
-     * set by ngx_pcalloc():
-     *
-     *     conf->conns = NULL;
-     */
-
-    return conf;
-}
-
-
 static char *
 ngx_http_upstream_least_conn(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 {

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

@@ -0,0 +1,246 @@
+
+/*
+ * Copyright (C) Ruslan Ermilov
+ * Copyright (C) Nginx, Inc.
+ */
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+#include <ngx_http.h>
+
+
+static char *ngx_http_upstream_zone(ngx_conf_t *cf, ngx_command_t *cmd,
+    void *conf);
+static ngx_int_t ngx_http_upstream_init_zone(ngx_shm_zone_t *shm_zone,
+    void *data);
+static ngx_http_upstream_rr_peers_t *ngx_http_upstream_zone_copy_peers(
+    ngx_slab_pool_t *shpool, ngx_http_upstream_srv_conf_t *uscf);
+
+
+static ngx_command_t  ngx_http_upstream_zone_commands[] = {
+
+    { ngx_string("zone"),
+      NGX_HTTP_UPS_CONF|NGX_CONF_TAKE12,
+      ngx_http_upstream_zone,
+      0,
+      0,
+      NULL },
+
+      ngx_null_command
+};
+
+
+static ngx_http_module_t  ngx_http_upstream_zone_module_ctx = {
+    NULL,                                  /* preconfiguration */
+    NULL,                                  /* postconfiguration */
+
+    NULL,                                  /* create main configuration */
+    NULL,                                  /* init main configuration */
+
+    NULL,                                  /* create server configuration */
+    NULL,                                  /* merge server configuration */
+
+    NULL,                                  /* create location configuration */
+    NULL                                   /* merge location configuration */
+};
+
+
+ngx_module_t  ngx_http_upstream_zone_module = {
+    NGX_MODULE_V1,
+    &ngx_http_upstream_zone_module_ctx,    /* module context */
+    ngx_http_upstream_zone_commands,       /* module directives */
+    NGX_HTTP_MODULE,                       /* module type */
+    NULL,                                  /* init master */
+    NULL,                                  /* init module */
+    NULL,                                  /* init process */
+    NULL,                                  /* init thread */
+    NULL,                                  /* exit thread */
+    NULL,                                  /* exit process */
+    NULL,                                  /* exit master */
+    NGX_MODULE_V1_PADDING
+};
+
+
+static char *
+ngx_http_upstream_zone(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    ssize_t                         size;
+    ngx_str_t                      *value;
+    ngx_http_upstream_srv_conf_t   *uscf;
+    ngx_http_upstream_main_conf_t  *umcf;
+
+    uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);
+    umcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_upstream_module);
+
+    value = cf->args->elts;
+
+    if (!value[1].len) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                           "invalid zone name \"%V\"", &value[1]);
+        return NGX_CONF_ERROR;
+    }
+
+    if (cf->args->nelts == 3) {
+        size = ngx_parse_size(&value[2]);
+
+        if (size == NGX_ERROR) {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                               "invalid zone size \"%V\"", &value[2]);
+            return NGX_CONF_ERROR;
+        }
+
+        if (size < (ssize_t) (8 * ngx_pagesize)) {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                               "zone \"%V\" is too small", &value[1]);
+            return NGX_CONF_ERROR;
+        }
+
+    } else {
+        size = 0;
+    }
+
+    uscf->shm_zone = ngx_shared_memory_add(cf, &value[1], size,
+                                           &ngx_http_upstream_module);
+    if (uscf->shm_zone == NULL) {
+        return NGX_CONF_ERROR;
+    }
+
+    uscf->shm_zone->init = ngx_http_upstream_init_zone;
+    uscf->shm_zone->data = umcf;
+
+    uscf->shm_zone->noreuse = 1;
+
+    return NGX_CONF_OK;
+}
+
+
+static ngx_int_t
+ngx_http_upstream_init_zone(ngx_shm_zone_t *shm_zone, void *data)
+{
+    size_t                          len;
+    ngx_uint_t                      i;
+    ngx_slab_pool_t                *shpool;
+    ngx_http_upstream_rr_peers_t   *peers, **peersp;
+    ngx_http_upstream_srv_conf_t   *uscf, **uscfp;
+    ngx_http_upstream_main_conf_t  *umcf;
+
+    shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;
+    umcf = shm_zone->data;
+    uscfp = umcf->upstreams.elts;
+
+    if (shm_zone->shm.exists) {
+        peers = shpool->data;
+
+        for (i = 0; i < umcf->upstreams.nelts; i++) {
+            uscf = uscfp[i];
+
+            if (uscf->shm_zone != shm_zone) {
+                continue;
+            }
+
+            uscf->peer.data = peers;
+            peers = peers->zone_next;
+        }
+
+        return NGX_OK;
+    }
+
+    len = sizeof(" in upstream zone \"\"") + shm_zone->shm.name.len;
+
+    shpool->log_ctx = ngx_slab_alloc(shpool, len);
+    if (shpool->log_ctx == NULL) {
+        return NGX_ERROR;
+    }
+
+    ngx_sprintf(shpool->log_ctx, " in upstream zone \"%V\"%Z",
+                &shm_zone->shm.name);
+
+
+    /* copy peers to shared memory */
+
+    peersp = (ngx_http_upstream_rr_peers_t **) (void *) &shpool->data;
+
+    for (i = 0; i < umcf->upstreams.nelts; i++) {
+        uscf = uscfp[i];
+
+        if (uscf->shm_zone != shm_zone) {
+            continue;
+        }
+
+        peers = ngx_http_upstream_zone_copy_peers(shpool, uscf);
+        if (peers == NULL) {
+            return NGX_ERROR;
+        }
+
+        *peersp = peers;
+        peersp = &peers->zone_next;
+    }
+
+    return NGX_OK;
+}
+
+
+static ngx_http_upstream_rr_peers_t *
+ngx_http_upstream_zone_copy_peers(ngx_slab_pool_t *shpool,
+    ngx_http_upstream_srv_conf_t *uscf)
+{
+    ngx_http_upstream_rr_peer_t   *peer, **peerp;
+    ngx_http_upstream_rr_peers_t  *peers, *backup;
+
+    peers = ngx_slab_alloc(shpool, sizeof(ngx_http_upstream_rr_peers_t));
+    if (peers == NULL) {
+        return NULL;
+    }
+
+    ngx_memcpy(peers, uscf->peer.data, sizeof(ngx_http_upstream_rr_peers_t));
+
+    peers->shpool = shpool;
+
+    for (peerp = &peers->peer; *peerp; peerp = &peer->next) {
+        /* pool is unlocked */
+        peer = ngx_slab_calloc_locked(shpool,
+                                      sizeof(ngx_http_upstream_rr_peer_t));
+        if (peer == NULL) {
+            return NULL;
+        }
+
+        ngx_memcpy(peer, *peerp, sizeof(ngx_http_upstream_rr_peer_t));
+
+        *peerp = peer;
+    }
+
+    if (peers->next == NULL) {
+        goto done;
+    }
+
+    backup = ngx_slab_alloc(shpool, sizeof(ngx_http_upstream_rr_peers_t));
+    if (backup == NULL) {
+        return NULL;
+    }
+
+    ngx_memcpy(backup, peers->next, sizeof(ngx_http_upstream_rr_peers_t));
+
+    backup->shpool = shpool;
+
+    for (peerp = &backup->peer; *peerp; peerp = &peer->next) {
+        /* pool is unlocked */
+        peer = ngx_slab_calloc_locked(shpool,
+                                      sizeof(ngx_http_upstream_rr_peer_t));
+        if (peer == NULL) {
+            return NULL;
+        }
+
+        ngx_memcpy(peer, *peerp, sizeof(ngx_http_upstream_rr_peer_t));
+
+        *peerp = peer;
+    }
+
+    peers->next = backup;
+
+done:
+
+    uscf->peer.data = peers;
+
+    return peers;
+}