One Level Up Top Level

src/http/modules/ngx_http_upstream_least_conn_module.c - nginx-1.7.10

Global variables defined

Data types defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Maxim Dounin
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_http.h>


  13. typedef struct {
  14.     ngx_uint_t                        *conns;
  15. ‌} ngx_http_upstream_least_conn_conf_t;


  18. typedef struct {
  19.     /* the round robin data must be first */
  20.     ngx_http_upstream_rr_peer_data_t   rrp;

  22.     ngx_uint_t                        *conns;

  24.     ngx_event_get_peer_pt              get_rr_peer;
  25.     ngx_event_free_peer_pt             free_rr_peer;
  26. ‌} ngx_http_upstream_lc_peer_data_t;


  29. static ngx_int_t ngx_http_upstream_init_least_conn_peer(ngx_http_request_t *r,
  30.     ngx_http_upstream_srv_conf_t *us);
  31. static ngx_int_t ngx_http_upstream_get_least_conn_peer(
  32.     ngx_peer_connection_t *pc, void *data);
  33. static void ngx_http_upstream_free_least_conn_peer(ngx_peer_connection_t *pc,
  34.     void *data, ngx_uint_t state);
  35. static void *ngx_http_upstream_least_conn_create_conf(ngx_conf_t *cf);
  36. static char *ngx_http_upstream_least_conn(ngx_conf_t *cf, ngx_command_t *cmd,
  37.     void *conf);


  40. ‌static ngx_command_t  ngx_http_upstream_least_conn_commands[] = {

  42.     { ngx_string("least_conn"),
  43.       NGX_HTTP_UPS_CONF|NGX_CONF_NOARGS,
  44.       ngx_http_upstream_least_conn,
  45.       0,
  46.       0,
  47.       NULL },

  49.       ngx_null_command
  50. };


  53. ‌static ngx_http_module_t  ngx_http_upstream_least_conn_module_ctx = {
  54.     NULL,                                  /* preconfiguration */
  55.     NULL,                                  /* postconfiguration */

  57.     NULL,                                  /* create main configuration */
  58.     NULL,                                  /* init main configuration */

  60.     ngx_http_upstream_least_conn_create_conf, /* create server configuration */
  61.     NULL,                                  /* merge server configuration */

  63.     NULL,                                  /* create location configuration */
  64.     NULL                                   /* merge location configuration */
  65. };


  68. ‌ngx_module_t  ngx_http_upstream_least_conn_module = {
  69.     NGX_MODULE_V1,
  70.     &ngx_http_upstream_least_conn_module_ctx, /* module context */
  71.     ngx_http_upstream_least_conn_commands, /* module directives */
  72.     NGX_HTTP_MODULE,                       /* module type */
  73.     NULL,                                  /* init master */
  74.     NULL,                                  /* init module */
  75.     NULL,                                  /* init process */
  76.     NULL,                                  /* init thread */
  77.     NULL,                                  /* exit thread */
  78.     NULL,                                  /* exit process */
  79.     NULL,                                  /* exit master */
  80.     NGX_MODULE_V1_PADDING
  81. };


  84. static ngx_int_t
  85. ‌ngx_http_upstream_init_least_conn(ngx_conf_t *cf,
  86.     ngx_http_upstream_srv_conf_t *us)
  87. {
  88.     ngx_uint_t                            n;
  89.     ngx_http_upstream_rr_peers_t         *peers;
  90.     ngx_http_upstream_least_conn_conf_t  *lcf;

  92.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0,
  93.                    "init least conn");

  95.     if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) {
  96.         return NGX_ERROR;
  97.     }

  99.     peers = us->peer.data;

  101.     n = peers->number;

  103.     if (peers->next) {
  104.         n += peers->next->number;
  105.     }

  107.     lcf = ngx_http_conf_upstream_srv_conf(us,
  108.                                           ngx_http_upstream_least_conn_module);

  110.     lcf->conns = ngx_pcalloc(cf->pool, sizeof(ngx_uint_t) * n);
  111.     if (lcf->conns == NULL) {
  112.         return NGX_ERROR;
  113.     }

  115.     us->peer.init = ngx_http_upstream_init_least_conn_peer;

  117.     return NGX_OK;
  118. }


  121. static ngx_int_t
  122. ‌ngx_http_upstream_init_least_conn_peer(ngx_http_request_t *r,
  123.     ngx_http_upstream_srv_conf_t *us)
  124. {
  125.     ngx_http_upstream_lc_peer_data_t     *lcp;
  126.     ngx_http_upstream_least_conn_conf_t  *lcf;

  128.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  129.                    "init least conn peer");

  131.     lcf = ngx_http_conf_upstream_srv_conf(us,
  132.                                           ngx_http_upstream_least_conn_module);

  134.     lcp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_lc_peer_data_t));
  135.     if (lcp == NULL) {
  136.         return NGX_ERROR;
  137.     }

  139.     lcp->conns = lcf->conns;

  141.     r->upstream->peer.data = &lcp->rrp;

  143.     if (ngx_http_upstream_init_round_robin_peer(r, us) != NGX_OK) {
  144.         return NGX_ERROR;
  145.     }

  147.     r->upstream->peer.get = ngx_http_upstream_get_least_conn_peer;
  148.     r->upstream->peer.free = ngx_http_upstream_free_least_conn_peer;

  150.     lcp->get_rr_peer = ngx_http_upstream_get_round_robin_peer;
  151.     lcp->free_rr_peer = ngx_http_upstream_free_round_robin_peer;

  153.     return NGX_OK;
  154. }


  157. static ngx_int_t
  158. ‌ngx_http_upstream_get_least_conn_peer(ngx_peer_connection_t *pc, void *data)
  159. {
  160.     ngx_http_upstream_lc_peer_data_t  *lcp = data;

  162.     time_t                         now;
  163.     uintptr_t                      m;
  164.     ngx_int_t                      rc, total;
  165.     ngx_uint_t                     i, n, p, many;
  166.     ngx_http_upstream_rr_peer_t   *peer, *best;
  167.     ngx_http_upstream_rr_peers_t  *peers;

  169.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  170.                    "get least conn peer, try: %ui", pc->tries);

  172.     if (lcp->rrp.peers->single) {
  173.         return lcp->get_rr_peer(pc, &lcp->rrp);
  174.     }

  176.     pc->cached = 0;
  177.     pc->connection = NULL;

  179.     now = ngx_time();

  181.     peers = lcp->rrp.peers;

  183.     best = NULL;
  184.     total = 0;

  186. #if (NGX_SUPPRESS_WARN)
  187.     many = 0;
  188.     p = 0;
  189. #endif

  191.     for (i = 0; i < peers->number; i++) {

  193.         n = i / (8 * sizeof(uintptr_t));
  194.         m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

  196.         if (lcp->rrp.tried[n] & m) {
  197.             continue;
  198.         }

  200.         peer = &peers->peer[i];

  202.         if (peer->down) {
  203.             continue;
  204.         }

  206.         if (peer->max_fails
  207.             && peer->fails >= peer->max_fails
  208.             && now - peer->checked <= peer->fail_timeout)
  209.         {
  210.             continue;
  211.         }

  213.         /*
  214.          * select peer with least number of connections; if there are
  215.          * multiple peers with the same number of connections, select
  216.          * based on round-robin
  217.          */

  219.         if (best == NULL
  220.             || lcp->conns[i] * best->weight < lcp->conns[p] * peer->weight)
  221.         {
  222.             best = peer;
  223.             many = 0;
  224.             p = i;

  226.         } else if (lcp->conns[i] * best->weight
  227.                    == lcp->conns[p] * peer->weight)
  228.         {
  229.             many = 1;
  230.         }
  231.     }

  233.     if (best == NULL) {
  234.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  235.                        "get least conn peer, no peer found");

  237.         goto failed;
  238.     }

  240.     if (many) {
  241.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  242.                        "get least conn peer, many");

  244.         for (i = p; i < peers->number; i++) {

  246.             n = i / (8 * sizeof(uintptr_t));
  247.             m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

  249.             if (lcp->rrp.tried[n] & m) {
  250.                 continue;
  251.             }

  253.             peer = &peers->peer[i];

  255.             if (peer->down) {
  256.                 continue;
  257.             }

  259.             if (lcp->conns[i] * best->weight != lcp->conns[p] * peer->weight) {
  260.                 continue;
  261.             }

  263.             if (peer->max_fails
  264.                 && peer->fails >= peer->max_fails
  265.                 && now - peer->checked <= peer->fail_timeout)
  266.             {
  267.                 continue;
  268.             }

  270.             peer->current_weight += peer->effective_weight;
  271.             total += peer->effective_weight;

  273.             if (peer->effective_weight < peer->weight) {
  274.                 peer->effective_weight++;
  275.             }

  277.             if (peer->current_weight > best->current_weight) {
  278.                 best = peer;
  279.                 p = i;
  280.             }
  281.         }
  282.     }

  284.     best->current_weight -= total;

  286.     if (now - best->checked > best->fail_timeout) {
  287.         best->checked = now;
  288.     }

  290.     pc->sockaddr = best->sockaddr;
  291.     pc->socklen = best->socklen;
  292.     pc->name = &best->name;

  294.     lcp->rrp.current = p;

  296.     n = p / (8 * sizeof(uintptr_t));
  297.     m = (uintptr_t) 1 << p % (8 * sizeof(uintptr_t));

  299.     lcp->rrp.tried[n] |= m;
  300.     lcp->conns[p]++;

  302.     return NGX_OK;

  304. failed:

  306.     if (peers->next) {
  307.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  308.                        "get least conn peer, backup servers");

  310.         lcp->conns += peers->number;

  312.         lcp->rrp.peers = peers->next;

  314.         n = (lcp->rrp.peers->number + (8 * sizeof(uintptr_t) - 1))
  315.                 / (8 * sizeof(uintptr_t));

  317.         for (i = 0; i < n; i++) {
  318.              lcp->rrp.tried[i] = 0;
  319.         }

  321.         rc = ngx_http_upstream_get_least_conn_peer(pc, lcp);

  323.         if (rc != NGX_BUSY) {
  324.             return rc;
  325.         }
  326.     }

  328.     /* all peers failed, mark them as live for quick recovery */

  330.     for (i = 0; i < peers->number; i++) {
  331.         peers->peer[i].fails = 0;
  332.     }

  334.     pc->name = peers->name;

  336.     return NGX_BUSY;
  337. }


  340. static void
  341. ‌ngx_http_upstream_free_least_conn_peer(ngx_peer_connection_t *pc,
  342.     void *data, ngx_uint_t state)
  343. {
  344.     ngx_http_upstream_lc_peer_data_t  *lcp = data;

  346.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  347.                    "free least conn peer %ui %ui", pc->tries, state);

  349.     if (lcp->rrp.peers->single) {
  350.         lcp->free_rr_peer(pc, &lcp->rrp, state);
  351.         return;
  352.     }

  354.     lcp->conns[lcp->rrp.current]--;

  356.     lcp->free_rr_peer(pc, &lcp->rrp, state);
  357. }


  360. static void *
  361. ‌ngx_http_upstream_least_conn_create_conf(ngx_conf_t *cf)
  362. {
  363.     ngx_http_upstream_least_conn_conf_t  *conf;

  365.     conf = ngx_pcalloc(cf->pool,
  366.                        sizeof(ngx_http_upstream_least_conn_conf_t));
  367.     if (conf == NULL) {
  368.         return NULL;
  369.     }

  371.     /*
  372.      * set by ngx_pcalloc():
  373.      *
  374.      *     conf->conns = NULL;
  375.      */

  377.     return conf;
  378. }


  381. static char *
  382. ‌ngx_http_upstream_least_conn(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  383. {
  384.     ngx_http_upstream_srv_conf_t  *uscf;

  386.     uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);

  388.     if (uscf->peer.init_upstream) {
  389.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  390.                            "load balancing method redefined");
  391.     }

  393.     uscf->peer.init_upstream = ngx_http_upstream_init_least_conn;

  395.     uscf->flags = NGX_HTTP_UPSTREAM_CREATE
  396.                   |NGX_HTTP_UPSTREAM_WEIGHT
  397.                   |NGX_HTTP_UPSTREAM_MAX_FAILS
  398.                   |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
  399.                   |NGX_HTTP_UPSTREAM_DOWN
  400.                   |NGX_HTTP_UPSTREAM_BACKUP;

  402.     return NGX_CONF_OK;
  403. }

One Level Up Top Level