One Level Up Top Level

src/stream/ngx_stream_upstream.c - nginx source code

Global variables defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


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


  13. static ngx_int_t ngx_stream_upstream_add_variables(ngx_conf_t *cf);
  14. static ngx_int_t ngx_stream_upstream_addr_variable(ngx_stream_session_t *s,
  15.     ngx_stream_variable_value_t *v, uintptr_t data);
  16. static ngx_int_t ngx_stream_upstream_response_time_variable(
  17.     ngx_stream_session_t *s, ngx_stream_variable_value_t *v, uintptr_t data);
  18. static ngx_int_t ngx_stream_upstream_bytes_variable(ngx_stream_session_t *s,
  19.     ngx_stream_variable_value_t *v, uintptr_t data);

  21. static char *ngx_stream_upstream(ngx_conf_t *cf, ngx_command_t *cmd,
  22.     void *dummy);
  23. static char *ngx_stream_upstream_server(ngx_conf_t *cf, ngx_command_t *cmd,
  24.     void *conf);
  25. #if (NGX_STREAM_UPSTREAM_ZONE)
  26. static char *ngx_stream_upstream_resolver(ngx_conf_t *cf, ngx_command_t *cmd,
  27.     void *conf);
  28. #endif

  30. static void *ngx_stream_upstream_create_main_conf(ngx_conf_t *cf);
  31. static char *ngx_stream_upstream_init_main_conf(ngx_conf_t *cf, void *conf);


  34. ‌static ngx_command_t  ngx_stream_upstream_commands[] = {

  36.     { ngx_string("upstream"),
  37.       NGX_STREAM_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE1,
  38.       ngx_stream_upstream,
  39.       0,
  40.       0,
  41.       NULL },

  43.     { ngx_string("server"),
  44.       NGX_STREAM_UPS_CONF|NGX_CONF_1MORE,
  45.       ngx_stream_upstream_server,
  46.       NGX_STREAM_SRV_CONF_OFFSET,
  47.       0,
  48.       NULL },

  50. #if (NGX_STREAM_UPSTREAM_ZONE)

  52.     { ngx_string("resolver"),
  53.       NGX_STREAM_UPS_CONF|NGX_CONF_1MORE,
  54.       ngx_stream_upstream_resolver,
  55.       NGX_STREAM_SRV_CONF_OFFSET,
  56.       0,
  57.       NULL },

  59.     { ngx_string("resolver_timeout"),
  60.       NGX_STREAM_UPS_CONF|NGX_CONF_TAKE1,
  61.       ngx_conf_set_msec_slot,
  62.       NGX_STREAM_SRV_CONF_OFFSET,
  63.       offsetof(ngx_stream_upstream_srv_conf_t, resolver_timeout),
  64.       NULL },

  66. #endif

  68.       ngx_null_command
  69. };


  72. ‌static ngx_stream_module_t  ngx_stream_upstream_module_ctx = {
  73.     ngx_stream_upstream_add_variables,     /* preconfiguration */
  74.     NULL,                                  /* postconfiguration */

  76.     ngx_stream_upstream_create_main_conf,  /* create main configuration */
  77.     ngx_stream_upstream_init_main_conf,    /* init main configuration */

  79.     NULL,                                  /* create server configuration */
  80.     NULL                                   /* merge server configuration */
  81. };


  84. ‌ngx_module_t  ngx_stream_upstream_module = {
  85.     NGX_MODULE_V1,
  86.     &ngx_stream_upstream_module_ctx,       /* module context */
  87.     ngx_stream_upstream_commands,          /* module directives */
  88.     NGX_STREAM_MODULE,                     /* module type */
  89.     NULL,                                  /* init master */
  90.     NULL,                                  /* init module */
  91.     NULL,                                  /* init process */
  92.     NULL,                                  /* init thread */
  93.     NULL,                                  /* exit thread */
  94.     NULL,                                  /* exit process */
  95.     NULL,                                  /* exit master */
  96.     NGX_MODULE_V1_PADDING
  97. };


  100. ‌static ngx_stream_variable_t  ngx_stream_upstream_vars[] = {

  102.     { ngx_string("upstream_addr"), NULL,
  103.       ngx_stream_upstream_addr_variable, 0,
  104.       NGX_STREAM_VAR_NOCACHEABLE, 0 },

  106.     { ngx_string("upstream_bytes_sent"), NULL,
  107.       ngx_stream_upstream_bytes_variable, 0,
  108.       NGX_STREAM_VAR_NOCACHEABLE, 0 },

  110.     { ngx_string("upstream_connect_time"), NULL,
  111.       ngx_stream_upstream_response_time_variable, 2,
  112.       NGX_STREAM_VAR_NOCACHEABLE, 0 },

  114.     { ngx_string("upstream_first_byte_time"), NULL,
  115.       ngx_stream_upstream_response_time_variable, 1,
  116.       NGX_STREAM_VAR_NOCACHEABLE, 0 },

  118.     { ngx_string("upstream_session_time"), NULL,
  119.       ngx_stream_upstream_response_time_variable, 0,
  120.       NGX_STREAM_VAR_NOCACHEABLE, 0 },

  122.     { ngx_string("upstream_bytes_received"), NULL,
  123.       ngx_stream_upstream_bytes_variable, 1,
  124.       NGX_STREAM_VAR_NOCACHEABLE, 0 },

  126.       ngx_stream_null_variable
  127. };


  130. static ngx_int_t
  131. ‌ngx_stream_upstream_add_variables(ngx_conf_t *cf)
  132. {
  133.     ngx_stream_variable_t  *var, *v;

  135.     for (v = ngx_stream_upstream_vars; v->name.len; v++) {
  136.         var = ngx_stream_add_variable(cf, &v->name, v->flags);
  137.         if (var == NULL) {
  138.             return NGX_ERROR;
  139.         }

  141.         var->get_handler = v->get_handler;
  142.         var->data = v->data;
  143.     }

  145.     return NGX_OK;
  146. }


  149. static ngx_int_t
  150. ‌ngx_stream_upstream_addr_variable(ngx_stream_session_t *s,
  151.     ngx_stream_variable_value_t *v, uintptr_t data)
  152. {
  153.     u_char                       *p;
  154.     size_t                        len;
  155.     ngx_uint_t                    i;
  156.     ngx_stream_upstream_state_t  *state;

  158.     v->valid = 1;
  159.     v->no_cacheable = 0;
  160.     v->not_found = 0;

  162.     if (s->upstream_states == NULL || s->upstream_states->nelts == 0) {
  163.         v->not_found = 1;
  164.         return NGX_OK;
  165.     }

  167.     len = 0;
  168.     state = s->upstream_states->elts;

  170.     for (i = 0; i < s->upstream_states->nelts; i++) {
  171.         if (state[i].peer) {
  172.             len += state[i].peer->len;
  173.         }

  175.         len += 2;
  176.     }

  178.     p = ngx_pnalloc(s->connection->pool, len);
  179.     if (p == NULL) {
  180.         return NGX_ERROR;
  181.     }

  183.     v->data = p;

  185.     i = 0;

  187.     for ( ;; ) {
  188.         if (state[i].peer) {
  189.             p = ngx_cpymem(p, state[i].peer->data, state[i].peer->len);
  190.         }

  192.         if (++i == s->upstream_states->nelts) {
  193.             break;
  194.         }

  196.         *p++ = ',';
  197.         *p++ = ' ';
  198.     }

  200.     v->len = p - v->data;

  202.     return NGX_OK;
  203. }


  206. static ngx_int_t
  207. ‌ngx_stream_upstream_bytes_variable(ngx_stream_session_t *s,
  208.     ngx_stream_variable_value_t *v, uintptr_t data)
  209. {
  210.     u_char                       *p;
  211.     size_t                        len;
  212.     ngx_uint_t                    i;
  213.     ngx_stream_upstream_state_t  *state;

  215.     v->valid = 1;
  216.     v->no_cacheable = 0;
  217.     v->not_found = 0;

  219.     if (s->upstream_states == NULL || s->upstream_states->nelts == 0) {
  220.         v->not_found = 1;
  221.         return NGX_OK;
  222.     }

  224.     len = s->upstream_states->nelts * (NGX_OFF_T_LEN + 2);

  226.     p = ngx_pnalloc(s->connection->pool, len);
  227.     if (p == NULL) {
  228.         return NGX_ERROR;
  229.     }

  231.     v->data = p;

  233.     i = 0;
  234.     state = s->upstream_states->elts;

  236.     for ( ;; ) {

  238.         if (data == 1) {
  239.             p = ngx_sprintf(p, "%O", state[i].bytes_received);

  241.         } else {
  242.             p = ngx_sprintf(p, "%O", state[i].bytes_sent);
  243.         }

  245.         if (++i == s->upstream_states->nelts) {
  246.             break;
  247.         }

  249.         *p++ = ',';
  250.         *p++ = ' ';
  251.     }

  253.     v->len = p - v->data;

  255.     return NGX_OK;
  256. }


  259. static ngx_int_t
  260. ‌ngx_stream_upstream_response_time_variable(ngx_stream_session_t *s,
  261.     ngx_stream_variable_value_t *v, uintptr_t data)
  262. {
  263.     u_char                       *p;
  264.     size_t                        len;
  265.     ngx_uint_t                    i;
  266.     ngx_msec_int_t                ms;
  267.     ngx_stream_upstream_state_t  *state;

  269.     v->valid = 1;
  270.     v->no_cacheable = 0;
  271.     v->not_found = 0;

  273.     if (s->upstream_states == NULL || s->upstream_states->nelts == 0) {
  274.         v->not_found = 1;
  275.         return NGX_OK;
  276.     }

  278.     len = s->upstream_states->nelts * (NGX_TIME_T_LEN + 4 + 2);

  280.     p = ngx_pnalloc(s->connection->pool, len);
  281.     if (p == NULL) {
  282.         return NGX_ERROR;
  283.     }

  285.     v->data = p;

  287.     i = 0;
  288.     state = s->upstream_states->elts;

  290.     for ( ;; ) {

  292.         if (data == 1) {
  293.             ms = state[i].first_byte_time;

  295.         } else if (data == 2) {
  296.             ms = state[i].connect_time;

  298.         } else {
  299.             ms = state[i].response_time;
  300.         }

  302.         if (ms != -1) {
  303.             ms = ngx_max(ms, 0);
  304.             p = ngx_sprintf(p, "%T.%03M", (time_t) ms / 1000, ms % 1000);

  306.         } else {
  307.             *p++ = '-';
  308.         }

  310.         if (++i == s->upstream_states->nelts) {
  311.             break;
  312.         }

  314.         *p++ = ',';
  315.         *p++ = ' ';
  316.     }

  318.     v->len = p - v->data;

  320.     return NGX_OK;
  321. }


  324. static char *
  325. ‌ngx_stream_upstream(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
  326. {
  327.     char                            *rv;
  328.     void                            *mconf;
  329.     ngx_str_t                       *value;
  330.     ngx_url_t                        u;
  331.     ngx_uint_t                       m;
  332.     ngx_conf_t                       pcf;
  333.     ngx_stream_module_t             *module;
  334.     ngx_stream_conf_ctx_t           *ctx, *stream_ctx;
  335.     ngx_stream_upstream_srv_conf_t  *uscf;

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

  339.     value = cf->args->elts;
  340.     u.host = value[1];
  341.     u.no_resolve = 1;
  342.     u.no_port = 1;

  344.     uscf = ngx_stream_upstream_add(cf, &u, NGX_STREAM_UPSTREAM_CREATE
  345.                                            |NGX_STREAM_UPSTREAM_MODIFY
  346.                                            |NGX_STREAM_UPSTREAM_WEIGHT
  347.                                            |NGX_STREAM_UPSTREAM_MAX_CONNS
  348.                                            |NGX_STREAM_UPSTREAM_MAX_FAILS
  349.                                            |NGX_STREAM_UPSTREAM_FAIL_TIMEOUT
  350.                                            |NGX_STREAM_UPSTREAM_DOWN
  351.                                            |NGX_STREAM_UPSTREAM_BACKUP);
  352.     if (uscf == NULL) {
  353.         return NGX_CONF_ERROR;
  354.     }


  357.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_stream_conf_ctx_t));
  358.     if (ctx == NULL) {
  359.         return NGX_CONF_ERROR;
  360.     }

  362.     stream_ctx = cf->ctx;
  363.     ctx->main_conf = stream_ctx->main_conf;

  365.     /* the upstream{}'s srv_conf */

  367.     ctx->srv_conf = ngx_pcalloc(cf->pool,
  368.                                 sizeof(void *) * ngx_stream_max_module);
  369.     if (ctx->srv_conf == NULL) {
  370.         return NGX_CONF_ERROR;
  371.     }

  373.     ctx->srv_conf[ngx_stream_upstream_module.ctx_index] = uscf;

  375.     uscf->srv_conf = ctx->srv_conf;

  377.     for (m = 0; cf->cycle->modules[m]; m++) {
  378.         if (cf->cycle->modules[m]->type != NGX_STREAM_MODULE) {
  379.             continue;
  380.         }

  382.         module = cf->cycle->modules[m]->ctx;

  384.         if (module->create_srv_conf) {
  385.             mconf = module->create_srv_conf(cf);
  386.             if (mconf == NULL) {
  387.                 return NGX_CONF_ERROR;
  388.             }

  390.             ctx->srv_conf[cf->cycle->modules[m]->ctx_index] = mconf;
  391.         }
  392.     }

  394.     uscf->servers = ngx_array_create(cf->pool, 4,
  395.                                      sizeof(ngx_stream_upstream_server_t));
  396.     if (uscf->servers == NULL) {
  397.         return NGX_CONF_ERROR;
  398.     }


  401.     /* parse inside upstream{} */

  403.     pcf = *cf;
  404.     cf->ctx = ctx;
  405.     cf->cmd_type = NGX_STREAM_UPS_CONF;

  407.     rv = ngx_conf_parse(cf, NULL);

  409.     *cf = pcf;

  411.     if (rv != NGX_CONF_OK) {
  412.         return rv;
  413.     }

  415.     if (uscf->servers->nelts == 0) {
  416.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  417.                            "no servers are inside upstream");
  418.         return NGX_CONF_ERROR;
  419.     }

  421.     return rv;
  422. }


  425. static char *
  426. ‌ngx_stream_upstream_server(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  427. {
  428.     ngx_stream_upstream_srv_conf_t  *uscf = conf;

  430.     time_t                         fail_timeout;
  431.     ngx_str_t                     *value, s;
  432.     ngx_url_t                      u;
  433.     ngx_int_t                      weight, max_conns, max_fails;
  434.     ngx_uint_t                     i;
  435. #if (NGX_STREAM_UPSTREAM_ZONE)
  436.     ngx_uint_t                     resolve;
  437. #endif
  438.     ngx_stream_upstream_server_t  *us;

  440.     us = ngx_array_push(uscf->servers);
  441.     if (us == NULL) {
  442.         return NGX_CONF_ERROR;
  443.     }

  445.     ngx_memzero(us, sizeof(ngx_stream_upstream_server_t));

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

  449.     weight = 1;
  450.     max_conns = 0;
  451.     max_fails = 1;
  452.     fail_timeout = 10;
  453. #if (NGX_STREAM_UPSTREAM_ZONE)
  454.     resolve = 0;
  455. #endif

  457.     for (i = 2; i < cf->args->nelts; i++) {

  459.         if (ngx_strncmp(value[i].data, "weight=", 7) == 0) {

  461.             if (!(uscf->flags & NGX_STREAM_UPSTREAM_WEIGHT)) {
  462.                 goto not_supported;
  463.             }

  465.             weight = ngx_atoi(&value[i].data[7], value[i].len - 7);

  467.             if (weight == NGX_ERROR || weight == 0) {
  468.                 goto invalid;
  469.             }

  471.             continue;
  472.         }

  474.         if (ngx_strncmp(value[i].data, "max_conns=", 10) == 0) {

  476.             if (!(uscf->flags & NGX_STREAM_UPSTREAM_MAX_CONNS)) {
  477.                 goto not_supported;
  478.             }

  480.             max_conns = ngx_atoi(&value[i].data[10], value[i].len - 10);

  482.             if (max_conns == NGX_ERROR) {
  483.                 goto invalid;
  484.             }

  486.             continue;
  487.         }

  489.         if (ngx_strncmp(value[i].data, "max_fails=", 10) == 0) {

  491.             if (!(uscf->flags & NGX_STREAM_UPSTREAM_MAX_FAILS)) {
  492.                 goto not_supported;
  493.             }

  495.             max_fails = ngx_atoi(&value[i].data[10], value[i].len - 10);

  497.             if (max_fails == NGX_ERROR) {
  498.                 goto invalid;
  499.             }

  501.             continue;
  502.         }

  504.         if (ngx_strncmp(value[i].data, "fail_timeout=", 13) == 0) {

  506.             if (!(uscf->flags & NGX_STREAM_UPSTREAM_FAIL_TIMEOUT)) {
  507.                 goto not_supported;
  508.             }

  510.             s.len = value[i].len - 13;
  511.             s.data = &value[i].data[13];

  513.             fail_timeout = ngx_parse_time(&s, 1);

  515.             if (fail_timeout == (time_t) NGX_ERROR) {
  516.                 goto invalid;
  517.             }

  519.             continue;
  520.         }

  522.         if (ngx_strcmp(value[i].data, "backup") == 0) {

  524.             if (!(uscf->flags & NGX_STREAM_UPSTREAM_BACKUP)) {
  525.                 goto not_supported;
  526.             }

  528.             us->backup = 1;

  530.             continue;
  531.         }

  533.         if (ngx_strcmp(value[i].data, "down") == 0) {

  535.             if (!(uscf->flags & NGX_STREAM_UPSTREAM_DOWN)) {
  536.                 goto not_supported;
  537.             }

  539.             us->down = 1;

  541.             continue;
  542.         }

  544. #if (NGX_STREAM_UPSTREAM_ZONE)
  545.         if (ngx_strcmp(value[i].data, "resolve") == 0) {
  546.             resolve = 1;
  547.             continue;
  548.         }

  550.         if (ngx_strncmp(value[i].data, "service=", 8) == 0) {

  552.             us->service.len = value[i].len - 8;
  553.             us->service.data = &value[i].data[8];

  555.             if (us->service.len == 0) {
  556.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "service is empty");
  557.                 return NGX_CONF_ERROR;
  558.             }

  560.             continue;
  561.         }
  562. #endif

  564.         goto invalid;
  565.     }

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

  569.     u.url = value[1];

  571. #if (NGX_STREAM_UPSTREAM_ZONE)
  572.     if (resolve) {
  573.         /* resolve at run time */
  574.         u.no_resolve = 1;
  575.     }

  577.     if (us->service.len && !resolve) {
  578.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  579.                            "service upstream \"%V\" requires "
  580.                            "\"resolve\" parameter",
  581.                            &u.url);
  582.         return NGX_CONF_ERROR;
  583.     }

  585. #endif

  587.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  588.         if (u.err) {
  589.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  590.                                "%s in upstream \"%V\"", u.err, &u.url);
  591.         }

  593.         return NGX_CONF_ERROR;
  594.     }

  596.     if (u.no_port
  597. #if (NGX_STREAM_UPSTREAM_ZONE)
  598.         && us->service.len == 0
  599. #endif
  600.         )
  601.     {
  602.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  603.                            "no port in upstream \"%V\"", &u.url);
  604.         return NGX_CONF_ERROR;
  605.     }

  607.     us->name = u.url;

  609. #if (NGX_STREAM_UPSTREAM_ZONE)

  611.     if (us->service.len && !u.no_port) {
  612.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  613.                            "service upstream \"%V\" may not have port",
  614.                            &us->name);

  616.         return NGX_CONF_ERROR;
  617.     }

  619.     if (us->service.len && u.naddrs) {
  620.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  621.                            "service upstream \"%V\" requires domain name",
  622.                            &us->name);

  624.         return NGX_CONF_ERROR;
  625.     }

  627.     if (resolve && u.naddrs == 0) {
  628.         ngx_addr_t  *addr;

  630.         /* save port */

  632.         addr = ngx_pcalloc(cf->pool, sizeof(ngx_addr_t));
  633.         if (addr == NULL) {
  634.             return NGX_CONF_ERROR;
  635.         }

  637.         addr->sockaddr = ngx_palloc(cf->pool, u.socklen);
  638.         if (addr->sockaddr == NULL) {
  639.             return NGX_CONF_ERROR;
  640.         }

  642.         ngx_memcpy(addr->sockaddr, &u.sockaddr, u.socklen);

  644.         addr->socklen = u.socklen;

  646.         us->addrs = addr;
  647.         us->naddrs = 1;

  649.         us->host = u.host;

  651.     } else {
  652.         us->addrs = u.addrs;
  653.         us->naddrs = u.naddrs;
  654.     }

  656. #else

  658.     us->addrs = u.addrs;
  659.     us->naddrs = u.naddrs;

  661. #endif

  663.     us->weight = weight;
  664.     us->max_conns = max_conns;
  665.     us->max_fails = max_fails;
  666.     us->fail_timeout = fail_timeout;

  668.     return NGX_CONF_OK;

  670. invalid:

  672.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  673.                        "invalid parameter \"%V\"", &value[i]);

  675.     return NGX_CONF_ERROR;

  677. not_supported:

  679.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  680.                        "balancing method does not support parameter \"%V\"",
  681.                        &value[i]);

  683.     return NGX_CONF_ERROR;
  684. }


  687. #if (NGX_STREAM_UPSTREAM_ZONE)

  689. static char *
  690. ‌ngx_stream_upstream_resolver(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  691. {
  692.     ngx_stream_upstream_srv_conf_t  *uscf = conf;

  694.     ngx_str_t  *value;

  696.     if (uscf->resolver) {
  697.         return "is duplicate";
  698.     }

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

  702.     uscf->resolver = ngx_resolver_create(cf, &value[1], cf->args->nelts - 1);
  703.     if (uscf->resolver == NULL) {
  704.         return NGX_CONF_ERROR;
  705.     }

  707.     return NGX_CONF_OK;
  708. }

  710. #endif


  713. ngx_stream_upstream_srv_conf_t *
  714. ‌ngx_stream_upstream_add(ngx_conf_t *cf, ngx_url_t *u, ngx_uint_t flags)
  715. {
  716.     ngx_uint_t                        i;
  717.     ngx_stream_upstream_server_t     *us;
  718.     ngx_stream_upstream_srv_conf_t   *uscf, **uscfp;
  719.     ngx_stream_upstream_main_conf_t  *umcf;

  721.     if (!(flags & NGX_STREAM_UPSTREAM_CREATE)) {

  723.         if (ngx_parse_url(cf->pool, u) != NGX_OK) {
  724.             if (u->err) {
  725.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  726.                                    "%s in upstream \"%V\"", u->err, &u->url);
  727.             }

  729.             return NULL;
  730.         }
  731.     }

  733.     umcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_upstream_module);

  735.     uscfp = umcf->upstreams.elts;

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

  739.         if (uscfp[i]->host.len != u->host.len
  740.             || ngx_strncasecmp(uscfp[i]->host.data, u->host.data, u->host.len)
  741.                != 0)
  742.         {
  743.             continue;
  744.         }

  746.         if ((flags & NGX_STREAM_UPSTREAM_CREATE)
  747.              && (uscfp[i]->flags & NGX_STREAM_UPSTREAM_CREATE))
  748.         {
  749.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  750.                                "duplicate upstream \"%V\"", &u->host);
  751.             return NULL;
  752.         }

  754.         if ((uscfp[i]->flags & NGX_STREAM_UPSTREAM_CREATE) && !u->no_port) {
  755.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  756.                                "upstream \"%V\" may not have port %d",
  757.                                &u->host, u->port);
  758.             return NULL;
  759.         }

  761.         if ((flags & NGX_STREAM_UPSTREAM_CREATE) && !uscfp[i]->no_port) {
  762.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  763.                           "upstream \"%V\" may not have port %d in %s:%ui",
  764.                           &u->host, uscfp[i]->port,
  765.                           uscfp[i]->file_name, uscfp[i]->line);
  766.             return NULL;
  767.         }

  769.         if (uscfp[i]->port != u->port) {
  770.             continue;
  771.         }

  773.         if (flags & NGX_STREAM_UPSTREAM_CREATE) {
  774.             uscfp[i]->flags = flags;
  775.         }

  777.         return uscfp[i];
  778.     }

  780.     uscf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_upstream_srv_conf_t));
  781.     if (uscf == NULL) {
  782.         return NULL;
  783.     }

  785.     uscf->flags = flags;
  786.     uscf->host = u->host;
  787.     uscf->file_name = cf->conf_file->file.name.data;
  788.     uscf->line = cf->conf_file->line;
  789.     uscf->port = u->port;
  790.     uscf->no_port = u->no_port;
  791. #if (NGX_STREAM_UPSTREAM_ZONE)
  792.     uscf->resolver_timeout = NGX_CONF_UNSET_MSEC;
  793. #endif

  795.     if (u->naddrs == 1 && (u->port || u->family == AF_UNIX)) {
  796.         uscf->servers = ngx_array_create(cf->pool, 1,
  797.                                          sizeof(ngx_stream_upstream_server_t));
  798.         if (uscf->servers == NULL) {
  799.             return NULL;
  800.         }

  802.         us = ngx_array_push(uscf->servers);
  803.         if (us == NULL) {
  804.             return NULL;
  805.         }

  807.         ngx_memzero(us, sizeof(ngx_stream_upstream_server_t));

  809.         us->addrs = u->addrs;
  810.         us->naddrs = 1;
  811.     }

  813.     uscfp = ngx_array_push(&umcf->upstreams);
  814.     if (uscfp == NULL) {
  815.         return NULL;
  816.     }

  818.     *uscfp = uscf;

  820.     return uscf;
  821. }


  824. static void *
  825. ‌ngx_stream_upstream_create_main_conf(ngx_conf_t *cf)
  826. {
  827.     ngx_stream_upstream_main_conf_t  *umcf;

  829.     umcf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_upstream_main_conf_t));
  830.     if (umcf == NULL) {
  831.         return NULL;
  832.     }

  834.     if (ngx_array_init(&umcf->upstreams, cf->pool, 4,
  835.                        sizeof(ngx_stream_upstream_srv_conf_t *))
  836.         != NGX_OK)
  837.     {
  838.         return NULL;
  839.     }

  841.     return umcf;
  842. }


  845. static char *
  846. ‌ngx_stream_upstream_init_main_conf(ngx_conf_t *cf, void *conf)
  847. {
  848.     ngx_stream_upstream_main_conf_t *umcf = conf;

  850.     ngx_uint_t                        i;
  851.     ngx_stream_upstream_init_pt       init;
  852.     ngx_stream_upstream_srv_conf_t  **uscfp;

  854.     uscfp = umcf->upstreams.elts;

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

  858.         init = uscfp[i]->peer.init_upstream
  859.                                          ? uscfp[i]->peer.init_upstream
  860.                                          : ngx_stream_upstream_init_round_robin;

  862.         if (init(cf, uscfp[i]) != NGX_OK) {
  863.             return NGX_CONF_ERROR;
  864.         }
  865.     }

  867.     return NGX_CONF_OK;
  868. }

One Level Up Top Level