nginxtra 1.2.1.3 → 1.2.2.3

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

@@ -0,0 +1,402 @@
+
+/*
+ * Copyright (C) Maxim Dounin
+ * Copyright (C) Nginx, Inc.
+ */
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+#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);
+
+
+static ngx_command_t  ngx_http_upstream_least_conn_commands[] = {
+
+    { ngx_string("least_conn"),
+      NGX_HTTP_UPS_CONF|NGX_CONF_NOARGS,
+      ngx_http_upstream_least_conn,
+      0,
+      0,
+      NULL },
+
+      ngx_null_command
+};
+
+
+static ngx_http_module_t  ngx_http_upstream_least_conn_module_ctx = {
+    NULL,                                  /* preconfiguration */
+    NULL,                                  /* postconfiguration */
+
+    NULL,                                  /* create main configuration */
+    NULL,                                  /* init main configuration */
+
+    ngx_http_upstream_least_conn_create_conf, /* create server configuration */
+    NULL,                                  /* merge server configuration */
+
+    NULL,                                  /* create location configuration */
+    NULL                                   /* merge location configuration */
+};
+
+
+ngx_module_t  ngx_http_upstream_least_conn_module = {
+    NGX_MODULE_V1,
+    &ngx_http_upstream_least_conn_module_ctx, /* module context */
+    ngx_http_upstream_least_conn_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
+};
+
+
+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");
+
+    if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) {
+        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;
+}
+
+
+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;
+}
+
+
+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;
+
+    time_t                         now;
+    uintptr_t                      m;
+    ngx_int_t                      rc, total;
+    ngx_uint_t                     i, n, p, many;
+    ngx_http_upstream_rr_peer_t   *peer, *best;
+    ngx_http_upstream_rr_peers_t  *peers;
+
+    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);
+    }
+
+    pc->cached = 0;
+    pc->connection = NULL;
+
+    now = ngx_time();
+
+    peers = lcp->rrp.peers;
+
+    best = NULL;
+    total = 0;
+
+#if (NGX_SUPPRESS_WARN)
+    many = 0;
+    p = 0;
+#endif
+
+    for (i = 0; i < peers->number; i++) {
+
+        n = i / (8 * sizeof(uintptr_t));
+        m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));
+
+        if (lcp->rrp.tried[n] & m) {
+            continue;
+        }
+
+        peer = &peers->peer[i];
+
+        if (peer->down) {
+            continue;
+        }
+
+        if (peer->max_fails
+            && peer->fails >= peer->max_fails
+            && now - peer->checked <= peer->fail_timeout)
+        {
+            continue;
+        }
+
+        /*
+         * select peer with least number of connections; if there are
+         * multiple peers with the same number of connections, select
+         * based on round-robin
+         */
+
+        if (best == NULL
+            || lcp->conns[i] * best->weight < lcp->conns[p] * peer->weight)
+        {
+            best = peer;
+            many = 0;
+            p = i;
+
+        } else if (lcp->conns[i] * best->weight
+                   == lcp->conns[p] * peer->weight)
+        {
+            many = 1;
+        }
+    }
+
+    if (best == NULL) {
+        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
+                       "get least conn peer, no peer found");
+
+        goto failed;
+    }
+
+    if (many) {
+        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
+                       "get least conn peer, many");
+
+        for (i = p; i < peers->number; i++) {
+
+            n = i / (8 * sizeof(uintptr_t));
+            m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));
+
+            if (lcp->rrp.tried[n] & m) {
+                continue;
+            }
+
+            peer = &peers->peer[i];
+
+            if (peer->down) {
+                continue;
+            }
+
+            if (lcp->conns[i] * best->weight != lcp->conns[p] * peer->weight) {
+                continue;
+            }
+
+            if (peer->max_fails
+                && peer->fails >= peer->max_fails
+                && now - peer->checked <= peer->fail_timeout)
+            {
+                continue;
+            }
+
+            peer->current_weight += peer->effective_weight;
+            total += peer->effective_weight;
+
+            if (peer->effective_weight < peer->weight) {
+                peer->effective_weight++;
+            }
+
+            if (peer->current_weight > best->current_weight) {
+                best = peer;
+                p = i;
+            }
+        }
+    }
+
+    best->current_weight -= total;
+    best->checked = now;
+
+    pc->sockaddr = best->sockaddr;
+    pc->socklen = best->socklen;
+    pc->name = &best->name;
+
+    lcp->rrp.current = p;
+
+    n = p / (8 * sizeof(uintptr_t));
+    m = (uintptr_t) 1 << p % (8 * sizeof(uintptr_t));
+
+    lcp->rrp.tried[n] |= m;
+    lcp->conns[p]++;
+
+    if (pc->tries == 1 && peers->next) {
+        pc->tries += peers->next->number;
+    }
+
+    return NGX_OK;
+
+failed:
+
+    if (peers->next) {
+        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;
+        pc->tries = lcp->rrp.peers->number;
+
+        n = lcp->rrp.peers->number / (8 * sizeof(uintptr_t)) + 1;
+        for (i = 0; i < n; i++) {
+             lcp->rrp.tried[i] = 0;
+        }
+
+        rc = ngx_http_upstream_get_least_conn_peer(pc, lcp);
+
+        if (rc != NGX_BUSY) {
+            return rc;
+        }
+    }
+
+    /* all peers failed, mark them as live for quick recovery */
+
+    for (i = 0; i < peers->number; i++) {
+        peers->peer[i].fails = 0;
+    }
+
+    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;
+    }
+
+    if (state == 0 && pc->tries == 0) {
+        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)
+{
+    ngx_http_upstream_srv_conf_t  *uscf;
+
+    uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);
+
+    uscf->peer.init_upstream = ngx_http_upstream_init_least_conn;
+
+    uscf->flags = NGX_HTTP_UPSTREAM_CREATE
+                  |NGX_HTTP_UPSTREAM_WEIGHT
+                  |NGX_HTTP_UPSTREAM_MAX_FAILS
+                  |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
+                  |NGX_HTTP_UPSTREAM_DOWN
+                  |NGX_HTTP_UPSTREAM_BACKUP;
+
+    return NGX_CONF_OK;
+}

