One Level Up Top Level

src/http/modules/ngx_http_upstream_random_module.c - nginx source code

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.     for ( ;; ) {

  254.         i = ngx_http_upstream_peek_random_peer(peers, rp);

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

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

  261.         if (rrp->tried[n] & m) {
  262.             goto next;
  263.         }

  265.         ngx_http_upstream_rr_peer_lock(peers, peer);

  267.         if (peer->down) {
  268.             ngx_http_upstream_rr_peer_unlock(peers, peer);
  269.             goto next;
  270.         }

  272.         if (peer->max_fails
  273.             && peer->fails >= peer->max_fails
  274.             && now - peer->checked <= peer->fail_timeout)
  275.         {
  276.             ngx_http_upstream_rr_peer_unlock(peers, peer);
  277.             goto next;
  278.         }

  280.         if (peer->max_conns && peer->conns >= peer->max_conns) {
  281.             ngx_http_upstream_rr_peer_unlock(peers, peer);
  282.             goto next;
  283.         }

  285.         break;

  287.     next:

  289.         if (++rp->tries > 20) {
  290.             ngx_http_upstream_rr_peers_unlock(peers);
  291.             return ngx_http_upstream_get_round_robin_peer(pc, rrp);
  292.         }
  293.     }

  295.     rrp->current = peer;
  296.     ngx_http_upstream_rr_peer_ref(peers, peer);

  298.     if (now - peer->checked > peer->fail_timeout) {
  299.         peer->checked = now;
  300.     }

  302.     pc->sockaddr = peer->sockaddr;
  303.     pc->socklen = peer->socklen;
  304.     pc->name = &peer->name;

  306.     peer->conns++;

  308.     ngx_http_upstream_rr_peer_unlock(peers, peer);
  309.     ngx_http_upstream_rr_peers_unlock(peers);

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

  313.     return NGX_OK;
  314. }


  317. static ngx_int_t
  318. ‌ngx_http_upstream_get_random2_peer(ngx_peer_connection_t *pc, void *data)
  319. {
  320.     ngx_http_upstream_random_peer_data_t  *rp = data;

  322.     time_t                             now;
  323.     uintptr_t                          m;
  324.     ngx_uint_t                         i, n, p;
  325.     ngx_http_upstream_rr_peer_t       *peer, *prev;
  326.     ngx_http_upstream_rr_peers_t      *peers;
  327.     ngx_http_upstream_rr_peer_data_t  *rrp;

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

  332.     rrp = &rp->rrp;
  333.     peers = rrp->peers;

  335.     ngx_http_upstream_rr_peers_wlock(peers);

  337.     if (rp->tries > 20 || peers->number < 2) {
  338.         ngx_http_upstream_rr_peers_unlock(peers);
  339.         return ngx_http_upstream_get_round_robin_peer(pc, rrp);
  340.     }

  342. #if (NGX_HTTP_UPSTREAM_ZONE)
  343.     if (peers->config && rrp->config != *peers->config) {
  344.         ngx_http_upstream_rr_peers_unlock(peers);
  345.         return ngx_http_upstream_get_round_robin_peer(pc, rrp);
  346.     }
  347. #endif

  349.     pc->cached = 0;
  350.     pc->connection = NULL;

  352.     now = ngx_time();

  354.     prev = NULL;

  356. #if (NGX_SUPPRESS_WARN)
  357.     p = 0;
  358. #endif

  360.     for ( ;; ) {

  362.         i = ngx_http_upstream_peek_random_peer(peers, rp);

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

  366.         if (peer == prev) {
  367.             goto next;
  368.         }

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

  373.         if (rrp->tried[n] & m) {
  374.             goto next;
  375.         }

  377.         if (peer->down) {
  378.             goto next;
  379.         }

  381.         if (peer->max_fails
  382.             && peer->fails >= peer->max_fails
  383.             && now - peer->checked <= peer->fail_timeout)
  384.         {
  385.             goto next;
  386.         }

  388.         if (peer->max_conns && peer->conns >= peer->max_conns) {
  389.             goto next;
  390.         }

  392.         if (prev) {
  393.             if (peer->conns * prev->weight > prev->conns * peer->weight) {
  394.                 peer = prev;
  395.                 n = p / (8 * sizeof(uintptr_t));
  396.                 m = (uintptr_t) 1 << p % (8 * sizeof(uintptr_t));
  397.             }

  399.             break;
  400.         }

  402.         prev = peer;
  403.         p = i;

  405.     next:

  407.         if (++rp->tries > 20) {
  408.             ngx_http_upstream_rr_peers_unlock(peers);
  409.             return ngx_http_upstream_get_round_robin_peer(pc, rrp);
  410.         }
  411.     }

  413.     rrp->current = peer;
  414.     ngx_http_upstream_rr_peer_ref(peers, peer);

  416.     if (now - peer->checked > peer->fail_timeout) {
  417.         peer->checked = now;
  418.     }

  420.     pc->sockaddr = peer->sockaddr;
  421.     pc->socklen = peer->socklen;
  422.     pc->name = &peer->name;

  424.     peer->conns++;

  426.     ngx_http_upstream_rr_peers_unlock(peers);

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

  430.     return NGX_OK;
  431. }


  434. static ngx_uint_t
  435. ‌ngx_http_upstream_peek_random_peer(ngx_http_upstream_rr_peers_t *peers,
  436.     ngx_http_upstream_random_peer_data_t *rp)
  437. {
  438.     ngx_uint_t  i, j, k, x;

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

  442.     i = 0;
  443.     j = peers->number;

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

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

  451.         } else {
  452.             i = k;
  453.         }
  454.     }

  456.     return i;
  457. }


  460. static void *
  461. ‌ngx_http_upstream_random_create_conf(ngx_conf_t *cf)
  462. {
  463.     ngx_http_upstream_random_srv_conf_t  *conf;

  465.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_random_srv_conf_t));
  466.     if (conf == NULL) {
  467.         return NULL;
  468.     }

  470.     /*
  471.      * set by ngx_pcalloc():
  472.      *
  473.      *     conf->two = 0;
  474.      */

  476.     return conf;
  477. }


  480. static char *
  481. ‌ngx_http_upstream_random(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  482. {
  483.     ngx_http_upstream_random_srv_conf_t  *rcf = conf;

  485.     ngx_str_t                     *value;
  486.     ngx_http_upstream_srv_conf_t  *uscf;

  488.     uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);

  490.     if (uscf->peer.init_upstream) {
  491.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  492.                            "load balancing method redefined");
  493.     }

  495.     uscf->peer.init_upstream = ngx_http_upstream_init_random;

  497.     uscf->flags = NGX_HTTP_UPSTREAM_CREATE
  498.                   |NGX_HTTP_UPSTREAM_MODIFY
  499.                   |NGX_HTTP_UPSTREAM_WEIGHT
  500.                   |NGX_HTTP_UPSTREAM_MAX_CONNS
  501.                   |NGX_HTTP_UPSTREAM_MAX_FAILS
  502.                   |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
  503.                   |NGX_HTTP_UPSTREAM_DOWN;

  505.     if (cf->args->nelts == 1) {
  506.         return NGX_CONF_OK;
  507.     }

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

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

  514.     } else {
  515.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  516.                            "invalid parameter \"%V\"", &value[1]);
  517.         return NGX_CONF_ERROR;
  518.     }

  520.     if (cf->args->nelts == 2) {
  521.         return NGX_CONF_OK;
  522.     }

  524.     if (ngx_strcmp(value[2].data, "least_conn") != 0) {
  525.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  526.                            "invalid parameter \"%V\"", &value[2]);
  527.         return NGX_CONF_ERROR;
  528.     }

  530.     return NGX_CONF_OK;
  531. }

One Level Up Top Level