One Level Up Top Level

src/stream/ngx_stream_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_stream.h>


  13. ‌typedef struct {
  14.     uint32_t                              hash;
  15.     ngx_str_t                            *server;
  16. ‌} ngx_stream_upstream_chash_point_t;


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


  25. ‌typedef struct {
  26. #if (NGX_STREAM_UPSTREAM_ZONE)
  27.     ngx_uint_t                            config;
  28. #endif
  29.     ngx_stream_complex_value_t            key;
  30.     ngx_stream_upstream_chash_points_t   *points;
  31. ‌} ngx_stream_upstream_hash_srv_conf_t;


  34. ‌typedef struct {
  35.     /* the round robin data must be first */
  36.     ngx_stream_upstream_rr_peer_data_t    rrp;
  37.     ngx_stream_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_stream_upstream_hash_peer_data_t;


  46. static ngx_int_t ngx_stream_upstream_init_hash(ngx_conf_t *cf,
  47.     ngx_stream_upstream_srv_conf_t *us);
  48. static ngx_int_t ngx_stream_upstream_init_hash_peer(ngx_stream_session_t *s,
  49.     ngx_stream_upstream_srv_conf_t *us);
  50. static ngx_int_t ngx_stream_upstream_get_hash_peer(ngx_peer_connection_t *pc,
  51.     void *data);

  53. static ngx_int_t ngx_stream_upstream_init_chash(ngx_conf_t *cf,
  54.     ngx_stream_upstream_srv_conf_t *us);
  55. static ngx_int_t ngx_stream_upstream_update_chash(ngx_pool_t *pool,
  56.     ngx_stream_upstream_srv_conf_t *us);
  57. static int ngx_libc_cdecl
  58.     ngx_stream_upstream_chash_cmp_points(const void *one, const void *two);
  59. static ngx_uint_t ngx_stream_upstream_find_chash_point(
  60.     ngx_stream_upstream_chash_points_t *points, uint32_t hash);
  61. static ngx_int_t ngx_stream_upstream_init_chash_peer(ngx_stream_session_t *s,
  62.     ngx_stream_upstream_srv_conf_t *us);
  63. static ngx_int_t ngx_stream_upstream_get_chash_peer(ngx_peer_connection_t *pc,
  64.     void *data);

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


  71. ‌static ngx_command_t  ngx_stream_upstream_hash_commands[] = {

  73.     { ngx_string("hash"),
  74.       NGX_STREAM_UPS_CONF|NGX_CONF_TAKE12,
  75.       ngx_stream_upstream_hash,
  76.       NGX_STREAM_SRV_CONF_OFFSET,
  77.       0,
  78.       NULL },

  80.       ngx_null_command
  81. };


  84. ‌static ngx_stream_module_t  ngx_stream_upstream_hash_module_ctx = {
  85.     NULL,                                  /* preconfiguration */
  86.     NULL,                                  /* postconfiguration */

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

  91.     ngx_stream_upstream_hash_create_conf,  /* create server configuration */
  92.     NULL                                   /* merge server configuration */
  93. };


  96. ‌ngx_module_t  ngx_stream_upstream_hash_module = {
  97.     NGX_MODULE_V1,
  98.     &ngx_stream_upstream_hash_module_ctx,  /* module context */
  99.     ngx_stream_upstream_hash_commands,     /* module directives */
  100.     NGX_STREAM_MODULE,                     /* module type */
  101.     NULL,                                  /* init master */
  102.     NULL,                                  /* init module */
  103.     NULL,                                  /* init process */
  104.     NULL,                                  /* init thread */
  105.     NULL,                                  /* exit thread */
  106.     NULL,                                  /* exit process */
  107.     NULL,                                  /* exit master */
  108.     NGX_MODULE_V1_PADDING
  109. };


  112. static ngx_int_t
  113. ‌ngx_stream_upstream_init_hash(ngx_conf_t *cf,
  114.     ngx_stream_upstream_srv_conf_t *us)
  115. {
  116.     if (ngx_stream_upstream_init_round_robin(cf, us) != NGX_OK) {
  117.         return NGX_ERROR;
  118.     }

  120.     us->peer.init = ngx_stream_upstream_init_hash_peer;

  122.     return NGX_OK;
  123. }


  126. static ngx_int_t
  127. ‌ngx_stream_upstream_init_hash_peer(ngx_stream_session_t *s,
  128.     ngx_stream_upstream_srv_conf_t *us)
  129. {
  130.     ngx_stream_upstream_hash_srv_conf_t   *hcf;
  131.     ngx_stream_upstream_hash_peer_data_t  *hp;

  133.     hp = ngx_palloc(s->connection->pool,
  134.                     sizeof(ngx_stream_upstream_hash_peer_data_t));
  135.     if (hp == NULL) {
  136.         return NGX_ERROR;
  137.     }

  139.     s->upstream->peer.data = &hp->rrp;

  141.     if (ngx_stream_upstream_init_round_robin_peer(s, us) != NGX_OK) {
  142.         return NGX_ERROR;
  143.     }

  145.     s->upstream->peer.get = ngx_stream_upstream_get_hash_peer;

  147.     hcf = ngx_stream_conf_upstream_srv_conf(us,
  148.                                             ngx_stream_upstream_hash_module);

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

  154.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, s->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_stream_upstream_get_round_robin_peer;

  163.     return NGX_OK;
  164. }


  167. static ngx_int_t
  168. ‌ngx_stream_upstream_get_hash_peer(ngx_peer_connection_t *pc, void *data)
  169. {
  170.     ngx_stream_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_stream_upstream_rr_peer_t  *peer;

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

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

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

  191. #if (NGX_STREAM_UPSTREAM_ZONE)
  192.     if (hp->rrp.peers->config && hp->rrp.config != *hp->rrp.peers->config) {
  193.         ngx_stream_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->connection = NULL;

  202.     for ( ;; ) {

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

  210.         ngx_crc32_init(hash);

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

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

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

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

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

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

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

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

  242.         ngx_stream_upstream_rr_peer_lock(hp->rrp.peers, peer);

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

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

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

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

  265.         break;

  267.     next:

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

  275.     hp->rrp.current = peer;
  276.     ngx_stream_upstream_rr_peer_ref(hp->rrp.peers, peer);

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

  282.     peer->conns++;

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

  288.     ngx_stream_upstream_rr_peer_unlock(hp->rrp.peers, peer);
  289.     ngx_stream_upstream_rr_peers_unlock(hp->rrp.peers);

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

  293.     return NGX_OK;
  294. }


  297. static ngx_int_t
  298. ‌ngx_stream_upstream_init_chash(ngx_conf_t *cf,
  299.     ngx_stream_upstream_srv_conf_t *us)
  300. {
  301.     if (ngx_stream_upstream_init_round_robin(cf, us) != NGX_OK) {
  302.         return NGX_ERROR;
  303.     }

  305.     us->peer.init = ngx_stream_upstream_init_chash_peer;

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

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


  317. static ngx_int_t
  318. ‌ngx_stream_upstream_update_chash(ngx_pool_t *pool,
  319.     ngx_stream_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_stream_upstream_rr_peer_t        *peer;
  327.     ngx_stream_upstream_rr_peers_t       *peers;
  328.     ngx_stream_upstream_chash_points_t   *points;
  329.     ngx_stream_upstream_hash_srv_conf_t  *hcf;
  330. ‌    union {
  331.         uint32_t                          value;
  332.         u_char                            byte[4];
  333.     } prev_hash;

  335.     hcf = ngx_stream_conf_upstream_srv_conf(us,
  336.                                             ngx_stream_upstream_hash_module);

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

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

  346.     size = sizeof(ngx_stream_upstream_chash_points_t)
  347.            - sizeof(ngx_stream_upstream_chash_point_t)
  348.            + sizeof(ngx_stream_upstream_chash_point_t) * npoints;

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

  355.     points->number = 0;

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

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

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

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

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

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

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

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

  401.     done:

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

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

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

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

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

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

  432.     ngx_qsort(points->point,
  433.               points->number,
  434.               sizeof(ngx_stream_upstream_chash_point_t),
  435.               ngx_stream_upstream_chash_cmp_points);

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

  443.     points->number = i + 1;

  445.     hcf->points = points;

  447.     return NGX_OK;
  448. }


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

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

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

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


  471. static ngx_uint_t
  472. ‌ngx_stream_upstream_find_chash_point(ngx_stream_upstream_chash_points_t *points,
  473.     uint32_t hash)
  474. {
  475.     ngx_uint_t                          i, j, k;
  476.     ngx_stream_upstream_chash_point_t  *point;

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

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

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

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

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

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

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

  499.     return i;
  500. }


  503. static ngx_int_t
  504. ‌ngx_stream_upstream_init_chash_peer(ngx_stream_session_t *s,
  505.     ngx_stream_upstream_srv_conf_t *us)
  506. {
  507.     uint32_t                               hash;
  508.     ngx_stream_upstream_hash_srv_conf_t   *hcf;
  509.     ngx_stream_upstream_hash_peer_data_t  *hp;

  511.     if (ngx_stream_upstream_init_hash_peer(s, us) != NGX_OK) {
  512.         return NGX_ERROR;
  513.     }

  515.     s->upstream->peer.get = ngx_stream_upstream_get_chash_peer;

  517.     hp = s->upstream->peer.data;
  518.     hcf = ngx_stream_conf_upstream_srv_conf(us,
  519.                                             ngx_stream_upstream_hash_module);

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

  523.     ngx_stream_upstream_rr_peers_rlock(hp->rrp.peers);

  525. #if (NGX_STREAM_UPSTREAM_ZONE)
  526.     if (hp->rrp.peers->config
  527.         && (hcf->points == NULL || hcf->config != *hp->rrp.peers->config))
  528.     {
  529.         if (ngx_stream_upstream_update_chash(NULL, us) != NGX_OK) {
  530.             ngx_stream_upstream_rr_peers_unlock(hp->rrp.peers);
  531.             return NGX_ERROR;
  532.         }

  534.         hcf->config = *hp->rrp.peers->config;
  535.     }
  536. #endif

  538.     if (hcf->points->number) {
  539.         hp->hash = ngx_stream_upstream_find_chash_point(hcf->points, hash);
  540.     }

  542.     ngx_stream_upstream_rr_peers_unlock(hp->rrp.peers);

  544.     return NGX_OK;
  545. }


  548. static ngx_int_t
  549. ‌ngx_stream_upstream_get_chash_peer(ngx_peer_connection_t *pc, void *data)
  550. {
  551.     ngx_stream_upstream_hash_peer_data_t *hp = data;

  553.     time_t                                now;
  554.     intptr_t                              m;
  555.     ngx_str_t                            *server;
  556.     ngx_int_t                             total;
  557.     ngx_uint_t                            i, n, best_i;
  558.     ngx_stream_upstream_rr_peer_t        *peer, *best;
  559.     ngx_stream_upstream_chash_point_t    *point;
  560.     ngx_stream_upstream_chash_points_t   *points;
  561.     ngx_stream_upstream_hash_srv_conf_t  *hcf;

  563.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, pc->log, 0,
  564.                    "get consistent hash peer, try: %ui", pc->tries);

  566.     ngx_stream_upstream_rr_peers_wlock(hp->rrp.peers);

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

  573.     pc->connection = NULL;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  652.         if (best) {
  653.             best->current_weight -= total;
  654.             break;
  655.         }

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

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

  666.     hp->rrp.current = best;
  667.     ngx_stream_upstream_rr_peer_ref(hp->rrp.peers, best);

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

  673.     best->conns++;

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

  679.     ngx_stream_upstream_rr_peers_unlock(hp->rrp.peers);

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

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

  686.     return NGX_OK;
  687. }


  690. static void *
  691. ‌ngx_stream_upstream_hash_create_conf(ngx_conf_t *cf)
  692. {
  693.     ngx_stream_upstream_hash_srv_conf_t  *conf;

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

  700.     conf->points = NULL;

  702.     return conf;
  703. }


  706. static char *
  707. ‌ngx_stream_upstream_hash(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  708. {
  709.     ngx_stream_upstream_hash_srv_conf_t  *hcf = conf;

  711.     ngx_str_t                           *value;
  712.     ngx_stream_upstream_srv_conf_t      *uscf;
  713.     ngx_stream_compile_complex_value_t   ccv;

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

  717.     ngx_memzero(&ccv, sizeof(ngx_stream_compile_complex_value_t));

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

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

  727.     uscf = ngx_stream_conf_get_module_srv_conf(cf, ngx_stream_upstream_module);

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

  734.     uscf->flags = NGX_STREAM_UPSTREAM_CREATE
  735.                   |NGX_STREAM_UPSTREAM_MODIFY
  736.                   |NGX_STREAM_UPSTREAM_WEIGHT
  737.                   |NGX_STREAM_UPSTREAM_MAX_CONNS
  738.                   |NGX_STREAM_UPSTREAM_MAX_FAILS
  739.                   |NGX_STREAM_UPSTREAM_FAIL_TIMEOUT
  740.                   |NGX_STREAM_UPSTREAM_DOWN;

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

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

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

  754.     return NGX_CONF_OK;
  755. }

One Level Up Top Level