One Level Up Top Level

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

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

  205.         /*
  206.          * Hash expression is compatible with Cache::Memcached:
  207.          * ((crc32([REHASH] KEY) >> 16) & 0x7fff) + PREV_HASH
  208.          * with REHASH omitted at the first iteration.
  209.          */

  211.         ngx_crc32_init(hash);

  213.         if (hp->rehash > 0) {
  214.             size = ngx_sprintf(buf, "%ui", hp->rehash) - buf;
  215.             ngx_crc32_update(&hash, buf, size);
  216.         }

  218.         ngx_crc32_update(&hash, hp->key.data, hp->key.len);
  219.         ngx_crc32_final(hash);

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

  223.         hp->hash += hash;
  224.         hp->rehash++;

  226.         w = hp->hash % hp->rrp.peers->total_weight;
  227.         peer = hp->rrp.peers->peer;
  228.         p = 0;

  230.         while (w >= peer->weight) {
  231.             w -= peer->weight;
  232.             peer = peer->next;
  233.             p++;
  234.         }

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

  239.         if (hp->rrp.tried[n] & m) {
  240.             goto next;
  241.         }

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

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

  248.         if (peer->down) {
  249.             ngx_http_upstream_rr_peer_unlock(hp->rrp.peers, peer);
  250.             goto next;
  251.         }

  253.         if (peer->max_fails
  254.             && peer->fails >= peer->max_fails
  255.             && now - peer->checked <= peer->fail_timeout)
  256.         {
  257.             ngx_http_upstream_rr_peer_unlock(hp->rrp.peers, peer);
  258.             goto next;
  259.         }

  261.         if (peer->max_conns && peer->conns >= peer->max_conns) {
  262.             ngx_http_upstream_rr_peer_unlock(hp->rrp.peers, peer);
  263.             goto next;
  264.         }

  266.         break;

  268.     next:

  270.         if (++hp->tries > 20) {
  271.             ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
  272.             return hp->get_rr_peer(pc, &hp->rrp);
  273.         }
  274.     }

  276.     hp->rrp.current = peer;
  277.     ngx_http_upstream_rr_peer_ref(hp->rrp.peers, peer);

  279.     pc->sockaddr = peer->sockaddr;
  280.     pc->socklen = peer->socklen;
  281.     pc->name = &peer->name;

  283.     peer->conns++;

  285.     if (now - peer->checked > peer->fail_timeout) {
  286.         peer->checked = now;
  287.     }

  289.     ngx_http_upstream_rr_peer_unlock(hp->rrp.peers, peer);
  290.     ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);

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

  294.     return NGX_OK;
  295. }


  298. static ngx_int_t
  299. ‌ngx_http_upstream_init_chash(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us)
  300. {
  301.     if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) {
  302.         return NGX_ERROR;
  303.     }

  305.     us->peer.init = ngx_http_upstream_init_chash_peer;

  307. #if (NGX_HTTP_UPSTREAM_ZONE)
  308.     if (us->shm_zone) {
  309.         return NGX_OK;
  310.     }
  311. #endif

  313.     return ngx_http_upstream_update_chash(cf->pool, us);
  314. }


  317. static ngx_int_t
  318. ‌ngx_http_upstream_update_chash(ngx_pool_t *pool,
  319.     ngx_http_upstream_srv_conf_t *us)
  320. {
  321.     u_char                             *host, *port, c;
  322.     size_t                              host_len, port_len, size;
  323.     uint32_t                            hash, base_hash;
  324.     ngx_str_t                          *server;
  325.     ngx_uint_t                          npoints, i, j;
  326.     ngx_http_upstream_rr_peer_t        *peer;
  327.     ngx_http_upstream_rr_peers_t       *peers;
  328.     ngx_http_upstream_chash_points_t   *points;
  329.     ngx_http_upstream_hash_srv_conf_t  *hcf;
  330. ‌    union {
  331.         uint32_t                        value;
  332.         u_char                          byte[4];
  333.     } prev_hash;

  335.     hcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_hash_module);

  337.     if (hcf->points) {
  338.         ngx_free(hcf->points);
  339.         hcf->points = NULL;
  340.     }

  342.     peers = us->peer.data;
  343.     npoints = peers->total_weight * 160;

  345.     size = sizeof(ngx_http_upstream_chash_points_t)
  346.            - sizeof(ngx_http_upstream_chash_point_t)
  347.            + sizeof(ngx_http_upstream_chash_point_t) * npoints;

  349.     points = pool ? ngx_palloc(pool, size) : ngx_alloc(size, ngx_cycle->log);
  350.     if (points == NULL) {
  351.         return NGX_ERROR;
  352.     }

  354.     points->number = 0;

  356.     if (npoints == 0) {
  357.         hcf->points = points;
  358.         return NGX_OK;
  359.     }

  361.     for (peer = peers->peer; peer; peer = peer->next) {
  362.         server = &peer->server;

  364.         /*
  365.          * Hash expression is compatible with Cache::Memcached::Fast:
  366.          * crc32(HOST \0 PORT PREV_HASH).
  367.          */

  369.         if (server->len >= 5
  370.             && ngx_strncasecmp(server->data, (u_char *) "unix:", 5) == 0)
  371.         {
  372.             host = server->data + 5;
  373.             host_len = server->len - 5;
  374.             port = NULL;
  375.             port_len = 0;
  376.             goto done;
  377.         }

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

  382.             if (c == ':') {
  383.                 host = server->data;
  384.                 host_len = server->len - j - 1;
  385.                 port = server->data + server->len - j;
  386.                 port_len = j;
  387.                 goto done;
  388.             }

  390.             if (c < '0' || c > '9') {
  391.                 break;
  392.             }
  393.         }

  395.         host = server->data;
  396.         host_len = server->len;
  397.         port = NULL;
  398.         port_len = 0;

  400.     done:

  402.         ngx_crc32_init(base_hash);
  403.         ngx_crc32_update(&base_hash, host, host_len);
  404.         ngx_crc32_update(&base_hash, (u_char *) "", 1);
  405.         ngx_crc32_update(&base_hash, port, port_len);

  407.         prev_hash.value = 0;
  408.         npoints = peer->weight * 160;

  410.         for (j = 0; j < npoints; j++) {
  411.             hash = base_hash;

  413.             ngx_crc32_update(&hash, prev_hash.byte, 4);
  414.             ngx_crc32_final(hash);

  416.             points->point[points->number].hash = hash;
  417.             points->point[points->number].server = server;
  418.             points->number++;

  420. #if (NGX_HAVE_LITTLE_ENDIAN)
  421.             prev_hash.value = hash;
  422. #else
  423.             prev_hash.byte[0] = (u_char) (hash & 0xff);
  424.             prev_hash.byte[1] = (u_char) ((hash >> 8) & 0xff);
  425.             prev_hash.byte[2] = (u_char) ((hash >> 16) & 0xff);
  426.             prev_hash.byte[3] = (u_char) ((hash >> 24) & 0xff);
  427. #endif
  428.         }
  429.     }

  431.     ngx_qsort(points->point,
  432.               points->number,
  433.               sizeof(ngx_http_upstream_chash_point_t),
  434.               ngx_http_upstream_chash_cmp_points);

  436.     for (i = 0, j = 1; j < points->number; j++) {
  437.         if (points->point[i].hash != points->point[j].hash) {
  438.             points->point[++i] = points->point[j];
  439.         }
  440.     }

  442.     points->number = i + 1;

  444.     hcf->points = points;

  446.     return NGX_OK;
  447. }


  450. static int ngx_libc_cdecl
  451. ‌ngx_http_upstream_chash_cmp_points(const void *one, const void *two)
  452. {
  453.     ngx_http_upstream_chash_point_t *first =
  454.                                        (ngx_http_upstream_chash_point_t *) one;
  455.     ngx_http_upstream_chash_point_t *second =
  456.                                        (ngx_http_upstream_chash_point_t *) two;

  458.     if (first->hash < second->hash) {
  459.         return -1;

  461.     } else if (first->hash > second->hash) {
  462.         return 1;

  464.     } else {
  465.         return 0;
  466.     }
  467. }


  470. static ngx_uint_t
  471. ‌ngx_http_upstream_find_chash_point(ngx_http_upstream_chash_points_t *points,
  472.     uint32_t hash)
  473. {
  474.     ngx_uint_t                        i, j, k;
  475.     ngx_http_upstream_chash_point_t  *point;

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

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

  481.     i = 0;
  482.     j = points->number;

  484.     while (i < j) {
  485.         k = (i + j) / 2;

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

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

  493.         } else {
  494.             return k;
  495.         }
  496.     }

  498.     return i;
  499. }


  502. static ngx_int_t
  503. ‌ngx_http_upstream_init_chash_peer(ngx_http_request_t *r,
  504.     ngx_http_upstream_srv_conf_t *us)
  505. {
  506.     uint32_t                             hash;
  507.     ngx_http_upstream_hash_srv_conf_t   *hcf;
  508.     ngx_http_upstream_hash_peer_data_t  *hp;

  510.     if (ngx_http_upstream_init_hash_peer(r, us) != NGX_OK) {
  511.         return NGX_ERROR;
  512.     }

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

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

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

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

  523. #if (NGX_HTTP_UPSTREAM_ZONE)
  524.     if (hp->rrp.peers->config
  525.         && (hcf->points == NULL || hcf->config != *hp->rrp.peers->config))
  526.     {
  527.         if (ngx_http_upstream_update_chash(NULL, us) != NGX_OK) {
  528.             ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
  529.             return NGX_ERROR;
  530.         }

  532.         hcf->config = *hp->rrp.peers->config;
  533.     }
  534. #endif

  536.     if (hcf->points->number) {
  537.         hp->hash = ngx_http_upstream_find_chash_point(hcf->points, hash);
  538.     }

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

  542.     return NGX_OK;
  543. }


  546. static ngx_int_t
  547. ‌ngx_http_upstream_get_chash_peer(ngx_peer_connection_t *pc, void *data)
  548. {
  549.     ngx_http_upstream_hash_peer_data_t  *hp = data;

  551.     time_t                              now;
  552.     intptr_t                            m;
  553.     ngx_str_t                          *server;
  554.     ngx_int_t                           total;
  555.     ngx_uint_t                          i, n, best_i;
  556.     ngx_http_upstream_rr_peer_t        *peer, *best;
  557.     ngx_http_upstream_chash_point_t    *point;
  558.     ngx_http_upstream_chash_points_t   *points;
  559.     ngx_http_upstream_hash_srv_conf_t  *hcf;

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

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

  566.     if (hp->tries > 20 || hp->rrp.peers->single || hp->key.len == 0) {
  567.         ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
  568.         return hp->get_rr_peer(pc, &hp->rrp);
  569.     }

  571.     pc->cached = 0;
  572.     pc->connection = NULL;

  574.     if (hp->rrp.peers->number == 0) {
  575.         pc->name = hp->rrp.peers->name;
  576.         ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
  577.         return NGX_BUSY;
  578.     }

  580. #if (NGX_HTTP_UPSTREAM_ZONE)
  581.     if (hp->rrp.peers->config && hp->rrp.config != *hp->rrp.peers->config) {
  582.         pc->name = hp->rrp.peers->name;
  583.         ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
  584.         return NGX_BUSY;
  585.     }
  586. #endif

  588.     now = ngx_time();
  589.     hcf = hp->conf;

  591.     points = hcf->points;
  592.     point = &points->point[0];

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

  597.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  598.                        "consistent hash peer:%uD, server:\"%V\"",
  599.                        hp->hash, server);

  601.         best = NULL;
  602.         best_i = 0;
  603.         total = 0;

  605.         for (peer = hp->rrp.peers->peer, i = 0;
  606.              peer;
  607.              peer = peer->next, i++)
  608.         {
  609.             n = i / (8 * sizeof(uintptr_t));
  610.             m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

  612.             if (hp->rrp.tried[n] & m) {
  613.                 continue;
  614.             }

  616.             if (peer->down) {
  617.                 continue;
  618.             }

  620.             if (peer->max_fails
  621.                 && peer->fails >= peer->max_fails
  622.                 && now - peer->checked <= peer->fail_timeout)
  623.             {
  624.                 continue;
  625.             }

  627.             if (peer->max_conns && peer->conns >= peer->max_conns) {
  628.                 continue;
  629.             }

  631.             if (peer->server.len != server->len
  632.                 || ngx_strncmp(peer->server.data, server->data, server->len)
  633.                    != 0)
  634.             {
  635.                 continue;
  636.             }

  638.             peer->current_weight += peer->effective_weight;
  639.             total += peer->effective_weight;

  641.             if (peer->effective_weight < peer->weight) {
  642.                 peer->effective_weight++;
  643.             }

  645.             if (best == NULL || peer->current_weight > best->current_weight) {
  646.                 best = peer;
  647.                 best_i = i;
  648.             }
  649.         }

  651.         if (best) {
  652.             best->current_weight -= total;
  653.             goto found;
  654.         }

  656.         hp->hash++;
  657.         hp->tries++;

  659.         if (hp->tries > 20) {
  660.             ngx_http_upstream_rr_peers_unlock(hp->rrp.peers);
  661.             return hp->get_rr_peer(pc, &hp->rrp);
  662.         }
  663.     }

  665. found:

  667.     hp->rrp.current = best;
  668.     ngx_http_upstream_rr_peer_ref(hp->rrp.peers, best);

  670.     pc->sockaddr = best->sockaddr;
  671.     pc->socklen = best->socklen;
  672.     pc->name = &best->name;

  674.     best->conns++;

  676.     if (now - best->checked > best->fail_timeout) {
  677.         best->checked = now;
  678.     }

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

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

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

  687.     return NGX_OK;
  688. }


  691. static void *
  692. ‌ngx_http_upstream_hash_create_conf(ngx_conf_t *cf)
  693. {
  694.     ngx_http_upstream_hash_srv_conf_t  *conf;

  696.     conf = ngx_palloc(cf->pool, sizeof(ngx_http_upstream_hash_srv_conf_t));
  697.     if (conf == NULL) {
  698.         return NULL;
  699.     }

  701.     conf->points = NULL;

  703.     return conf;
  704. }


  707. static char *
  708. ‌ngx_http_upstream_hash(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  709. {
  710.     ngx_http_upstream_hash_srv_conf_t  *hcf = conf;

  712.     ngx_str_t                         *value;
  713.     ngx_http_upstream_srv_conf_t      *uscf;
  714.     ngx_http_compile_complex_value_t   ccv;

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

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

  720.     ccv.cf = cf;
  721.     ccv.value = &value[1];
  722.     ccv.complex_value = &hcf->key;

  724.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  725.         return NGX_CONF_ERROR;
  726.     }

  728.     uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);

  730.     if (uscf->peer.init_upstream) {
  731.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  732.                            "load balancing method redefined");
  733.     }

  735.     uscf->flags = NGX_HTTP_UPSTREAM_CREATE
  736.                   |NGX_HTTP_UPSTREAM_MODIFY
  737.                   |NGX_HTTP_UPSTREAM_WEIGHT
  738.                   |NGX_HTTP_UPSTREAM_MAX_CONNS
  739.                   |NGX_HTTP_UPSTREAM_MAX_FAILS
  740.                   |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
  741.                   |NGX_HTTP_UPSTREAM_DOWN;

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

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

  749.     } else {
  750.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  751.                            "invalid parameter \"%V\"", &value[2]);
  752.         return NGX_CONF_ERROR;
  753.     }

  755.     return NGX_CONF_OK;
  756. }

One Level Up Top Level