One Level Up Top Level

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


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


  17. static ngx_stream_upstream_rr_peer_t *ngx_stream_upstream_get_peer(
  18.     ngx_stream_upstream_rr_peer_data_t *rrp);
  19. static void ngx_stream_upstream_notify_round_robin_peer(
  20.     ngx_peer_connection_t *pc, void *data, ngx_uint_t state);

  22. #if (NGX_STREAM_SSL)

  24. static ngx_int_t ngx_stream_upstream_set_round_robin_peer_session(
  25.     ngx_peer_connection_t *pc, void *data);
  26. static void ngx_stream_upstream_save_round_robin_peer_session(
  27.     ngx_peer_connection_t *pc, void *data);
  28. static ngx_int_t ngx_stream_upstream_empty_set_session(
  29.     ngx_peer_connection_t *pc, void *data);
  30. static void ngx_stream_upstream_empty_save_session(ngx_peer_connection_t *pc,
  31.     void *data);

  33. #endif


  36. ngx_int_t
  37. ‌ngx_stream_upstream_init_round_robin(ngx_conf_t *cf,
  38.     ngx_stream_upstream_srv_conf_t *us)
  39. {
  40.     ngx_url_t                        u;
  41.     ngx_uint_t                       i, j, n, r, w, t;
  42.     ngx_stream_upstream_server_t    *server;
  43.     ngx_stream_upstream_rr_peer_t   *peer, **peerp;
  44.     ngx_stream_upstream_rr_peers_t  *peers, *backup;
  45. #if (NGX_STREAM_UPSTREAM_ZONE)
  46.     ngx_uint_t                       resolve;
  47.     ngx_stream_core_srv_conf_t      *cscf;
  48.     ngx_stream_upstream_rr_peer_t  **rpeerp;
  49. #endif

  51.     us->peer.init = ngx_stream_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_STREAM_UPSTREAM_ZONE)
  62.         resolve = 0;
  63. #endif

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

  67. #if (NGX_STREAM_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_STREAM_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_STREAM_UPSTREAM_ZONE)
  93.         if (us->shm_zone) {

  95.             if (resolve && !(us->flags & NGX_STREAM_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.             cscf = ngx_stream_conf_get_module_srv_conf(cf,
  105.                                                        ngx_stream_core_module);

  107.             if (us->resolver == NULL) {
  108.                 us->resolver = cscf->resolver;
  109.             }

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

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

  128.         } else if (resolve) {

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

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

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

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

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

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

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

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

  176. #if (NGX_STREAM_UPSTREAM_ZONE)
  177.             if (server[i].host.len) {

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

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

  188.                 peer[n].sockaddr = server[i].addrs[0].sockaddr;
  189.                 peer[n].socklen = server[i].addrs[0].socklen;
  190.                 peer[n].name = server[i].addrs[0].name;
  191.                 peer[n].weight = server[i].weight;
  192.                 peer[n].effective_weight = server[i].weight;
  193.                 peer[n].current_weight = 0;
  194.                 peer[n].max_conns = server[i].max_conns;
  195.                 peer[n].max_fails = server[i].max_fails;
  196.                 peer[n].fail_timeout = server[i].fail_timeout;
  197.                 peer[n].down = server[i].down;
  198.                 peer[n].server = server[i].name;
  199.                 *rpeerp = &peer[n];
  200.                 rpeerp = &peer[n].next;
  201.                 n++;

  203.                 continue;
  204.             }
  205. #endif

  207.             for (j = 0; j < server[i].naddrs; j++) {
  208.                 peer[n].sockaddr = server[i].addrs[j].sockaddr;
  209.                 peer[n].socklen = server[i].addrs[j].socklen;
  210.                 peer[n].name = server[i].addrs[j].name;
  211.                 peer[n].weight = server[i].weight;
  212.                 peer[n].effective_weight = server[i].weight;
  213.                 peer[n].current_weight = 0;
  214.                 peer[n].max_conns = server[i].max_conns;
  215.                 peer[n].max_fails = server[i].max_fails;
  216.                 peer[n].fail_timeout = server[i].fail_timeout;
  217.                 peer[n].down = server[i].down;
  218.                 peer[n].server = server[i].name;

  220.                 *peerp = &peer[n];
  221.                 peerp = &peer[n].next;
  222.                 n++;
  223.             }
  224.         }

  226.         us->peer.data = peers;

  228.         /* backup servers */

  230.         n = 0;
  231.         r = 0;
  232.         w = 0;
  233.         t = 0;

  235.         for (i = 0; i < us->servers->nelts; i++) {
  236.             if (!server[i].backup) {
  237.                 continue;
  238.             }

  240. #if (NGX_STREAM_UPSTREAM_ZONE)
  241.             if (server[i].host.len) {
  242.                 r++;
  243.                 continue;
  244.             }
  245. #endif

  247.             n += server[i].naddrs;
  248.             w += server[i].naddrs * server[i].weight;

  250.             if (!server[i].down) {
  251.                 t += server[i].naddrs;
  252.             }
  253.         }

  255.         if (n == 0
  256. #if (NGX_STREAM_UPSTREAM_ZONE)
  257.             && !resolve
  258. #endif
  259.         ) {
  260.             return NGX_OK;
  261.         }

  263.         if (n + r == 0 && !(us->flags & NGX_STREAM_UPSTREAM_BACKUP)) {
  264.             return NGX_OK;
  265.         }

  267.         backup = ngx_pcalloc(cf->pool, sizeof(ngx_stream_upstream_rr_peers_t));
  268.         if (backup == NULL) {
  269.             return NGX_ERROR;
  270.         }

  272.         peer = ngx_pcalloc(cf->pool, sizeof(ngx_stream_upstream_rr_peer_t)
  273.                                      * (n + r));
  274.         if (peer == NULL) {
  275.             return NGX_ERROR;
  276.         }

  278.         if (n > 0) {
  279.             peers->single = 0;
  280.         }

  282.         backup->single = 0;
  283.         backup->number = n;
  284.         backup->weighted = (w != n);
  285.         backup->total_weight = w;
  286.         backup->tries = t;
  287.         backup->name = &us->host;

  289.         n = 0;
  290.         peerp = &backup->peer;

  292. #if (NGX_STREAM_UPSTREAM_ZONE)
  293.         rpeerp = &backup->resolve;
  294. #endif

  296.         for (i = 0; i < us->servers->nelts; i++) {
  297.             if (!server[i].backup) {
  298.                 continue;
  299.             }

  301. #if (NGX_STREAM_UPSTREAM_ZONE)
  302.             if (server[i].host.len) {

  304.                 peer[n].host = ngx_pcalloc(cf->pool,
  305.                                            sizeof(ngx_stream_upstream_host_t));
  306.                 if (peer[n].host == NULL) {
  307.                     return NGX_ERROR;
  308.                 }

  310.                 peer[n].host->name = server[i].host;
  311.                 peer[n].host->service = server[i].service;

  313.                 peer[n].sockaddr = server[i].addrs[0].sockaddr;
  314.                 peer[n].socklen = server[i].addrs[0].socklen;
  315.                 peer[n].name = server[i].addrs[0].name;
  316.                 peer[n].weight = server[i].weight;
  317.                 peer[n].effective_weight = server[i].weight;
  318.                 peer[n].current_weight = 0;
  319.                 peer[n].max_conns = server[i].max_conns;
  320.                 peer[n].max_fails = server[i].max_fails;
  321.                 peer[n].fail_timeout = server[i].fail_timeout;
  322.                 peer[n].down = server[i].down;
  323.                 peer[n].server = server[i].name;
  324.                 *rpeerp = &peer[n];
  325.                 rpeerp = &peer[n].next;
  326.                 n++;

  328.                 continue;
  329.             }
  330. #endif

  332.             for (j = 0; j < server[i].naddrs; j++) {
  333.                 peer[n].sockaddr = server[i].addrs[j].sockaddr;
  334.                 peer[n].socklen = server[i].addrs[j].socklen;
  335.                 peer[n].name = server[i].addrs[j].name;
  336.                 peer[n].weight = server[i].weight;
  337.                 peer[n].effective_weight = server[i].weight;
  338.                 peer[n].current_weight = 0;
  339.                 peer[n].max_conns = server[i].max_conns;
  340.                 peer[n].max_fails = server[i].max_fails;
  341.                 peer[n].fail_timeout = server[i].fail_timeout;
  342.                 peer[n].down = server[i].down;
  343.                 peer[n].server = server[i].name;

  345.                 *peerp = &peer[n];
  346.                 peerp = &peer[n].next;
  347.                 n++;
  348.             }
  349.         }

  351.         peers->next = backup;

  353.         return NGX_OK;
  354.     }


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

  359.     if (us->port == 0) {
  360.         ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  361.                       "no port in upstream \"%V\" in %s:%ui",
  362.                       &us->host, us->file_name, us->line);
  363.         return NGX_ERROR;
  364.     }

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

  368.     u.host = us->host;
  369.     u.port = us->port;

  371.     if (ngx_inet_resolve_host(cf->pool, &u) != NGX_OK) {
  372.         if (u.err) {
  373.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  374.                           "%s in upstream \"%V\" in %s:%ui",
  375.                           u.err, &us->host, us->file_name, us->line);
  376.         }

  378.         return NGX_ERROR;
  379.     }

  381.     n = u.naddrs;

  383.     peers = ngx_pcalloc(cf->pool, sizeof(ngx_stream_upstream_rr_peers_t));
  384.     if (peers == NULL) {
  385.         return NGX_ERROR;
  386.     }

  388.     peer = ngx_pcalloc(cf->pool, sizeof(ngx_stream_upstream_rr_peer_t) * n);
  389.     if (peer == NULL) {
  390.         return NGX_ERROR;
  391.     }

  393.     peers->single = (n == 1);
  394.     peers->number = n;
  395.     peers->weighted = 0;
  396.     peers->total_weight = n;
  397.     peers->tries = n;
  398.     peers->name = &us->host;

  400.     peerp = &peers->peer;

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

  416.     us->peer.data = peers;

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

  420.     return NGX_OK;
  421. }


  424. ngx_int_t
  425. ‌ngx_stream_upstream_init_round_robin_peer(ngx_stream_session_t *s,
  426.     ngx_stream_upstream_srv_conf_t *us)
  427. {
  428.     ngx_uint_t                           n;
  429.     ngx_stream_upstream_rr_peer_data_t  *rrp;

  431.     rrp = s->upstream->peer.data;

  433.     if (rrp == NULL) {
  434.         rrp = ngx_palloc(s->connection->pool,
  435.                          sizeof(ngx_stream_upstream_rr_peer_data_t));
  436.         if (rrp == NULL) {
  437.             return NGX_ERROR;
  438.         }

  440.         s->upstream->peer.data = rrp;
  441.     }

  443.     rrp->peers = us->peer.data;
  444.     rrp->current = NULL;

  446.     ngx_stream_upstream_rr_peers_rlock(rrp->peers);

  448. #if (NGX_STREAM_UPSTREAM_ZONE)
  449.     rrp->config = rrp->peers->config ? *rrp->peers->config : 0;
  450. #endif

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

  454.     if (rrp->peers->next && rrp->peers->next->number > n) {
  455.         n = rrp->peers->next->number;
  456.     }

  458.     s->upstream->peer.tries = ngx_stream_upstream_tries(rrp->peers);

  460.     ngx_stream_upstream_rr_peers_unlock(rrp->peers);

  462.     if (n <= 8 * sizeof(uintptr_t)) {
  463.         rrp->tried = &rrp->data;
  464.         rrp->data = 0;

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

  469.         rrp->tried = ngx_pcalloc(s->connection->pool, n * sizeof(uintptr_t));
  470.         if (rrp->tried == NULL) {
  471.             return NGX_ERROR;
  472.         }
  473.     }

  475.     s->upstream->peer.get = ngx_stream_upstream_get_round_robin_peer;
  476.     s->upstream->peer.free = ngx_stream_upstream_free_round_robin_peer;
  477.     s->upstream->peer.notify = ngx_stream_upstream_notify_round_robin_peer;

  479. #if (NGX_STREAM_SSL)
  480.     s->upstream->peer.set_session =
  481.                              ngx_stream_upstream_set_round_robin_peer_session;
  482.     s->upstream->peer.save_session =
  483.                              ngx_stream_upstream_save_round_robin_peer_session;
  484. #endif

  486.     return NGX_OK;
  487. }


  490. ngx_int_t
  491. ‌ngx_stream_upstream_create_round_robin_peer(ngx_stream_session_t *s,
  492.     ngx_stream_upstream_resolved_t *ur)
  493. {
  494.     u_char                              *p;
  495.     size_t                               len;
  496.     socklen_t                            socklen;
  497.     ngx_uint_t                           i, n;
  498.     struct sockaddr                     *sockaddr;
  499.     ngx_stream_upstream_rr_peer_t       *peer, **peerp;
  500.     ngx_stream_upstream_rr_peers_t      *peers;
  501.     ngx_stream_upstream_rr_peer_data_t  *rrp;

  503.     rrp = s->upstream->peer.data;

  505.     if (rrp == NULL) {
  506.         rrp = ngx_palloc(s->connection->pool,
  507.                          sizeof(ngx_stream_upstream_rr_peer_data_t));
  508.         if (rrp == NULL) {
  509.             return NGX_ERROR;
  510.         }

  512.         s->upstream->peer.data = rrp;
  513.     }

  515.     peers = ngx_pcalloc(s->connection->pool,
  516.                         sizeof(ngx_stream_upstream_rr_peers_t));
  517.     if (peers == NULL) {
  518.         return NGX_ERROR;
  519.     }

  521.     peer = ngx_pcalloc(s->connection->pool,
  522.                        sizeof(ngx_stream_upstream_rr_peer_t) * ur->naddrs);
  523.     if (peer == NULL) {
  524.         return NGX_ERROR;
  525.     }

  527.     peers->single = (ur->naddrs == 1);
  528.     peers->number = ur->naddrs;
  529.     peers->tries = ur->naddrs;
  530.     peers->name = &ur->host;

  532.     if (ur->sockaddr) {
  533.         peer[0].sockaddr = ur->sockaddr;
  534.         peer[0].socklen = ur->socklen;
  535.         peer[0].name = ur->name;
  536.         peer[0].weight = 1;
  537.         peer[0].effective_weight = 1;
  538.         peer[0].current_weight = 0;
  539.         peer[0].max_conns = 0;
  540.         peer[0].max_fails = 1;
  541.         peer[0].fail_timeout = 10;
  542.         peers->peer = peer;

  544.     } else {
  545.         peerp = &peers->peer;

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

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

  551.             sockaddr = ngx_palloc(s->connection->pool, socklen);
  552.             if (sockaddr == NULL) {
  553.                 return NGX_ERROR;
  554.             }

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

  559.             p = ngx_pnalloc(s->connection->pool, NGX_SOCKADDR_STRLEN);
  560.             if (p == NULL) {
  561.                 return NGX_ERROR;
  562.             }

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

  566.             peer[i].sockaddr = sockaddr;
  567.             peer[i].socklen = socklen;
  568.             peer[i].name.len = len;
  569.             peer[i].name.data = p;
  570.             peer[i].weight = 1;
  571.             peer[i].effective_weight = 1;
  572.             peer[i].current_weight = 0;
  573.             peer[i].max_conns = 0;
  574.             peer[i].max_fails = 1;
  575.             peer[i].fail_timeout = 10;
  576.             *peerp = &peer[i];
  577.             peerp = &peer[i].next;
  578.         }
  579.     }

  581.     rrp->peers = peers;
  582.     rrp->current = NULL;
  583.     rrp->config = 0;

  585.     if (rrp->peers->number <= 8 * sizeof(uintptr_t)) {
  586.         rrp->tried = &rrp->data;
  587.         rrp->data = 0;

  589.     } else {
  590.         n = (rrp->peers->number + (8 * sizeof(uintptr_t) - 1))
  591.                 / (8 * sizeof(uintptr_t));

  593.         rrp->tried = ngx_pcalloc(s->connection->pool, n * sizeof(uintptr_t));
  594.         if (rrp->tried == NULL) {
  595.             return NGX_ERROR;
  596.         }
  597.     }

  599.     s->upstream->peer.get = ngx_stream_upstream_get_round_robin_peer;
  600.     s->upstream->peer.free = ngx_stream_upstream_free_round_robin_peer;
  601.     s->upstream->peer.tries = ngx_stream_upstream_tries(rrp->peers);
  602. #if (NGX_STREAM_SSL)
  603.     s->upstream->peer.set_session = ngx_stream_upstream_empty_set_session;
  604.     s->upstream->peer.save_session = ngx_stream_upstream_empty_save_session;
  605. #endif

  607.     return NGX_OK;
  608. }


  611. ngx_int_t
  612. ‌ngx_stream_upstream_get_round_robin_peer(ngx_peer_connection_t *pc, void *data)
  613. {
  614.     ngx_stream_upstream_rr_peer_data_t *rrp = data;

  616.     ngx_int_t                        rc;
  617.     ngx_uint_t                       i, n;
  618.     ngx_stream_upstream_rr_peer_t   *peer;
  619.     ngx_stream_upstream_rr_peers_t  *peers;

  621.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, pc->log, 0,
  622.                    "get rr peer, try: %ui", pc->tries);

  624.     pc->connection = NULL;

  626.     peers = rrp->peers;
  627.     ngx_stream_upstream_rr_peers_wlock(peers);

  629. #if (NGX_STREAM_UPSTREAM_ZONE)
  630.     if (peers->config && rrp->config != *peers->config) {
  631.         goto busy;
  632.     }
  633. #endif

  635.     if (peers->single) {
  636.         peer = peers->peer;

  638.         if (peer->down) {
  639.             goto failed;
  640.         }

  642.         if (peer->max_conns && peer->conns >= peer->max_conns) {
  643.             goto failed;
  644.         }

  646.         rrp->current = peer;
  647.         ngx_stream_upstream_rr_peer_ref(peers, peer);

  649.     } else {

  651.         /* there are several peers */

  653.         peer = ngx_stream_upstream_get_peer(rrp);

  655.         if (peer == NULL) {
  656.             goto failed;
  657.         }

  659.         ngx_log_debug2(NGX_LOG_DEBUG_STREAM, pc->log, 0,
  660.                        "get rr peer, current: %p %i",
  661.                        peer, peer->current_weight);
  662.     }

  664.     pc->sockaddr = peer->sockaddr;
  665.     pc->socklen = peer->socklen;
  666.     pc->name = &peer->name;

  668.     peer->conns++;

  670.     ngx_stream_upstream_rr_peers_unlock(peers);

  672.     return NGX_OK;

  674. failed:

  676.     if (peers->next) {

  678.         ngx_log_debug0(NGX_LOG_DEBUG_STREAM, pc->log, 0, "backup servers");

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

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

  685.         for (i = 0; i < n; i++) {
  686.             rrp->tried[i] = 0;
  687.         }

  689.         ngx_stream_upstream_rr_peers_unlock(peers);

  691.         rc = ngx_stream_upstream_get_round_robin_peer(pc, rrp);

  693.         if (rc != NGX_BUSY) {
  694.             return rc;
  695.         }

  697.         ngx_stream_upstream_rr_peers_wlock(peers);
  698.     }

  700. #if (NGX_STREAM_UPSTREAM_ZONE)
  701. busy:
  702. #endif

  704.     ngx_stream_upstream_rr_peers_unlock(peers);

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

  708.     return NGX_BUSY;
  709. }


  712. static ngx_stream_upstream_rr_peer_t *
  713. ‌ngx_stream_upstream_get_peer(ngx_stream_upstream_rr_peer_data_t *rrp)
  714. {
  715.     time_t                          now;
  716.     uintptr_t                       m;
  717.     ngx_int_t                       total;
  718.     ngx_uint_t                      i, n, p;
  719.     ngx_stream_upstream_rr_peer_t  *peer, *best;

  721.     now = ngx_time();

  723.     best = NULL;
  724.     total = 0;

  726. #if (NGX_SUPPRESS_WARN)
  727.     p = 0;
  728. #endif

  730.     for (peer = rrp->peers->peer, i = 0;
  731.          peer;
  732.          peer = peer->next, i++)
  733.     {
  734.         n = i / (8 * sizeof(uintptr_t));
  735.         m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

  737.         if (rrp->tried[n] & m) {
  738.             continue;
  739.         }

  741.         if (peer->down) {
  742.             continue;
  743.         }

  745.         if (peer->max_fails
  746.             && peer->fails >= peer->max_fails
  747.             && now - peer->checked <= peer->fail_timeout)
  748.         {
  749.             continue;
  750.         }

  752.         if (peer->max_conns && peer->conns >= peer->max_conns) {
  753.             continue;
  754.         }

  756.         peer->current_weight += peer->effective_weight;
  757.         total += peer->effective_weight;

  759.         if (peer->effective_weight < peer->weight) {
  760.             peer->effective_weight++;
  761.         }

  763.         if (best == NULL || peer->current_weight > best->current_weight) {
  764.             best = peer;
  765.             p = i;
  766.         }
  767.     }

  769.     if (best == NULL) {
  770.         return NULL;
  771.     }

  773.     rrp->current = best;
  774.     ngx_stream_upstream_rr_peer_ref(rrp->peers, best);

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

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

  781.     best->current_weight -= total;

  783.     if (now - best->checked > best->fail_timeout) {
  784.         best->checked = now;
  785.     }

  787.     return best;
  788. }


  791. void
  792. ‌ngx_stream_upstream_free_round_robin_peer(ngx_peer_connection_t *pc, void *data,
  793.     ngx_uint_t state)
  794. {
  795.     ngx_stream_upstream_rr_peer_data_t  *rrp = data;

  797.     time_t                          now;
  798.     ngx_stream_upstream_rr_peer_t  *peer;

  800.     ngx_log_debug2(NGX_LOG_DEBUG_STREAM, pc->log, 0,
  801.                    "free rr peer %ui %ui", pc->tries, state);

  803.     peer = rrp->current;

  805.     ngx_stream_upstream_rr_peers_rlock(rrp->peers);
  806.     ngx_stream_upstream_rr_peer_lock(rrp->peers, peer);

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

  810.         if (peer->fails) {
  811.             peer->fails = 0;
  812.         }

  814.         peer->conns--;

  816.         if (ngx_stream_upstream_rr_peer_unref(rrp->peers, peer) == NGX_OK) {
  817.             ngx_stream_upstream_rr_peer_unlock(rrp->peers, peer);
  818.         }

  820.         ngx_stream_upstream_rr_peers_unlock(rrp->peers);

  822.         pc->tries = 0;
  823.         return;
  824.     }

  826.     if (state & NGX_PEER_FAILED) {
  827.         now = ngx_time();

  829.         peer->fails++;
  830.         peer->accessed = now;
  831.         peer->checked = now;

  833.         if (peer->max_fails) {
  834.             peer->effective_weight -= peer->weight / peer->max_fails;

  836.             if (peer->fails >= peer->max_fails) {
  837.                 ngx_log_error(NGX_LOG_WARN, pc->log, 0,
  838.                               "upstream server temporarily disabled");
  839.             }
  840.         }

  842.         ngx_log_debug2(NGX_LOG_DEBUG_STREAM, pc->log, 0,
  843.                        "free rr peer failed: %p %i",
  844.                        peer, peer->effective_weight);

  846.         if (peer->effective_weight < 0) {
  847.             peer->effective_weight = 0;
  848.         }

  850.     } else {

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

  854.         if (peer->accessed < peer->checked) {
  855.             peer->fails = 0;
  856.         }
  857.     }

  859.     peer->conns--;

  861.     if (ngx_stream_upstream_rr_peer_unref(rrp->peers, peer) == NGX_OK) {
  862.         ngx_stream_upstream_rr_peer_unlock(rrp->peers, peer);
  863.     }

  865.     ngx_stream_upstream_rr_peers_unlock(rrp->peers);

  867.     if (pc->tries) {
  868.         pc->tries--;
  869.     }
  870. }


  873. static void
  874. ‌ngx_stream_upstream_notify_round_robin_peer(ngx_peer_connection_t *pc,
  875.     void *data, ngx_uint_t type)
  876. {
  877.     ngx_stream_upstream_rr_peer_data_t  *rrp = data;

  879.     ngx_stream_upstream_rr_peer_t  *peer;

  881.     peer = rrp->current;

  883.     if (type == NGX_STREAM_UPSTREAM_NOTIFY_CONNECT
  884.         && pc->connection->type == SOCK_STREAM)
  885.     {
  886.         ngx_stream_upstream_rr_peers_rlock(rrp->peers);
  887.         ngx_stream_upstream_rr_peer_lock(rrp->peers, peer);

  889.         if (peer->accessed < peer->checked) {
  890.             peer->fails = 0;
  891.         }

  893.         ngx_stream_upstream_rr_peer_unlock(rrp->peers, peer);
  894.         ngx_stream_upstream_rr_peers_unlock(rrp->peers);
  895.     }
  896. }


  899. #if (NGX_STREAM_SSL)

  901. static ngx_int_t
  902. ‌ngx_stream_upstream_set_round_robin_peer_session(ngx_peer_connection_t *pc,
  903.     void *data)
  904. {
  905.     ngx_stream_upstream_rr_peer_data_t  *rrp = data;

  907.     ngx_int_t                        rc;
  908.     ngx_ssl_session_t               *ssl_session;
  909.     ngx_stream_upstream_rr_peer_t   *peer;
  910. #if (NGX_STREAM_UPSTREAM_ZONE)
  911.     int                              len;
  912.     const u_char                    *p;
  913.     ngx_stream_upstream_rr_peers_t  *peers;
  914.     u_char                           buf[NGX_SSL_MAX_SESSION_SIZE];
  915. #endif

  917.     peer = rrp->current;

  919. #if (NGX_STREAM_UPSTREAM_ZONE)
  920.     peers = rrp->peers;

  922.     if (peers->shpool) {
  923.         ngx_stream_upstream_rr_peers_rlock(peers);
  924.         ngx_stream_upstream_rr_peer_lock(peers, peer);

  926.         if (peer->ssl_session == NULL) {
  927.             ngx_stream_upstream_rr_peer_unlock(peers, peer);
  928.             ngx_stream_upstream_rr_peers_unlock(peers);
  929.             return NGX_OK;
  930.         }

  932.         len = peer->ssl_session_len;

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

  936.         ngx_stream_upstream_rr_peer_unlock(peers, peer);
  937.         ngx_stream_upstream_rr_peers_unlock(peers);

  939.         p = buf;
  940.         ssl_session = d2i_SSL_SESSION(NULL, &p, len);

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

  944.         ngx_log_debug1(NGX_LOG_DEBUG_STREAM, pc->log, 0,
  945.                        "set session: %p", ssl_session);

  947.         ngx_ssl_free_session(ssl_session);

  949.         return rc;
  950.     }
  951. #endif

  953.     ssl_session = peer->ssl_session;

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

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

  960.     return rc;
  961. }


  964. static void
  965. ‌ngx_stream_upstream_save_round_robin_peer_session(ngx_peer_connection_t *pc,
  966.     void *data)
  967. {
  968.     ngx_stream_upstream_rr_peer_data_t  *rrp = data;

  970.     ngx_ssl_session_t               *old_ssl_session, *ssl_session;
  971.     ngx_stream_upstream_rr_peer_t   *peer;
  972. #if (NGX_STREAM_UPSTREAM_ZONE)
  973.     int                              len;
  974.     u_char                          *p;
  975.     ngx_stream_upstream_rr_peers_t  *peers;
  976.     u_char                           buf[NGX_SSL_MAX_SESSION_SIZE];
  977. #endif

  979. #if (NGX_STREAM_UPSTREAM_ZONE)
  980.     peers = rrp->peers;

  982.     if (peers->shpool) {

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

  986.         if (ssl_session == NULL) {
  987.             return;
  988.         }

  990.         ngx_log_debug1(NGX_LOG_DEBUG_STREAM, pc->log, 0,
  991.                        "save session: %p", ssl_session);

  993.         len = i2d_SSL_SESSION(ssl_session, NULL);

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

  997.         if (len > NGX_SSL_MAX_SESSION_SIZE) {
  998.             return;
  999.         }

  1001.         p = buf;
  1002.         (void) i2d_SSL_SESSION(ssl_session, &p);

  1004.         peer = rrp->current;

  1006.         ngx_stream_upstream_rr_peers_rlock(peers);
  1007.         ngx_stream_upstream_rr_peer_lock(peers, peer);

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

  1012.             if (peer->ssl_session) {
  1013.                 ngx_slab_free_locked(peers->shpool, peer->ssl_session);
  1014.             }

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

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

  1020.             if (peer->ssl_session == NULL) {
  1021.                 peer->ssl_session_len = 0;

  1023.                 ngx_stream_upstream_rr_peer_unlock(peers, peer);
  1024.                 ngx_stream_upstream_rr_peers_unlock(peers);
  1025.                 return;
  1026.             }

  1028.             peer->ssl_session_len = len;
  1029.         }

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

  1033.         ngx_stream_upstream_rr_peer_unlock(peers, peer);
  1034.         ngx_stream_upstream_rr_peers_unlock(peers);

  1036.         return;
  1037.     }
  1038. #endif

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

  1042.     if (ssl_session == NULL) {
  1043.         return;
  1044.     }

  1046.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, pc->log, 0,
  1047.                    "save session: %p", ssl_session);

  1049.     peer = rrp->current;

  1051.     old_ssl_session = peer->ssl_session;
  1052.     peer->ssl_session = ssl_session;

  1054.     if (old_ssl_session) {

  1056.         ngx_log_debug1(NGX_LOG_DEBUG_STREAM, pc->log, 0,
  1057.                        "old session: %p", old_ssl_session);

  1059.         /* TODO: may block */

  1061.         ngx_ssl_free_session(old_ssl_session);
  1062.     }
  1063. }


  1066. static ngx_int_t
  1067. ‌ngx_stream_upstream_empty_set_session(ngx_peer_connection_t *pc, void *data)
  1068. {
  1069.     return NGX_OK;
  1070. }


  1073. static void
  1074. ‌ngx_stream_upstream_empty_save_session(ngx_peer_connection_t *pc, void *data)
  1075. {
  1076.     return;
  1077. }

  1079. #endif

One Level Up Top Level