One Level Up Top Level

src/stream/ngx_stream_upstream_least_conn_module.c - nginx source code

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_stream.h>


  13. static ngx_int_t ngx_stream_upstream_init_least_conn_peer(
  14.     ngx_stream_session_t *s, ngx_stream_upstream_srv_conf_t *us);
  15. static ngx_int_t ngx_stream_upstream_get_least_conn_peer(
  16.     ngx_peer_connection_t *pc, void *data);
  17. static char *ngx_stream_upstream_least_conn(ngx_conf_t *cf, ngx_command_t *cmd,
  18.     void *conf);


  21. ‌static ngx_command_t  ngx_stream_upstream_least_conn_commands[] = {

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

  30.       ngx_null_command
  31. };


  34. ‌static ngx_stream_module_t  ngx_stream_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 */
  43. };


  46. ‌ngx_module_t  ngx_stream_upstream_least_conn_module = {
  47.     NGX_MODULE_V1,
  48.     &ngx_stream_upstream_least_conn_module_ctx, /* module context */
  49.     ngx_stream_upstream_least_conn_commands, /* module directives */
  50.     NGX_STREAM_MODULE,                       /* module type */
  51.     NULL,                                    /* init master */
  52.     NULL,                                    /* init module */
  53.     NULL,                                    /* init process */
  54.     NULL,                                    /* init thread */
  55.     NULL,                                    /* exit thread */
  56.     NULL,                                    /* exit process */
  57.     NULL,                                    /* exit master */
  58.     NGX_MODULE_V1_PADDING
  59. };


  62. static ngx_int_t
  63. ‌ngx_stream_upstream_init_least_conn(ngx_conf_t *cf,
  64.     ngx_stream_upstream_srv_conf_t *us)
  65. {
  66.     ngx_log_debug0(NGX_LOG_DEBUG_STREAM, cf->log, 0,
  67.                    "init least conn");

  69.     if (ngx_stream_upstream_init_round_robin(cf, us) != NGX_OK) {
  70.         return NGX_ERROR;
  71.     }

  73.     us->peer.init = ngx_stream_upstream_init_least_conn_peer;

  75.     return NGX_OK;
  76. }


  79. static ngx_int_t
  80. ‌ngx_stream_upstream_init_least_conn_peer(ngx_stream_session_t *s,
  81.     ngx_stream_upstream_srv_conf_t *us)
  82. {
  83.     ngx_log_debug0(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  84.                    "init least conn peer");

  86.     if (ngx_stream_upstream_init_round_robin_peer(s, us) != NGX_OK) {
  87.         return NGX_ERROR;
  88.     }

  90.     s->upstream->peer.get = ngx_stream_upstream_get_least_conn_peer;

  92.     return NGX_OK;
  93. }


  96. static ngx_int_t
  97. ‌ngx_stream_upstream_get_least_conn_peer(ngx_peer_connection_t *pc, void *data)
  98. {
  99.     ngx_stream_upstream_rr_peer_data_t *rrp = data;

  101.     time_t                           now;
  102.     uintptr_t                        m;
  103.     ngx_int_t                        rc, total;
  104.     ngx_uint_t                       i, n, p, many;
  105.     ngx_stream_upstream_rr_peer_t   *peer, *best;
  106.     ngx_stream_upstream_rr_peers_t  *peers;

  108.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, pc->log, 0,
  109.                    "get least conn peer, try: %ui", pc->tries);

  111.     if (rrp->peers->single) {
  112.         return ngx_stream_upstream_get_round_robin_peer(pc, rrp);
  113.     }

  115.     pc->connection = NULL;

  117.     now = ngx_time();

  119.     peers = rrp->peers;

  121.     ngx_stream_upstream_rr_peers_wlock(peers);

  123. #if (NGX_STREAM_UPSTREAM_ZONE)
  124.     if (peers->config && rrp->config != *peers->config) {
  125.         goto busy;
  126.     }
  127. #endif

  129.     best = NULL;
  130.     total = 0;

  132. #if (NGX_SUPPRESS_WARN)
  133.     many = 0;
  134.     p = 0;
  135. #endif

  137.     for (peer = peers->peer, i = 0;
  138.          peer;
  139.          peer = peer->next, i++)
  140.     {
  141.         n = i / (8 * sizeof(uintptr_t));
  142.         m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

  144.         if (rrp->tried[n] & m) {
  145.             continue;
  146.         }

  148.         if (peer->down) {
  149.             continue;
  150.         }

  152.         if (peer->max_fails
  153.             && peer->fails >= peer->max_fails
  154.             && now - peer->checked <= peer->fail_timeout)
  155.         {
  156.             continue;
  157.         }

  159.         if (peer->max_conns && peer->conns >= peer->max_conns) {
  160.             continue;
  161.         }

  163.         /*
  164.          * select peer with least number of connections; if there are
  165.          * multiple peers with the same number of connections, select
  166.          * based on round-robin
  167.          */

  169.         if (best == NULL
  170.             || peer->conns * best->weight < best->conns * peer->weight)
  171.         {
  172.             best = peer;
  173.             many = 0;
  174.             p = i;

  176.         } else if (peer->conns * best->weight == best->conns * peer->weight) {
  177.             many = 1;
  178.         }
  179.     }

  181.     if (best == NULL) {
  182.         ngx_log_debug0(NGX_LOG_DEBUG_STREAM, pc->log, 0,
  183.                        "get least conn peer, no peer found");

  185.         goto failed;
  186.     }

  188.     if (many) {
  189.         ngx_log_debug0(NGX_LOG_DEBUG_STREAM, pc->log, 0,
  190.                        "get least conn peer, many");

  192.         for (peer = best, i = p;
  193.              peer;
  194.              peer = peer->next, i++)
  195.         {
  196.             n = i / (8 * sizeof(uintptr_t));
  197.             m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

  199.             if (rrp->tried[n] & m) {
  200.                 continue;
  201.             }

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

  207.             if (peer->conns * best->weight != best->conns * peer->weight) {
  208.                 continue;
  209.             }

  211.             if (peer->max_fails
  212.                 && peer->fails >= peer->max_fails
  213.                 && now - peer->checked <= peer->fail_timeout)
  214.             {
  215.                 continue;
  216.             }

  218.             if (peer->max_conns && peer->conns >= peer->max_conns) {
  219.                 continue;
  220.             }

  222.             peer->current_weight += peer->effective_weight;
  223.             total += peer->effective_weight;

  225.             if (peer->effective_weight < peer->weight) {
  226.                 peer->effective_weight++;
  227.             }

  229.             if (peer->current_weight > best->current_weight) {
  230.                 best = peer;
  231.                 p = i;
  232.             }
  233.         }
  234.     }

  236.     best->current_weight -= total;

  238.     if (now - best->checked > best->fail_timeout) {
  239.         best->checked = now;
  240.     }

  242.     pc->sockaddr = best->sockaddr;
  243.     pc->socklen = best->socklen;
  244.     pc->name = &best->name;

  246.     best->conns++;

  248.     rrp->current = best;
  249.     ngx_stream_upstream_rr_peer_ref(peers, best);

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

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

  256.     ngx_stream_upstream_rr_peers_unlock(peers);

  258.     return NGX_OK;

  260. failed:

  262.     if (peers->next) {
  263.         ngx_log_debug0(NGX_LOG_DEBUG_STREAM, pc->log, 0,
  264.                        "get least conn peer, backup servers");

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

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

  271.         for (i = 0; i < n; i++) {
  272.             rrp->tried[i] = 0;
  273.         }

  275.         ngx_stream_upstream_rr_peers_unlock(peers);

  277.         rc = ngx_stream_upstream_get_least_conn_peer(pc, rrp);

  279.         if (rc != NGX_BUSY) {
  280.             return rc;
  281.         }

  283.         ngx_stream_upstream_rr_peers_wlock(peers);
  284.     }

  286. #if (NGX_STREAM_UPSTREAM_ZONE)
  287. busy:
  288. #endif

  290.     ngx_stream_upstream_rr_peers_unlock(peers);

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

  294.     return NGX_BUSY;
  295. }


  298. static char *
  299. ‌ngx_stream_upstream_least_conn(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  300. {
  301.     ngx_stream_upstream_srv_conf_t  *uscf;

  303.     uscf = ngx_stream_conf_get_module_srv_conf(cf, ngx_stream_upstream_module);

  305.     if (uscf->peer.init_upstream) {
  306.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  307.                            "load balancing method redefined");
  308.     }

  310.     uscf->peer.init_upstream = ngx_stream_upstream_init_least_conn;

  312.     uscf->flags = NGX_STREAM_UPSTREAM_CREATE
  313.                   |NGX_STREAM_UPSTREAM_MODIFY
  314.                   |NGX_STREAM_UPSTREAM_WEIGHT
  315.                   |NGX_STREAM_UPSTREAM_MAX_CONNS
  316.                   |NGX_STREAM_UPSTREAM_MAX_FAILS
  317.                   |NGX_STREAM_UPSTREAM_FAIL_TIMEOUT
  318.                   |NGX_STREAM_UPSTREAM_DOWN
  319.                   |NGX_STREAM_UPSTREAM_BACKUP;

  321.     return NGX_CONF_OK;
  322. }

One Level Up Top Level