data/src/nginx/src/http/modules/ngx_http_xslt_filter_module.c

@@ -810,7 +810,7 @@ ngx_http_xslt_entities(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 
     file = xmcf->dtd_files.elts;
     for (i = 0; i < xmcf->dtd_files.nelts; i++) {
-        if (ngx_strcmp(file[i].name, &value[1].data) == 0) {
+        if (ngx_strcmp(file[i].name, value[1].data) == 0) {
             xlcf->dtd = file[i].data;
             return NGX_CONF_OK;
         }
@@ -884,7 +884,7 @@ ngx_http_xslt_stylesheet(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 
     file = xmcf->sheet_files.elts;
     for (i = 0; i < xmcf->sheet_files.nelts; i++) {
-        if (ngx_strcmp(file[i].name, &value[1].data) == 0) {
+        if (ngx_strcmp(file[i].name, value[1].data) == 0) {
             sheet->stylesheet = file[i].data;
             goto found;
         }

data/src/nginx/src/http/modules/perl/nginx.pm

@@ -50,7 +50,7 @@ our @EXPORT = qw(
     HTTP_INSUFFICIENT_STORAGE
 );
 
-our $VERSION = '1.2.1';
+our $VERSION = '1.2.2';
 
 require XSLoader;
 XSLoader::load('nginx', $VERSION);

data/src/nginx/src/http/modules/perl/nginx.xs

@@ -476,7 +476,7 @@ header_out(r, key, value)
     }
 
     if (header->key.len == sizeof("Content-Encoding") - 1
-        && ngx_strncasecmp(header->key.data, "Content-Encoding",
+        && ngx_strncasecmp(header->key.data, (u_char *) "Content-Encoding",
                            sizeof("Content-Encoding") - 1) == 0)
     {
         r->headers_out.content_encoding = header;

data/src/nginx/src/http/ngx_http_core_module.c

@@ -4662,7 +4662,7 @@ ngx_http_core_try_files(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 
         code = ngx_atoi(tf[i - 1].name.data + 1, tf[i - 1].name.len - 2);
 
-        if (code == NGX_ERROR) {
+        if (code == NGX_ERROR || code > 999) {
             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                                "invalid code \"%*s\"",
                                tf[i - 1].name.len - 1, tf[i - 1].name.data);

data/src/nginx/src/http/ngx_http_header_filter_module.c

@@ -395,7 +395,7 @@ ngx_http_header_filter(ngx_http_request_t *r)
         }
 
     } else {
-        len += sizeof("Connection: closed" CRLF) - 1;
+        len += sizeof("Connection: close" CRLF) - 1;
     }
 
 #if (NGX_HTTP_GZIP)
@@ -445,7 +445,7 @@ ngx_http_header_filter(ngx_http_request_t *r)
         b->last = ngx_copy(b->last, status_line->data, status_line->len);
 
     } else {
-        b->last = ngx_sprintf(b->last, "%ui", status);
+        b->last = ngx_sprintf(b->last, "%03ui", status);
     }
     *b->last++ = CR; *b->last++ = LF;
 

data/src/nginx/src/http/ngx_http_request.c

@@ -138,7 +138,7 @@ ngx_http_header_t  ngx_http_headers_in[] = {
     { ngx_string("Keep-Alive"), offsetof(ngx_http_headers_in_t, keep_alive),
                  ngx_http_process_header_line },
 
-#if (NGX_HTTP_PROXY || NGX_HTTP_REALIP || NGX_HTTP_GEO)
+#if (NGX_HTTP_X_FORWARDED_FOR)
     { ngx_string("X-Forwarded-For"),
                  offsetof(ngx_http_headers_in_t, x_forwarded_for),
                  ngx_http_process_header_line },

data/src/nginx/src/http/ngx_http_request.h

@@ -137,6 +137,13 @@
 #define NGX_HTTP_COPY_BUFFERED             0x04
 
 
+#if (NGX_HTTP_PROXY || NGX_HTTP_REALIP || NGX_HTTP_GEO)
+#ifndef NGX_HTTP_X_FORWARDED_FOR
+#define NGX_HTTP_X_FORWARDED_FOR           1
+#endif
+#endif
+
+
 typedef enum {
     NGX_HTTP_INITING_REQUEST_STATE = 0,
     NGX_HTTP_READING_REQUEST_STATE,
@@ -192,7 +199,7 @@ typedef struct {
 
     ngx_table_elt_t                  *keep_alive;
 
-#if (NGX_HTTP_PROXY || NGX_HTTP_REALIP || NGX_HTTP_GEO)
+#if (NGX_HTTP_X_FORWARDED_FOR)
     ngx_table_elt_t                  *x_forwarded_for;
 #endif
 

data/src/nginx/src/http/ngx_http_upstream.c

@@ -3677,6 +3677,7 @@ static ngx_int_t
 ngx_http_upstream_rewrite_set_cookie(ngx_http_request_t *r, ngx_table_elt_t *h,
     ngx_uint_t offset)
 {
+    ngx_int_t         rc;
     ngx_table_elt_t  *ho;
 
     ho = ngx_list_push(&r->headers_out.headers);
@@ -3687,7 +3688,20 @@ ngx_http_upstream_rewrite_set_cookie(ngx_http_request_t *r, ngx_table_elt_t *h,
     *ho = *h;
 
     if (r->upstream->rewrite_cookie) {
-        return r->upstream->rewrite_cookie(r, ho);
+        rc = r->upstream->rewrite_cookie(r, ho);
+
+        if (rc == NGX_DECLINED) {
+            return NGX_OK;
+        }
+
+#if (NGX_DEBUG)
+        if (rc == NGX_OK) {
+            ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                           "rewritten cookie: \"%V\"", &ho->value);
+        }
+#endif
+
+        return rc;
     }
 
     return NGX_OK;

data/src/nginx/src/http/ngx_http_upstream_round_robin.c

@@ -30,7 +30,7 @@ ngx_http_upstream_init_round_robin(ngx_conf_t *cf,
     ngx_http_upstream_srv_conf_t *us)
 {
     ngx_url_t                      u;
-    ngx_uint_t                     i, j, n;
+    ngx_uint_t                     i, j, n, w;
     ngx_http_upstream_server_t    *server;
     ngx_http_upstream_rr_peers_t  *peers, *backup;
 
@@ -40,6 +40,7 @@ ngx_http_upstream_init_round_robin(ngx_conf_t *cf,
         server = us->servers->elts;
 
         n = 0;
+        w = 0;
 
         for (i = 0; i < us->servers->nelts; i++) {
             if (server[i].backup) {
@@ -47,6 +48,7 @@ ngx_http_upstream_init_round_robin(ngx_conf_t *cf,
             }
 
             n += server[i].naddrs;
+            w += server[i].naddrs * server[i].weight;
         }
 
         if (n == 0) {
@@ -64,6 +66,8 @@ ngx_http_upstream_init_round_robin(ngx_conf_t *cf,
 
         peers->single = (n == 1);
         peers->number = n;
+        peers->weighted = (w != n);
+        peers->total_weight = w;
         peers->name = &us->host;
 
         n = 0;
@@ -96,6 +100,7 @@ ngx_http_upstream_init_round_robin(ngx_conf_t *cf,
         /* backup servers */
 
         n = 0;
+        w = 0;
 
         for (i = 0; i < us->servers->nelts; i++) {
             if (!server[i].backup) {
@@ -103,6 +108,7 @@ ngx_http_upstream_init_round_robin(ngx_conf_t *cf,
             }
 
             n += server[i].naddrs;
+            w += server[i].naddrs * server[i].weight;
         }
 
         if (n == 0) {
@@ -118,6 +124,8 @@ ngx_http_upstream_init_round_robin(ngx_conf_t *cf,
         peers->single = 0;
         backup->single = 0;
         backup->number = n;
+        backup->weighted = (w != n);
+        backup->total_weight = w;
         backup->name = &us->host;
 
         n = 0;
@@ -185,6 +193,8 @@ ngx_http_upstream_init_round_robin(ngx_conf_t *cf,
 
     peers->single = (n == 1);
     peers->number = n;
+    peers->weighted = 0;
+    peers->total_weight = n;
     peers->name = &us->host;
 
     for (i = 0; i < u.naddrs; i++) {

data/src/nginx/src/http/ngx_http_upstream_round_robin.h

@@ -41,13 +41,17 @@ typedef struct {
 typedef struct ngx_http_upstream_rr_peers_s  ngx_http_upstream_rr_peers_t;
 
 struct ngx_http_upstream_rr_peers_s {
-    ngx_uint_t                      single;        /* unsigned  single:1; */
     ngx_uint_t                      number;
     ngx_uint_t                      last_cached;
 
  /* ngx_mutex_t                    *mutex; */
     ngx_connection_t              **cached;
 
+    ngx_uint_t                      total_weight;
+
+    unsigned                        single:1;
+    unsigned                        weighted:1;
+
     ngx_str_t                      *name;
 
     ngx_http_upstream_rr_peers_t   *next;