One Level Up Top Level

src/http/modules/ngx_http_upstream_random_module.c - nginx

Global variables defined

Data types defined

Functions defined

Source code


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


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


  12. ‌typedef struct {
  13.     ngx_http_upstream_rr_peer_t          *peer;
  14.     ngx_uint_t                            range;
  15. ‌} ngx_http_upstream_random_range_t;


  18. ‌typedef struct {
  19.     ngx_uint_t                            two;
  20. #if (NGX_HTTP_UPSTREAM_ZONE)
  21.     ngx_uint_t                            config;
  22. #endif
  23.     ngx_http_upstream_random_range_t     *ranges;
  24. ‌} ngx_http_upstream_random_srv_conf_t;


  27. ‌typedef struct {
  28.     /* the round robin data must be first */
  29.     ngx_http_upstream_rr_peer_data_t      rrp;

  31.     ngx_http_upstream_random_srv_conf_t  *conf;
  32.     u_char                                tries;
  33. ‌} ngx_http_upstream_random_peer_data_t;


  36. static ngx_int_t ngx_http_upstream_init_random(ngx_conf_t *cf,
  37.     ngx_http_upstream_srv_conf_t *us);
  38. static ngx_int_t ngx_http_upstream_update_random(ngx_pool_t *pool,
  39.     ngx_http_upstream_srv_conf_t *us);

  41. static ngx_int_t ngx_http_upstream_init_random_peer(ngx_http_request_t *r,
  42.     ngx_http_upstream_srv_conf_t *us);
  43. static ngx_int_t ngx_http_upstream_get_random_peer(ngx_peer_connection_t *pc,
  44.     void *data);
  45. static ngx_int_t ngx_http_upstream_get_random2_peer(ngx_peer_connection_t *pc,
  46.     void *data);
  47. static ngx_uint_t ngx_http_upstream_peek_random_peer(
  48.     ngx_http_upstream_rr_peers_t *peers,
  49.     ngx_http_upstream_random_peer_data_t *rp);
  50. static void *ngx_http_upstream_random_create_conf(ngx_conf_t *cf);
  51. static char *ngx_http_upstream_random(ngx_conf_t *cf, ngx_command_t *cmd,
  52.     void *conf);


  55. ‌static ngx_command_t  ngx_http_upstream_random_commands[] = {

  57.     { ngx_string("random"),
  58.       NGX_HTTP_UPS_CONF|NGX_CONF_NOARGS|NGX_CONF_TAKE12,
  59.       ngx_http_upstream_random,
  60.       NGX_HTTP_SRV_CONF_OFFSET,
  61.       0,
  62.       NULL },

  64.       ngx_null_command
  65. };


  68. ‌static ngx_http_module_t  ngx_http_upstream_random_module_ctx = {
  69.     NULL,                                  /* preconfiguration */
  70.     NULL,                                  /* postconfiguration */

  72.     NULL,                                  /* create main configuration */
  73.     NULL,                                  /* init main configuration */

  75.     ngx_http_upstream_random_create_conf,  /* create server configuration */
  76.     NULL,                                  /* merge server configuration */

  78.     NULL,                                  /* create location configuration */
  79.     NULL                                   /* merge location configuration */
  80. };


  83. ‌ngx_module_t  ngx_http_upstream_random_module = {
  84.     NGX_MODULE_V1,
  85.     &ngx_http_upstream_random_module_ctx,  /* module context */
  86.     ngx_http_upstream_random_commands,     /* module directives */
  87.     NGX_HTTP_MODULE,                       /* module type */
  88.     NULL,                                  /* init master */
  89.     NULL,                                  /* init module */
  90.     NULL,                                  /* init process */
  91.     NULL,                                  /* init thread */
  92.     NULL,                                  /* exit thread */
  93.     NULL,                                  /* exit process */
  94.     NULL,                                  /* exit master */
  95.     NGX_MODULE_V1_PADDING
  96. };


  99. static ngx_int_t
  100. ‌ngx_http_upstream_init_random(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us)
  101. {
  102.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0, "init random");

  104.     if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) {
  105.         return NGX_ERROR;
  106.     }

  108.     us->peer.init = ngx_http_upstream_init_random_peer;

  110. #if (NGX_HTTP_UPSTREAM_ZONE)
  111.     if (us->shm_zone) {
  112.         return NGX_OK;
  113.     }
  114. #endif

  116.     return ngx_http_upstream_update_random(cf->pool, us);
  117. }


  120. static ngx_int_t
  121. ‌ngx_http_upstream_update_random(ngx_pool_t *pool,
  122.     ngx_http_upstream_srv_conf_t *us)
  123. {
  124.     size_t                                size;
  125.     ngx_uint_t                            i, total_weight;
  126.     ngx_http_upstream_rr_peer_t          *peer;
  127.     ngx_http_upstream_rr_peers_t         *peers;
  128.     ngx_http_upstream_random_range_t     *ranges;
  129.     ngx_http_upstream_random_srv_conf_t  *rcf;

  131.     rcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_random_module);

  133.     if (rcf->ranges) {
  134.         ngx_free(rcf->ranges);
  135.         rcf->ranges = NULL;
  136.     }

  138.     peers = us->peer.data;

  140.     size = peers->number * sizeof(ngx_http_upstream_random_range_t);

  142.     ranges = pool ? ngx_palloc(pool, size) : ngx_alloc(size, ngx_cycle->log);
  143.     if (ranges == NULL) {
  144.         return NGX_ERROR;
  145.     }

  147.     total_weight = 0;

  149.     for (peer = peers->peer, i = 0; peer; peer = peer->next, i++) {
  150.         ranges[i].peer = peer;
  151.         ranges[i].range = total_weight;
  152.         total_weight += peer->weight;
  153.     }

  155.     rcf->ranges = ranges;

  157.     return NGX_OK;
  158. }


  161. static ngx_int_t
  162. ‌ngx_http_upstream_init_random_peer(ngx_http_request_t *r,
  163.     ngx_http_upstream_srv_conf_t *us)
  164. {
  165.     ngx_http_upstream_random_srv_conf_t   *rcf;
  166.     ngx_http_upstream_random_peer_data_t  *rp;

  168.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  169.                    "init random peer");

  171.     rcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_random_module);

  173.     rp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_random_peer_data_t));
  174.     if (rp == NULL) {
  175.         return NGX_ERROR;
  176.     }

  178.     r->upstream->peer.data = &rp->rrp;

  180.     if (ngx_http_upstream_init_round_robin_peer(r, us) != NGX_OK) {
  181.         return NGX_ERROR;
  182.     }

  184.     if (rcf->two) {
  185.         r->upstream->peer.get = ngx_http_upstream_get_random2_peer;

  187.     } else {
  188.         r->upstream->peer.get = ngx_http_upstream_get_random_peer;
  189.     }

  191.     rp->conf = rcf;
  192.     rp->tries = 0;

  194.     ngx_http_upstream_rr_peers_rlock(rp->rrp.peers);

  196. #if (NGX_HTTP_UPSTREAM_ZONE)
  197.     if (rp->rrp.peers->config
  198.         && (rcf->ranges == NULL || rcf->config != *rp->rrp.peers->config))
  199.     {
  200.         if (ngx_http_upstream_update_random(NULL, us) != NGX_OK) {
  201.             ngx_http_upstream_rr_peers_unlock(rp->rrp.peers);
  202.             return NGX_ERROR;
  203.         }

  205.         rcf->config = *rp->rrp.peers->config;
  206.     }
  207. #endif

  209.     ngx_http_upstream_rr_peers_unlock(rp->rrp.peers);

  211.     return NGX_OK;
  212. }


  215. static ngx_int_t
  216. ‌ngx_http_upstream_get_random_peer(ngx_peer_connection_t *pc, void *data)
  217. {
  218.     ngx_http_upstream_random_peer_data_t  *rp = data;

  220.     time_t                             now;
  221.     uintptr_t                          m;
  222.     ngx_uint_t                         i, n;
  223.     ngx_http_upstream_rr_peer_t       *peer;
  224.     ngx_http_upstream_rr_peers_t      *peers;
  225.     ngx_http_upstream_rr_peer_data_t  *rrp;

  227.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  228.                    "get random peer, try: %ui", pc->tries);

  230.     rrp = &rp->rrp;
  231.     peers = rrp->peers;

  233.     ngx_http_upstream_rr_peers_rlock(peers);

  235.     if (rp->tries > 20 || peers->number < 2) {
  236.         ngx_http_upstream_rr_peers_unlock(peers);
  237.         return ngx_http_upstream_get_round_robin_peer(pc, rrp);
  238.     }

  240. #if (NGX_HTTP_UPSTREAM_ZONE)
  241.     if (peers->config && rrp->config != *peers->config) {
  242.         ngx_http_upstream_rr_peers_unlock(peers);
  243.         return ngx_http_upstream_get_round_robin_peer(pc, rrp);
  244.     }
  245. #endif

  247.     pc->cached = 0;
  248.     pc->connection = NULL;

  250.     now = ngx_time();

  252. #if (NGX_HTTP_UPSTREAM_SID)
  253.     peer = ngx_http_upstream_get_rr_peer_by_sid(rrp, pc->hint, &i, 1);

  255.     if (peer) {
  256.         n = i / (8 * sizeof(uintptr_t));
  257.         m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

  259.         goto found;
  260.     }
  261. #endif

  263.     for ( ;; ) {

  265.         i = ngx_http_upstream_peek_random_peer(peers, rp);

  267.         peer = rp->conf->ranges[i].peer;

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

  272.         if (rrp->tried[n] & m) {
  273.             goto next;
  274.         }

  276.         ngx_http_upstream_rr_peer_lock(peers, peer);

  278.         if (peer->down) {
  279.             ngx_http_upstream_rr_peer_unlock(peers, peer);
  280.             goto next;
  281.         }

  283.         if (peer->max_fails
  284.             && peer->fails >= peer->max_fails
  285.             && now - peer->checked <= peer->fail_timeout)
  286.         {
  287.             ngx_http_upstream_rr_peer_unlock(peers, peer);
  288.             goto next;
  289.         }

  291.         if (peer->max_conns && peer->conns >= peer->max_conns) {
  292.             ngx_http_upstream_rr_peer_unlock(peers, peer);
  293.             goto next;
  294.         }

  296.         break;

  298.     next:

  300.         if (++rp->tries > 20) {
  301.             ngx_http_upstream_rr_peers_unlock(peers);
  302.             return ngx_http_upstream_get_round_robin_peer(pc, rrp);
  303.         }
  304.     }

  306. #if (NGX_HTTP_UPSTREAM_SID)
  307. found:
  308. #endif

  310.     rrp->current = peer;
  311.     ngx_http_upstream_rr_peer_ref(peers, peer);

  313.     if (now - peer->checked > peer->fail_timeout) {
  314.         peer->checked = now;
  315.     }

  317.     pc->sockaddr = peer->sockaddr;
  318.     pc->socklen = peer->socklen;
  319.     pc->name = &peer->name;

  321. #if (NGX_HTTP_UPSTREAM_SID)
  322.     pc->sid = &peer->sid;
  323. #endif

  325.     peer->conns++;

  327.     ngx_http_upstream_rr_peer_unlock(peers, peer);
  328.     ngx_http_upstream_rr_peers_unlock(peers);

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

  332.     return NGX_OK;
  333. }


  336. static ngx_int_t
  337. ‌ngx_http_upstream_get_random2_peer(ngx_peer_connection_t *pc, void *data)
  338. {
  339.     ngx_http_upstream_random_peer_data_t  *rp = data;

  341.     time_t                             now;
  342.     uintptr_t                          m;
  343.     ngx_uint_t                         i, n, p;
  344.     ngx_http_upstream_rr_peer_t       *peer, *prev;
  345.     ngx_http_upstream_rr_peers_t      *peers;
  346.     ngx_http_upstream_rr_peer_data_t  *rrp;

  348.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  349.                    "get random2 peer, try: %ui", pc->tries);

  351.     rrp = &rp->rrp;
  352.     peers = rrp->peers;

  354.     ngx_http_upstream_rr_peers_wlock(peers);

  356.     if (rp->tries > 20 || peers->number < 2) {
  357.         ngx_http_upstream_rr_peers_unlock(peers);
  358.         return ngx_http_upstream_get_round_robin_peer(pc, rrp);
  359.     }

  361. #if (NGX_HTTP_UPSTREAM_ZONE)
  362.     if (peers->config && rrp->config != *peers->config) {
  363.         ngx_http_upstream_rr_peers_unlock(peers);
  364.         return ngx_http_upstream_get_round_robin_peer(pc, rrp);
  365.     }
  366. #endif

  368.     pc->cached = 0;
  369.     pc->connection = NULL;

  371.     now = ngx_time();

  373.     prev = NULL;

  375. #if (NGX_SUPPRESS_WARN)
  376.     p = 0;
  377. #endif

  379. #if (NGX_HTTP_UPSTREAM_SID)
  380.     peer = ngx_http_upstream_get_rr_peer_by_sid(rrp, pc->hint, &i, 0);

  382.     if (peer) {
  383.         n = i / (8 * sizeof(uintptr_t));
  384.         m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

  386.         goto found;
  387.     }
  388. #endif

  390.     for ( ;; ) {

  392.         i = ngx_http_upstream_peek_random_peer(peers, rp);

  394.         peer = rp->conf->ranges[i].peer;

  396.         if (peer == prev) {
  397.             goto next;
  398.         }

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

  403.         if (rrp->tried[n] & m) {
  404.             goto next;
  405.         }

  407.         if (peer->down) {
  408.             goto next;
  409.         }

  411.         if (peer->max_fails
  412.             && peer->fails >= peer->max_fails
  413.             && now - peer->checked <= peer->fail_timeout)
  414.         {
  415.             goto next;
  416.         }

  418.         if (peer->max_conns && peer->conns >= peer->max_conns) {
  419.             goto next;
  420.         }

  422.         if (prev) {
  423.             if (peer->conns * prev->weight > prev->conns * peer->weight) {
  424.                 peer = prev;
  425.                 n = p / (8 * sizeof(uintptr_t));
  426.                 m = (uintptr_t) 1 << p % (8 * sizeof(uintptr_t));
  427.             }

  429.             break;
  430.         }

  432.         prev = peer;
  433.         p = i;

  435.     next:

  437.         if (++rp->tries > 20) {
  438.             ngx_http_upstream_rr_peers_unlock(peers);
  439.             return ngx_http_upstream_get_round_robin_peer(pc, rrp);
  440.         }
  441.     }

  443. #if (NGX_HTTP_UPSTREAM_SID)
  444. found:
  445. #endif

  447.     rrp->current = peer;
  448.     ngx_http_upstream_rr_peer_ref(peers, peer);

  450.     if (now - peer->checked > peer->fail_timeout) {
  451.         peer->checked = now;
  452.     }

  454.     pc->sockaddr = peer->sockaddr;
  455.     pc->socklen = peer->socklen;
  456.     pc->name = &peer->name;

  458. #if (NGX_HTTP_UPSTREAM_SID)
  459.     pc->sid = &peer->sid;
  460. #endif

  462.     peer->conns++;

  464.     ngx_http_upstream_rr_peers_unlock(peers);

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

  468.     return NGX_OK;
  469. }


  472. static ngx_uint_t
  473. ‌ngx_http_upstream_peek_random_peer(ngx_http_upstream_rr_peers_t *peers,
  474.     ngx_http_upstream_random_peer_data_t *rp)
  475. {
  476.     ngx_uint_t  i, j, k, x;

  478.     x = ngx_random() % peers->total_weight;

  480.     i = 0;
  481.     j = peers->number;

  483.     while (j - i > 1) {
  484.         k = (i + j) / 2;

  486.         if (x < rp->conf->ranges[k].range) {
  487.             j = k;

  489.         } else {
  490.             i = k;
  491.         }
  492.     }

  494.     return i;
  495. }


  498. static void *
  499. ‌ngx_http_upstream_random_create_conf(ngx_conf_t *cf)
  500. {
  501.     ngx_http_upstream_random_srv_conf_t  *conf;

  503.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_random_srv_conf_t));
  504.     if (conf == NULL) {
  505.         return NULL;
  506.     }

  508.     /*
  509.      * set by ngx_pcalloc():
  510.      *
  511.      *     conf->two = 0;
  512.      */

  514.     return conf;
  515. }


  518. static char *
  519. ‌ngx_http_upstream_random(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  520. {
  521.     ngx_http_upstream_random_srv_conf_t  *rcf = conf;

  523.     ngx_str_t                     *value;
  524.     ngx_http_upstream_srv_conf_t  *uscf;

  526.     uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);

  528.     if (uscf->peer.init_upstream) {
  529.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  530.                            "load balancing method redefined");
  531.     }

  533.     uscf->peer.init_upstream = ngx_http_upstream_init_random;

  535.     uscf->flags = NGX_HTTP_UPSTREAM_CREATE
  536.                   |NGX_HTTP_UPSTREAM_MODIFY
  537.                   |NGX_HTTP_UPSTREAM_WEIGHT
  538.                   |NGX_HTTP_UPSTREAM_MAX_CONNS
  539.                   |NGX_HTTP_UPSTREAM_MAX_FAILS
  540.                   |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
  541.                   |NGX_HTTP_UPSTREAM_DOWN;

  543.     if (cf->args->nelts == 1) {
  544.         return NGX_CONF_OK;
  545.     }

  547.     value = cf->args->elts;

  549.     if (ngx_strcmp(value[1].data, "two") == 0) {
  550.         rcf->two = 1;

  552.     } else {
  553.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  554.                            "invalid parameter \"%V\"", &value[1]);
  555.         return NGX_CONF_ERROR;
  556.     }

  558.     if (cf->args->nelts == 2) {
  559.         return NGX_CONF_OK;
  560.     }

  562.     if (ngx_strcmp(value[2].data, "least_conn") != 0) {
  563.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  564.                            "invalid parameter \"%V\"", &value[2]);
  565.         return NGX_CONF_ERROR;
  566.     }

  568.     return NGX_CONF_OK;
  569. }

One Level Up Top Level