One Level Up Top Level

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


  13. static char *ngx_stream_upstream_zone(ngx_conf_t *cf, ngx_command_t *cmd,
  14.     void *conf);
  15. static ngx_int_t ngx_stream_upstream_init_zone(ngx_shm_zone_t *shm_zone,
  16.     void *data);
  17. static ngx_stream_upstream_rr_peers_t *ngx_stream_upstream_zone_copy_peers(
  18.     ngx_slab_pool_t *shpool, ngx_stream_upstream_srv_conf_t *uscf,
  19.     ngx_stream_upstream_srv_conf_t *ouscf);
  20. static ngx_stream_upstream_rr_peer_t *ngx_stream_upstream_zone_copy_peer(
  21.     ngx_stream_upstream_rr_peers_t *peers, ngx_stream_upstream_rr_peer_t *src);
  22. static ngx_int_t ngx_stream_upstream_zone_preresolve(
  23.     ngx_stream_upstream_rr_peer_t *resolve,
  24.     ngx_stream_upstream_rr_peers_t *peers,
  25.     ngx_stream_upstream_rr_peer_t *oresolve,
  26.     ngx_stream_upstream_rr_peers_t *opeers);
  27. static void ngx_stream_upstream_zone_set_single(
  28.     ngx_stream_upstream_srv_conf_t *uscf);
  29. static void ngx_stream_upstream_zone_remove_peer_locked(
  30.     ngx_stream_upstream_rr_peers_t *peers, ngx_stream_upstream_rr_peer_t *peer);
  31. static ngx_int_t ngx_stream_upstream_zone_init_worker(ngx_cycle_t *cycle);
  32. static void ngx_stream_upstream_zone_resolve_timer(ngx_event_t *event);
  33. static void ngx_stream_upstream_zone_resolve_handler(ngx_resolver_ctx_t *ctx);


  36. ‌static ngx_command_t  ngx_stream_upstream_zone_commands[] = {

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

  45.       ngx_null_command
  46. };


  49. ‌static ngx_stream_module_t  ngx_stream_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 */
  58. };


  61. ‌ngx_module_t  ngx_stream_upstream_zone_module = {
  62.     NGX_MODULE_V1,
  63.     &ngx_stream_upstream_zone_module_ctx,  /* module context */
  64.     ngx_stream_upstream_zone_commands,     /* module directives */
  65.     NGX_STREAM_MODULE,                     /* module type */
  66.     NULL,                                  /* init master */
  67.     NULL,                                  /* init module */
  68.     ngx_stream_upstream_zone_init_worker,  /* init process */
  69.     NULL,                                  /* init thread */
  70.     NULL,                                  /* exit thread */
  71.     NULL,                                  /* exit process */
  72.     NULL,                                  /* exit master */
  73.     NGX_MODULE_V1_PADDING
  74. };


  77. static char *
  78. ‌ngx_stream_upstream_zone(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  79. {
  80.     ssize_t                           size;
  81.     ngx_str_t                        *value;
  82.     ngx_stream_upstream_srv_conf_t   *uscf;
  83.     ngx_stream_upstream_main_conf_t  *umcf;

  85.     uscf = ngx_stream_conf_get_module_srv_conf(cf, ngx_stream_upstream_module);
  86.     umcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_upstream_module);

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

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

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

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

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

  111.     } else {
  112.         size = 0;
  113.     }

  115.     uscf->shm_zone = ngx_shared_memory_add(cf, &value[1], size,
  116.                                            &ngx_stream_upstream_module);
  117.     if (uscf->shm_zone == NULL) {
  118.         return NGX_CONF_ERROR;
  119.     }

  121.     uscf->shm_zone->init = ngx_stream_upstream_init_zone;
  122.     uscf->shm_zone->data = umcf;

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

  126.     return NGX_CONF_OK;
  127. }


  130. static ngx_int_t
  131. ‌ngx_stream_upstream_init_zone(ngx_shm_zone_t *shm_zone, void *data)
  132. {
  133.     size_t                            len;
  134.     ngx_uint_t                        i, j;
  135.     ngx_slab_pool_t                  *shpool;
  136.     ngx_stream_upstream_rr_peers_t   *peers, **peersp;
  137.     ngx_stream_upstream_srv_conf_t   *uscf, *ouscf, **uscfp, **ouscfp;
  138.     ngx_stream_upstream_main_conf_t  *umcf, *oumcf;

  140.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;
  141.     umcf = shm_zone->data;
  142.     uscfp = umcf->upstreams.elts;

  144.     if (shm_zone->shm.exists) {
  145.         peers = shpool->data;

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

  150.             if (uscf->shm_zone != shm_zone) {
  151.                 continue;
  152.             }

  154.             uscf->peer.data = peers;
  155.             peers = peers->zone_next;
  156.         }

  158.         return NGX_OK;
  159.     }

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

  163.     shpool->log_ctx = ngx_slab_alloc(shpool, len);
  164.     if (shpool->log_ctx == NULL) {
  165.         return NGX_ERROR;
  166.     }

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


  172.     /* copy peers to shared memory */

  174.     peersp = (ngx_stream_upstream_rr_peers_t **) (void *) &shpool->data;
  175.     oumcf = data;

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

  180.         if (uscf->shm_zone != shm_zone) {
  181.             continue;
  182.         }

  184.         ouscf = NULL;

  186.         if (oumcf) {
  187.             ouscfp = oumcf->upstreams.elts;

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

  191.                  if (ouscfp[j]->shm_zone == NULL) {
  192.                      continue;
  193.                  }

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

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

  215.         peers = ngx_stream_upstream_zone_copy_peers(shpool, uscf, ouscf);
  216.         if (peers == NULL) {
  217.             return NGX_ERROR;
  218.         }

  220.         *peersp = peers;
  221.         peersp = &peers->zone_next;
  222.     }

  224.     return NGX_OK;
  225. }


  228. static ngx_stream_upstream_rr_peers_t *
  229. ‌ngx_stream_upstream_zone_copy_peers(ngx_slab_pool_t *shpool,
  230.     ngx_stream_upstream_srv_conf_t *uscf, ngx_stream_upstream_srv_conf_t *ouscf)
  231. {
  232.     ngx_str_t                       *name;
  233.     ngx_uint_t                      *config;
  234.     ngx_stream_upstream_rr_peer_t   *peer, **peerp;
  235.     ngx_stream_upstream_rr_peers_t  *peers, *opeers, *backup;

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

  239.     config = ngx_slab_calloc(shpool, sizeof(ngx_uint_t));
  240.     if (config == NULL) {
  241.         return NULL;
  242.     }

  244.     peers = ngx_slab_alloc(shpool, sizeof(ngx_stream_upstream_rr_peers_t));
  245.     if (peers == NULL) {
  246.         return NULL;
  247.     }

  249.     ngx_memcpy(peers, uscf->peer.data, sizeof(ngx_stream_upstream_rr_peers_t));

  251.     name = ngx_slab_alloc(shpool, sizeof(ngx_str_t));
  252.     if (name == NULL) {
  253.         return NULL;
  254.     }

  256.     name->data = ngx_slab_alloc(shpool, peers->name->len);
  257.     if (name->data == NULL) {
  258.         return NULL;
  259.     }

  261.     ngx_memcpy(name->data, peers->name->data, peers->name->len);
  262.     name->len = peers->name->len;

  264.     peers->name = name;

  266.     peers->shpool = shpool;
  267.     peers->config = config;

  269.     for (peerp = &peers->peer; *peerp; peerp = &peer->next) {
  270.         /* pool is unlocked */
  271.         peer = ngx_stream_upstream_zone_copy_peer(peers, *peerp);
  272.         if (peer == NULL) {
  273.             return NULL;
  274.         }

  276.         *peerp = peer;
  277.         (*peers->config)++;
  278.     }

  280.     for (peerp = &peers->resolve; *peerp; peerp = &peer->next) {
  281.         peer = ngx_stream_upstream_zone_copy_peer(peers, *peerp);
  282.         if (peer == NULL) {
  283.             return NULL;
  284.         }

  286.         *peerp = peer;
  287.         (*peers->config)++;
  288.     }

  290.     if (opeers) {

  292.         if (ngx_stream_upstream_zone_preresolve(peers->resolve, peers,
  293.                                                 opeers->resolve, opeers)
  294.             != NGX_OK)
  295.         {
  296.             return NULL;
  297.         }
  298.     }

  300.     if (peers->next == NULL) {
  301.         goto done;
  302.     }

  304.     backup = ngx_slab_alloc(shpool, sizeof(ngx_stream_upstream_rr_peers_t));
  305.     if (backup == NULL) {
  306.         return NULL;
  307.     }

  309.     ngx_memcpy(backup, peers->next, sizeof(ngx_stream_upstream_rr_peers_t));

  311.     backup->name = name;

  313.     backup->shpool = shpool;
  314.     backup->config = config;

  316.     for (peerp = &backup->peer; *peerp; peerp = &peer->next) {
  317.         /* pool is unlocked */
  318.         peer = ngx_stream_upstream_zone_copy_peer(backup, *peerp);
  319.         if (peer == NULL) {
  320.             return NULL;
  321.         }

  323.         *peerp = peer;
  324.         (*backup->config)++;
  325.     }

  327.     for (peerp = &backup->resolve; *peerp; peerp = &peer->next) {
  328.         peer = ngx_stream_upstream_zone_copy_peer(backup, *peerp);
  329.         if (peer == NULL) {
  330.             return NULL;
  331.         }

  333.         *peerp = peer;
  334.         (*backup->config)++;
  335.     }

  337.     peers->next = backup;

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

  341.         if (ngx_stream_upstream_zone_preresolve(peers->resolve, backup,
  342.                                                 opeers->resolve, opeers->next)
  343.             != NGX_OK)
  344.         {
  345.             return NULL;
  346.         }

  348.         if (ngx_stream_upstream_zone_preresolve(backup->resolve, backup,
  349.                                                 opeers->next->resolve,
  350.                                                 opeers->next)
  351.             != NGX_OK)
  352.         {
  353.             return NULL;
  354.         }
  355.     }

  357. done:

  359.     uscf->peer.data = peers;

  361.     ngx_stream_upstream_zone_set_single(uscf);

  363.     return peers;
  364. }


  367. static ngx_stream_upstream_rr_peer_t *
  368. ‌ngx_stream_upstream_zone_copy_peer(ngx_stream_upstream_rr_peers_t *peers,
  369.     ngx_stream_upstream_rr_peer_t *src)
  370. {
  371.     ngx_slab_pool_t                *pool;
  372.     ngx_stream_upstream_rr_peer_t  *dst;

  374.     pool = peers->shpool;

  376.     dst = ngx_slab_calloc_locked(pool, sizeof(ngx_stream_upstream_rr_peer_t));
  377.     if (dst == NULL) {
  378.         return NULL;
  379.     }

  381.     if (src) {
  382.         ngx_memcpy(dst, src, sizeof(ngx_stream_upstream_rr_peer_t));
  383.         dst->sockaddr = NULL;
  384.         dst->name.data = NULL;
  385.         dst->server.data = NULL;
  386.         dst->host = NULL;
  387.     }

  389.     dst->sockaddr = ngx_slab_calloc_locked(pool, sizeof(ngx_sockaddr_t));
  390.     if (dst->sockaddr == NULL) {
  391.         goto failed;
  392.     }

  394.     dst->name.data = ngx_slab_calloc_locked(pool, NGX_SOCKADDR_STRLEN);
  395.     if (dst->name.data == NULL) {
  396.         goto failed;
  397.     }

  399.     if (src) {
  400.         ngx_memcpy(dst->sockaddr, src->sockaddr, src->socklen);
  401.         ngx_memcpy(dst->name.data, src->name.data, src->name.len);

  403.         dst->server.data = ngx_slab_alloc_locked(pool, src->server.len);
  404.         if (dst->server.data == NULL) {
  405.             goto failed;
  406.         }

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

  410.         if (src->host) {
  411.             dst->host = ngx_slab_calloc_locked(pool,
  412.                                             sizeof(ngx_stream_upstream_host_t));
  413.             if (dst->host == NULL) {
  414.                 goto failed;
  415.             }

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

  423.             dst->host->peers = peers;
  424.             dst->host->peer = dst;

  426.             dst->host->name.len = src->host->name.len;
  427.             ngx_memcpy(dst->host->name.data, src->host->name.data,
  428.                        src->host->name.len);

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

  437.                 dst->host->service.len = src->host->service.len;
  438.                 ngx_memcpy(dst->host->service.data, src->host->service.data,
  439.                            src->host->service.len);
  440.             }
  441.         }
  442.     }

  444.     return dst;

  446. failed:

  448.     if (dst->host) {
  449.         if (dst->host->name.data) {
  450.             ngx_slab_free_locked(pool, dst->host->name.data);
  451.         }

  453.         ngx_slab_free_locked(pool, dst->host);
  454.     }

  456.     if (dst->server.data) {
  457.         ngx_slab_free_locked(pool, dst->server.data);
  458.     }

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

  464.     if (dst->sockaddr) {
  465.         ngx_slab_free_locked(pool, dst->sockaddr);
  466.     }

  468.     ngx_slab_free_locked(pool, dst);

  470.     return NULL;
  471. }


  474. static ngx_int_t
  475. ‌ngx_stream_upstream_zone_preresolve(ngx_stream_upstream_rr_peer_t *resolve,
  476.     ngx_stream_upstream_rr_peers_t *peers,
  477.     ngx_stream_upstream_rr_peer_t *oresolve,
  478.     ngx_stream_upstream_rr_peers_t *opeers)
  479. {
  480.     in_port_t                       port;
  481.     ngx_str_t                      *server;
  482.     ngx_stream_upstream_host_t     *host;
  483.     ngx_stream_upstream_rr_peer_t  *peer, *template, *opeer, **peerp;

  485.     if (resolve == NULL || oresolve == NULL) {
  486.         return NGX_OK;
  487.     }

  489.     for (peerp = &peers->peer; *peerp; peerp = &(*peerp)->next) {
  490.         /* void */
  491.     }

  493.     ngx_stream_upstream_rr_peers_rlock(opeers);

  495.     for (template = resolve; template; template = template->next) {
  496.         for (opeer = oresolve; opeer; opeer = opeer->next) {

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

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

  516.             host = opeer->host;

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

  520.                 if (opeer->host != host) {
  521.                     continue;
  522.                 }

  524.                 peer = ngx_stream_upstream_zone_copy_peer(peers, NULL);
  525.                 if (peer == NULL) {
  526.                     ngx_stream_upstream_rr_peers_unlock(opeers);
  527.                     return NGX_ERROR;
  528.                 }

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

  532.                 if (template->host->service.len == 0) {
  533.                     port = ngx_inet_get_port(template->sockaddr);
  534.                     ngx_inet_set_port(peer->sockaddr, port);
  535.                 }

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

  539.                 peer->name.len = ngx_sock_ntop(peer->sockaddr, peer->socklen,
  540.                                                peer->name.data,
  541.                                                NGX_SOCKADDR_STRLEN, 1);

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

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

  547.                 server = template->host->service.len ? &opeer->server
  548.                                                      : &template->server;

  550.                 peer->server.data = ngx_slab_alloc(peers->shpool, server->len);
  551.                 if (peer->server.data == NULL) {
  552.                     ngx_stream_upstream_rr_peers_unlock(opeers);
  553.                     return NGX_ERROR;
  554.                 }

  556.                 ngx_memcpy(peer->server.data, server->data, server->len);
  557.                 peer->server.len = server->len;

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

  562.                 } else {
  563.                     peer->weight = (template->weight != 1 ? template->weight
  564.                                                           : opeer->weight);
  565.                 }

  567.                 peer->effective_weight = peer->weight;
  568.                 peer->max_conns = template->max_conns;
  569.                 peer->max_fails = template->max_fails;
  570.                 peer->fail_timeout = template->fail_timeout;
  571.                 peer->down = template->down;

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

  575.                 *peerp = peer;
  576.                 peerp = &peer->next;

  578.                 peers->number++;
  579.                 peers->tries += (peer->down == 0);
  580.                 peers->total_weight += peer->weight;
  581.                 peers->weighted = (peers->total_weight != peers->number);
  582.             }

  584.             break;
  585.         }
  586.     }

  588.     ngx_stream_upstream_rr_peers_unlock(opeers);
  589.     return NGX_OK;
  590. }


  593. static void
  594. ‌ngx_stream_upstream_zone_set_single(ngx_stream_upstream_srv_conf_t *uscf)
  595. {
  596.     ngx_stream_upstream_rr_peers_t  *peers;

  598.     peers = uscf->peer.data;

  600.     if (peers->number == 1
  601.         && (peers->next == NULL || peers->next->number == 0))
  602.     {
  603.         peers->single = 1;

  605.     } else {
  606.         peers->single = 0;
  607.     }
  608. }


  611. static void
  612. ‌ngx_stream_upstream_zone_remove_peer_locked(
  613.     ngx_stream_upstream_rr_peers_t *peers, ngx_stream_upstream_rr_peer_t *peer)
  614. {
  615.     peers->total_weight -= peer->weight;
  616.     peers->number--;
  617.     peers->tries -= (peer->down == 0);
  618.     (*peers->config)++;
  619.     peers->weighted = (peers->total_weight != peers->number);

  621.     ngx_stream_upstream_rr_peer_free(peers, peer);
  622. }


  625. static ngx_int_t
  626. ‌ngx_stream_upstream_zone_init_worker(ngx_cycle_t *cycle)
  627. {
  628.     time_t                            now;
  629.     ngx_msec_t                        timer;
  630.     ngx_uint_t                        i;
  631.     ngx_event_t                      *event;
  632.     ngx_stream_upstream_rr_peer_t    *peer;
  633.     ngx_stream_upstream_rr_peers_t   *peers;
  634.     ngx_stream_upstream_srv_conf_t   *uscf, **uscfp;
  635.     ngx_stream_upstream_main_conf_t  *umcf;

  637.     if (ngx_process != NGX_PROCESS_WORKER
  638.         && ngx_process != NGX_PROCESS_SINGLE)
  639.     {
  640.         return NGX_OK;
  641.     }

  643.     now = ngx_time();
  644.     umcf = ngx_stream_cycle_get_module_main_conf(cycle,
  645.                                                  ngx_stream_upstream_module);

  647.     if (umcf == NULL) {
  648.         return NGX_OK;
  649.     }

  651.     uscfp = umcf->upstreams.elts;

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

  655.         uscf = uscfp[i];

  657.         if (uscf->shm_zone == NULL) {
  658.             continue;
  659.         }

  661.         peers = uscf->peer.data;

  663.         do {
  664.             ngx_stream_upstream_rr_peers_wlock(peers);

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

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

  672.                 event = &peer->host->event;
  673.                 ngx_memzero(event, sizeof(ngx_event_t));

  675.                 event->data = uscf;
  676.                 event->handler = ngx_stream_upstream_zone_resolve_timer;
  677.                 event->log = cycle->log;
  678.                 event->cancelable = 1;

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

  683.                 ngx_add_timer(event, timer);
  684.             }

  686.             ngx_stream_upstream_rr_peers_unlock(peers);

  688.             peers = peers->next;

  690.         } while (peers);
  691.     }

  693.     return NGX_OK;
  694. }


  697. static void
  698. ‌ngx_stream_upstream_zone_resolve_timer(ngx_event_t *event)
  699. {
  700.     ngx_resolver_ctx_t              *ctx;
  701.     ngx_stream_upstream_host_t      *host;
  702.     ngx_stream_upstream_srv_conf_t  *uscf;

  704.     host = (ngx_stream_upstream_host_t *) event;
  705.     uscf = event->data;

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

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

  718.     ctx->name = host->name;
  719.     ctx->handler = ngx_stream_upstream_zone_resolve_handler;
  720.     ctx->data = host;
  721.     ctx->timeout = uscf->resolver_timeout;
  722.     ctx->service = host->service;
  723.     ctx->cancelable = 1;

  725.     if (ngx_resolve_name(ctx) == NGX_OK) {
  726.         return;
  727.     }

  729. retry:

  731.     ngx_add_timer(event, ngx_max(uscf->resolver_timeout, 1000));
  732. }


  735. ‌#define ngx_stream_upstream_zone_addr_marked(addr)                            \
  736.     ((uintptr_t) (addr)->sockaddr & 1)

  738. ‌#define ngx_stream_upstream_zone_mark_addr(addr)                              \
  739.     (addr)->sockaddr = (struct sockaddr *) ((uintptr_t) (addr)->sockaddr | 1)

  741. ‌#define ngx_stream_upstream_zone_unmark_addr(addr)                            \
  742.     (addr)->sockaddr =                                                        \
  743.         (struct sockaddr *) ((uintptr_t) (addr)->sockaddr & ~((uintptr_t) 1))

  745. static void
  746. ‌ngx_stream_upstream_zone_resolve_handler(ngx_resolver_ctx_t *ctx)
  747. {
  748.     time_t                           now;
  749.     u_short                          min_priority;
  750.     in_port_t                        port;
  751.     ngx_str_t                       *server;
  752.     ngx_msec_t                       timer;
  753.     ngx_uint_t                       i, j, backup, addr_backup;
  754.     ngx_event_t                     *event;
  755.     ngx_resolver_addr_t             *addr;
  756.     ngx_resolver_srv_name_t         *srv;
  757.     ngx_stream_upstream_host_t      *host;
  758.     ngx_stream_upstream_rr_peer_t   *peer, *template, **peerp;
  759.     ngx_stream_upstream_rr_peers_t  *peers;
  760.     ngx_stream_upstream_srv_conf_t  *uscf;

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

  768.     ngx_stream_upstream_rr_peers_wlock(peers);

  770.     now = ngx_time();

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

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

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

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

  799.         if (ctx->state != NGX_RESOLVE_NXDOMAIN) {
  800.             ngx_stream_upstream_rr_peers_unlock(peers);

  802.             ngx_resolve_name_done(ctx);

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

  808.         /* NGX_RESOLVE_NXDOMAIN */

  810.         ctx->naddrs = 0;
  811.     }

  813.     backup = 0;
  814.     min_priority = 65535;

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

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

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

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

  839. again:

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

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

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

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

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

  857.             if (ngx_stream_upstream_zone_addr_marked(addr)) {
  858.                 continue;
  859.             }

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

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

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

  882.             ngx_stream_upstream_zone_mark_addr(addr);

  884.             goto next;
  885.         }

  887.         *peerp = peer->next;
  888.         ngx_stream_upstream_zone_remove_peer_locked(peers, peer);

  890.         ngx_stream_upstream_zone_set_single(uscf);

  892.         continue;

  894.     next:

  896.         peerp = &peer->next;
  897.     }

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

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

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

  908.         if (ngx_stream_upstream_zone_addr_marked(addr)) {
  909.             ngx_stream_upstream_zone_unmark_addr(addr);
  910.             continue;
  911.         }

  913.         ngx_shmtx_lock(&peers->shpool->mutex);
  914.         peer = ngx_stream_upstream_zone_copy_peer(peers, NULL);
  915.         ngx_shmtx_unlock(&peers->shpool->mutex);

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

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

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

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

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

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

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

  940.         peer->server.data = ngx_slab_alloc(peers->shpool, server->len);
  941.         if (peer->server.data == NULL) {
  942.             ngx_stream_upstream_rr_peer_free(peers, peer);

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

  950.         peer->server.len = server->len;
  951.         ngx_memcpy(peer->server.data, server->data, server->len);

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

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

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

  967.         *peerp = peer;
  968.         peerp = &peer->next;

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

  976.         ngx_stream_upstream_zone_set_single(uscf);
  977.     }

  979.     if (host->service.len && peers->next) {
  980.         ngx_stream_upstream_rr_peers_unlock(peers);

  982.         peers = peers->next;
  983.         backup = 1;

  985.         ngx_stream_upstream_rr_peers_wlock(peers);

  987.         goto again;
  988.     }

  990. done:

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

  994.     ngx_stream_upstream_rr_peers_unlock(peers);

  996.     while (++i < ctx->naddrs) {
  997.         ngx_stream_upstream_zone_unmark_addr(&ctx->addrs[i]);
  998.     }

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

  1002.     ngx_resolve_name_done(ctx);

  1004.     ngx_add_timer(event, timer);
  1005. }

One Level Up Top Level