One Level Up Top Level

src/http/ngx_http_upstream_round_robin.c - nginx-1.31.3 nginx/ @ 42f8df65b

Functions defined

Macros defined

Source code


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


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_http.h>
  11. #include <ngx_md5.h>


  14. ‌#define ngx_http_upstream_tries(p) ((p)->tries                                \
  15.                                     + ((p)->next ? (p)->next->tries : 0))


  18. #if (NGX_HTTP_UPSTREAM_SID)
  19. static ngx_int_t ngx_http_upstream_create_sid(ngx_conf_t *cf,
  20.     ngx_http_upstream_rr_peer_t *peer, ngx_str_t *route);
  21. #endif

  23. static ngx_http_upstream_rr_peer_t *ngx_http_upstream_get_peer(
  24.     ngx_http_upstream_rr_peer_data_t *rrp, ngx_peer_connection_t *pc);

  26. #if (NGX_HTTP_SSL)

  28. static ngx_int_t ngx_http_upstream_empty_set_session(ngx_peer_connection_t *pc,
  29.     void *data);
  30. static void ngx_http_upstream_empty_save_session(ngx_peer_connection_t *pc,
  31.     void *data);

  33. #endif


  36. ngx_int_t
  37. ‌ngx_http_upstream_init_round_robin(ngx_conf_t *cf,
  38.     ngx_http_upstream_srv_conf_t *us)
  39. {
  40.     ngx_url_t                      u;
  41.     ngx_uint_t                     i, j, n, r, w, t;
  42.     ngx_http_upstream_server_t    *server;
  43.     ngx_http_upstream_rr_peer_t   *peer, **peerp;
  44.     ngx_http_upstream_rr_peers_t  *peers, *backup;
  45. #if (NGX_HTTP_UPSTREAM_ZONE)
  46.     ngx_uint_t                     resolve;
  47.     ngx_http_core_loc_conf_t      *clcf;
  48.     ngx_http_upstream_rr_peer_t  **rpeerp;
  49. #endif

  51.     us->peer.init = ngx_http_upstream_init_round_robin_peer;

  53.     if (us->servers) {
  54.         server = us->servers->elts;

  56.         n = 0;
  57.         r = 0;
  58.         w = 0;
  59.         t = 0;

  61. #if (NGX_HTTP_UPSTREAM_ZONE)
  62.         resolve = 0;
  63. #endif

  65.         for (i = 0; i < us->servers->nelts; i++) {

  67. #if (NGX_HTTP_UPSTREAM_ZONE)
  68.             if (server[i].host.len) {
  69.                 resolve = 1;
  70.             }
  71. #endif

  73.             if (server[i].backup) {
  74.                 continue;
  75.             }

  77. #if (NGX_HTTP_UPSTREAM_ZONE)
  78.             if (server[i].host.len) {
  79.                 r++;
  80.                 continue;
  81.             }
  82. #endif

  84.             n += server[i].naddrs;
  85.             w += server[i].naddrs * server[i].weight;

  87.             if (!server[i].down) {
  88.                 t += server[i].naddrs;
  89.             }
  90.         }

  92. #if (NGX_HTTP_UPSTREAM_ZONE)
  93.         if (us->shm_zone) {

  95.             if (resolve && !(us->flags & NGX_HTTP_UPSTREAM_MODIFY)) {
  96.                 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  97.                               "load balancing method does not support"
  98.                               " resolving names at run time in"
  99.                               " upstream \"%V\" in %s:%ui",
  100.                               &us->host, us->file_name, us->line);
  101.                 return NGX_ERROR;
  102.             }

  104.             clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  106.             if (us->resolver == NULL) {
  107.                 us->resolver = clcf->resolver;
  108.             }

  110.             /*
  111.              * Without "resolver_timeout" in http{} the merged value is unset.
  112.              */
  113.             ngx_conf_merge_msec_value(us->resolver_timeout,
  114.                                       clcf->resolver_timeout, 30000);

  116.             if (resolve
  117.                 && (us->resolver == NULL
  118.                     || us->resolver->connections.nelts == 0))
  119.             {
  120.                 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  121.                               "no resolver defined to resolve names"
  122.                               " at run time in upstream \"%V\" in %s:%ui",
  123.                               &us->host, us->file_name, us->line);
  124.                 return NGX_ERROR;
  125.             }

  127.         } else if (resolve) {

  129.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  130.                           "resolving names at run time requires"
  131.                           " upstream \"%V\" in %s:%ui"
  132.                           " to be in shared memory",
  133.                           &us->host, us->file_name, us->line);
  134.             return NGX_ERROR;
  135.         }
  136. #endif

  138.         if (n + r == 0) {
  139.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  140.                           "no servers in upstream \"%V\" in %s:%ui",
  141.                           &us->host, us->file_name, us->line);
  142.             return NGX_ERROR;
  143.         }

  145.         peers = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t));
  146.         if (peers == NULL) {
  147.             return NGX_ERROR;
  148.         }

  150.         peer = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peer_t)
  151.                                      * (n + r));
  152.         if (peer == NULL) {
  153.             return NGX_ERROR;
  154.         }

  156.         peers->single = (n == 1);
  157.         peers->number = n;
  158.         peers->weighted = (w != n);
  159.         peers->total_weight = w;
  160.         peers->tries = t;
  161.         peers->name = &us->host;

  163.         n = 0;
  164.         peerp = &peers->peer;

  166. #if (NGX_HTTP_UPSTREAM_ZONE)
  167.         rpeerp = &peers->resolve;
  168. #endif

  170.         for (i = 0; i < us->servers->nelts; i++) {
  171.             if (server[i].backup) {
  172.                 continue;
  173.             }

  175. #if (NGX_HTTP_UPSTREAM_ZONE)
  176.             if (server[i].host.len) {

  178.                 peer[n].host = ngx_pcalloc(cf->pool,
  179.                                            sizeof(ngx_http_upstream_host_t));
  180.                 if (peer[n].host == NULL) {
  181.                     return NGX_ERROR;
  182.                 }

  184.                 peer[n].host->name = server[i].host;
  185.                 peer[n].host->service = server[i].service;

  187.                 peer[n].sockaddr = server[i].addrs[0].sockaddr;
  188.                 peer[n].socklen = server[i].addrs[0].socklen;
  189.                 peer[n].name = server[i].addrs[0].name;
  190.                 peer[n].weight = server[i].weight;
  191.                 peer[n].effective_weight = server[i].weight;
  192.                 peer[n].current_weight = 0;
  193.                 peer[n].max_conns = server[i].max_conns;
  194.                 peer[n].max_fails = server[i].max_fails;
  195.                 peer[n].fail_timeout = server[i].fail_timeout;
  196.                 peer[n].down = server[i].down;
  197.                 peer[n].server = server[i].name;

  199. #if (NGX_HTTP_UPSTREAM_SID)
  200.                 if (ngx_http_upstream_create_sid(cf, &peer[n], &server[i].sid)
  201.                     != NGX_OK)
  202.                 {
  203.                     return NGX_ERROR;
  204.                 }
  205. #endif

  207.                 *rpeerp = &peer[n];
  208.                 rpeerp = &peer[n].next;
  209.                 n++;

  211.                 continue;
  212.             }
  213. #endif

  215.             for (j = 0; j < server[i].naddrs; j++) {
  216.                 peer[n].sockaddr = server[i].addrs[j].sockaddr;
  217.                 peer[n].socklen = server[i].addrs[j].socklen;
  218.                 peer[n].name = server[i].addrs[j].name;
  219.                 peer[n].weight = server[i].weight;
  220.                 peer[n].effective_weight = server[i].weight;
  221.                 peer[n].current_weight = 0;
  222.                 peer[n].max_conns = server[i].max_conns;
  223.                 peer[n].max_fails = server[i].max_fails;
  224.                 peer[n].fail_timeout = server[i].fail_timeout;
  225.                 peer[n].down = server[i].down;
  226.                 peer[n].server = server[i].name;

  228. #if (NGX_HTTP_UPSTREAM_SID)
  229.                 if (ngx_http_upstream_create_sid(cf, &peer[n], &server[i].sid)
  230.                     != NGX_OK)
  231.                 {
  232.                     return NGX_ERROR;
  233.                 }
  234. #endif

  236.                 *peerp = &peer[n];
  237.                 peerp = &peer[n].next;
  238.                 n++;
  239.             }
  240.         }

  242.         us->peer.data = peers;

  244.         /* backup servers */

  246.         n = 0;
  247.         r = 0;
  248.         w = 0;
  249.         t = 0;

  251.         for (i = 0; i < us->servers->nelts; i++) {
  252.             if (!server[i].backup) {
  253.                 continue;
  254.             }

  256. #if (NGX_HTTP_UPSTREAM_ZONE)
  257.             if (server[i].host.len) {
  258.                 r++;
  259.                 continue;
  260.             }
  261. #endif

  263.             n += server[i].naddrs;
  264.             w += server[i].naddrs * server[i].weight;

  266.             if (!server[i].down) {
  267.                 t += server[i].naddrs;
  268.             }
  269.         }

  271.         if (n == 0
  272. #if (NGX_HTTP_UPSTREAM_ZONE)
  273.             && !resolve
  274. #endif
  275.         ) {
  276.             return NGX_OK;
  277.         }

  279.         if (n + r == 0 && !(us->flags & NGX_HTTP_UPSTREAM_BACKUP)) {
  280.             return NGX_OK;
  281.         }

  283.         backup = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t));
  284.         if (backup == NULL) {
  285.             return NGX_ERROR;
  286.         }

  288.         peer = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peer_t)
  289.                                      * (n + r));
  290.         if (peer == NULL) {
  291.             return NGX_ERROR;
  292.         }

  294.         if (n > 0) {
  295.             peers->single = 0;
  296.         }

  298.         backup->single = 0;
  299.         backup->number = n;
  300.         backup->weighted = (w != n);
  301.         backup->total_weight = w;
  302.         backup->tries = t;
  303.         backup->name = &us->host;

  305.         n = 0;
  306.         peerp = &backup->peer;

  308. #if (NGX_HTTP_UPSTREAM_ZONE)
  309.         rpeerp = &backup->resolve;
  310. #endif

  312.         for (i = 0; i < us->servers->nelts; i++) {
  313.             if (!server[i].backup) {
  314.                 continue;
  315.             }

  317. #if (NGX_HTTP_UPSTREAM_ZONE)
  318.             if (server[i].host.len) {

  320.                 peer[n].host = ngx_pcalloc(cf->pool,
  321.                                            sizeof(ngx_http_upstream_host_t));
  322.                 if (peer[n].host == NULL) {
  323.                     return NGX_ERROR;
  324.                 }

  326.                 peer[n].host->name = server[i].host;
  327.                 peer[n].host->service = server[i].service;

  329.                 peer[n].sockaddr = server[i].addrs[0].sockaddr;
  330.                 peer[n].socklen = server[i].addrs[0].socklen;
  331.                 peer[n].name = server[i].addrs[0].name;
  332.                 peer[n].weight = server[i].weight;
  333.                 peer[n].effective_weight = server[i].weight;
  334.                 peer[n].current_weight = 0;
  335.                 peer[n].max_conns = server[i].max_conns;
  336.                 peer[n].max_fails = server[i].max_fails;
  337.                 peer[n].fail_timeout = server[i].fail_timeout;
  338.                 peer[n].down = server[i].down;
  339.                 peer[n].server = server[i].name;

  341. #if (NGX_HTTP_UPSTREAM_SID)
  342.                 if (ngx_http_upstream_create_sid(cf, &peer[n], &server[i].sid)
  343.                     != NGX_OK)
  344.                 {
  345.                     return NGX_ERROR;
  346.                 }
  347. #endif

  349.                 *rpeerp = &peer[n];
  350.                 rpeerp = &peer[n].next;
  351.                 n++;

  353.                 continue;
  354.             }
  355. #endif

  357.             for (j = 0; j < server[i].naddrs; j++) {
  358.                 peer[n].sockaddr = server[i].addrs[j].sockaddr;
  359.                 peer[n].socklen = server[i].addrs[j].socklen;
  360.                 peer[n].name = server[i].addrs[j].name;
  361.                 peer[n].weight = server[i].weight;
  362.                 peer[n].effective_weight = server[i].weight;
  363.                 peer[n].current_weight = 0;
  364.                 peer[n].max_conns = server[i].max_conns;
  365.                 peer[n].max_fails = server[i].max_fails;
  366.                 peer[n].fail_timeout = server[i].fail_timeout;
  367.                 peer[n].down = server[i].down;
  368.                 peer[n].server = server[i].name;

  370. #if (NGX_HTTP_UPSTREAM_SID)
  371.                 if (ngx_http_upstream_create_sid(cf, &peer[n], &server[i].sid)
  372.                     != NGX_OK)
  373.                 {
  374.                     return NGX_ERROR;
  375.                 }
  376. #endif

  378.                 *peerp = &peer[n];
  379.                 peerp = &peer[n].next;
  380.                 n++;
  381.             }
  382.         }

  384.         peers->next = backup;

  386.         return NGX_OK;
  387.     }


  390.     /* an upstream implicitly defined by proxy_pass, etc. */

  392.     if (us->port == 0) {
  393.         ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  394.                       "no port in upstream \"%V\" in %s:%ui",
  395.                       &us->host, us->file_name, us->line);
  396.         return NGX_ERROR;
  397.     }

  399.     ngx_memzero(&u, sizeof(ngx_url_t));

  401.     u.host = us->host;
  402.     u.port = us->port;

  404.     if (ngx_inet_resolve_host(cf->pool, &u) != NGX_OK) {
  405.         if (u.err) {
  406.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  407.                           "%s in upstream \"%V\" in %s:%ui",
  408.                           u.err, &us->host, us->file_name, us->line);
  409.         }

  411.         return NGX_ERROR;
  412.     }

  414.     n = u.naddrs;

  416.     peers = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t));
  417.     if (peers == NULL) {
  418.         return NGX_ERROR;
  419.     }

  421.     peer = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peer_t) * n);
  422.     if (peer == NULL) {
  423.         return NGX_ERROR;
  424.     }

  426.     peers->single = (n == 1);
  427.     peers->number = n;
  428.     peers->weighted = 0;
  429.     peers->total_weight = n;
  430.     peers->tries = n;
  431.     peers->name = &us->host;

  433.     peerp = &peers->peer;

  435.     for (i = 0; i < u.naddrs; i++) {
  436.         peer[i].sockaddr = u.addrs[i].sockaddr;
  437.         peer[i].socklen = u.addrs[i].socklen;
  438.         peer[i].name = u.addrs[i].name;
  439.         peer[i].weight = 1;
  440.         peer[i].effective_weight = 1;
  441.         peer[i].current_weight = 0;
  442.         peer[i].max_conns = 0;
  443.         peer[i].max_fails = 1;
  444.         peer[i].fail_timeout = 10;
  445.         *peerp = &peer[i];
  446.         peerp = &peer[i].next;
  447.     }

  449.     us->peer.data = peers;

  451.     /* implicitly defined upstream has no backup servers */

  453.     return NGX_OK;
  454. }


  457. #if (NGX_HTTP_UPSTREAM_SID)

  459. static ngx_int_t
  460. ‌ngx_http_upstream_create_sid(ngx_conf_t *cf, ngx_http_upstream_rr_peer_t *peer,
  461.     ngx_str_t *route)
  462. {
  463.     if (route->len) {
  464.         peer->route = 1;
  465.         peer->sid = *route;
  466.         return NGX_OK;
  467.     }

  469.     peer->sid.data = ngx_pnalloc(cf->pool, NGX_HTTP_UPSTREAM_SID_LEN);
  470.     if (peer->sid.data == NULL) {
  471.         return NGX_ERROR;
  472.     }

  474.     ngx_http_upstream_init_round_robin_sid(peer, NULL);

  476.     return NGX_OK;
  477. }


  480. void
  481. ‌ngx_http_upstream_init_round_robin_sid(ngx_http_upstream_rr_peer_t *peer,
  482.     ngx_str_t *route)
  483. {
  484.     u_char     hash[16];
  485.     ngx_md5_t  md5;

  487.     if (route && route->len) {
  488.         peer->route = 1;
  489.         peer->sid.len = route->len;
  490.         ngx_memcpy(peer->sid.data, route->data, route->len);
  491.         return;
  492.     }

  494.     peer->route = 0;

  496.     /* SID is the MD5 hash of a printable socket address */

  498.     if (peer->name.len == 0) {
  499.         peer->sid.len = 0;
  500.         return;
  501.     }

  503.     ngx_md5_init(&md5);
  504.     ngx_md5_update(&md5, peer->name.data, peer->name.len);
  505.     ngx_md5_final(hash, &md5);

  507.     ngx_hex_dump(peer->sid.data, hash, 16);
  508.     peer->sid.len = NGX_HTTP_UPSTREAM_SID_LEN;
  509. }

  511. #endif


  514. ngx_int_t
  515. ‌ngx_http_upstream_init_round_robin_peer(ngx_http_request_t *r,
  516.     ngx_http_upstream_srv_conf_t *us)
  517. {
  518.     ngx_uint_t                         n;
  519.     ngx_http_upstream_rr_peer_data_t  *rrp;

  521.     rrp = r->upstream->peer.data;

  523.     if (rrp == NULL) {
  524.         rrp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_rr_peer_data_t));
  525.         if (rrp == NULL) {
  526.             return NGX_ERROR;
  527.         }

  529.         r->upstream->peer.data = rrp;
  530.     }

  532.     rrp->peers = us->peer.data;
  533.     rrp->current = NULL;

  535.     ngx_http_upstream_rr_peers_rlock(rrp->peers);

  537. #if (NGX_HTTP_UPSTREAM_ZONE)
  538.     rrp->config = rrp->peers->config ? *rrp->peers->config : 0;
  539. #endif

  541.     n = rrp->peers->number;

  543.     if (rrp->peers->next && rrp->peers->next->number > n) {
  544.         n = rrp->peers->next->number;
  545.     }

  547.     r->upstream->peer.tries = ngx_http_upstream_tries(rrp->peers);

  549.     ngx_http_upstream_rr_peers_unlock(rrp->peers);

  551.     if (n <= 8 * sizeof(uintptr_t)) {
  552.         rrp->tried = &rrp->data;
  553.         rrp->data = 0;

  555.     } else {
  556.         n = (n + (8 * sizeof(uintptr_t) - 1)) / (8 * sizeof(uintptr_t));

  558.         rrp->tried = ngx_pcalloc(r->pool, n * sizeof(uintptr_t));
  559.         if (rrp->tried == NULL) {
  560.             return NGX_ERROR;
  561.         }
  562.     }

  564.     r->upstream->peer.get = ngx_http_upstream_get_round_robin_peer;
  565.     r->upstream->peer.free = ngx_http_upstream_free_round_robin_peer;
  566. #if (NGX_HTTP_SSL)
  567.     r->upstream->peer.set_session =
  568.                                ngx_http_upstream_set_round_robin_peer_session;
  569.     r->upstream->peer.save_session =
  570.                                ngx_http_upstream_save_round_robin_peer_session;
  571. #endif

  573.     return NGX_OK;
  574. }


  577. ngx_int_t
  578. ‌ngx_http_upstream_create_round_robin_peer(ngx_http_request_t *r,
  579.     ngx_http_upstream_resolved_t *ur)
  580. {
  581.     u_char                            *p;
  582.     size_t                             len;
  583.     socklen_t                          socklen;
  584.     ngx_uint_t                         i, n;
  585.     struct sockaddr                   *sockaddr;
  586.     ngx_http_upstream_rr_peer_t       *peer, **peerp;
  587.     ngx_http_upstream_rr_peers_t      *peers;
  588.     ngx_http_upstream_rr_peer_data_t  *rrp;

  590.     rrp = r->upstream->peer.data;

  592.     if (rrp == NULL) {
  593.         rrp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_rr_peer_data_t));
  594.         if (rrp == NULL) {
  595.             return NGX_ERROR;
  596.         }

  598.         r->upstream->peer.data = rrp;
  599.     }

  601.     peers = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_rr_peers_t));
  602.     if (peers == NULL) {
  603.         return NGX_ERROR;
  604.     }

  606.     peer = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_rr_peer_t)
  607.                                 * ur->naddrs);
  608.     if (peer == NULL) {
  609.         return NGX_ERROR;
  610.     }

  612.     peers->single = (ur->naddrs == 1);
  613.     peers->number = ur->naddrs;
  614.     peers->tries = ur->naddrs;
  615.     peers->name = &ur->host;

  617.     if (ur->sockaddr) {
  618.         peer[0].sockaddr = ur->sockaddr;
  619.         peer[0].socklen = ur->socklen;
  620.         peer[0].name = ur->name.data ? ur->name : ur->host;
  621.         peer[0].weight = 1;
  622.         peer[0].effective_weight = 1;
  623.         peer[0].current_weight = 0;
  624.         peer[0].max_conns = 0;
  625.         peer[0].max_fails = 1;
  626.         peer[0].fail_timeout = 10;
  627.         peers->peer = peer;

  629.     } else {
  630.         peerp = &peers->peer;

  632.         for (i = 0; i < ur->naddrs; i++) {

  634.             socklen = ur->addrs[i].socklen;

  636.             sockaddr = ngx_palloc(r->pool, socklen);
  637.             if (sockaddr == NULL) {
  638.                 return NGX_ERROR;
  639.             }

  641.             ngx_memcpy(sockaddr, ur->addrs[i].sockaddr, socklen);
  642.             ngx_inet_set_port(sockaddr, ur->port);

  644.             p = ngx_pnalloc(r->pool, NGX_SOCKADDR_STRLEN);
  645.             if (p == NULL) {
  646.                 return NGX_ERROR;
  647.             }

  649.             len = ngx_sock_ntop(sockaddr, socklen, p, NGX_SOCKADDR_STRLEN, 1);

  651.             peer[i].sockaddr = sockaddr;
  652.             peer[i].socklen = socklen;
  653.             peer[i].name.len = len;
  654.             peer[i].name.data = p;
  655.             peer[i].weight = 1;
  656.             peer[i].effective_weight = 1;
  657.             peer[i].current_weight = 0;
  658.             peer[i].max_conns = 0;
  659.             peer[i].max_fails = 1;
  660.             peer[i].fail_timeout = 10;
  661.             *peerp = &peer[i];
  662.             peerp = &peer[i].next;
  663.         }
  664.     }

  666.     rrp->peers = peers;
  667.     rrp->current = NULL;
  668.     rrp->config = 0;

  670.     if (rrp->peers->number <= 8 * sizeof(uintptr_t)) {
  671.         rrp->tried = &rrp->data;
  672.         rrp->data = 0;

  674.     } else {
  675.         n = (rrp->peers->number + (8 * sizeof(uintptr_t) - 1))
  676.                 / (8 * sizeof(uintptr_t));

  678.         rrp->tried = ngx_pcalloc(r->pool, n * sizeof(uintptr_t));
  679.         if (rrp->tried == NULL) {
  680.             return NGX_ERROR;
  681.         }
  682.     }

  684.     r->upstream->peer.get = ngx_http_upstream_get_round_robin_peer;
  685.     r->upstream->peer.free = ngx_http_upstream_free_round_robin_peer;
  686.     r->upstream->peer.tries = ngx_http_upstream_tries(rrp->peers);
  687. #if (NGX_HTTP_SSL)
  688.     r->upstream->peer.set_session = ngx_http_upstream_empty_set_session;
  689.     r->upstream->peer.save_session = ngx_http_upstream_empty_save_session;
  690. #endif

  692.     return NGX_OK;
  693. }


  696. ngx_int_t
  697. ‌ngx_http_upstream_get_round_robin_peer(ngx_peer_connection_t *pc, void *data)
  698. {
  699.     ngx_http_upstream_rr_peer_data_t  *rrp = data;

  701.     ngx_int_t                      rc;
  702.     ngx_uint_t                     i, n;
  703.     ngx_http_upstream_rr_peer_t   *peer;
  704.     ngx_http_upstream_rr_peers_t  *peers;

  706.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  707.                    "get rr peer, try: %ui", pc->tries);

  709.     pc->cached = 0;
  710.     pc->connection = NULL;

  712.     peers = rrp->peers;
  713.     ngx_http_upstream_rr_peers_wlock(peers);

  715. #if (NGX_HTTP_UPSTREAM_ZONE)
  716.     if (peers->config && rrp->config != *peers->config) {
  717.         goto busy;
  718.     }
  719. #endif

  721.     if (peers->single) {
  722. #if (NGX_HTTP_UPSTREAM_SID)
  723.         peer = ngx_http_upstream_get_rr_peer_by_sid(rrp, pc->hint, &i, 0);

  725.         if (peer == NULL) {
  726. #endif
  727.             peer = peers->peer;

  729.             if (peer->down) {
  730.                 goto failed;
  731.             }

  733.             if (peer->max_conns && peer->conns >= peer->max_conns) {
  734.                 goto failed;
  735.             }
  736. #if (NGX_HTTP_UPSTREAM_SID)
  737.         }
  738. #endif

  740.         rrp->current = peer;
  741.         ngx_http_upstream_rr_peer_ref(peers, peer);

  743.     } else {

  745.         /* there are several peers */

  747.         peer = ngx_http_upstream_get_peer(rrp, pc);

  749.         if (peer == NULL) {
  750.             goto failed;
  751.         }

  753.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  754.                        "get rr peer, current: %p %i",
  755.                        peer, peer->current_weight);
  756.     }

  758.     pc->sockaddr = peer->sockaddr;
  759.     pc->socklen = peer->socklen;
  760.     pc->name = &peer->name;

  762. #if (NGX_HTTP_UPSTREAM_SID)
  763.     pc->sid = &peer->sid;
  764. #endif

  766.     peer->conns++;

  768.     ngx_http_upstream_rr_peers_unlock(peers);

  770.     return NGX_OK;

  772. failed:

  774.     if (peers->next) {

  776.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0, "backup servers");

  778.         rrp->peers = peers->next;

  780.         n = (rrp->peers->number + (8 * sizeof(uintptr_t) - 1))
  781.                 / (8 * sizeof(uintptr_t));

  783.         for (i = 0; i < n; i++) {
  784.             rrp->tried[i] = 0;
  785.         }

  787.         ngx_http_upstream_rr_peers_unlock(peers);

  789.         rc = ngx_http_upstream_get_round_robin_peer(pc, rrp);

  791.         if (rc != NGX_BUSY) {
  792.             return rc;
  793.         }

  795.         ngx_http_upstream_rr_peers_wlock(peers);
  796.     }

  798. #if (NGX_HTTP_UPSTREAM_ZONE)
  799. busy:
  800. #endif

  802.     ngx_http_upstream_rr_peers_unlock(peers);

  804.     pc->name = peers->name;

  806.     return NGX_BUSY;
  807. }


  810. static ngx_http_upstream_rr_peer_t *
  811. ‌ngx_http_upstream_get_peer(ngx_http_upstream_rr_peer_data_t *rrp,
  812.     ngx_peer_connection_t *pc)
  813. {
  814.     time_t                        now;
  815.     uintptr_t                     m;
  816.     ngx_int_t                     total;
  817.     ngx_uint_t                    i, n, p;
  818.     ngx_http_upstream_rr_peer_t  *peer, *best;

  820. #if (NGX_HTTP_UPSTREAM_SID)
  821.     ngx_int_t                     low_limit;
  822.     ngx_uint_t                    st_p;
  823.     ngx_http_upstream_rr_peer_t  *st_peer;
  824. #endif

  826.     now = ngx_time();

  828.     best = NULL;
  829.     total = 0;

  831. #if (NGX_SUPPRESS_WARN)
  832.     p = 0;
  833. #endif

  835. #if (NGX_HTTP_UPSTREAM_SID)
  836.     st_peer = ngx_http_upstream_get_rr_peer_by_sid(rrp, pc->hint, &p, 0);

  838.     if (st_peer) {

  840.         low_limit = -((ngx_int_t)(rrp->peers->total_weight - st_peer->weight));

  842.         /*
  843.          * note: current code accounts only one sticky request in a row, if it
  844.          *       is required to account more, multiply low_limit by N below
  845.          */
  846.         if (st_peer->current_weight <= low_limit) {

  848.             /* do not update weights if the limit exceeded */
  849.             best = st_peer;
  850.             goto best_chosen;
  851.         }
  852.         /* else: proceed to reweight with existing st_peer */
  853.     }

  855.     st_p = p;
  856. #endif

  858.     for (peer = rrp->peers->peer, i = 0;
  859.          peer;
  860.          peer = peer->next, i++)
  861.     {
  862.         n = i / (8 * sizeof(uintptr_t));
  863.         m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

  865.         if (rrp->tried[n] & m) {
  866.             continue;
  867.         }

  869.         if (peer->down) {
  870.             continue;
  871.         }

  873.         if (peer->max_fails
  874.             && peer->fails >= peer->max_fails
  875.             && now - peer->checked <= peer->fail_timeout)
  876.         {
  877.             continue;
  878.         }

  880.         if (peer->max_conns && peer->conns >= peer->max_conns) {
  881.             continue;
  882.         }

  884.         peer->current_weight += peer->effective_weight;
  885.         total += peer->effective_weight;

  887.         if (peer->effective_weight < peer->weight) {
  888.             peer->effective_weight++;
  889.         }

  891.         if (best == NULL || peer->current_weight > best->current_weight) {
  892.             best = peer;
  893.             p = i;
  894.         }
  895.     }

  897. #if (NGX_HTTP_UPSTREAM_SID)
  898.     /* prefer peer chosen by sticky to best from RR */

  900.     if (st_peer) {
  901.         best = st_peer;
  902.         p = st_p;
  903.     }
  904. #endif

  906.     if (best == NULL) {
  907.         return NULL;
  908.     }

  910.     best->current_weight -= total;

  912. #if (NGX_HTTP_UPSTREAM_SID)
  913. best_chosen:
  914. #endif

  916.     rrp->current = best;
  917.     ngx_http_upstream_rr_peer_ref(rrp->peers, best);

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

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

  924.     if (now - best->checked > best->fail_timeout) {
  925.         best->checked = now;
  926.     }

  928.     return best;
  929. }


  932. #if (NGX_HTTP_UPSTREAM_SID)

  934. ngx_http_upstream_rr_peer_t *
  935. ‌ngx_http_upstream_get_rr_peer_by_sid(ngx_http_upstream_rr_peer_data_t *rrp,
  936.     ngx_str_t *hint, ngx_uint_t *p, ngx_uint_t lock)
  937. {
  938.     uintptr_t                     m;
  939.     ngx_uint_t                    i, n;
  940.     ngx_http_upstream_rr_peer_t  *peer;

  942.     if (hint == NULL) {
  943.         return NULL;
  944.     }

  946.     for (peer = rrp->peers->peer, i = 0;
  947.          peer;
  948.          peer = peer->next, i++)
  949.     {

  951.         if (peer->sid.len == hint->len
  952.             && ngx_memcmp(peer->sid.data, hint->data, hint->len) == 0)
  953.         {
  954.             goto found;
  955.         }
  956.     }

  958.     return NULL;

  960. found:

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

  965.     if (rrp->tried[n] & m) {
  966.         return NULL;
  967.     }

  969.     if (lock) {
  970.         ngx_http_upstream_rr_peer_lock(rrp->peers, peer);
  971.     }

  973.     if (peer->down
  974. #if (NGX_HTTP_UPSTREAM_STICKY)
  975.         & ~NGX_HTTP_UPSTREAM_DRAINING
  976. #endif
  977.     ) {
  978.         goto failed;
  979.     }

  981.     if (peer->max_fails
  982.         && peer->fails >= peer->max_fails
  983.         && ngx_time() - peer->checked <= peer->fail_timeout)
  984.     {
  985.         goto failed;
  986.     }

  988.     if (peer->max_conns && peer->conns >= peer->max_conns) {
  989.         goto failed;
  990.     }

  992.     *p = i;
  993.     return peer;

  995. failed:

  997.     if (lock) {
  998.         ngx_http_upstream_rr_peer_unlock(rrp->peers, peer);
  999.     }

  1001.     return NULL;
  1002. }

  1004. #endif


  1007. void
  1008. ‌ngx_http_upstream_free_round_robin_peer(ngx_peer_connection_t *pc, void *data,
  1009.     ngx_uint_t state)
  1010. {
  1011. #if (NGX_HTTP_UPSTREAM_ZONE)
  1012.     ngx_http_upstream_rr_peer_data_t  *rrp = data;

  1014.     ngx_http_upstream_rr_peers_rlock(rrp->peers);
  1015.     ngx_http_upstream_rr_peer_lock(rrp->peers, rrp->current);
  1016. #endif

  1018.     ngx_http_upstream_free_round_robin_peer_locked(pc, data, state);
  1019. }


  1022. void
  1023. ‌ngx_http_upstream_free_round_robin_peer_locked(ngx_peer_connection_t *pc,
  1024.     void *data, ngx_uint_t state)
  1025. {
  1026.     ngx_http_upstream_rr_peer_data_t  *rrp = data;

  1028.     time_t                       now;
  1029.     ngx_http_upstream_rr_peer_t  *peer;

  1031.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  1032.                    "free rr peer %ui %ui", pc->tries, state);

  1034.     /* TODO: NGX_PEER_KEEPALIVE */

  1036.     peer = rrp->current;

  1038.     if (rrp->peers->single) {

  1040.         if (peer->fails) {
  1041.             peer->fails = 0;
  1042.         }

  1044.         peer->conns--;

  1046.         if (ngx_http_upstream_rr_peer_unref(rrp->peers, peer) == NGX_OK) {
  1047.             ngx_http_upstream_rr_peer_unlock(rrp->peers, peer);
  1048.         }

  1050.         ngx_http_upstream_rr_peers_unlock(rrp->peers);

  1052.         pc->tries = 0;
  1053.         return;
  1054.     }

  1056.     if (state & NGX_PEER_FAILED) {
  1057.         now = ngx_time();

  1059.         peer->fails++;
  1060.         peer->accessed = now;
  1061.         peer->checked = now;

  1063.         if (peer->max_fails) {
  1064.             peer->effective_weight -= peer->weight / peer->max_fails;

  1066.             if (peer->fails >= peer->max_fails) {
  1067.                 ngx_log_error(NGX_LOG_WARN, pc->log, 0,
  1068.                               "upstream server temporarily disabled");
  1069.             }
  1070.         }

  1072.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  1073.                        "free rr peer failed: %p %i",
  1074.                        peer, peer->effective_weight);

  1076.         if (peer->effective_weight < 0) {
  1077.             peer->effective_weight = 0;
  1078.         }

  1080.     } else {

  1082.         /* mark peer live if check passed */

  1084.         if (peer->accessed < peer->checked) {
  1085.             peer->fails = 0;
  1086.         }
  1087.     }

  1089.     peer->conns--;

  1091.     if (ngx_http_upstream_rr_peer_unref(rrp->peers, peer) == NGX_OK) {
  1092.         ngx_http_upstream_rr_peer_unlock(rrp->peers, peer);
  1093.     }

  1095.     ngx_http_upstream_rr_peers_unlock(rrp->peers);

  1097.     if (pc->tries) {
  1098.         pc->tries--;
  1099.     }
  1100. }


  1103. #if (NGX_HTTP_SSL)

  1105. ngx_int_t
  1106. ‌ngx_http_upstream_set_round_robin_peer_session(ngx_peer_connection_t *pc,
  1107.     void *data)
  1108. {
  1109.     ngx_http_upstream_rr_peer_data_t  *rrp = data;

  1111.     ngx_int_t                      rc;
  1112.     ngx_ssl_session_t             *ssl_session;
  1113.     ngx_http_upstream_rr_peer_t   *peer;
  1114. #if (NGX_HTTP_UPSTREAM_ZONE)
  1115.     int                            len;
  1116.     const u_char                  *p;
  1117.     ngx_http_upstream_rr_peers_t  *peers;
  1118. #endif

  1120.     peer = rrp->current;

  1122. #if (NGX_HTTP_UPSTREAM_ZONE)
  1123.     peers = rrp->peers;

  1125.     if (peers->shpool) {
  1126.         ngx_http_upstream_rr_peers_rlock(peers);
  1127.         ngx_http_upstream_rr_peer_lock(peers, peer);

  1129.         if (peer->ssl_session == NULL) {
  1130.             ngx_http_upstream_rr_peer_unlock(peers, peer);
  1131.             ngx_http_upstream_rr_peers_unlock(peers);
  1132.             return NGX_OK;
  1133.         }

  1135.         len = peer->ssl_session_len;

  1137.         ngx_memcpy(ngx_ssl_session_buffer, peer->ssl_session, len);

  1139.         ngx_http_upstream_rr_peer_unlock(peers, peer);
  1140.         ngx_http_upstream_rr_peers_unlock(peers);

  1142.         p = ngx_ssl_session_buffer;
  1143.         ssl_session = d2i_SSL_SESSION(NULL, &p, len);

  1145.         rc = ngx_ssl_set_session(pc->connection, ssl_session);

  1147.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  1148.                        "set session: %p", ssl_session);

  1150.         ngx_ssl_free_session(ssl_session);

  1152.         return rc;
  1153.     }
  1154. #endif

  1156.     ssl_session = peer->ssl_session;

  1158.     rc = ngx_ssl_set_session(pc->connection, ssl_session);

  1160.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  1161.                    "set session: %p", ssl_session);

  1163.     return rc;
  1164. }


  1167. void
  1168. ‌ngx_http_upstream_save_round_robin_peer_session(ngx_peer_connection_t *pc,
  1169.     void *data)
  1170. {
  1171.     ngx_http_upstream_rr_peer_data_t  *rrp = data;

  1173.     ngx_ssl_session_t             *old_ssl_session, *ssl_session;
  1174.     ngx_http_upstream_rr_peer_t   *peer;
  1175. #if (NGX_HTTP_UPSTREAM_ZONE)
  1176.     int                            len;
  1177.     u_char                        *p;
  1178.     ngx_http_upstream_rr_peers_t  *peers;
  1179. #endif

  1181. #if (NGX_HTTP_UPSTREAM_ZONE)
  1182.     peers = rrp->peers;

  1184.     if (peers->shpool) {

  1186.         ssl_session = ngx_ssl_get0_session(pc->connection);

  1188.         if (ssl_session == NULL) {
  1189.             return;
  1190.         }

  1192.         len = i2d_SSL_SESSION(ssl_session, NULL);

  1194.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  1195.                        "save session: %p:%d", ssl_session, len);

  1197.         /* do not cache too big session */

  1199.         if (len > NGX_SSL_MAX_SESSION_SIZE) {
  1200.             return;
  1201.         }

  1203.         p = ngx_ssl_session_buffer;
  1204.         (void) i2d_SSL_SESSION(ssl_session, &p);

  1206.         peer = rrp->current;

  1208.         ngx_http_upstream_rr_peers_rlock(peers);
  1209.         ngx_http_upstream_rr_peer_lock(peers, peer);

  1211.         if (len > peer->ssl_session_len) {
  1212.             ngx_shmtx_lock(&peers->shpool->mutex);

  1214.             if (peer->ssl_session) {
  1215.                 ngx_slab_free_locked(peers->shpool, peer->ssl_session);
  1216.             }

  1218.             peer->ssl_session = ngx_slab_alloc_locked(peers->shpool, len);

  1220.             ngx_shmtx_unlock(&peers->shpool->mutex);

  1222.             if (peer->ssl_session == NULL) {
  1223.                 peer->ssl_session_len = 0;

  1225.                 ngx_http_upstream_rr_peer_unlock(peers, peer);
  1226.                 ngx_http_upstream_rr_peers_unlock(peers);
  1227.                 return;
  1228.             }

  1230.             peer->ssl_session_len = len;
  1231.         }

  1233.         ngx_memcpy(peer->ssl_session, ngx_ssl_session_buffer, len);

  1235.         ngx_http_upstream_rr_peer_unlock(peers, peer);
  1236.         ngx_http_upstream_rr_peers_unlock(peers);

  1238.         return;
  1239.     }
  1240. #endif

  1242.     ssl_session = ngx_ssl_get_session(pc->connection);

  1244.     if (ssl_session == NULL) {
  1245.         return;
  1246.     }

  1248.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  1249.                    "save session: %p", ssl_session);

  1251.     peer = rrp->current;

  1253.     old_ssl_session = peer->ssl_session;
  1254.     peer->ssl_session = ssl_session;

  1256.     if (old_ssl_session) {

  1258.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  1259.                        "old session: %p", old_ssl_session);

  1261.         ngx_ssl_free_session(old_ssl_session);
  1262.     }
  1263. }


  1266. static ngx_int_t
  1267. ‌ngx_http_upstream_empty_set_session(ngx_peer_connection_t *pc, void *data)
  1268. {
  1269.     return NGX_OK;
  1270. }


  1273. static void
  1274. ‌ngx_http_upstream_empty_save_session(ngx_peer_connection_t *pc, void *data)
  1275. {
  1276.     return;
  1277. }

  1279. #endif

One Level Up Top Level