One Level Up Top Level

src/http/modules/ngx_http_upstream_least_conn_module.c - nginx-1.31.3 nginx/ @ 42f8df65b

Global variables 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. static ngx_int_t ngx_http_upstream_init_least_conn_peer(ngx_http_request_t *r,
  14.     ngx_http_upstream_srv_conf_t *us);
  15. static ngx_int_t ngx_http_upstream_get_least_conn_peer(
  16.     ngx_peer_connection_t *pc, void *data);
  17. static char *ngx_http_upstream_least_conn(ngx_conf_t *cf, ngx_command_t *cmd,
  18.     void *conf);


  21. ‌static ngx_command_t  ngx_http_upstream_least_conn_commands[] = {

  23.     { ngx_string("least_conn"),
  24.       NGX_HTTP_UPS_CONF|NGX_CONF_NOARGS,
  25.       ngx_http_upstream_least_conn,
  26.       0,
  27.       0,
  28.       NULL },

  30.       ngx_null_command
  31. };


  34. ‌static ngx_http_module_t  ngx_http_upstream_least_conn_module_ctx = {
  35.     NULL,                                  /* preconfiguration */
  36.     NULL,                                  /* postconfiguration */

  38.     NULL,                                  /* create main configuration */
  39.     NULL,                                  /* init main configuration */

  41.     NULL,                                  /* create server configuration */
  42.     NULL,                                  /* merge server configuration */

  44.     NULL,                                  /* create location configuration */
  45.     NULL                                   /* merge location configuration */
  46. };


  49. ‌ngx_module_t  ngx_http_upstream_least_conn_module = {
  50.     NGX_MODULE_V1,
  51.     &ngx_http_upstream_least_conn_module_ctx, /* module context */
  52.     ngx_http_upstream_least_conn_commands, /* module directives */
  53.     NGX_HTTP_MODULE,                       /* module type */
  54.     NULL,                                  /* init master */
  55.     NULL,                                  /* init module */
  56.     NULL,                                  /* init process */
  57.     NULL,                                  /* init thread */
  58.     NULL,                                  /* exit thread */
  59.     NULL,                                  /* exit process */
  60.     NULL,                                  /* exit master */
  61.     NGX_MODULE_V1_PADDING
  62. };


  65. static ngx_int_t
  66. ‌ngx_http_upstream_init_least_conn(ngx_conf_t *cf,
  67.     ngx_http_upstream_srv_conf_t *us)
  68. {
  69.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0,
  70.                    "init least conn");

  72.     if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) {
  73.         return NGX_ERROR;
  74.     }

  76.     us->peer.init = ngx_http_upstream_init_least_conn_peer;

  78.     return NGX_OK;
  79. }


  82. static ngx_int_t
  83. ‌ngx_http_upstream_init_least_conn_peer(ngx_http_request_t *r,
  84.     ngx_http_upstream_srv_conf_t *us)
  85. {
  86.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  87.                    "init least conn peer");

  89.     if (ngx_http_upstream_init_round_robin_peer(r, us) != NGX_OK) {
  90.         return NGX_ERROR;
  91.     }

  93.     r->upstream->peer.get = ngx_http_upstream_get_least_conn_peer;

  95.     return NGX_OK;
  96. }


  99. static ngx_int_t
  100. ‌ngx_http_upstream_get_least_conn_peer(ngx_peer_connection_t *pc, void *data)
  101. {
  102.     ngx_http_upstream_rr_peer_data_t  *rrp = data;

  104.     time_t                         now;
  105.     uintptr_t                      m;
  106.     ngx_int_t                      rc, total;
  107.     ngx_uint_t                     i, n, p, many;
  108.     ngx_http_upstream_rr_peer_t   *peer, *best;
  109.     ngx_http_upstream_rr_peers_t  *peers;

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

  114.     if (rrp->peers->single) {
  115.         return ngx_http_upstream_get_round_robin_peer(pc, rrp);
  116.     }

  118.     pc->cached = 0;
  119.     pc->connection = NULL;

  121.     now = ngx_time();

  123.     peers = rrp->peers;

  125.     ngx_http_upstream_rr_peers_wlock(peers);

  127. #if (NGX_HTTP_UPSTREAM_ZONE)
  128.     if (peers->config && rrp->config != *peers->config) {
  129.         goto busy;
  130.     }
  131. #endif

  133.     best = NULL;
  134.     total = 0;

  136. #if (NGX_SUPPRESS_WARN)
  137.     many = 0;
  138.     p = 0;
  139. #endif

  141. #if (NGX_HTTP_UPSTREAM_SID)
  142.     best = ngx_http_upstream_get_rr_peer_by_sid(rrp, pc->hint, &p, 0);

  144.     if (best) {
  145.         goto best_chosen;
  146.     }
  147. #endif

  149.     for (peer = peers->peer, i = 0;
  150.          peer;
  151.          peer = peer->next, i++)
  152.     {
  153.         n = i / (8 * sizeof(uintptr_t));
  154.         m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

  156.         if (rrp->tried[n] & m) {
  157.             continue;
  158.         }

  160.         if (peer->down) {
  161.             continue;
  162.         }

  164.         if (peer->max_fails
  165.             && peer->fails >= peer->max_fails
  166.             && now - peer->checked <= peer->fail_timeout)
  167.         {
  168.             continue;
  169.         }

  171.         if (peer->max_conns && peer->conns >= peer->max_conns) {
  172.             continue;
  173.         }

  175.         /*
  176.          * select peer with least number of connections; if there are
  177.          * multiple peers with the same number of connections, select
  178.          * based on round-robin
  179.          */

  181.         if (best == NULL
  182.             || peer->conns * best->weight < best->conns * peer->weight)
  183.         {
  184.             best = peer;
  185.             many = 0;
  186.             p = i;

  188.         } else if (peer->conns * best->weight == best->conns * peer->weight) {
  189.             many = 1;
  190.         }
  191.     }

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

  197.         goto failed;
  198.     }

  200.     if (many) {
  201.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  202.                        "get least conn peer, many");

  204.         for (peer = best, i = p;
  205.              peer;
  206.              peer = peer->next, i++)
  207.         {
  208.             n = i / (8 * sizeof(uintptr_t));
  209.             m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

  211.             if (rrp->tried[n] & m) {
  212.                 continue;
  213.             }

  215.             if (peer->down) {
  216.                 continue;
  217.             }

  219.             if (peer->conns * best->weight != best->conns * peer->weight) {
  220.                 continue;
  221.             }

  223.             if (peer->max_fails
  224.                 && peer->fails >= peer->max_fails
  225.                 && now - peer->checked <= peer->fail_timeout)
  226.             {
  227.                 continue;
  228.             }

  230.             if (peer->max_conns && peer->conns >= peer->max_conns) {
  231.                 continue;
  232.             }

  234.             peer->current_weight += peer->effective_weight;
  235.             total += peer->effective_weight;

  237.             if (peer->effective_weight < peer->weight) {
  238.                 peer->effective_weight++;
  239.             }

  241.             if (peer->current_weight > best->current_weight) {
  242.                 best = peer;
  243.                 p = i;
  244.             }
  245.         }
  246.     }

  248.     best->current_weight -= total;

  250. #if (NGX_HTTP_UPSTREAM_SID)
  251. best_chosen:
  252. #endif

  254.     if (now - best->checked > best->fail_timeout) {
  255.         best->checked = now;
  256.     }

  258.     pc->sockaddr = best->sockaddr;
  259.     pc->socklen = best->socklen;
  260.     pc->name = &best->name;

  262. #if (NGX_HTTP_UPSTREAM_SID)
  263.     pc->sid = &best->sid;
  264. #endif

  266.     best->conns++;

  268.     rrp->current = best;
  269.     ngx_http_upstream_rr_peer_ref(peers, best);

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

  274.     rrp->tried[n] |= m;

  276.     ngx_http_upstream_rr_peers_unlock(peers);

  278.     return NGX_OK;

  280. failed:

  282.     if (peers->next) {
  283.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  284.                        "get least conn peer, backup servers");

  286.         rrp->peers = peers->next;

  288.         n = (rrp->peers->number + (8 * sizeof(uintptr_t) - 1))
  289.                 / (8 * sizeof(uintptr_t));

  291.         for (i = 0; i < n; i++) {
  292.             rrp->tried[i] = 0;
  293.         }

  295.         ngx_http_upstream_rr_peers_unlock(peers);

  297.         rc = ngx_http_upstream_get_least_conn_peer(pc, rrp);

  299.         if (rc != NGX_BUSY) {
  300.             return rc;
  301.         }

  303.         ngx_http_upstream_rr_peers_wlock(peers);
  304.     }

  306. #if (NGX_HTTP_UPSTREAM_ZONE)
  307. busy:
  308. #endif

  310.     ngx_http_upstream_rr_peers_unlock(peers);

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

  314.     return NGX_BUSY;
  315. }


  318. static char *
  319. ‌ngx_http_upstream_least_conn(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  320. {
  321.     ngx_http_upstream_srv_conf_t  *uscf;

  323.     uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);

  325.     if (uscf->peer.init_upstream) {
  326.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  327.                            "load balancing method redefined");
  328.     }

  330.     uscf->peer.init_upstream = ngx_http_upstream_init_least_conn;

  332.     uscf->flags = NGX_HTTP_UPSTREAM_CREATE
  333.                   |NGX_HTTP_UPSTREAM_MODIFY
  334.                   |NGX_HTTP_UPSTREAM_WEIGHT
  335.                   |NGX_HTTP_UPSTREAM_MAX_CONNS
  336.                   |NGX_HTTP_UPSTREAM_MAX_FAILS
  337.                   |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
  338.                   |NGX_HTTP_UPSTREAM_DOWN
  339.                   |NGX_HTTP_UPSTREAM_BACKUP;

  341.     return NGX_CONF_OK;
  342. }

One Level Up Top Level