One Level Up Top Level

src/http/modules/ngx_http_upstream_zone_module.c - nginx

Global variables defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Ruslan Ermilov
  4. * Copyright (C) Nginx, Inc.
  5. */


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


  13. static char *ngx_http_upstream_zone(ngx_conf_t *cf, ngx_command_t *cmd,
  14.     void *conf);
  15. static ngx_int_t ngx_http_upstream_init_zone(ngx_shm_zone_t *shm_zone,
  16.     void *data);
  17. static ngx_http_upstream_rr_peers_t *ngx_http_upstream_zone_copy_peers(
  18.     ngx_slab_pool_t *shpool, ngx_http_upstream_srv_conf_t *uscf,
  19.     ngx_http_upstream_srv_conf_t *ouscf);
  20. static ngx_http_upstream_rr_peer_t *ngx_http_upstream_zone_copy_peer(
  21.     ngx_http_upstream_rr_peers_t *peers, ngx_http_upstream_rr_peer_t *src);
  22. static ngx_int_t ngx_http_upstream_zone_preresolve(
  23.     ngx_http_upstream_rr_peer_t *resolve,
  24.     ngx_http_upstream_rr_peers_t *peers,
  25.     ngx_http_upstream_rr_peer_t *oresolve,
  26.     ngx_http_upstream_rr_peers_t *opeers);
  27. static void ngx_http_upstream_zone_set_single(
  28.     ngx_http_upstream_srv_conf_t *uscf);
  29. static void ngx_http_upstream_zone_remove_peer_locked(
  30.     ngx_http_upstream_rr_peers_t *peers, ngx_http_upstream_rr_peer_t *peer);
  31. static ngx_int_t ngx_http_upstream_zone_init_worker(ngx_cycle_t *cycle);
  32. static void ngx_http_upstream_zone_resolve_timer(ngx_event_t *event);
  33. static void ngx_http_upstream_zone_resolve_handler(ngx_resolver_ctx_t *ctx);


  36. ‌static ngx_command_t  ngx_http_upstream_zone_commands[] = {

  38.     { ngx_string("zone"),
  39.       NGX_HTTP_UPS_CONF|NGX_CONF_TAKE12,
  40.       ngx_http_upstream_zone,
  41.       0,
  42.       0,
  43.       NULL },

  45.       ngx_null_command
  46. };


  49. ‌static ngx_http_module_t  ngx_http_upstream_zone_module_ctx = {
  50.     NULL,                                  /* preconfiguration */
  51.     NULL,                                  /* postconfiguration */

  53.     NULL,                                  /* create main configuration */
  54.     NULL,                                  /* init main configuration */

  56.     NULL,                                  /* create server configuration */
  57.     NULL,                                  /* merge server configuration */

  59.     NULL,                                  /* create location configuration */
  60.     NULL                                   /* merge location configuration */
  61. };


  64. ‌ngx_module_t  ngx_http_upstream_zone_module = {
  65.     NGX_MODULE_V1,
  66.     &ngx_http_upstream_zone_module_ctx,    /* module context */
  67.     ngx_http_upstream_zone_commands,       /* module directives */
  68.     NGX_HTTP_MODULE,                       /* module type */
  69.     NULL,                                  /* init master */
  70.     NULL,                                  /* init module */
  71.     ngx_http_upstream_zone_init_worker,    /* init process */
  72.     NULL,                                  /* init thread */
  73.     NULL,                                  /* exit thread */
  74.     NULL,                                  /* exit process */
  75.     NULL,                                  /* exit master */
  76.     NGX_MODULE_V1_PADDING
  77. };


  80. static char *
  81. ‌ngx_http_upstream_zone(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  82. {
  83.     ssize_t                         size;
  84.     ngx_str_t                      *value;
  85.     ngx_http_upstream_srv_conf_t   *uscf;
  86.     ngx_http_upstream_main_conf_t  *umcf;

  88.     uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);
  89.     umcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_upstream_module);

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

  93.     if (!value[1].len) {
  94.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  95.                            "invalid zone name \"%V\"", &value[1]);
  96.         return NGX_CONF_ERROR;
  97.     }

  99.     if (cf->args->nelts == 3) {
  100.         size = ngx_parse_size(&value[2]);

  102.         if (size == NGX_ERROR) {
  103.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  104.                                "invalid zone size \"%V\"", &value[2]);
  105.             return NGX_CONF_ERROR;
  106.         }

  108.         if (size < (ssize_t) (8 * ngx_pagesize)) {
  109.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  110.                                "zone \"%V\" is too small", &value[1]);
  111.             return NGX_CONF_ERROR;
  112.         }

  114.     } else {
  115.         size = 0;
  116.     }

  118.     uscf->shm_zone = ngx_shared_memory_add(cf, &value[1], size,
  119.                                            &ngx_http_upstream_module);
  120.     if (uscf->shm_zone == NULL) {
  121.         return NGX_CONF_ERROR;
  122.     }

  124.     uscf->shm_zone->init = ngx_http_upstream_init_zone;
  125.     uscf->shm_zone->data = umcf;

  127.     uscf->shm_zone->noreuse = 1;

  129.     return NGX_CONF_OK;
  130. }


  133. static ngx_int_t
  134. ‌ngx_http_upstream_init_zone(ngx_shm_zone_t *shm_zone, void *data)
  135. {
  136.     size_t                          len;
  137.     ngx_uint_t                      i, j;
  138.     ngx_slab_pool_t                *shpool;
  139.     ngx_http_upstream_rr_peers_t   *peers, **peersp;
  140.     ngx_http_upstream_srv_conf_t   *uscf, *ouscf, **uscfp, **ouscfp;
  141.     ngx_http_upstream_main_conf_t  *umcf, *oumcf;

  143.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;
  144.     umcf = shm_zone->data;
  145.     uscfp = umcf->upstreams.elts;

  147.     if (shm_zone->shm.exists) {
  148.         peers = shpool->data;

  150.         for (i = 0; i < umcf->upstreams.nelts; i++) {
  151.             uscf = uscfp[i];

  153.             if (uscf->shm_zone != shm_zone) {
  154.                 continue;
  155.             }

  157.             uscf->peer.data = peers;
  158.             peers = peers->zone_next;
  159.         }

  161.         return NGX_OK;
  162.     }

  164.     len = sizeof(" in upstream zone \"\"") + shm_zone->shm.name.len;

  166.     shpool->log_ctx = ngx_slab_alloc(shpool, len);
  167.     if (shpool->log_ctx == NULL) {
  168.         return NGX_ERROR;
  169.     }

  171.     ngx_sprintf(shpool->log_ctx, " in upstream zone \"%V\"%Z",
  172.                 &shm_zone->shm.name);


  175.     /* copy peers to shared memory */

  177.     peersp = (ngx_http_upstream_rr_peers_t **) (void *) &shpool->data;
  178.     oumcf = data;

  180.     for (i = 0; i < umcf->upstreams.nelts; i++) {
  181.         uscf = uscfp[i];

  183.         if (uscf->shm_zone != shm_zone) {
  184.             continue;
  185.         }

  187.         ouscf = NULL;

  189.         if (oumcf) {
  190.             ouscfp = oumcf->upstreams.elts;

  192.             for (j = 0; j < oumcf->upstreams.nelts; j++) {

  194.                  if (ouscfp[j]->shm_zone == NULL) {
  195.                      continue;
  196.                  }

  198.                  if (ouscfp[j]->shm_zone->shm.name.len != shm_zone->shm.name.len
  199.                      || ngx_memcmp(ouscfp[j]->shm_zone->shm.name.data,
  200.                                    shm_zone->shm.name.data,
  201.                                    shm_zone->shm.name.len)
  202.                         != 0)
  203.                  {
  204.                      continue;
  205.                  }

  207.                  if (ouscfp[j]->host.len == uscf->host.len
  208.                      && ngx_memcmp(ouscfp[j]->host.data, uscf->host.data,
  209.                                    uscf->host.len)
  210.                         == 0)
  211.                  {
  212.                      ouscf = ouscfp[j];
  213.                      break;
  214.                  }
  215.             }
  216.         }

  218.         peers = ngx_http_upstream_zone_copy_peers(shpool, uscf, ouscf);
  219.         if (peers == NULL) {
  220.             return NGX_ERROR;
  221.         }

  223.         *peersp = peers;
  224.         peersp = &peers->zone_next;
  225.     }

  227.     return NGX_OK;
  228. }


  231. static ngx_http_upstream_rr_peers_t *
  232. ‌ngx_http_upstream_zone_copy_peers(ngx_slab_pool_t *shpool,
  233.     ngx_http_upstream_srv_conf_t *uscf, ngx_http_upstream_srv_conf_t *ouscf)
  234. {
  235.     ngx_str_t                     *name;
  236.     ngx_uint_t                    *config;
  237.     ngx_http_upstream_rr_peer_t   *peer, **peerp;
  238.     ngx_http_upstream_rr_peers_t  *peers, *opeers, *backup;

  240.     opeers = (ouscf ? ouscf->peer.data : NULL);

  242.     config = ngx_slab_calloc(shpool, sizeof(ngx_uint_t));
  243.     if (config == NULL) {
  244.         return NULL;
  245.     }

  247.     peers = ngx_slab_alloc(shpool, sizeof(ngx_http_upstream_rr_peers_t));
  248.     if (peers == NULL) {
  249.         return NULL;
  250.     }

  252.     ngx_memcpy(peers, uscf->peer.data, sizeof(ngx_http_upstream_rr_peers_t));

  254.     name = ngx_slab_alloc(shpool, sizeof(ngx_str_t));
  255.     if (name == NULL) {
  256.         return NULL;
  257.     }

  259.     name->data = ngx_slab_alloc(shpool, peers->name->len);
  260.     if (name->data == NULL) {
  261.         return NULL;
  262.     }

  264.     ngx_memcpy(name->data, peers->name->data, peers->name->len);
  265.     name->len = peers->name->len;

  267.     peers->name = name;

  269.     peers->shpool = shpool;
  270.     peers->config = config;

  272.     for (peerp = &peers->peer; *peerp; peerp = &peer->next) {
  273.         /* pool is unlocked */
  274.         peer = ngx_http_upstream_zone_copy_peer(peers, *peerp);
  275.         if (peer == NULL) {
  276.             return NULL;
  277.         }

  279.         *peerp = peer;
  280.         (*peers->config)++;
  281.     }

  283.     for (peerp = &peers->resolve; *peerp; peerp = &peer->next) {
  284.         peer = ngx_http_upstream_zone_copy_peer(peers, *peerp);
  285.         if (peer == NULL) {
  286.             return NULL;
  287.         }

  289.         *peerp = peer;
  290.         (*peers->config)++;
  291.     }

  293.     if (opeers) {

  295.         if (ngx_http_upstream_zone_preresolve(peers->resolve, peers,
  296.                                               opeers->resolve, opeers)
  297.             != NGX_OK)
  298.         {
  299.             return NULL;
  300.         }
  301.     }

  303.     if (peers->next == NULL) {
  304.         goto done;
  305.     }

  307.     backup = ngx_slab_alloc(shpool, sizeof(ngx_http_upstream_rr_peers_t));
  308.     if (backup == NULL) {
  309.         return NULL;
  310.     }

  312.     ngx_memcpy(backup, peers->next, sizeof(ngx_http_upstream_rr_peers_t));

  314.     backup->name = name;

  316.     backup->shpool = shpool;
  317.     backup->config = config;

  319.     for (peerp = &backup->peer; *peerp; peerp = &peer->next) {
  320.         /* pool is unlocked */
  321.         peer = ngx_http_upstream_zone_copy_peer(backup, *peerp);
  322.         if (peer == NULL) {
  323.             return NULL;
  324.         }

  326.         *peerp = peer;
  327.         (*backup->config)++;
  328.     }

  330.     for (peerp = &backup->resolve; *peerp; peerp = &peer->next) {
  331.         peer = ngx_http_upstream_zone_copy_peer(backup, *peerp);
  332.         if (peer == NULL) {
  333.             return NULL;
  334.         }

  336.         *peerp = peer;
  337.         (*backup->config)++;
  338.     }

  340.     peers->next = backup;

  342.     if (opeers && opeers->next) {

  344.         if (ngx_http_upstream_zone_preresolve(peers->resolve, backup,
  345.                                               opeers->resolve, opeers->next)
  346.             != NGX_OK)
  347.         {
  348.             return NULL;
  349.         }

  351.         if (ngx_http_upstream_zone_preresolve(backup->resolve, backup,
  352.                                               opeers->next->resolve,
  353.                                               opeers->next)
  354.             != NGX_OK)
  355.         {
  356.             return NULL;
  357.         }
  358.     }

  360. done:

  362.     uscf->peer.data = peers;

  364.     ngx_http_upstream_zone_set_single(uscf);

  366.     return peers;
  367. }


  370. static ngx_http_upstream_rr_peer_t *
  371. ‌ngx_http_upstream_zone_copy_peer(ngx_http_upstream_rr_peers_t *peers,
  372.     ngx_http_upstream_rr_peer_t *src)
  373. {
  374.     ngx_slab_pool_t              *pool;
  375.     ngx_http_upstream_rr_peer_t  *dst;

  377.     pool = peers->shpool;

  379.     dst = ngx_slab_calloc_locked(pool, sizeof(ngx_http_upstream_rr_peer_t));
  380.     if (dst == NULL) {
  381.         return NULL;
  382.     }

  384.     if (src) {
  385.         ngx_memcpy(dst, src, sizeof(ngx_http_upstream_rr_peer_t));
  386.         dst->sockaddr = NULL;
  387.         dst->name.data = NULL;
  388. #if (NGX_HTTP_UPSTREAM_SID)
  389.         dst->sid.data = NULL;
  390. #endif
  391.         dst->server.data = NULL;
  392.         dst->host = NULL;
  393.     }

  395.     dst->sockaddr = ngx_slab_calloc_locked(pool, sizeof(ngx_sockaddr_t));
  396.     if (dst->sockaddr == NULL) {
  397.         goto failed;
  398.     }

  400.     dst->name.data = ngx_slab_calloc_locked(pool, NGX_SOCKADDR_STRLEN);
  401.     if (dst->name.data == NULL) {
  402.         goto failed;
  403.     }

  405. #if (NGX_HTTP_UPSTREAM_SID)
  406.     dst->sid.data = ngx_slab_calloc_locked(pool, NGX_HTTP_UPSTREAM_SID_LEN);
  407.     if (dst->sid.data == NULL) {
  408.         goto failed;
  409.     }
  410. #endif

  412.     if (src) {
  413.         ngx_memcpy(dst->sockaddr, src->sockaddr, src->socklen);
  414.         ngx_memcpy(dst->name.data, src->name.data, src->name.len);
  415. #if (NGX_HTTP_UPSTREAM_SID)
  416.         ngx_memcpy(dst->sid.data, src->sid.data, src->sid.len);
  417. #endif

  419.         dst->server.data = ngx_slab_alloc_locked(pool, src->server.len);
  420.         if (dst->server.data == NULL) {
  421.             goto failed;
  422.         }

  424.         ngx_memcpy(dst->server.data, src->server.data, src->server.len);

  426.         if (src->host) {
  427.             dst->host = ngx_slab_calloc_locked(pool,
  428.                                              sizeof(ngx_http_upstream_host_t));
  429.             if (dst->host == NULL) {
  430.                 goto failed;
  431.             }

  433.             dst->host->name.data = ngx_slab_alloc_locked(pool,
  434.                                                          src->host->name.len);
  435.             if (dst->host->name.data == NULL) {
  436.                 goto failed;
  437.             }

  439.             dst->host->peers = peers;
  440.             dst->host->peer = dst;

  442.             dst->host->name.len = src->host->name.len;
  443.             ngx_memcpy(dst->host->name.data, src->host->name.data,
  444.                        src->host->name.len);

  446.             if (src->host->service.len) {
  447.                 dst->host->service.data = ngx_slab_alloc_locked(pool,
  448.                                                         src->host->service.len);
  449.                 if (dst->host->service.data == NULL) {
  450.                     goto failed;
  451.                 }

  453.                 dst->host->service.len = src->host->service.len;
  454.                 ngx_memcpy(dst->host->service.data, src->host->service.data,
  455.                            src->host->service.len);
  456.             }
  457.         }
  458.     }

  460.     return dst;

  462. failed:

  464.     if (dst->host) {
  465.         if (dst->host->name.data) {
  466.             ngx_slab_free_locked(pool, dst->host->name.data);
  467.         }

  469.         ngx_slab_free_locked(pool, dst->host);
  470.     }

  472.     if (dst->server.data) {
  473.         ngx_slab_free_locked(pool, dst->server.data);
  474.     }

  476. #if (NGX_HTTP_UPSTREAM_SID)
  477.     if (dst->sid.data) {
  478.         ngx_slab_free_locked(pool, dst->sid.data);
  479.     }
  480. #endif

  482.     if (dst->name.data) {
  483.         ngx_slab_free_locked(pool, dst->name.data);
  484.     }

  486.     if (dst->sockaddr) {
  487.         ngx_slab_free_locked(pool, dst->sockaddr);
  488.     }

  490.     ngx_slab_free_locked(pool, dst);

  492.     return NULL;
  493. }


  496. static ngx_int_t
  497. ‌ngx_http_upstream_zone_preresolve(ngx_http_upstream_rr_peer_t *resolve,
  498.     ngx_http_upstream_rr_peers_t *peers,
  499.     ngx_http_upstream_rr_peer_t *oresolve,
  500.     ngx_http_upstream_rr_peers_t *opeers)
  501. {
  502.     in_port_t                     port;
  503.     ngx_str_t                    *server;
  504.     ngx_http_upstream_host_t     *host;
  505.     ngx_http_upstream_rr_peer_t  *peer, *template, *opeer, **peerp;

  507.     if (resolve == NULL || oresolve == NULL) {
  508.         return NGX_OK;
  509.     }

  511.     for (peerp = &peers->peer; *peerp; peerp = &(*peerp)->next) {
  512.         /* void */
  513.     }

  515.     ngx_http_upstream_rr_peers_rlock(opeers);

  517.     for (template = resolve; template; template = template->next) {
  518.         for (opeer = oresolve; opeer; opeer = opeer->next) {

  520.             if (opeer->host->name.len != template->host->name.len
  521.                 || ngx_memcmp(opeer->host->name.data,
  522.                               template->host->name.data,
  523.                               template->host->name.len)
  524.                    != 0)
  525.             {
  526.                 continue;
  527.             }

  529.             if (opeer->host->service.len != template->host->service.len
  530.                 || ngx_memcmp(opeer->host->service.data,
  531.                               template->host->service.data,
  532.                               template->host->service.len)
  533.                    != 0)
  534.             {
  535.                 continue;
  536.             }

  538.             host = opeer->host;

  540.             for (opeer = opeers->peer; opeer; opeer = opeer->next) {

  542.                 if (opeer->host != host) {
  543.                     continue;
  544.                 }

  546.                 peer = ngx_http_upstream_zone_copy_peer(peers, NULL);
  547.                 if (peer == NULL) {
  548.                     ngx_http_upstream_rr_peers_unlock(opeers);
  549.                     return NGX_ERROR;
  550.                 }

  552.                 ngx_memcpy(peer->sockaddr, opeer->sockaddr, opeer->socklen);

  554.                 if (template->host->service.len == 0) {
  555.                     port = ngx_inet_get_port(template->sockaddr);
  556.                     ngx_inet_set_port(peer->sockaddr, port);
  557.                 }

  559.                 peer->socklen = opeer->socklen;

  561.                 peer->name.len = ngx_sock_ntop(peer->sockaddr, peer->socklen,
  562.                                                peer->name.data,
  563.                                                NGX_SOCKADDR_STRLEN, 1);

  565.                 peer->host = template->host;

  567.                 template->host->valid = host->valid;

  569.                 server = template->host->service.len ? &opeer->server
  570.                                                      : &template->server;

  572.                 peer->server.data = ngx_slab_alloc(peers->shpool, server->len);
  573.                 if (peer->server.data == NULL) {
  574.                     ngx_http_upstream_rr_peers_unlock(opeers);
  575.                     return NGX_ERROR;
  576.                 }

  578.                 ngx_memcpy(peer->server.data, server->data, server->len);
  579.                 peer->server.len = server->len;

  581.                 if (host->service.len == 0) {
  582.                     peer->weight = template->weight;

  584.                 } else {
  585.                     peer->weight = (template->weight != 1 ? template->weight
  586.                                                           : opeer->weight);
  587.                 }

  589.                 peer->effective_weight = peer->weight;
  590.                 peer->max_conns = template->max_conns;
  591.                 peer->max_fails = template->max_fails;
  592.                 peer->fail_timeout = template->fail_timeout;
  593.                 peer->down = template->down;

  595. #if (NGX_HTTP_UPSTREAM_SID)
  596.                 ngx_http_upstream_copy_round_robin_sid(peer, template);
  597. #endif

  599.                 (*peers->config)++;

  601.                 *peerp = peer;
  602.                 peerp = &peer->next;

  604.                 peers->number++;
  605.                 peers->tries += (peer->down == 0);
  606.                 peers->total_weight += peer->weight;
  607.                 peers->weighted = (peers->total_weight != peers->number);
  608.             }

  610.             break;
  611.         }
  612.     }

  614.     ngx_http_upstream_rr_peers_unlock(opeers);
  615.     return NGX_OK;
  616. }


  619. static void
  620. ‌ngx_http_upstream_zone_set_single(ngx_http_upstream_srv_conf_t *uscf)
  621. {
  622.     ngx_http_upstream_rr_peers_t  *peers;

  624.     peers = uscf->peer.data;

  626.     if (peers->number == 1
  627.         && (peers->next == NULL || peers->next->number == 0))
  628.     {
  629.         peers->single = 1;

  631.     } else {
  632.         peers->single = 0;
  633.     }
  634. }


  637. static void
  638. ‌ngx_http_upstream_zone_remove_peer_locked(ngx_http_upstream_rr_peers_t *peers,
  639.     ngx_http_upstream_rr_peer_t *peer)
  640. {
  641.     peers->total_weight -= peer->weight;
  642.     peers->number--;
  643.     peers->tries -= (peer->down == 0);
  644.     (*peers->config)++;
  645.     peers->weighted = (peers->total_weight != peers->number);

  647.     ngx_http_upstream_rr_peer_free(peers, peer);
  648. }


  651. static ngx_int_t
  652. ‌ngx_http_upstream_zone_init_worker(ngx_cycle_t *cycle)
  653. {
  654.     time_t                          now;
  655.     ngx_msec_t                      timer;
  656.     ngx_uint_t                      i;
  657.     ngx_event_t                    *event;
  658.     ngx_http_upstream_rr_peer_t    *peer;
  659.     ngx_http_upstream_rr_peers_t   *peers;
  660.     ngx_http_upstream_srv_conf_t   *uscf, **uscfp;
  661.     ngx_http_upstream_main_conf_t  *umcf;

  663.     if (ngx_process != NGX_PROCESS_WORKER
  664.         && ngx_process != NGX_PROCESS_SINGLE)
  665.     {
  666.         return NGX_OK;
  667.     }

  669.     now = ngx_time();
  670.     umcf = ngx_http_cycle_get_module_main_conf(cycle, ngx_http_upstream_module);

  672.     if (umcf == NULL) {
  673.         return NGX_OK;
  674.     }

  676.     uscfp = umcf->upstreams.elts;

  678.     for (i = 0; i < umcf->upstreams.nelts; i++) {

  680.         uscf = uscfp[i];

  682.         if (uscf->shm_zone == NULL) {
  683.             continue;
  684.         }

  686.         peers = uscf->peer.data;

  688.         do {
  689.             ngx_http_upstream_rr_peers_wlock(peers);

  691.             for (peer = peers->resolve; peer; peer = peer->next) {

  693.                 if (peer->host->worker != ngx_worker) {
  694.                     continue;
  695.                 }

  697.                 event = &peer->host->event;
  698.                 ngx_memzero(event, sizeof(ngx_event_t));

  700.                 event->data = uscf;
  701.                 event->handler = ngx_http_upstream_zone_resolve_timer;
  702.                 event->log = cycle->log;
  703.                 event->cancelable = 1;

  705.                 timer = (peer->host->valid > now)
  706.                         ? (ngx_msec_t) 1000 * (peer->host->valid - now) : 1;

  708.                 ngx_add_timer(event, timer);
  709.             }

  711.             ngx_http_upstream_rr_peers_unlock(peers);

  713.             peers = peers->next;

  715.         } while (peers);
  716.     }

  718.     return NGX_OK;
  719. }


  722. static void
  723. ‌ngx_http_upstream_zone_resolve_timer(ngx_event_t *event)
  724. {
  725.     ngx_resolver_ctx_t            *ctx;
  726.     ngx_http_upstream_host_t      *host;
  727.     ngx_http_upstream_srv_conf_t  *uscf;

  729.     host = (ngx_http_upstream_host_t *) event;
  730.     uscf = event->data;

  732.     ctx = ngx_resolve_start(uscf->resolver, NULL);
  733.     if (ctx == NULL) {
  734.         goto retry;
  735.     }

  737.     if (ctx == NGX_NO_RESOLVER) {
  738.         ngx_log_error(NGX_LOG_ERR, event->log, 0,
  739.                       "no resolver defined to resolve %V", &host->name);
  740.         return;
  741.     }

  743.     ctx->name = host->name;
  744.     ctx->handler = ngx_http_upstream_zone_resolve_handler;
  745.     ctx->data = host;
  746.     ctx->timeout = uscf->resolver_timeout;
  747.     ctx->service = host->service;
  748.     ctx->cancelable = 1;

  750.     if (ngx_resolve_name(ctx) == NGX_OK) {
  751.         return;
  752.     }

  754. retry:

  756.     ngx_add_timer(event, ngx_max(uscf->resolver_timeout, 1000));
  757. }


  760. ‌#define ngx_http_upstream_zone_addr_marked(addr)                              \
  761.     ((uintptr_t) (addr)->sockaddr & 1)

  763. ‌#define ngx_http_upstream_zone_mark_addr(addr)                                \
  764.     (addr)->sockaddr = (struct sockaddr *) ((uintptr_t) (addr)->sockaddr | 1)

  766. ‌#define ngx_http_upstream_zone_unmark_addr(addr)                              \
  767.     (addr)->sockaddr =                                                        \
  768.         (struct sockaddr *) ((uintptr_t) (addr)->sockaddr & ~((uintptr_t) 1))

  770. static void
  771. ‌ngx_http_upstream_zone_resolve_handler(ngx_resolver_ctx_t *ctx)
  772. {
  773.     time_t                         now;
  774.     u_short                        min_priority;
  775.     in_port_t                      port;
  776.     ngx_str_t                     *server;
  777.     ngx_msec_t                     timer;
  778.     ngx_uint_t                     i, j, backup, addr_backup;
  779.     ngx_event_t                   *event;
  780.     ngx_resolver_addr_t           *addr;
  781.     ngx_resolver_srv_name_t       *srv;
  782.     ngx_http_upstream_host_t      *host;
  783.     ngx_http_upstream_rr_peer_t   *peer, *template, **peerp;
  784.     ngx_http_upstream_rr_peers_t  *peers;
  785.     ngx_http_upstream_srv_conf_t  *uscf;

  787.     host = ctx->data;
  788.     event = &host->event;
  789.     uscf = event->data;
  790.     peers = host->peers;
  791.     template = host->peer;

  793.     ngx_http_upstream_rr_peers_wlock(peers);

  795.     now = ngx_time();

  797.     for (i = 0; i < ctx->nsrvs; i++) {
  798.         srv = &ctx->srvs[i];

  800.         if (srv->state) {
  801.             ngx_log_error(NGX_LOG_ERR, event->log, 0,
  802.                           "%V could not be resolved (%i: %s) "
  803.                           "while resolving service %V of %V",
  804.                           &srv->name, srv->state,
  805.                           ngx_resolver_strerror(srv->state), &ctx->service,
  806.                           &ctx->name);
  807.         }
  808.     }

  810.     if (ctx->state) {
  811.         if (ctx->service.len) {
  812.             ngx_log_error(NGX_LOG_ERR, event->log, 0,
  813.                           "service %V of %V could not be resolved (%i: %s)",
  814.                           &ctx->service, &ctx->name, ctx->state,
  815.                           ngx_resolver_strerror(ctx->state));

  817.         } else {
  818.             ngx_log_error(NGX_LOG_ERR, event->log, 0,
  819.                           "%V could not be resolved (%i: %s)",
  820.                           &ctx->name, ctx->state,
  821.                           ngx_resolver_strerror(ctx->state));
  822.         }

  824.         if (ctx->state != NGX_RESOLVE_NXDOMAIN) {
  825.             ngx_http_upstream_rr_peers_unlock(peers);

  827.             ngx_resolve_name_done(ctx);

  829.             ngx_add_timer(event, ngx_max(uscf->resolver_timeout, 1000));
  830.             return;
  831.         }

  833.         /* NGX_RESOLVE_NXDOMAIN */

  835.         ctx->naddrs = 0;
  836.     }

  838.     backup = 0;
  839.     min_priority = 65535;

  841.     for (i = 0; i < ctx->naddrs; i++) {
  842.         min_priority = ngx_min(ctx->addrs[i].priority, min_priority);
  843.     }

  845. #if (NGX_DEBUG)
  846.     {
  847.     u_char  text[NGX_SOCKADDR_STRLEN];
  848.     size_t  len;

  850.     for (i = 0; i < ctx->naddrs; i++) {
  851.         len = ngx_sock_ntop(ctx->addrs[i].sockaddr, ctx->addrs[i].socklen,
  852.                             text, NGX_SOCKADDR_STRLEN, 1);

  854.         ngx_log_debug7(NGX_LOG_DEBUG_HTTP, event->log, 0,
  855.                        "name %V was resolved to %*s "
  856.                        "s:\"%V\" n:\"%V\" w:%d %s",
  857.                        &host->name, len, text, &host->service,
  858.                        &ctx->addrs[i].name, ctx->addrs[i].weight,
  859.                        ctx->addrs[i].priority != min_priority ? "backup" : "");
  860.     }
  861.     }
  862. #endif

  864. again:

  866.     for (peerp = &peers->peer; *peerp; /* void */ ) {
  867.         peer = *peerp;

  869.         if (peer->host != host) {
  870.             goto next;
  871.         }

  873.         for (j = 0; j < ctx->naddrs; j++) {

  875.             addr = &ctx->addrs[j];

  877.             addr_backup = (addr->priority != min_priority);
  878.             if (addr_backup != backup) {
  879.                 continue;
  880.             }

  882.             if (ngx_http_upstream_zone_addr_marked(addr)) {
  883.                 continue;
  884.             }

  886.             if (ngx_cmp_sockaddr(peer->sockaddr, peer->socklen,
  887.                                  addr->sockaddr, addr->socklen,
  888.                                  host->service.len != 0)
  889.                 != NGX_OK)
  890.             {
  891.                 continue;
  892.             }

  894.             if (host->service.len) {
  895.                 if (addr->name.len != peer->server.len
  896.                     || ngx_strncmp(addr->name.data, peer->server.data,
  897.                                    addr->name.len))
  898.                 {
  899.                     continue;
  900.                 }

  902.                 if (template->weight == 1 && addr->weight != peer->weight) {
  903.                     continue;
  904.                 }
  905.             }

  907.             ngx_http_upstream_zone_mark_addr(addr);

  909.             goto next;
  910.         }

  912.         *peerp = peer->next;
  913.         ngx_http_upstream_zone_remove_peer_locked(peers, peer);

  915.         ngx_http_upstream_zone_set_single(uscf);

  917.         continue;

  919.     next:

  921.         peerp = &peer->next;
  922.     }

  924.     for (i = 0; i < ctx->naddrs; i++) {

  926.         addr = &ctx->addrs[i];

  928.         addr_backup = (addr->priority != min_priority);
  929.         if (addr_backup != backup) {
  930.             continue;
  931.         }

  933.         if (ngx_http_upstream_zone_addr_marked(addr)) {
  934.             ngx_http_upstream_zone_unmark_addr(addr);
  935.             continue;
  936.         }

  938.         ngx_shmtx_lock(&peers->shpool->mutex);
  939.         peer = ngx_http_upstream_zone_copy_peer(peers, NULL);
  940.         ngx_shmtx_unlock(&peers->shpool->mutex);

  942.         if (peer == NULL) {
  943.             ngx_log_error(NGX_LOG_ERR, event->log, 0,
  944.                           "cannot add new server to upstream \"%V\", "
  945.                           "memory exhausted", peers->name);
  946.             goto done;
  947.         }

  949.         ngx_memcpy(peer->sockaddr, addr->sockaddr, addr->socklen);

  951.         if (host->service.len == 0) {
  952.             port = ngx_inet_get_port(template->sockaddr);
  953.             ngx_inet_set_port(peer->sockaddr, port);
  954.         }

  956.         peer->socklen = addr->socklen;

  958.         peer->name.len = ngx_sock_ntop(peer->sockaddr, peer->socklen,
  959.                                        peer->name.data, NGX_SOCKADDR_STRLEN, 1);

  961.         peer->host = template->host;

  963.         server = host->service.len ? &addr->name : &template->server;

  965.         peer->server.data = ngx_slab_alloc(peers->shpool, server->len);
  966.         if (peer->server.data == NULL) {
  967.             ngx_http_upstream_rr_peer_free(peers, peer);

  969.             ngx_log_error(NGX_LOG_ERR, event->log, 0,
  970.                           "cannot add new server to upstream \"%V\", "
  971.                           "memory exhausted", peers->name);
  972.             goto done;
  973.         }

  975.         peer->server.len = server->len;
  976.         ngx_memcpy(peer->server.data, server->data, server->len);

  978.         if (host->service.len == 0) {
  979.             peer->weight = template->weight;

  981.         } else {
  982.             peer->weight = (template->weight != 1 ? template->weight
  983.                                                   : addr->weight);
  984.         }

  986.         peer->effective_weight = peer->weight;
  987.         peer->max_conns = template->max_conns;
  988.         peer->max_fails = template->max_fails;
  989.         peer->fail_timeout = template->fail_timeout;
  990.         peer->down = template->down;

  992. #if (NGX_HTTP_UPSTREAM_SID)
  993.         ngx_http_upstream_copy_round_robin_sid(peer, template);
  994. #endif

  996.         *peerp = peer;
  997.         peerp = &peer->next;

  999.         peers->number++;
  1000.         peers->tries += (peer->down == 0);
  1001.         peers->total_weight += peer->weight;
  1002.         peers->weighted = (peers->total_weight != peers->number);
  1003.         (*peers->config)++;

  1005.         ngx_http_upstream_zone_set_single(uscf);
  1006.     }

  1008.     if (host->service.len && peers->next) {
  1009.         ngx_http_upstream_rr_peers_unlock(peers);

  1011.         peers = peers->next;
  1012.         backup = 1;

  1014.         ngx_http_upstream_rr_peers_wlock(peers);

  1016.         goto again;
  1017.     }

  1019. done:

  1021.     host->valid = ctx->valid;

  1023.     ngx_http_upstream_rr_peers_unlock(peers);

  1025.     while (++i < ctx->naddrs) {
  1026.         ngx_http_upstream_zone_unmark_addr(&ctx->addrs[i]);
  1027.     }

  1029.     timer = (ngx_msec_t) 1000 * (ctx->valid > now ? ctx->valid - now + 1 : 1);

  1031.     ngx_resolve_name_done(ctx);

  1033.     ngx_add_timer(event, timer);
  1034. }

One Level Up Top Level