One Level Up Top Level

src/http/modules/ngx_http_upstream_zone_module.c - nginx source code

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.         dst->server.data = NULL;
  389.         dst->host = NULL;
  390.     }

  392.     dst->sockaddr = ngx_slab_calloc_locked(pool, sizeof(ngx_sockaddr_t));
  393.     if (dst->sockaddr == NULL) {
  394.         goto failed;
  395.     }

  397.     dst->name.data = ngx_slab_calloc_locked(pool, NGX_SOCKADDR_STRLEN);
  398.     if (dst->name.data == NULL) {
  399.         goto failed;
  400.     }

  402.     if (src) {
  403.         ngx_memcpy(dst->sockaddr, src->sockaddr, src->socklen);
  404.         ngx_memcpy(dst->name.data, src->name.data, src->name.len);

  406.         dst->server.data = ngx_slab_alloc_locked(pool, src->server.len);
  407.         if (dst->server.data == NULL) {
  408.             goto failed;
  409.         }

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

  413.         if (src->host) {
  414.             dst->host = ngx_slab_calloc_locked(pool,
  415.                                              sizeof(ngx_http_upstream_host_t));
  416.             if (dst->host == NULL) {
  417.                 goto failed;
  418.             }

  420.             dst->host->name.data = ngx_slab_alloc_locked(pool,
  421.                                                          src->host->name.len);
  422.             if (dst->host->name.data == NULL) {
  423.                 goto failed;
  424.             }

  426.             dst->host->peers = peers;
  427.             dst->host->peer = dst;

  429.             dst->host->name.len = src->host->name.len;
  430.             ngx_memcpy(dst->host->name.data, src->host->name.data,
  431.                        src->host->name.len);

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

  440.                 dst->host->service.len = src->host->service.len;
  441.                 ngx_memcpy(dst->host->service.data, src->host->service.data,
  442.                            src->host->service.len);
  443.             }
  444.         }
  445.     }

  447.     return dst;

  449. failed:

  451.     if (dst->host) {
  452.         if (dst->host->name.data) {
  453.             ngx_slab_free_locked(pool, dst->host->name.data);
  454.         }

  456.         ngx_slab_free_locked(pool, dst->host);
  457.     }

  459.     if (dst->server.data) {
  460.         ngx_slab_free_locked(pool, dst->server.data);
  461.     }

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

  467.     if (dst->sockaddr) {
  468.         ngx_slab_free_locked(pool, dst->sockaddr);
  469.     }

  471.     ngx_slab_free_locked(pool, dst);

  473.     return NULL;
  474. }


  477. static ngx_int_t
  478. ‌ngx_http_upstream_zone_preresolve(ngx_http_upstream_rr_peer_t *resolve,
  479.     ngx_http_upstream_rr_peers_t *peers,
  480.     ngx_http_upstream_rr_peer_t *oresolve,
  481.     ngx_http_upstream_rr_peers_t *opeers)
  482. {
  483.     in_port_t                     port;
  484.     ngx_str_t                    *server;
  485.     ngx_http_upstream_host_t     *host;
  486.     ngx_http_upstream_rr_peer_t  *peer, *template, *opeer, **peerp;

  488.     if (resolve == NULL || oresolve == NULL) {
  489.         return NGX_OK;
  490.     }

  492.     for (peerp = &peers->peer; *peerp; peerp = &(*peerp)->next) {
  493.         /* void */
  494.     }

  496.     ngx_http_upstream_rr_peers_rlock(opeers);

  498.     for (template = resolve; template; template = template->next) {
  499.         for (opeer = oresolve; opeer; opeer = opeer->next) {

  501.             if (opeer->host->name.len != template->host->name.len
  502.                 || ngx_memcmp(opeer->host->name.data,
  503.                               template->host->name.data,
  504.                               template->host->name.len)
  505.                    != 0)
  506.             {
  507.                 continue;
  508.             }

  510.             if (opeer->host->service.len != template->host->service.len
  511.                 || ngx_memcmp(opeer->host->service.data,
  512.                               template->host->service.data,
  513.                               template->host->service.len)
  514.                    != 0)
  515.             {
  516.                 continue;
  517.             }

  519.             host = opeer->host;

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

  523.                 if (opeer->host != host) {
  524.                     continue;
  525.                 }

  527.                 peer = ngx_http_upstream_zone_copy_peer(peers, NULL);
  528.                 if (peer == NULL) {
  529.                     ngx_http_upstream_rr_peers_unlock(opeers);
  530.                     return NGX_ERROR;
  531.                 }

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

  535.                 if (template->host->service.len == 0) {
  536.                     port = ngx_inet_get_port(template->sockaddr);
  537.                     ngx_inet_set_port(peer->sockaddr, port);
  538.                 }

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

  542.                 peer->name.len = ngx_sock_ntop(peer->sockaddr, peer->socklen,
  543.                                                peer->name.data,
  544.                                                NGX_SOCKADDR_STRLEN, 1);

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

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

  550.                 server = template->host->service.len ? &opeer->server
  551.                                                      : &template->server;

  553.                 peer->server.data = ngx_slab_alloc(peers->shpool, server->len);
  554.                 if (peer->server.data == NULL) {
  555.                     ngx_http_upstream_rr_peers_unlock(opeers);
  556.                     return NGX_ERROR;
  557.                 }

  559.                 ngx_memcpy(peer->server.data, server->data, server->len);
  560.                 peer->server.len = server->len;

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

  565.                 } else {
  566.                     peer->weight = (template->weight != 1 ? template->weight
  567.                                                           : opeer->weight);
  568.                 }

  570.                 peer->effective_weight = peer->weight;
  571.                 peer->max_conns = template->max_conns;
  572.                 peer->max_fails = template->max_fails;
  573.                 peer->fail_timeout = template->fail_timeout;
  574.                 peer->down = template->down;

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

  578.                 *peerp = peer;
  579.                 peerp = &peer->next;

  581.                 peers->number++;
  582.                 peers->tries += (peer->down == 0);
  583.                 peers->total_weight += peer->weight;
  584.                 peers->weighted = (peers->total_weight != peers->number);
  585.             }

  587.             break;
  588.         }
  589.     }

  591.     ngx_http_upstream_rr_peers_unlock(opeers);
  592.     return NGX_OK;
  593. }


  596. static void
  597. ‌ngx_http_upstream_zone_set_single(ngx_http_upstream_srv_conf_t *uscf)
  598. {
  599.     ngx_http_upstream_rr_peers_t  *peers;

  601.     peers = uscf->peer.data;

  603.     if (peers->number == 1
  604.         && (peers->next == NULL || peers->next->number == 0))
  605.     {
  606.         peers->single = 1;

  608.     } else {
  609.         peers->single = 0;
  610.     }
  611. }


  614. static void
  615. ‌ngx_http_upstream_zone_remove_peer_locked(ngx_http_upstream_rr_peers_t *peers,
  616.     ngx_http_upstream_rr_peer_t *peer)
  617. {
  618.     peers->total_weight -= peer->weight;
  619.     peers->number--;
  620.     peers->tries -= (peer->down == 0);
  621.     (*peers->config)++;
  622.     peers->weighted = (peers->total_weight != peers->number);

  624.     ngx_http_upstream_rr_peer_free(peers, peer);
  625. }


  628. static ngx_int_t
  629. ‌ngx_http_upstream_zone_init_worker(ngx_cycle_t *cycle)
  630. {
  631.     time_t                          now;
  632.     ngx_msec_t                      timer;
  633.     ngx_uint_t                      i;
  634.     ngx_event_t                    *event;
  635.     ngx_http_upstream_rr_peer_t    *peer;
  636.     ngx_http_upstream_rr_peers_t   *peers;
  637.     ngx_http_upstream_srv_conf_t   *uscf, **uscfp;
  638.     ngx_http_upstream_main_conf_t  *umcf;

  640.     if (ngx_process != NGX_PROCESS_WORKER
  641.         && ngx_process != NGX_PROCESS_SINGLE)
  642.     {
  643.         return NGX_OK;
  644.     }

  646.     now = ngx_time();
  647.     umcf = ngx_http_cycle_get_module_main_conf(cycle, ngx_http_upstream_module);

  649.     if (umcf == NULL) {
  650.         return NGX_OK;
  651.     }

  653.     uscfp = umcf->upstreams.elts;

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

  657.         uscf = uscfp[i];

  659.         if (uscf->shm_zone == NULL) {
  660.             continue;
  661.         }

  663.         peers = uscf->peer.data;

  665.         do {
  666.             ngx_http_upstream_rr_peers_wlock(peers);

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

  670.                 if (peer->host->worker != ngx_worker) {
  671.                     continue;
  672.                 }

  674.                 event = &peer->host->event;
  675.                 ngx_memzero(event, sizeof(ngx_event_t));

  677.                 event->data = uscf;
  678.                 event->handler = ngx_http_upstream_zone_resolve_timer;
  679.                 event->log = cycle->log;
  680.                 event->cancelable = 1;

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

  685.                 ngx_add_timer(event, timer);
  686.             }

  688.             ngx_http_upstream_rr_peers_unlock(peers);

  690.             peers = peers->next;

  692.         } while (peers);
  693.     }

  695.     return NGX_OK;
  696. }


  699. static void
  700. ‌ngx_http_upstream_zone_resolve_timer(ngx_event_t *event)
  701. {
  702.     ngx_resolver_ctx_t            *ctx;
  703.     ngx_http_upstream_host_t      *host;
  704.     ngx_http_upstream_srv_conf_t  *uscf;

  706.     host = (ngx_http_upstream_host_t *) event;
  707.     uscf = event->data;

  709.     ctx = ngx_resolve_start(uscf->resolver, NULL);
  710.     if (ctx == NULL) {
  711.         goto retry;
  712.     }

  714.     if (ctx == NGX_NO_RESOLVER) {
  715.         ngx_log_error(NGX_LOG_ERR, event->log, 0,
  716.                       "no resolver defined to resolve %V", &host->name);
  717.         return;
  718.     }

  720.     ctx->name = host->name;
  721.     ctx->handler = ngx_http_upstream_zone_resolve_handler;
  722.     ctx->data = host;
  723.     ctx->timeout = uscf->resolver_timeout;
  724.     ctx->service = host->service;
  725.     ctx->cancelable = 1;

  727.     if (ngx_resolve_name(ctx) == NGX_OK) {
  728.         return;
  729.     }

  731. retry:

  733.     ngx_add_timer(event, ngx_max(uscf->resolver_timeout, 1000));
  734. }


  737. ‌#define ngx_http_upstream_zone_addr_marked(addr)                              \
  738.     ((uintptr_t) (addr)->sockaddr & 1)

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

  743. ‌#define ngx_http_upstream_zone_unmark_addr(addr)                              \
  744.     (addr)->sockaddr =                                                        \
  745.         (struct sockaddr *) ((uintptr_t) (addr)->sockaddr & ~((uintptr_t) 1))

  747. static void
  748. ‌ngx_http_upstream_zone_resolve_handler(ngx_resolver_ctx_t *ctx)
  749. {
  750.     time_t                         now;
  751.     u_short                        min_priority;
  752.     in_port_t                      port;
  753.     ngx_str_t                     *server;
  754.     ngx_msec_t                     timer;
  755.     ngx_uint_t                     i, j, backup, addr_backup;
  756.     ngx_event_t                   *event;
  757.     ngx_resolver_addr_t           *addr;
  758.     ngx_resolver_srv_name_t       *srv;
  759.     ngx_http_upstream_host_t      *host;
  760.     ngx_http_upstream_rr_peer_t   *peer, *template, **peerp;
  761.     ngx_http_upstream_rr_peers_t  *peers;
  762.     ngx_http_upstream_srv_conf_t  *uscf;

  764.     host = ctx->data;
  765.     event = &host->event;
  766.     uscf = event->data;
  767.     peers = host->peers;
  768.     template = host->peer;

  770.     ngx_http_upstream_rr_peers_wlock(peers);

  772.     now = ngx_time();

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

  777.         if (srv->state) {
  778.             ngx_log_error(NGX_LOG_ERR, event->log, 0,
  779.                           "%V could not be resolved (%i: %s) "
  780.                           "while resolving service %V of %V",
  781.                           &srv->name, srv->state,
  782.                           ngx_resolver_strerror(srv->state), &ctx->service,
  783.                           &ctx->name);
  784.         }
  785.     }

  787.     if (ctx->state) {
  788.         if (ctx->service.len) {
  789.             ngx_log_error(NGX_LOG_ERR, event->log, 0,
  790.                           "service %V of %V could not be resolved (%i: %s)",
  791.                           &ctx->service, &ctx->name, ctx->state,
  792.                           ngx_resolver_strerror(ctx->state));

  794.         } else {
  795.             ngx_log_error(NGX_LOG_ERR, event->log, 0,
  796.                           "%V could not be resolved (%i: %s)",
  797.                           &ctx->name, ctx->state,
  798.                           ngx_resolver_strerror(ctx->state));
  799.         }

  801.         if (ctx->state != NGX_RESOLVE_NXDOMAIN) {
  802.             ngx_http_upstream_rr_peers_unlock(peers);

  804.             ngx_resolve_name_done(ctx);

  806.             ngx_add_timer(event, ngx_max(uscf->resolver_timeout, 1000));
  807.             return;
  808.         }

  810.         /* NGX_RESOLVE_NXDOMAIN */

  812.         ctx->naddrs = 0;
  813.     }

  815.     backup = 0;
  816.     min_priority = 65535;

  818.     for (i = 0; i < ctx->naddrs; i++) {
  819.         min_priority = ngx_min(ctx->addrs[i].priority, min_priority);
  820.     }

  822. #if (NGX_DEBUG)
  823.     {
  824.     u_char  text[NGX_SOCKADDR_STRLEN];
  825.     size_t  len;

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

  831.         ngx_log_debug7(NGX_LOG_DEBUG_HTTP, event->log, 0,
  832.                        "name %V was resolved to %*s "
  833.                        "s:\"%V\" n:\"%V\" w:%d %s",
  834.                        &host->name, len, text, &host->service,
  835.                        &ctx->addrs[i].name, ctx->addrs[i].weight,
  836.                        ctx->addrs[i].priority != min_priority ? "backup" : "");
  837.     }
  838.     }
  839. #endif

  841. again:

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

  846.         if (peer->host != host) {
  847.             goto next;
  848.         }

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

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

  854.             addr_backup = (addr->priority != min_priority);
  855.             if (addr_backup != backup) {
  856.                 continue;
  857.             }

  859.             if (ngx_http_upstream_zone_addr_marked(addr)) {
  860.                 continue;
  861.             }

  863.             if (ngx_cmp_sockaddr(peer->sockaddr, peer->socklen,
  864.                                  addr->sockaddr, addr->socklen,
  865.                                  host->service.len != 0)
  866.                 != NGX_OK)
  867.             {
  868.                 continue;
  869.             }

  871.             if (host->service.len) {
  872.                 if (addr->name.len != peer->server.len
  873.                     || ngx_strncmp(addr->name.data, peer->server.data,
  874.                                    addr->name.len))
  875.                 {
  876.                     continue;
  877.                 }

  879.                 if (template->weight == 1 && addr->weight != peer->weight) {
  880.                     continue;
  881.                 }
  882.             }

  884.             ngx_http_upstream_zone_mark_addr(addr);

  886.             goto next;
  887.         }

  889.         *peerp = peer->next;
  890.         ngx_http_upstream_zone_remove_peer_locked(peers, peer);

  892.         ngx_http_upstream_zone_set_single(uscf);

  894.         continue;

  896.     next:

  898.         peerp = &peer->next;
  899.     }

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

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

  905.         addr_backup = (addr->priority != min_priority);
  906.         if (addr_backup != backup) {
  907.             continue;
  908.         }

  910.         if (ngx_http_upstream_zone_addr_marked(addr)) {
  911.             ngx_http_upstream_zone_unmark_addr(addr);
  912.             continue;
  913.         }

  915.         ngx_shmtx_lock(&peers->shpool->mutex);
  916.         peer = ngx_http_upstream_zone_copy_peer(peers, NULL);
  917.         ngx_shmtx_unlock(&peers->shpool->mutex);

  919.         if (peer == NULL) {
  920.             ngx_log_error(NGX_LOG_ERR, event->log, 0,
  921.                           "cannot add new server to upstream \"%V\", "
  922.                           "memory exhausted", peers->name);
  923.             goto done;
  924.         }

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

  928.         if (host->service.len == 0) {
  929.             port = ngx_inet_get_port(template->sockaddr);
  930.             ngx_inet_set_port(peer->sockaddr, port);
  931.         }

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

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

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

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

  942.         peer->server.data = ngx_slab_alloc(peers->shpool, server->len);
  943.         if (peer->server.data == NULL) {
  944.             ngx_http_upstream_rr_peer_free(peers, peer);

  946.             ngx_log_error(NGX_LOG_ERR, event->log, 0,
  947.                           "cannot add new server to upstream \"%V\", "
  948.                           "memory exhausted", peers->name);
  949.             goto done;
  950.         }

  952.         peer->server.len = server->len;
  953.         ngx_memcpy(peer->server.data, server->data, server->len);

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

  958.         } else {
  959.             peer->weight = (template->weight != 1 ? template->weight
  960.                                                   : addr->weight);
  961.         }

  963.         peer->effective_weight = peer->weight;
  964.         peer->max_conns = template->max_conns;
  965.         peer->max_fails = template->max_fails;
  966.         peer->fail_timeout = template->fail_timeout;
  967.         peer->down = template->down;

  969.         *peerp = peer;
  970.         peerp = &peer->next;

  972.         peers->number++;
  973.         peers->tries += (peer->down == 0);
  974.         peers->total_weight += peer->weight;
  975.         peers->weighted = (peers->total_weight != peers->number);
  976.         (*peers->config)++;

  978.         ngx_http_upstream_zone_set_single(uscf);
  979.     }

  981.     if (host->service.len && peers->next) {
  982.         ngx_http_upstream_rr_peers_unlock(peers);

  984.         peers = peers->next;
  985.         backup = 1;

  987.         ngx_http_upstream_rr_peers_wlock(peers);

  989.         goto again;
  990.     }

  992. done:

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

  996.     ngx_http_upstream_rr_peers_unlock(peers);

  998.     while (++i < ctx->naddrs) {
  999.         ngx_http_upstream_zone_unmark_addr(&ctx->addrs[i]);
  1000.     }

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

  1004.     ngx_resolve_name_done(ctx);

  1006.     ngx_add_timer(event, timer);
  1007. }

One Level Up Top Level