One Level Up Top Level

src/http/ngx_http_upstream_round_robin.c - nginx source code

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>


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


  17. static ngx_http_upstream_rr_peer_t *ngx_http_upstream_get_peer(
  18.     ngx_http_upstream_rr_peer_data_t *rrp);

  20. #if (NGX_HTTP_SSL)

  22. static ngx_int_t ngx_http_upstream_empty_set_session(ngx_peer_connection_t *pc,
  23.     void *data);
  24. static void ngx_http_upstream_empty_save_session(ngx_peer_connection_t *pc,
  25.     void *data);

  27. #endif


  30. ngx_int_t
  31. ‌ngx_http_upstream_init_round_robin(ngx_conf_t *cf,
  32.     ngx_http_upstream_srv_conf_t *us)
  33. {
  34.     ngx_url_t                      u;
  35.     ngx_uint_t                     i, j, n, r, w, t;
  36.     ngx_http_upstream_server_t    *server;
  37.     ngx_http_upstream_rr_peer_t   *peer, **peerp;
  38.     ngx_http_upstream_rr_peers_t  *peers, *backup;
  39. #if (NGX_HTTP_UPSTREAM_ZONE)
  40.     ngx_uint_t                     resolve;
  41.     ngx_http_core_loc_conf_t      *clcf;
  42.     ngx_http_upstream_rr_peer_t  **rpeerp;
  43. #endif

  45.     us->peer.init = ngx_http_upstream_init_round_robin_peer;

  47.     if (us->servers) {
  48.         server = us->servers->elts;

  50.         n = 0;
  51.         r = 0;
  52.         w = 0;
  53.         t = 0;

  55. #if (NGX_HTTP_UPSTREAM_ZONE)
  56.         resolve = 0;
  57. #endif

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

  61. #if (NGX_HTTP_UPSTREAM_ZONE)
  62.             if (server[i].host.len) {
  63.                 resolve = 1;
  64.             }
  65. #endif

  67.             if (server[i].backup) {
  68.                 continue;
  69.             }

  71. #if (NGX_HTTP_UPSTREAM_ZONE)
  72.             if (server[i].host.len) {
  73.                 r++;
  74.                 continue;
  75.             }
  76. #endif

  78.             n += server[i].naddrs;
  79.             w += server[i].naddrs * server[i].weight;

  81.             if (!server[i].down) {
  82.                 t += server[i].naddrs;
  83.             }
  84.         }

  86. #if (NGX_HTTP_UPSTREAM_ZONE)
  87.         if (us->shm_zone) {

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

  98.             clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  100.             if (us->resolver == NULL) {
  101.                 us->resolver = clcf->resolver;
  102.             }

  104.             /*
  105.              * Without "resolver_timeout" in http{} the merged value is unset.
  106.              */
  107.             ngx_conf_merge_msec_value(us->resolver_timeout,
  108.                                       clcf->resolver_timeout, 30000);

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

  121.         } else if (resolve) {

  123.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  124.                           "resolving names at run time requires"
  125.                           " upstream \"%V\" in %s:%ui"
  126.                           " to be in shared memory",
  127.                           &us->host, us->file_name, us->line);
  128.             return NGX_ERROR;
  129.         }
  130. #endif

  132.         if (n + r == 0) {
  133.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  134.                           "no servers in upstream \"%V\" in %s:%ui",
  135.                           &us->host, us->file_name, us->line);
  136.             return NGX_ERROR;
  137.         }

  139.         peers = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t));
  140.         if (peers == NULL) {
  141.             return NGX_ERROR;
  142.         }

  144.         peer = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peer_t)
  145.                                      * (n + r));
  146.         if (peer == NULL) {
  147.             return NGX_ERROR;
  148.         }

  150.         peers->single = (n == 1);
  151.         peers->number = n;
  152.         peers->weighted = (w != n);
  153.         peers->total_weight = w;
  154.         peers->tries = t;
  155.         peers->name = &us->host;

  157.         n = 0;
  158.         peerp = &peers->peer;

  160. #if (NGX_HTTP_UPSTREAM_ZONE)
  161.         rpeerp = &peers->resolve;
  162. #endif

  164.         for (i = 0; i < us->servers->nelts; i++) {
  165.             if (server[i].backup) {
  166.                 continue;
  167.             }

  169. #if (NGX_HTTP_UPSTREAM_ZONE)
  170.             if (server[i].host.len) {

  172.                 peer[n].host = ngx_pcalloc(cf->pool,
  173.                                            sizeof(ngx_http_upstream_host_t));
  174.                 if (peer[n].host == NULL) {
  175.                     return NGX_ERROR;
  176.                 }

  178.                 peer[n].host->name = server[i].host;
  179.                 peer[n].host->service = server[i].service;

  181.                 peer[n].sockaddr = server[i].addrs[0].sockaddr;
  182.                 peer[n].socklen = server[i].addrs[0].socklen;
  183.                 peer[n].name = server[i].addrs[0].name;
  184.                 peer[n].weight = server[i].weight;
  185.                 peer[n].effective_weight = server[i].weight;
  186.                 peer[n].current_weight = 0;
  187.                 peer[n].max_conns = server[i].max_conns;
  188.                 peer[n].max_fails = server[i].max_fails;
  189.                 peer[n].fail_timeout = server[i].fail_timeout;
  190.                 peer[n].down = server[i].down;
  191.                 peer[n].server = server[i].name;

  193.                 *rpeerp = &peer[n];
  194.                 rpeerp = &peer[n].next;
  195.                 n++;

  197.                 continue;
  198.             }
  199. #endif

  201.             for (j = 0; j < server[i].naddrs; j++) {
  202.                 peer[n].sockaddr = server[i].addrs[j].sockaddr;
  203.                 peer[n].socklen = server[i].addrs[j].socklen;
  204.                 peer[n].name = server[i].addrs[j].name;
  205.                 peer[n].weight = server[i].weight;
  206.                 peer[n].effective_weight = server[i].weight;
  207.                 peer[n].current_weight = 0;
  208.                 peer[n].max_conns = server[i].max_conns;
  209.                 peer[n].max_fails = server[i].max_fails;
  210.                 peer[n].fail_timeout = server[i].fail_timeout;
  211.                 peer[n].down = server[i].down;
  212.                 peer[n].server = server[i].name;

  214.                 *peerp = &peer[n];
  215.                 peerp = &peer[n].next;
  216.                 n++;
  217.             }
  218.         }

  220.         us->peer.data = peers;

  222.         /* backup servers */

  224.         n = 0;
  225.         r = 0;
  226.         w = 0;
  227.         t = 0;

  229.         for (i = 0; i < us->servers->nelts; i++) {
  230.             if (!server[i].backup) {
  231.                 continue;
  232.             }

  234. #if (NGX_HTTP_UPSTREAM_ZONE)
  235.             if (server[i].host.len) {
  236.                 r++;
  237.                 continue;
  238.             }
  239. #endif

  241.             n += server[i].naddrs;
  242.             w += server[i].naddrs * server[i].weight;

  244.             if (!server[i].down) {
  245.                 t += server[i].naddrs;
  246.             }
  247.         }

  249.         if (n == 0
  250. #if (NGX_HTTP_UPSTREAM_ZONE)
  251.             && !resolve
  252. #endif
  253.         ) {
  254.             return NGX_OK;
  255.         }

  257.         if (n + r == 0 && !(us->flags & NGX_HTTP_UPSTREAM_BACKUP)) {
  258.             return NGX_OK;
  259.         }

  261.         backup = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t));
  262.         if (backup == NULL) {
  263.             return NGX_ERROR;
  264.         }

  266.         peer = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peer_t)
  267.                                      * (n + r));
  268.         if (peer == NULL) {
  269.             return NGX_ERROR;
  270.         }

  272.         if (n > 0) {
  273.             peers->single = 0;
  274.         }

  276.         backup->single = 0;
  277.         backup->number = n;
  278.         backup->weighted = (w != n);
  279.         backup->total_weight = w;
  280.         backup->tries = t;
  281.         backup->name = &us->host;

  283.         n = 0;
  284.         peerp = &backup->peer;

  286. #if (NGX_HTTP_UPSTREAM_ZONE)
  287.         rpeerp = &backup->resolve;
  288. #endif

  290.         for (i = 0; i < us->servers->nelts; i++) {
  291.             if (!server[i].backup) {
  292.                 continue;
  293.             }

  295. #if (NGX_HTTP_UPSTREAM_ZONE)
  296.             if (server[i].host.len) {

  298.                 peer[n].host = ngx_pcalloc(cf->pool,
  299.                                            sizeof(ngx_http_upstream_host_t));
  300.                 if (peer[n].host == NULL) {
  301.                     return NGX_ERROR;
  302.                 }

  304.                 peer[n].host->name = server[i].host;
  305.                 peer[n].host->service = server[i].service;

  307.                 peer[n].sockaddr = server[i].addrs[0].sockaddr;
  308.                 peer[n].socklen = server[i].addrs[0].socklen;
  309.                 peer[n].name = server[i].addrs[0].name;
  310.                 peer[n].weight = server[i].weight;
  311.                 peer[n].effective_weight = server[i].weight;
  312.                 peer[n].current_weight = 0;
  313.                 peer[n].max_conns = server[i].max_conns;
  314.                 peer[n].max_fails = server[i].max_fails;
  315.                 peer[n].fail_timeout = server[i].fail_timeout;
  316.                 peer[n].down = server[i].down;
  317.                 peer[n].server = server[i].name;

  319.                 *rpeerp = &peer[n];
  320.                 rpeerp = &peer[n].next;
  321.                 n++;

  323.                 continue;
  324.             }
  325. #endif

  327.             for (j = 0; j < server[i].naddrs; j++) {
  328.                 peer[n].sockaddr = server[i].addrs[j].sockaddr;
  329.                 peer[n].socklen = server[i].addrs[j].socklen;
  330.                 peer[n].name = server[i].addrs[j].name;
  331.                 peer[n].weight = server[i].weight;
  332.                 peer[n].effective_weight = server[i].weight;
  333.                 peer[n].current_weight = 0;
  334.                 peer[n].max_conns = server[i].max_conns;
  335.                 peer[n].max_fails = server[i].max_fails;
  336.                 peer[n].fail_timeout = server[i].fail_timeout;
  337.                 peer[n].down = server[i].down;
  338.                 peer[n].server = server[i].name;

  340.                 *peerp = &peer[n];
  341.                 peerp = &peer[n].next;
  342.                 n++;
  343.             }
  344.         }

  346.         peers->next = backup;

  348.         return NGX_OK;
  349.     }


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

  354.     if (us->port == 0) {
  355.         ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  356.                       "no port in upstream \"%V\" in %s:%ui",
  357.                       &us->host, us->file_name, us->line);
  358.         return NGX_ERROR;
  359.     }

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

  363.     u.host = us->host;
  364.     u.port = us->port;

  366.     if (ngx_inet_resolve_host(cf->pool, &u) != NGX_OK) {
  367.         if (u.err) {
  368.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  369.                           "%s in upstream \"%V\" in %s:%ui",
  370.                           u.err, &us->host, us->file_name, us->line);
  371.         }

  373.         return NGX_ERROR;
  374.     }

  376.     n = u.naddrs;

  378.     peers = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t));
  379.     if (peers == NULL) {
  380.         return NGX_ERROR;
  381.     }

  383.     peer = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peer_t) * n);
  384.     if (peer == NULL) {
  385.         return NGX_ERROR;
  386.     }

  388.     peers->single = (n == 1);
  389.     peers->number = n;
  390.     peers->weighted = 0;
  391.     peers->total_weight = n;
  392.     peers->tries = n;
  393.     peers->name = &us->host;

  395.     peerp = &peers->peer;

  397.     for (i = 0; i < u.naddrs; i++) {
  398.         peer[i].sockaddr = u.addrs[i].sockaddr;
  399.         peer[i].socklen = u.addrs[i].socklen;
  400.         peer[i].name = u.addrs[i].name;
  401.         peer[i].weight = 1;
  402.         peer[i].effective_weight = 1;
  403.         peer[i].current_weight = 0;
  404.         peer[i].max_conns = 0;
  405.         peer[i].max_fails = 1;
  406.         peer[i].fail_timeout = 10;
  407.         *peerp = &peer[i];
  408.         peerp = &peer[i].next;
  409.     }

  411.     us->peer.data = peers;

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

  415.     return NGX_OK;
  416. }


  419. ngx_int_t
  420. ‌ngx_http_upstream_init_round_robin_peer(ngx_http_request_t *r,
  421.     ngx_http_upstream_srv_conf_t *us)
  422. {
  423.     ngx_uint_t                         n;
  424.     ngx_http_upstream_rr_peer_data_t  *rrp;

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

  428.     if (rrp == NULL) {
  429.         rrp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_rr_peer_data_t));
  430.         if (rrp == NULL) {
  431.             return NGX_ERROR;
  432.         }

  434.         r->upstream->peer.data = rrp;
  435.     }

  437.     rrp->peers = us->peer.data;
  438.     rrp->current = NULL;

  440.     ngx_http_upstream_rr_peers_rlock(rrp->peers);

  442. #if (NGX_HTTP_UPSTREAM_ZONE)
  443.     rrp->config = rrp->peers->config ? *rrp->peers->config : 0;
  444. #endif

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

  448.     if (rrp->peers->next && rrp->peers->next->number > n) {
  449.         n = rrp->peers->next->number;
  450.     }

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

  454.     ngx_http_upstream_rr_peers_unlock(rrp->peers);

  456.     if (n <= 8 * sizeof(uintptr_t)) {
  457.         rrp->tried = &rrp->data;
  458.         rrp->data = 0;

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

  463.         rrp->tried = ngx_pcalloc(r->pool, n * sizeof(uintptr_t));
  464.         if (rrp->tried == NULL) {
  465.             return NGX_ERROR;
  466.         }
  467.     }

  469.     r->upstream->peer.get = ngx_http_upstream_get_round_robin_peer;
  470.     r->upstream->peer.free = ngx_http_upstream_free_round_robin_peer;
  471. #if (NGX_HTTP_SSL)
  472.     r->upstream->peer.set_session =
  473.                                ngx_http_upstream_set_round_robin_peer_session;
  474.     r->upstream->peer.save_session =
  475.                                ngx_http_upstream_save_round_robin_peer_session;
  476. #endif

  478.     return NGX_OK;
  479. }


  482. ngx_int_t
  483. ‌ngx_http_upstream_create_round_robin_peer(ngx_http_request_t *r,
  484.     ngx_http_upstream_resolved_t *ur)
  485. {
  486.     u_char                            *p;
  487.     size_t                             len;
  488.     socklen_t                          socklen;
  489.     ngx_uint_t                         i, n;
  490.     struct sockaddr                   *sockaddr;
  491.     ngx_http_upstream_rr_peer_t       *peer, **peerp;
  492.     ngx_http_upstream_rr_peers_t      *peers;
  493.     ngx_http_upstream_rr_peer_data_t  *rrp;

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

  497.     if (rrp == NULL) {
  498.         rrp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_rr_peer_data_t));
  499.         if (rrp == NULL) {
  500.             return NGX_ERROR;
  501.         }

  503.         r->upstream->peer.data = rrp;
  504.     }

  506.     peers = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_rr_peers_t));
  507.     if (peers == NULL) {
  508.         return NGX_ERROR;
  509.     }

  511.     peer = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_rr_peer_t)
  512.                                 * ur->naddrs);
  513.     if (peer == NULL) {
  514.         return NGX_ERROR;
  515.     }

  517.     peers->single = (ur->naddrs == 1);
  518.     peers->number = ur->naddrs;
  519.     peers->tries = ur->naddrs;
  520.     peers->name = &ur->host;

  522.     if (ur->sockaddr) {
  523.         peer[0].sockaddr = ur->sockaddr;
  524.         peer[0].socklen = ur->socklen;
  525.         peer[0].name = ur->name.data ? ur->name : ur->host;
  526.         peer[0].weight = 1;
  527.         peer[0].effective_weight = 1;
  528.         peer[0].current_weight = 0;
  529.         peer[0].max_conns = 0;
  530.         peer[0].max_fails = 1;
  531.         peer[0].fail_timeout = 10;
  532.         peers->peer = peer;

  534.     } else {
  535.         peerp = &peers->peer;

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

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

  541.             sockaddr = ngx_palloc(r->pool, socklen);
  542.             if (sockaddr == NULL) {
  543.                 return NGX_ERROR;
  544.             }

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

  549.             p = ngx_pnalloc(r->pool, NGX_SOCKADDR_STRLEN);
  550.             if (p == NULL) {
  551.                 return NGX_ERROR;
  552.             }

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

  556.             peer[i].sockaddr = sockaddr;
  557.             peer[i].socklen = socklen;
  558.             peer[i].name.len = len;
  559.             peer[i].name.data = p;
  560.             peer[i].weight = 1;
  561.             peer[i].effective_weight = 1;
  562.             peer[i].current_weight = 0;
  563.             peer[i].max_conns = 0;
  564.             peer[i].max_fails = 1;
  565.             peer[i].fail_timeout = 10;
  566.             *peerp = &peer[i];
  567.             peerp = &peer[i].next;
  568.         }
  569.     }

  571.     rrp->peers = peers;
  572.     rrp->current = NULL;
  573.     rrp->config = 0;

  575.     if (rrp->peers->number <= 8 * sizeof(uintptr_t)) {
  576.         rrp->tried = &rrp->data;
  577.         rrp->data = 0;

  579.     } else {
  580.         n = (rrp->peers->number + (8 * sizeof(uintptr_t) - 1))
  581.                 / (8 * sizeof(uintptr_t));

  583.         rrp->tried = ngx_pcalloc(r->pool, n * sizeof(uintptr_t));
  584.         if (rrp->tried == NULL) {
  585.             return NGX_ERROR;
  586.         }
  587.     }

  589.     r->upstream->peer.get = ngx_http_upstream_get_round_robin_peer;
  590.     r->upstream->peer.free = ngx_http_upstream_free_round_robin_peer;
  591.     r->upstream->peer.tries = ngx_http_upstream_tries(rrp->peers);
  592. #if (NGX_HTTP_SSL)
  593.     r->upstream->peer.set_session = ngx_http_upstream_empty_set_session;
  594.     r->upstream->peer.save_session = ngx_http_upstream_empty_save_session;
  595. #endif

  597.     return NGX_OK;
  598. }


  601. ngx_int_t
  602. ‌ngx_http_upstream_get_round_robin_peer(ngx_peer_connection_t *pc, void *data)
  603. {
  604.     ngx_http_upstream_rr_peer_data_t  *rrp = data;

  606.     ngx_int_t                      rc;
  607.     ngx_uint_t                     i, n;
  608.     ngx_http_upstream_rr_peer_t   *peer;
  609.     ngx_http_upstream_rr_peers_t  *peers;

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

  614.     pc->cached = 0;
  615.     pc->connection = NULL;

  617.     peers = rrp->peers;
  618.     ngx_http_upstream_rr_peers_wlock(peers);

  620. #if (NGX_HTTP_UPSTREAM_ZONE)
  621.     if (peers->config && rrp->config != *peers->config) {
  622.         goto busy;
  623.     }
  624. #endif

  626.     if (peers->single) {
  627.         peer = peers->peer;

  629.         if (peer->down) {
  630.             goto failed;
  631.         }

  633.         if (peer->max_conns && peer->conns >= peer->max_conns) {
  634.             goto failed;
  635.         }

  637.         rrp->current = peer;
  638.         ngx_http_upstream_rr_peer_ref(peers, peer);

  640.     } else {

  642.         /* there are several peers */

  644.         peer = ngx_http_upstream_get_peer(rrp);

  646.         if (peer == NULL) {
  647.             goto failed;
  648.         }

  650.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  651.                        "get rr peer, current: %p %i",
  652.                        peer, peer->current_weight);
  653.     }

  655.     pc->sockaddr = peer->sockaddr;
  656.     pc->socklen = peer->socklen;
  657.     pc->name = &peer->name;

  659.     peer->conns++;

  661.     ngx_http_upstream_rr_peers_unlock(peers);

  663.     return NGX_OK;

  665. failed:

  667.     if (peers->next) {

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

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

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

  676.         for (i = 0; i < n; i++) {
  677.             rrp->tried[i] = 0;
  678.         }

  680.         ngx_http_upstream_rr_peers_unlock(peers);

  682.         rc = ngx_http_upstream_get_round_robin_peer(pc, rrp);

  684.         if (rc != NGX_BUSY) {
  685.             return rc;
  686.         }

  688.         ngx_http_upstream_rr_peers_wlock(peers);
  689.     }

  691. #if (NGX_HTTP_UPSTREAM_ZONE)
  692. busy:
  693. #endif

  695.     ngx_http_upstream_rr_peers_unlock(peers);

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

  699.     return NGX_BUSY;
  700. }


  703. static ngx_http_upstream_rr_peer_t *
  704. ‌ngx_http_upstream_get_peer(ngx_http_upstream_rr_peer_data_t *rrp)
  705. {
  706.     time_t                        now;
  707.     uintptr_t                     m;
  708.     ngx_int_t                     total;
  709.     ngx_uint_t                    i, n, p;
  710.     ngx_http_upstream_rr_peer_t  *peer, *best;

  712.     now = ngx_time();

  714.     best = NULL;
  715.     total = 0;

  717. #if (NGX_SUPPRESS_WARN)
  718.     p = 0;
  719. #endif

  721.     for (peer = rrp->peers->peer, i = 0;
  722.          peer;
  723.          peer = peer->next, i++)
  724.     {
  725.         n = i / (8 * sizeof(uintptr_t));
  726.         m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

  728.         if (rrp->tried[n] & m) {
  729.             continue;
  730.         }

  732.         if (peer->down) {
  733.             continue;
  734.         }

  736.         if (peer->max_fails
  737.             && peer->fails >= peer->max_fails
  738.             && now - peer->checked <= peer->fail_timeout)
  739.         {
  740.             continue;
  741.         }

  743.         if (peer->max_conns && peer->conns >= peer->max_conns) {
  744.             continue;
  745.         }

  747.         peer->current_weight += peer->effective_weight;
  748.         total += peer->effective_weight;

  750.         if (peer->effective_weight < peer->weight) {
  751.             peer->effective_weight++;
  752.         }

  754.         if (best == NULL || peer->current_weight > best->current_weight) {
  755.             best = peer;
  756.             p = i;
  757.         }
  758.     }

  760.     if (best == NULL) {
  761.         return NULL;
  762.     }

  764.     rrp->current = best;
  765.     ngx_http_upstream_rr_peer_ref(rrp->peers, best);

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

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

  772.     best->current_weight -= total;

  774.     if (now - best->checked > best->fail_timeout) {
  775.         best->checked = now;
  776.     }

  778.     return best;
  779. }


  782. void
  783. ‌ngx_http_upstream_free_round_robin_peer(ngx_peer_connection_t *pc, void *data,
  784.     ngx_uint_t state)
  785. {
  786.     ngx_http_upstream_rr_peer_data_t  *rrp = data;

  788.     time_t                       now;
  789.     ngx_http_upstream_rr_peer_t  *peer;

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

  794.     /* TODO: NGX_PEER_KEEPALIVE */

  796.     peer = rrp->current;

  798.     ngx_http_upstream_rr_peers_rlock(rrp->peers);
  799.     ngx_http_upstream_rr_peer_lock(rrp->peers, peer);

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

  803.         if (peer->fails) {
  804.             peer->fails = 0;
  805.         }

  807.         peer->conns--;

  809.         if (ngx_http_upstream_rr_peer_unref(rrp->peers, peer) == NGX_OK) {
  810.             ngx_http_upstream_rr_peer_unlock(rrp->peers, peer);
  811.         }

  813.         ngx_http_upstream_rr_peers_unlock(rrp->peers);

  815.         pc->tries = 0;
  816.         return;
  817.     }

  819.     if (state & NGX_PEER_FAILED) {
  820.         now = ngx_time();

  822.         peer->fails++;
  823.         peer->accessed = now;
  824.         peer->checked = now;

  826.         if (peer->max_fails) {
  827.             peer->effective_weight -= peer->weight / peer->max_fails;

  829.             if (peer->fails >= peer->max_fails) {
  830.                 ngx_log_error(NGX_LOG_WARN, pc->log, 0,
  831.                               "upstream server temporarily disabled");
  832.             }
  833.         }

  835.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  836.                        "free rr peer failed: %p %i",
  837.                        peer, peer->effective_weight);

  839.         if (peer->effective_weight < 0) {
  840.             peer->effective_weight = 0;
  841.         }

  843.     } else {

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

  847.         if (peer->accessed < peer->checked) {
  848.             peer->fails = 0;
  849.         }
  850.     }

  852.     peer->conns--;

  854.     if (ngx_http_upstream_rr_peer_unref(rrp->peers, peer) == NGX_OK) {
  855.         ngx_http_upstream_rr_peer_unlock(rrp->peers, peer);
  856.     }

  858.     ngx_http_upstream_rr_peers_unlock(rrp->peers);

  860.     if (pc->tries) {
  861.         pc->tries--;
  862.     }
  863. }


  866. #if (NGX_HTTP_SSL)

  868. ngx_int_t
  869. ‌ngx_http_upstream_set_round_robin_peer_session(ngx_peer_connection_t *pc,
  870.     void *data)
  871. {
  872.     ngx_http_upstream_rr_peer_data_t  *rrp = data;

  874.     ngx_int_t                      rc;
  875.     ngx_ssl_session_t             *ssl_session;
  876.     ngx_http_upstream_rr_peer_t   *peer;
  877. #if (NGX_HTTP_UPSTREAM_ZONE)
  878.     int                            len;
  879.     const u_char                  *p;
  880.     ngx_http_upstream_rr_peers_t  *peers;
  881.     u_char                         buf[NGX_SSL_MAX_SESSION_SIZE];
  882. #endif

  884.     peer = rrp->current;

  886. #if (NGX_HTTP_UPSTREAM_ZONE)
  887.     peers = rrp->peers;

  889.     if (peers->shpool) {
  890.         ngx_http_upstream_rr_peers_rlock(peers);
  891.         ngx_http_upstream_rr_peer_lock(peers, peer);

  893.         if (peer->ssl_session == NULL) {
  894.             ngx_http_upstream_rr_peer_unlock(peers, peer);
  895.             ngx_http_upstream_rr_peers_unlock(peers);
  896.             return NGX_OK;
  897.         }

  899.         len = peer->ssl_session_len;

  901.         ngx_memcpy(buf, peer->ssl_session, len);

  903.         ngx_http_upstream_rr_peer_unlock(peers, peer);
  904.         ngx_http_upstream_rr_peers_unlock(peers);

  906.         p = buf;
  907.         ssl_session = d2i_SSL_SESSION(NULL, &p, len);

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

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

  914.         ngx_ssl_free_session(ssl_session);

  916.         return rc;
  917.     }
  918. #endif

  920.     ssl_session = peer->ssl_session;

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

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

  927.     return rc;
  928. }


  931. void
  932. ‌ngx_http_upstream_save_round_robin_peer_session(ngx_peer_connection_t *pc,
  933.     void *data)
  934. {
  935.     ngx_http_upstream_rr_peer_data_t  *rrp = data;

  937.     ngx_ssl_session_t             *old_ssl_session, *ssl_session;
  938.     ngx_http_upstream_rr_peer_t   *peer;
  939. #if (NGX_HTTP_UPSTREAM_ZONE)
  940.     int                            len;
  941.     u_char                        *p;
  942.     ngx_http_upstream_rr_peers_t  *peers;
  943.     u_char                         buf[NGX_SSL_MAX_SESSION_SIZE];
  944. #endif

  946. #if (NGX_HTTP_UPSTREAM_ZONE)
  947.     peers = rrp->peers;

  949.     if (peers->shpool) {

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

  953.         if (ssl_session == NULL) {
  954.             return;
  955.         }

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

  960.         len = i2d_SSL_SESSION(ssl_session, NULL);

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

  964.         if (len > NGX_SSL_MAX_SESSION_SIZE) {
  965.             return;
  966.         }

  968.         p = buf;
  969.         (void) i2d_SSL_SESSION(ssl_session, &p);

  971.         peer = rrp->current;

  973.         ngx_http_upstream_rr_peers_rlock(peers);
  974.         ngx_http_upstream_rr_peer_lock(peers, peer);

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

  979.             if (peer->ssl_session) {
  980.                 ngx_slab_free_locked(peers->shpool, peer->ssl_session);
  981.             }

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

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

  987.             if (peer->ssl_session == NULL) {
  988.                 peer->ssl_session_len = 0;

  990.                 ngx_http_upstream_rr_peer_unlock(peers, peer);
  991.                 ngx_http_upstream_rr_peers_unlock(peers);
  992.                 return;
  993.             }

  995.             peer->ssl_session_len = len;
  996.         }

  998.         ngx_memcpy(peer->ssl_session, buf, len);

  1000.         ngx_http_upstream_rr_peer_unlock(peers, peer);
  1001.         ngx_http_upstream_rr_peers_unlock(peers);

  1003.         return;
  1004.     }
  1005. #endif

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

  1009.     if (ssl_session == NULL) {
  1010.         return;
  1011.     }

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

  1016.     peer = rrp->current;

  1018.     old_ssl_session = peer->ssl_session;
  1019.     peer->ssl_session = ssl_session;

  1021.     if (old_ssl_session) {

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

  1026.         /* TODO: may block */

  1028.         ngx_ssl_free_session(old_ssl_session);
  1029.     }
  1030. }


  1033. static ngx_int_t
  1034. ‌ngx_http_upstream_empty_set_session(ngx_peer_connection_t *pc, void *data)
  1035. {
  1036.     return NGX_OK;
  1037. }


  1040. static void
  1041. ‌ngx_http_upstream_empty_save_session(ngx_peer_connection_t *pc, void *data)
  1042. {
  1043.     return;
  1044. }

  1046. #endif

One Level Up Top Level