One Level Up Top Level

src/http/modules/ngx_http_upstream_hash_module.c - nginx

Global variables defined

Data types defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Roman Arutyunyan
  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.     uint32_t                            hash;
  15.     ngx_str_t                          *server;
  16. ‌} ngx_http_upstream_chash_point_t;


  19. ‌typedef struct {
  20.     ngx_uint_t                          number;
  21.     ngx_http_upstream_chash_point_t     point[1];
  22. ‌} ngx_http_upstream_chash_points_t;


  25. ‌typedef struct {
  26.     ngx_http_complex_value_t            key;
  27. #if (NGX_HTTP_UPSTREAM_ZONE)
  28.     ngx_uint_t                          config;
  29. #endif
  30.     ngx_http_upstream_chash_points_t   *points;
  31. ‌} ngx_http_upstream_hash_srv_conf_t;


  34. ‌typedef struct {
  35.     /* the round robin data must be first */
  36.     ngx_http_upstream_rr_peer_data_t    rrp;
  37.     ngx_http_upstream_hash_srv_conf_t  *conf;
  38.     ngx_str_t                           key;
  39.     ngx_uint_t                          tries;
  40.     ngx_uint_t                          rehash;
  41.     uint32_t                            hash;
  42.     ngx_event_get_peer_pt               get_rr_peer;
  43. ‌} ngx_http_upstream_hash_peer_data_t;


  46. static ngx_int_t ngx_http_upstream_init_hash(ngx_conf_t *cf,
  47.     ngx_http_upstream_srv_conf_t *us);
  48. static ngx_int_t ngx_http_upstream_init_hash_peer(ngx_http_request_t *r,
  49.     ngx_http_upstream_srv_conf_t *us);
  50. static ngx_int_t ngx_http_upstream_get_hash_peer(ngx_peer_connection_t *pc,
  51.     void *data);

  53. static ngx_int_t ngx_http_upstream_init_chash(ngx_conf_t *cf,
  54.     ngx_http_upstream_srv_conf_t *us);
  55. static ngx_int_t ngx_http_upstream_update_chash(ngx_pool_t *pool,
  56.     ngx_http_upstream_srv_conf_t *us);
  57. static int ngx_libc_cdecl
  58.     ngx_http_upstream_chash_cmp_points(const void *one, const void *two);
  59. static ngx_uint_t ngx_http_upstream_find_chash_point(
  60.     ngx_http_upstream_chash_points_t *points, uint32_t hash);
  61. static ngx_int_t ngx_http_upstream_init_chash_peer(ngx_http_request_t *r,
  62.     ngx_http_upstream_srv_conf_t *us);
  63. static ngx_int_t ngx_http_upstream_get_chash_peer(ngx_peer_connection_t *pc,
  64.     void *data);

  66. static void *ngx_http_upstream_hash_create_conf(ngx_conf_t *cf);
  67. static char *ngx_http_upstream_hash(ngx_conf_t *cf, ngx_command_t *cmd,
  68.     void *conf);


  71. ‌static ngx_command_t  ngx_http_upstream_hash_commands[] = {

  73.     { ngx_string("hash"),
  74.       NGX_HTTP_UPS_CONF|NGX_CONF_TAKE12,
  75.       ngx_http_upstream_hash,
  76.       NGX_HTTP_SRV_CONF_OFFSET,
  77.       0,
  78.       NULL },

  80.       ngx_null_command
  81. };


  84. ‌static ngx_http_module_t  ngx_http_upstream_hash_module_ctx = {
  85.     NULL,                                  /* preconfiguration */
  86.     NULL,                                  /* postconfiguration */

  88.     NULL,                                  /* create main configuration */
  89.     NULL,                                  /* init main configuration */

  91.     ngx_http_upstream_hash_create_conf,    /* create server configuration */
  92.     NULL,                                  /* merge server configuration */

  94.     NULL,                                  /* create location configuration */
  95.     NULL                                   /* merge location configuration */
  96. };


  99. ‌ngx_module_t  ngx_http_upstream_hash_module = {
  100.     NGX_MODULE_V1,
  101.     &ngx_http_upstream_hash_module_ctx,    /* module context */
  102.     ngx_http_upstream_hash_commands,       /* module directives */
  103.     NGX_HTTP_MODULE,                       /* module type */
  104.     NULL,                                  /* init master */
  105.     NULL,                                  /* init module */
  106.     NULL,                                  /* init process */
  107.     NULL,                                  /* init thread */
  108.     NULL,                                  /* exit thread */
  109.     NULL,                                  /* exit process */
  110.     NULL,                                  /* exit master */
  111.     NGX_MODULE_V1_PADDING
  112. };


  115. static ngx_int_t
  116. ‌ngx_http_upstream_init_hash(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us)
  117. {
  118.     if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) {
  119.         return NGX_ERROR;
  120.     }

  122.     us->peer.init = ngx_http_upstream_init_hash_peer;

  124.     return NGX_OK;
  125. }


  128. static ngx_int_t
  129. ‌ngx_http_upstream_init_hash_peer(ngx_http_request_t *r,
  130.     ngx_http_upstream_srv_conf_t *us)
  131. {
  132.     ngx_http_upstream_hash_srv_conf_t   *hcf;
  133.     ngx_http_upstream_hash_peer_data_t  *hp;

  135.     hp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_hash_peer_data_t));
  136.     if (hp == NULL) {
  137.         return NGX_ERROR;
  138.     }

  140.     r->upstream->peer.data = &hp->rrp;

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

  146.     r->upstream->peer.get = ngx_http_upstream_get_hash_peer;

  148.     hcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_hash_module);

  150.     if (ngx_http_complex_value(r, &hcf->key, &hp->key) != NGX_OK) {
  151.         return NGX_ERROR;
  152.     }

  154.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  155.                    "upstream hash key:\"%V\"", &hp->key);

  157.     hp->conf = hcf;
  158.     hp->tries = 0;
  159.     hp->rehash = 0;
  160.     hp->hash = 0;
  161.     hp->get_rr_peer = ngx_http_upstream_get_round_robin_peer;

  163.     return NGX_OK;
  164. }


  167. static ngx_int_t
  168. ‌ngx_http_upstream_get_hash_peer(ngx_peer_connection_t *pc, void *data)
  169. {
  170.     ngx_http_upstream_hash_peer_data_t  *hp = data;

  172.     time_t                        now;
  173.     u_char                        buf[NGX_INT_T_LEN];
  174.     size_t                        size;
  175.     uint32_t                      hash;
  176.     ngx_int_t                     w;
  177.     uintptr_t                     m;
  178.     ngx_uint_t                    n, p;
  179.     ngx_http_upstream_rr_peer_t  *peer;

  181.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  182.                    "get hash peer, try: %ui", pc->tries);

  184.     ngx_http_upstream_rr_peers_rlock(hp->rrp.peers);

  186.     if (hp->tries > 20 || hp->rrp.peers->number < 2 || hp->key.len == 0) {
  187.         ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
  188.         return hp->get_rr_peer(pc, &hp->rrp);
  189.     }

  191. #if (NGX_HTTP_UPSTREAM_ZONE)
  192.     if (hp->rrp.peers->config && hp->rrp.config != *hp->rrp.peers->config) {
  193.         ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
  194.         return hp->get_rr_peer(pc, &hp->rrp);
  195.     }
  196. #endif

  198.     now = ngx_time();

  200.     pc->cached = 0;
  201.     pc->connection = NULL;

  203. #if (NGX_HTTP_UPSTREAM_SID)
  204.     peer = ngx_http_upstream_get_rr_peer_by_sid(&hp->rrp, pc->hint, &p, 1);

  206.     if (peer) {
  207.         n = p / (8 * sizeof(uintptr_t));
  208.         m = (uintptr_t) 1 << p % (8 * sizeof(uintptr_t));

  210.         goto found;
  211.     }
  212. #endif

  214.     for ( ;; ) {

  216.         /*
  217.          * Hash expression is compatible with Cache::Memcached:
  218.          * ((crc32([REHASH] KEY) >> 16) & 0x7fff) + PREV_HASH
  219.          * with REHASH omitted at the first iteration.
  220.          */

  222.         ngx_crc32_init(hash);

  224.         if (hp->rehash > 0) {
  225.             size = ngx_sprintf(buf, "%ui", hp->rehash) - buf;
  226.             ngx_crc32_update(&hash, buf, size);
  227.         }

  229.         ngx_crc32_update(&hash, hp->key.data, hp->key.len);
  230.         ngx_crc32_final(hash);

  232.         hash = (hash >> 16) & 0x7fff;

  234.         hp->hash += hash;
  235.         hp->rehash++;

  237.         w = hp->hash % hp->rrp.peers->total_weight;
  238.         peer = hp->rrp.peers->peer;
  239.         p = 0;

  241.         while (w >= peer->weight) {
  242.             w -= peer->weight;
  243.             peer = peer->next;
  244.             p++;
  245.         }

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

  250.         if (hp->rrp.tried[n] & m) {
  251.             goto next;
  252.         }

  254.         ngx_http_upstream_rr_peer_lock(hp->rrp.peers, peer);

  256.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  257.                        "get hash peer, value:%uD, peer:%ui", hp->hash, p);

  259.         if (peer->down) {
  260.             ngx_http_upstream_rr_peer_unlock(hp->rrp.peers, peer);
  261.             goto next;
  262.         }

  264.         if (peer->max_fails
  265.             && peer->fails >= peer->max_fails
  266.             && now - peer->checked <= peer->fail_timeout)
  267.         {
  268.             ngx_http_upstream_rr_peer_unlock(hp->rrp.peers, peer);
  269.             goto next;
  270.         }

  272.         if (peer->max_conns && peer->conns >= peer->max_conns) {
  273.             ngx_http_upstream_rr_peer_unlock(hp->rrp.peers, peer);
  274.             goto next;
  275.         }

  277.         break;

  279.     next:

  281.         if (++hp->tries > 20) {
  282.             ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
  283.             return hp->get_rr_peer(pc, &hp->rrp);
  284.         }
  285.     }

  287. #if (NGX_HTTP_UPSTREAM_SID)
  288. found:
  289. #endif

  291.     hp->rrp.current = peer;
  292.     ngx_http_upstream_rr_peer_ref(hp->rrp.peers, peer);

  294.     pc->sockaddr = peer->sockaddr;
  295.     pc->socklen = peer->socklen;
  296.     pc->name = &peer->name;

  298. #if (NGX_HTTP_UPSTREAM_SID)
  299.     pc->sid = &peer->sid;
  300. #endif

  302.     peer->conns++;

  304.     if (now - peer->checked > peer->fail_timeout) {
  305.         peer->checked = now;
  306.     }

  308.     ngx_http_upstream_rr_peer_unlock(hp->rrp.peers, peer);
  309.     ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);

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

  313.     return NGX_OK;
  314. }


  317. static ngx_int_t
  318. ‌ngx_http_upstream_init_chash(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us)
  319. {
  320.     if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) {
  321.         return NGX_ERROR;
  322.     }

  324.     us->peer.init = ngx_http_upstream_init_chash_peer;

  326. #if (NGX_HTTP_UPSTREAM_ZONE)
  327.     if (us->shm_zone) {
  328.         return NGX_OK;
  329.     }
  330. #endif

  332.     return ngx_http_upstream_update_chash(cf->pool, us);
  333. }


  336. static ngx_int_t
  337. ‌ngx_http_upstream_update_chash(ngx_pool_t *pool,
  338.     ngx_http_upstream_srv_conf_t *us)
  339. {
  340.     u_char                             *host, *port, c;
  341.     size_t                              host_len, port_len, size;
  342.     uint32_t                            hash, base_hash;
  343.     ngx_str_t                          *server;
  344.     ngx_uint_t                          npoints, i, j;
  345.     ngx_http_upstream_rr_peer_t        *peer;
  346.     ngx_http_upstream_rr_peers_t       *peers;
  347.     ngx_http_upstream_chash_points_t   *points;
  348.     ngx_http_upstream_hash_srv_conf_t  *hcf;
  349. ‌    union {
  350.         uint32_t                        value;
  351.         u_char                          byte[4];
  352.     } prev_hash;

  354.     hcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_hash_module);

  356.     if (hcf->points) {
  357.         ngx_free(hcf->points);
  358.         hcf->points = NULL;
  359.     }

  361.     peers = us->peer.data;
  362.     npoints = peers->total_weight * 160;

  364.     size = sizeof(ngx_http_upstream_chash_points_t)
  365.            - sizeof(ngx_http_upstream_chash_point_t)
  366.            + sizeof(ngx_http_upstream_chash_point_t) * npoints;

  368.     points = pool ? ngx_palloc(pool, size) : ngx_alloc(size, ngx_cycle->log);
  369.     if (points == NULL) {
  370.         return NGX_ERROR;
  371.     }

  373.     points->number = 0;

  375.     if (npoints == 0) {
  376.         hcf->points = points;
  377.         return NGX_OK;
  378.     }

  380.     for (peer = peers->peer; peer; peer = peer->next) {
  381.         server = &peer->server;

  383.         /*
  384.          * Hash expression is compatible with Cache::Memcached::Fast:
  385.          * crc32(HOST \0 PORT PREV_HASH).
  386.          */

  388.         if (server->len >= 5
  389.             && ngx_strncasecmp(server->data, (u_char *) "unix:", 5) == 0)
  390.         {
  391.             host = server->data + 5;
  392.             host_len = server->len - 5;
  393.             port = NULL;
  394.             port_len = 0;
  395.             goto done;
  396.         }

  398.         for (j = 0; j < server->len; j++) {
  399.             c = server->data[server->len - j - 1];

  401.             if (c == ':') {
  402.                 host = server->data;
  403.                 host_len = server->len - j - 1;
  404.                 port = server->data + server->len - j;
  405.                 port_len = j;
  406.                 goto done;
  407.             }

  409.             if (c < '0' || c > '9') {
  410.                 break;
  411.             }
  412.         }

  414.         host = server->data;
  415.         host_len = server->len;
  416.         port = NULL;
  417.         port_len = 0;

  419.     done:

  421.         ngx_crc32_init(base_hash);
  422.         ngx_crc32_update(&base_hash, host, host_len);
  423.         ngx_crc32_update(&base_hash, (u_char *) "", 1);
  424.         ngx_crc32_update(&base_hash, port, port_len);

  426.         prev_hash.value = 0;
  427.         npoints = peer->weight * 160;

  429.         for (j = 0; j < npoints; j++) {
  430.             hash = base_hash;

  432.             ngx_crc32_update(&hash, prev_hash.byte, 4);
  433.             ngx_crc32_final(hash);

  435.             points->point[points->number].hash = hash;
  436.             points->point[points->number].server = server;
  437.             points->number++;

  439. #if (NGX_HAVE_LITTLE_ENDIAN)
  440.             prev_hash.value = hash;
  441. #else
  442.             prev_hash.byte[0] = (u_char) (hash & 0xff);
  443.             prev_hash.byte[1] = (u_char) ((hash >> 8) & 0xff);
  444.             prev_hash.byte[2] = (u_char) ((hash >> 16) & 0xff);
  445.             prev_hash.byte[3] = (u_char) ((hash >> 24) & 0xff);
  446. #endif
  447.         }
  448.     }

  450.     ngx_qsort(points->point,
  451.               points->number,
  452.               sizeof(ngx_http_upstream_chash_point_t),
  453.               ngx_http_upstream_chash_cmp_points);

  455.     for (i = 0, j = 1; j < points->number; j++) {
  456.         if (points->point[i].hash != points->point[j].hash) {
  457.             points->point[++i] = points->point[j];
  458.         }
  459.     }

  461.     points->number = i + 1;

  463.     hcf->points = points;

  465.     return NGX_OK;
  466. }


  469. static int ngx_libc_cdecl
  470. ‌ngx_http_upstream_chash_cmp_points(const void *one, const void *two)
  471. {
  472.     ngx_http_upstream_chash_point_t *first =
  473.                                        (ngx_http_upstream_chash_point_t *) one;
  474.     ngx_http_upstream_chash_point_t *second =
  475.                                        (ngx_http_upstream_chash_point_t *) two;

  477.     if (first->hash < second->hash) {
  478.         return -1;

  480.     } else if (first->hash > second->hash) {
  481.         return 1;

  483.     } else {
  484.         return 0;
  485.     }
  486. }


  489. static ngx_uint_t
  490. ‌ngx_http_upstream_find_chash_point(ngx_http_upstream_chash_points_t *points,
  491.     uint32_t hash)
  492. {
  493.     ngx_uint_t                        i, j, k;
  494.     ngx_http_upstream_chash_point_t  *point;

  496.     /* find first point >= hash */

  498.     point = &points->point[0];

  500.     i = 0;
  501.     j = points->number;

  503.     while (i < j) {
  504.         k = (i + j) / 2;

  506.         if (hash > point[k].hash) {
  507.             i = k + 1;

  509.         } else if (hash < point[k].hash) {
  510.             j = k;

  512.         } else {
  513.             return k;
  514.         }
  515.     }

  517.     return i;
  518. }


  521. static ngx_int_t
  522. ‌ngx_http_upstream_init_chash_peer(ngx_http_request_t *r,
  523.     ngx_http_upstream_srv_conf_t *us)
  524. {
  525.     uint32_t                             hash;
  526.     ngx_http_upstream_hash_srv_conf_t   *hcf;
  527.     ngx_http_upstream_hash_peer_data_t  *hp;

  529.     if (ngx_http_upstream_init_hash_peer(r, us) != NGX_OK) {
  530.         return NGX_ERROR;
  531.     }

  533.     r->upstream->peer.get = ngx_http_upstream_get_chash_peer;

  535.     hp = r->upstream->peer.data;
  536.     hcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_hash_module);

  538.     hash = ngx_crc32_long(hp->key.data, hp->key.len);

  540.     ngx_http_upstream_rr_peers_rlock(hp->rrp.peers);

  542. #if (NGX_HTTP_UPSTREAM_ZONE)
  543.     if (hp->rrp.peers->config
  544.         && (hcf->points == NULL || hcf->config != *hp->rrp.peers->config))
  545.     {
  546.         if (ngx_http_upstream_update_chash(NULL, us) != NGX_OK) {
  547.             ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
  548.             return NGX_ERROR;
  549.         }

  551.         hcf->config = *hp->rrp.peers->config;
  552.     }
  553. #endif

  555.     if (hcf->points->number) {
  556.         hp->hash = ngx_http_upstream_find_chash_point(hcf->points, hash);
  557.     }

  559.     ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);

  561.     return NGX_OK;
  562. }


  565. static ngx_int_t
  566. ‌ngx_http_upstream_get_chash_peer(ngx_peer_connection_t *pc, void *data)
  567. {
  568.     ngx_http_upstream_hash_peer_data_t  *hp = data;

  570.     time_t                              now;
  571.     intptr_t                            m;
  572.     ngx_str_t                          *server;
  573.     ngx_int_t                           total;
  574.     ngx_uint_t                          i, n, best_i;
  575.     ngx_http_upstream_rr_peer_t        *peer, *best;
  576.     ngx_http_upstream_chash_point_t    *point;
  577.     ngx_http_upstream_chash_points_t   *points;
  578.     ngx_http_upstream_hash_srv_conf_t  *hcf;

  580.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  581.                    "get consistent hash peer, try: %ui", pc->tries);

  583.     ngx_http_upstream_rr_peers_wlock(hp->rrp.peers);

  585.     if (hp->tries > 20 || hp->rrp.peers->single || hp->key.len == 0) {
  586.         ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
  587.         return hp->get_rr_peer(pc, &hp->rrp);
  588.     }

  590.     pc->cached = 0;
  591.     pc->connection = NULL;

  593.     if (hp->rrp.peers->number == 0) {
  594.         pc->name = hp->rrp.peers->name;
  595.         ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
  596.         return NGX_BUSY;
  597.     }

  599. #if (NGX_HTTP_UPSTREAM_ZONE)
  600.     if (hp->rrp.peers->config && hp->rrp.config != *hp->rrp.peers->config) {
  601.         pc->name = hp->rrp.peers->name;
  602.         ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
  603.         return NGX_BUSY;
  604.     }
  605. #endif

  607.     now = ngx_time();
  608.     hcf = hp->conf;

  610.     points = hcf->points;
  611.     point = &points->point[0];

  613. #if (NGX_HTTP_UPSTREAM_SID)
  614.     best = ngx_http_upstream_get_rr_peer_by_sid(&hp->rrp, pc->hint, &best_i, 0);

  616.     if (best) {
  617.         goto found;
  618.     }
  619. #endif

  621.     for ( ;; ) {
  622.         server = point[hp->hash % points->number].server;

  624.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  625.                        "consistent hash peer:%uD, server:\"%V\"",
  626.                        hp->hash, server);

  628.         best = NULL;
  629.         best_i = 0;
  630.         total = 0;

  632.         for (peer = hp->rrp.peers->peer, i = 0;
  633.              peer;
  634.              peer = peer->next, i++)
  635.         {
  636.             n = i / (8 * sizeof(uintptr_t));
  637.             m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

  639.             if (hp->rrp.tried[n] & m) {
  640.                 continue;
  641.             }

  643.             if (peer->down) {
  644.                 continue;
  645.             }

  647.             if (peer->max_fails
  648.                 && peer->fails >= peer->max_fails
  649.                 && now - peer->checked <= peer->fail_timeout)
  650.             {
  651.                 continue;
  652.             }

  654.             if (peer->max_conns && peer->conns >= peer->max_conns) {
  655.                 continue;
  656.             }

  658.             if (peer->server.len != server->len
  659.                 || ngx_strncmp(peer->server.data, server->data, server->len)
  660.                    != 0)
  661.             {
  662.                 continue;
  663.             }

  665.             peer->current_weight += peer->effective_weight;
  666.             total += peer->effective_weight;

  668.             if (peer->effective_weight < peer->weight) {
  669.                 peer->effective_weight++;
  670.             }

  672.             if (best == NULL || peer->current_weight > best->current_weight) {
  673.                 best = peer;
  674.                 best_i = i;
  675.             }
  676.         }

  678.         if (best) {
  679.             best->current_weight -= total;
  680.             goto found;
  681.         }

  683.         hp->hash++;
  684.         hp->tries++;

  686.         if (hp->tries > 20) {
  687.             ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
  688.             return hp->get_rr_peer(pc, &hp->rrp);
  689.         }
  690.     }

  692. found:

  694.     hp->rrp.current = best;
  695.     ngx_http_upstream_rr_peer_ref(hp->rrp.peers, best);

  697.     pc->sockaddr = best->sockaddr;
  698.     pc->socklen = best->socklen;
  699.     pc->name = &best->name;

  701. #if (NGX_HTTP_UPSTREAM_SID)
  702.     pc->sid = &best->sid;
  703. #endif

  705.     best->conns++;

  707.     if (now - best->checked > best->fail_timeout) {
  708.         best->checked = now;
  709.     }

  711.     ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);

  713.     n = best_i / (8 * sizeof(uintptr_t));
  714.     m = (uintptr_t) 1 << best_i % (8 * sizeof(uintptr_t));

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

  718.     return NGX_OK;
  719. }


  722. static void *
  723. ‌ngx_http_upstream_hash_create_conf(ngx_conf_t *cf)
  724. {
  725.     ngx_http_upstream_hash_srv_conf_t  *conf;

  727.     conf = ngx_palloc(cf->pool, sizeof(ngx_http_upstream_hash_srv_conf_t));
  728.     if (conf == NULL) {
  729.         return NULL;
  730.     }

  732.     conf->points = NULL;

  734.     return conf;
  735. }


  738. static char *
  739. ‌ngx_http_upstream_hash(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  740. {
  741.     ngx_http_upstream_hash_srv_conf_t  *hcf = conf;

  743.     ngx_str_t                         *value;
  744.     ngx_http_upstream_srv_conf_t      *uscf;
  745.     ngx_http_compile_complex_value_t   ccv;

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

  749.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  751.     ccv.cf = cf;
  752.     ccv.value = &value[1];
  753.     ccv.complex_value = &hcf->key;

  755.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  756.         return NGX_CONF_ERROR;
  757.     }

  759.     uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);

  761.     if (uscf->peer.init_upstream) {
  762.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  763.                            "load balancing method redefined");
  764.     }

  766.     uscf->flags = NGX_HTTP_UPSTREAM_CREATE
  767.                   |NGX_HTTP_UPSTREAM_MODIFY
  768.                   |NGX_HTTP_UPSTREAM_WEIGHT
  769.                   |NGX_HTTP_UPSTREAM_MAX_CONNS
  770.                   |NGX_HTTP_UPSTREAM_MAX_FAILS
  771.                   |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
  772.                   |NGX_HTTP_UPSTREAM_DOWN;

  774.     if (cf->args->nelts == 2) {
  775.         uscf->peer.init_upstream = ngx_http_upstream_init_hash;

  777.     } else if (ngx_strcmp(value[2].data, "consistent") == 0) {
  778.         uscf->peer.init_upstream = ngx_http_upstream_init_chash;

  780.     } else {
  781.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  782.                            "invalid parameter \"%V\"", &value[2]);
  783.         return NGX_CONF_ERROR;
  784.     }

  786.     return NGX_CONF_OK;
  787. }

One Level Up Top Level