static char *
ngx_http_upstream_keepalive_timeout(ngx_conf_t *cf, ngx_command_t *cmd,
void *conf)
{
ngx_http_upstream_srv_conf_t *uscf;
ngx_http_upstream_keepalive_srv_conf_t *kcf;
ngx_str_t *value;
ngx_msec_t timeout;
uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);
kcf = ngx_http_conf_upstream_srv_conf(uscf,
ngx_http_upstream_keepalive_module);
if (kcf->keepalive_timeout != NGX_CONF_UNSET_MSEC) {
return "is duplicate";
}
value = cf->args->elts;
timeout = ngx_parse_time(&value[1], 0);
if (timeout == (ngx_msec_t) NGX_ERROR) {
return "invalid value";
}
kcf->keepalive_timeout = timeout;
return NGX_CONF_OK;
}
static ngx_int_t
max_connections_init(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *uscf)
{
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0,
"max connections init");
max_connections_srv_conf_t *maxconn_cf =
ngx_http_conf_upstream_srv_conf(uscf, max_connections_module);
if (maxconn_cf->original_init_upstream(cf, uscf) != NGX_OK) {
return NGX_ERROR;
}
maxconn_cf->original_init_peer = uscf->peer.init;
uscf->peer.init = peer_init;
maxconn_cf->connections = 0;
maxconn_cf->queue_length = 0;
ngx_queue_init(&maxconn_cf->waiting_requests);
maxconn_cf->queue_check_event.handler = queue_check_event;
maxconn_cf->queue_check_event.log = cf->log;
maxconn_cf->queue_check_event.data = maxconn_cf;
return NGX_OK;
}
static ngx_int_t ngx_http_upstream_get_available_capacity_peer(ngx_peer_connection_t *pc, void *data)
{
ngx_http_upstream_available_capacity_data_t *cap_data = data;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0, "get available capacity peer, try: %ui", pc->tries);
pc->cached = 0;
pc->connection = NULL;
ngx_http_upstream_available_capacity_srv_conf_t *conf = ngx_http_conf_upstream_srv_conf(cap_data->conf, ngx_http_upstream_available_capacity_module);
ngx_http_upstream_available_capacity_server_t *found_server = NULL;
ngx_http_upstream_available_capacity_server_t *server = conf->search_start_peer;
size_t i = 0;
for (; i < conf->server_num; ++i) {
if (i != 0) {
server = NEXT_SERVER(conf, server);
}
if (server->capacity > 0) {
found_server = server;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0, "server_capacity = [%d]\n", server->capacity);
--server->capacity;
break;
}
}
conf->search_start_peer = (server == conf->search_start_peer) ? NEXT_SERVER(conf, server) : server;
if (found_server) {
pc->sockaddr = found_server->addr.sockaddr;
pc->socklen = found_server->addr.socklen;
pc->name = &found_server->server->name;
} else {
ngx_log_error_core(NGX_LOG_ERR, pc->log, 0, "cannot load balance");
return NGX_ERROR;
}
return NGX_OK;
}
static ngx_int_t ngx_http_upstream_resolveMK_init_peer(ngx_http_request_t *r,
ngx_http_upstream_srv_conf_t *us)
{
ngx_http_upstream_resolveMK_peer_data_t *urpd;
ngx_http_upstream_resolveMK_srv_conf_t *urcf;
urcf = ngx_http_conf_upstream_srv_conf(us,
ngx_http_upstream_resolveMK_module);
urpd = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolveMK_peer_data_t));
if (urpd == NULL) {
return NGX_ERROR;
}
urpd->conf = urcf;
urpd->clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
urpd->current = -1;
r->upstream->peer.data = urpd;
r->upstream->peer.free = ngx_http_upstream_resolveMK_free_peer;
r->upstream->peer.get = ngx_http_upstream_resolveMK_get_peer;
if (urcf->upstream_retry) {
r->upstream->peer.tries = (urcf->resolved_num != 1) ? urcf->resolved_num : 2;
} else {
r->upstream->peer.tries = 1;
}
#if (NGX_HTTP_SSL)
r->upstream->peer.set_session = ngx_http_upstream_set_resolveMK_peer_session;
r->upstream->peer.save_session = ngx_http_upstream_save_resolveMK_peer_session;
#endif
return NGX_OK;
}
static ngx_int_t
ngx_http_upstream_init_least_conn(ngx_conf_t *cf,
ngx_http_upstream_srv_conf_t *us)
{
ngx_uint_t n;
ngx_http_upstream_rr_peers_t *peers;
ngx_http_upstream_least_conn_conf_t *lcf;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0,
"init least conn");
if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) {
return NGX_ERROR;
}
peers = us->peer.data;
n = peers->number;
if (peers->next) {
n += peers->next->number;
}
lcf = ngx_http_conf_upstream_srv_conf(us,
ngx_http_upstream_least_conn_module);
lcf->conns = ngx_pcalloc(cf->pool, sizeof(ngx_uint_t) * n);
if (lcf->conns == NULL) {
return NGX_ERROR;
}
us->peer.init = ngx_http_upstream_init_least_conn_peer;
return NGX_OK;
}
static char *ngx_http_upstream_q_chash(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_upstream_srv_conf_t *uscf;
ngx_http_upstream_q_chash_srv_conf_t *uchscf;
ngx_str_t *value;
ngx_http_script_compile_t sc;
uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);
uchscf = ngx_http_conf_upstream_srv_conf(uscf, ngx_http_upstream_q_chash_module);
value = cf->args->elts;
ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));
sc.cf = cf;
sc.source = &value[1];
sc.lengths = &uchscf->lengths;
sc.values = &uchscf->values;
sc.complete_lengths = 1;
sc.complete_values = 1;
if (ngx_http_script_compile(&sc) != NGX_OK) {
return NGX_CONF_ERROR;
}
uscf->peer.init_upstream = ngx_http_upstream_init_q_chash;
uscf->flags = NGX_HTTP_UPSTREAM_CREATE
| NGX_HTTP_UPSTREAM_WEIGHT
| NGX_HTTP_UPSTREAM_MAX_FAILS
| NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
| NGX_HTTP_UPSTREAM_DOWN
| NGX_HTTP_UPSTREAM_BACKUP;
return NGX_CONF_OK;
}
static ngx_int_t
ngx_http_lua_balancer_init_peer(ngx_http_request_t *r,
ngx_http_upstream_srv_conf_t *us)
{
ngx_http_lua_srv_conf_t *bcf;
ngx_http_lua_balancer_peer_data_t *bp;
bp = ngx_pcalloc(r->pool, sizeof(ngx_http_lua_balancer_peer_data_t));
if (bp == NULL) {
return NGX_ERROR;
}
r->upstream->peer.data = &bp->rrp;
if (ngx_http_upstream_init_round_robin_peer(r, us) != NGX_OK) {
return NGX_ERROR;
}
r->upstream->peer.get = ngx_http_lua_balancer_get_peer;
r->upstream->peer.free = ngx_http_lua_balancer_free_peer;
#if (NGX_HTTP_SSL)
r->upstream->peer.set_session = ngx_http_lua_balancer_set_session;
r->upstream->peer.save_session = ngx_http_lua_balancer_save_session;
#endif
bcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_lua_module);
bp->conf = bcf;
bp->request = r;
return NGX_OK;
}
/*
* function called by the upstream module to init itself
* it's called once per instance
*/
static ngx_int_t
ngx_http_init_upstream_sticky(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us)
{
ngx_uint_t i;
ngx_http_sticky_srv_conf_t *conf;
ngx_http_upstream_rr_peers_t *rr_peers;
/* call the rr module on wich the sticky module is based on */
if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) {
return NGX_ERROR;
}
/* calculate each peer digest once and save */
rr_peers = us->peer.data;
/* do nothing there's only one peer */
if (rr_peers->number <= 1 || rr_peers->single) {
return NGX_OK;
}
/*
* tell the upstream module to call ngx_http_init_sticky_peer when
* it inits peer
*/
us->peer.init = ngx_http_init_sticky_peer;
conf = ngx_http_conf_upstream_srv_conf(us, ngx_http_sticky_module);
/* if 'index', no need to alloc and generate digest */
if (!conf->hash && !conf->hmac) {
conf->peers = NULL;
return NGX_OK;
}
/* create our own upstream indexes */
conf->peers = ngx_pcalloc(cf->pool, sizeof(ngx_http_sticky_peer_t)
* rr_peers->number);
if (conf->peers == NULL) {
return NGX_ERROR;
}
/* parse each peer and generate digest if necessary */
for (i = 0; i < rr_peers->number; i++) {
conf->peers[i].rr_peer = &rr_peers->peer[i];
if (conf->hmac) {
/* generate hmac */
conf->hmac(cf->pool, rr_peers->peer[i].sockaddr,
rr_peers->peer[i].socklen, &conf->hmac_key,
&conf->peers[i].digest);
} else {
/* generate hash */
conf->hash(cf->pool, rr_peers->peer[i].sockaddr,
rr_peers->peer[i].socklen, &conf->peers[i].digest);
}
}
return NGX_OK;
}
static char *
ngx_http_upstream_keepalive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_upstream_srv_conf_t *uscf;
ngx_http_upstream_keepalive_srv_conf_t *kcf;
ngx_int_t n;
ngx_str_t *value;
ngx_uint_t i;
uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);
kcf = ngx_http_conf_upstream_srv_conf(uscf,
ngx_http_upstream_keepalive_module);
if (kcf->original_init_upstream) {
return "is duplicate";
}
kcf->original_init_upstream = uscf->peer.init_upstream
? uscf->peer.init_upstream
: ngx_http_upstream_init_round_robin;
uscf->peer.init_upstream = ngx_http_upstream_init_keepalive;
/* read options */
value = cf->args->elts;
n = ngx_atoi(value[1].data, value[1].len);
if (n == NGX_ERROR || n == 0) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"invalid value \"%V\" in \"%V\" directive",
&value[1], &cmd->name);
return NGX_CONF_ERROR;
}
kcf->max_cached = n;
for (i = 2; i < cf->args->nelts; i++) {
if (ngx_strcmp(value[i].data, "single") == 0) {
ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
"the \"single\" parameter is deprecated");
continue;
}
goto invalid;
}
return NGX_CONF_OK;
invalid:
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"invalid parameter \"%V\"", &value[i]);
return NGX_CONF_ERROR;
}
static char *
max_connections_command (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_upstream_srv_conf_t *uscf =
ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);
max_connections_srv_conf_t *maxconn_cf =
ngx_http_conf_upstream_srv_conf(uscf, max_connections_module);
/* 1. set the initialization function */
maxconn_cf->original_init_upstream = uscf->peer.init_upstream
? uscf->peer.init_upstream
: ngx_http_upstream_init_round_robin;
uscf->peer.init_upstream = max_connections_init;
/* 2. set the number of max_connections */
ngx_str_t *value = cf->args->elts;
ngx_int_t max_connections = ngx_atoi(value[1].data, value[1].len);
if (max_connections == NGX_ERROR || max_connections == 0) {
ngx_conf_log_error( NGX_LOG_EMERG
, cf
, 0
, "invalid value \"%V\" in \"%V\" directive"
, &value[1]
, &cmd->name
);
return NGX_CONF_ERROR;
}
maxconn_cf->max_connections = (ngx_uint_t)max_connections;
return NGX_CONF_OK;
}
static ngx_int_t
ngx_http_upstream_session_sticky_init_upstream(ngx_conf_t *cf,
ngx_http_upstream_srv_conf_t *us)
{
ngx_uint_t number, i;
ngx_http_upstream_rr_peer_t *peer;
ngx_http_upstream_rr_peers_t *peers;
ngx_http_upstream_ss_srv_conf_t *sscf;
if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) {
return NGX_ERROR;
}
sscf = ngx_http_conf_upstream_srv_conf(us,
ngx_http_upstream_session_sticky_module);
if (sscf == NULL) {
return NGX_ERROR;
}
peers = (ngx_http_upstream_rr_peers_t *) us->peer.data;
number = peers->number;
sscf->server = ngx_palloc(cf->pool, number * sizeof(ngx_http_ss_server_t));
if (sscf->server == NULL) {
return NGX_ERROR;
}
sscf->number = number;
for (i = 0; i < number; i++) {
peer = &peers->peer[i];
sscf->server[i].name = &peer->name;
sscf->server[i].sockaddr = peer->sockaddr;
sscf->server[i].socklen = peer->socklen;
#if (NGX_HTTP_UPSTREAM_CHECK)
sscf->server[i].check_index = peer->check_index;
#endif
if (sscf->flag & NGX_HTTP_SESSION_STICKY_PLAIN) {
if (peer->id.len == 0) {
sscf->server[i].sid.data = peer->name.data;
sscf->server[i].sid.len = peer->name.len;
continue;
}
sscf->server[i].sid.data = peer->id.data;
sscf->server[i].sid.len = peer->id.len;
} else if (ngx_http_upstream_session_sticky_set_sid(
cf, &sscf->server[i]) != NGX_OK)
{
return NGX_ERROR;
}
}
us->peer.init = ngx_http_upstream_session_sticky_init_peer;
return NGX_OK;
}
static ngx_int_t
ngx_http_session_sticky_header_handler(ngx_http_request_t *r)
{
ngx_http_ss_ctx_t *ctx;
ngx_http_ss_loc_conf_t *slcf;
ngx_http_upstream_srv_conf_t *uscf;
ngx_http_upstream_ss_srv_conf_t *sscf;
slcf = ngx_http_get_module_loc_conf(r,
ngx_http_upstream_session_sticky_module);
if (slcf->uscf == NGX_CONF_UNSET_PTR) {
return NGX_DECLINED;
}
uscf = slcf->uscf;
sscf = ngx_http_conf_upstream_srv_conf(uscf,
ngx_http_upstream_session_sticky_module);
if (sscf != NULL &&
(sscf->flag & NGX_HTTP_SESSION_STICKY_REWRITE)) {
return NGX_DECLINED;
}
ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_ss_ctx_t));
if (ctx == NULL) {
return NGX_ERROR;
}
ngx_http_set_ctx(r, ctx, ngx_http_upstream_session_sticky_module);
ctx->sscf = sscf;
return ngx_http_session_sticky_get_cookie(r);
}
static ngx_int_t
ngx_http_upstream_init_least_conn_peer(ngx_http_request_t *r,
ngx_http_upstream_srv_conf_t *us)
{
ngx_http_upstream_lc_peer_data_t *lcp;
ngx_http_upstream_least_conn_conf_t *lcf;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"init least conn peer");
lcf = ngx_http_conf_upstream_srv_conf(us,
ngx_http_upstream_least_conn_module);
lcp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_lc_peer_data_t));
if (lcp == NULL) {
return NGX_ERROR;
}
lcp->conns = lcf->conns;
r->upstream->peer.data = &lcp->rrp;
if (ngx_http_upstream_init_round_robin_peer(r, us) != NGX_OK) {
return NGX_ERROR;
}
r->upstream->peer.get = ngx_http_upstream_get_least_conn_peer;
r->upstream->peer.free = ngx_http_upstream_free_least_conn_peer;
lcp->get_rr_peer = ngx_http_upstream_get_round_robin_peer;
lcp->free_rr_peer = ngx_http_upstream_free_round_robin_peer;
return NGX_OK;
}
static ngx_int_t
ngx_http_upstream_session_sticky_init_peer(ngx_http_request_t *r,
ngx_http_upstream_srv_conf_t *us)
{
ngx_int_t rc;
ngx_http_ss_ctx_t *ctx;
ngx_http_upstream_ss_srv_conf_t *sscf;
ngx_http_upstream_ss_peer_data_t *sspd;
sspd = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_ss_peer_data_t));
if (sspd == NULL) {
return NGX_ERROR;
}
r->upstream->peer.data = &sspd->rrp;
rc = ngx_http_upstream_init_round_robin_peer(r, us);
if (rc != NGX_OK) {
return rc;
}
sscf = ngx_http_conf_upstream_srv_conf(us,
ngx_http_upstream_session_sticky_module);
ctx = ngx_http_get_module_ctx(r, ngx_http_upstream_session_sticky_module);
if (ctx == NULL) {
ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_ss_ctx_t));
if (ctx == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"session sticky ctx allocated failed");
return NGX_ERROR;
}
ctx->sscf = sscf;
ngx_http_set_ctx(r, ctx, ngx_http_upstream_session_sticky_module);
rc = ngx_http_session_sticky_get_cookie(r);
if (rc != NGX_OK) {
return rc;
}
} else {
if (ctx->sscf != sscf) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"different sscf with header_handler");
}
}
sspd->r = r;
sspd->sscf = sscf;
sspd->get_rr_peer = ngx_http_upstream_get_round_robin_peer;
r->upstream->peer.data = sspd;
r->upstream->peer.get = ngx_http_upstream_session_sticky_get_peer;
return NGX_OK;
}
static ngx_int_t ngx_http_upstream_resolveMK_init(ngx_conf_t *cf,
ngx_http_upstream_srv_conf_t *us)
{
ngx_http_upstream_resolveMK_srv_conf_t *urcf;
us->peer.init = ngx_http_upstream_resolveMK_init_peer;
urcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_resolveMK_module);
urcf->resolver_stats = RESOLVE_STATS_DONE;
return NGX_OK;
}
static ngx_int_t
peer_init (ngx_http_request_t *r, ngx_http_upstream_srv_conf_t *uscf)
{
max_connections_srv_conf_t *maxconn_cf =
ngx_http_conf_upstream_srv_conf(uscf, max_connections_module);
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http max connections peer init");
if (maxconn_cf->original_init_peer(r, uscf) != NGX_OK) {
return NGX_ERROR;
}
max_connections_peer_data_t *peer_data =
ngx_palloc(r->pool, sizeof(max_connections_peer_data_t));
if(peer_data == NULL) return NGX_ERROR;
peer_data->maxconn_cf = maxconn_cf;
peer_data->r = r;
peer_data->accessed = ngx_current_msec;
peer_data->processing = 0;
peer_data->original_finalize_request = r->upstream->finalize_request;
peer_data->original_get_peer = r->upstream->peer.get;
peer_data->original_free_peer = r->upstream->peer.free;
peer_data->data = r->upstream->peer.data;
r->upstream->finalize_request = finalize_request;
r->upstream->peer.get = peer_get;
r->upstream->peer.free = peer_free;
r->upstream->peer.data = peer_data;
if (maxconn_cf->connections < maxconn_cf->max_connections) {
peer_data->processing = 1;
maxconn_cf->connections ++; /* keep track of how many slots are occupied */
return NGX_OK;
}
if (queue_push(maxconn_cf, peer_data) == NGX_ERROR) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"max connections queue push failed (queue_length: %ui, conn: %ui)",
maxconn_cf->queue_length, maxconn_cf->connections);
return NGX_ERROR;
}
ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
"max connections put in queue (queue_length: %ui, conn: %ui)",
maxconn_cf->queue_length, maxconn_cf->connections);
return NGX_BUSY;
}
static ngx_int_t ngx_http_upstream_init_available_capacity(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us)
{
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0, "init available_capacity");
// initialize us->peer.data
if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) {
return NGX_ERROR;
}
us->peer.init = ngx_http_upstream_init_available_capacity_peer;
ngx_http_upstream_available_capacity_srv_conf_t *conf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_available_capacity_module);
available_capacity_server_conf = conf;
return NGX_OK;
}
static ngx_int_t
ngx_http_upstream_init_keepalive_peer(ngx_http_request_t *r,
ngx_http_upstream_srv_conf_t *us)
{
ngx_http_upstream_keepalive_peer_data_t *kp;
ngx_http_upstream_keepalive_srv_conf_t *kcf;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"init keepalive peer");
kcf = ngx_http_conf_upstream_srv_conf(us,
ngx_http_upstream_keepalive_module);
kp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_keepalive_peer_data_t));
if (kp == NULL) {
return NGX_ERROR;
}
/*
先执行原始的初始化peer函数，即ngx_http_upstream_init_round_robin_peer。该
函数内部处理一些与负载均衡相关的操作并分别设置以下四个钩子：
r->upstream->peer.get和 r->upstream->peer.free
r->upstream->peer.set_session和 r->upstream->peer.save_session
*/
if (kcf->original_init_peer(r, us) != NGX_OK) {
return NGX_ERROR;
}
kp->conf = kcf;
kp->upstream = r->upstream;
// keepalive模块则保存上述原始钩子，并使用新的各类钩子覆盖旧钩子
kp->data = r->upstream->peer.data;
kp->original_get_peer = r->upstream->peer.get;
kp->original_free_peer = r->upstream->peer.free;
r->upstream->peer.data = kp;
r->upstream->peer.get = ngx_http_upstream_get_keepalive_peer;
r->upstream->peer.free = ngx_http_upstream_free_keepalive_peer;
#if (NGX_HTTP_SSL)
kp->original_set_session = r->upstream->peer.set_session;
kp->original_save_session = r->upstream->peer.save_session;
r->upstream->peer.set_session = ngx_http_upstream_keepalive_set_session;
r->upstream->peer.save_session = ngx_http_upstream_keepalive_save_session;
#endif
return NGX_OK;
}
static ngx_int_t setup_default_servers(ngx_http_request_t *r, ngx_http_upstream_srv_conf_t *us)
{
ngx_http_upstream_available_capacity_srv_conf_t *conf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_available_capacity_module);
if (conf->server_list) return NGX_OK;
ngx_slab_pool_t *shpool = (ngx_slab_pool_t *)us->shm_zone->shm.addr;
ngx_shmtx_lock(&shpool->mutex);
ngx_http_upstream_available_capacity_server_t *prev_server_conf = NULL;
size_t i = 0;
for (i = 0; i < us->servers->nelts; ++i) {
ngx_http_upstream_server_t *servers = us->servers->elts;
ngx_http_upstream_available_capacity_server_t *server_conf = ngx_slab_calloc_locked(shpool, sizeof(ngx_http_upstream_available_capacity_server_t));
server_conf->server = &servers[i];
server_conf->capacity = 1;
ngx_str_t server_address = ngx_string(server_conf->server->name.data);
ngx_url_t url;
ngx_memzero(&url, sizeof(ngx_url_t));
size_t server_address_size = strlen((char *)server_address.data);
url.url.len = server_address_size;
url.url.data = ngx_slab_alloc_locked(shpool, server_address_size);
url.default_port = 80;
ngx_cpystrn(url.url.data, server_address.data, server_address_size + 1);
if (ngx_parse_url_slab(shpool, &url) != NGX_OK) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "cannot parse url : %s", server_address.data);
return NGX_DECLINED;
}
server_conf->addr = *url.addrs;
server_conf->next = NULL;
if (prev_server_conf) {
prev_server_conf->next = server_conf;
} else {
conf->server_list = server_conf;
}
prev_server_conf = server_conf;
}
conf->server_num = us->servers->nelts;
conf->search_start_peer = conf->server_list;
ngx_shmtx_unlock(&shpool->mutex);
return NGX_OK;
}
static ngx_int_t ngx_http_upstream_init_q_chash_peer(ngx_http_request_t *r, ngx_http_upstream_srv_conf_t *us)
{
ngx_int_t rc;
ngx_http_upstream_q_chash_srv_conf_t *uchscf;
ngx_http_upstream_q_chash_peer_data_t *qchp;
ngx_http_upstream_q_chash_ring *q_chash_ring;
ngx_str_t evaluated_key_to_hash;
uchscf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_q_chash_module);
if (uchscf == NULL) {
return NGX_ERROR;
}
q_chash_ring = uchscf->q_chash_ring;
qchp = ngx_pcalloc(r->pool, sizeof(*qchp));
if(qchp == NULL)
return NGX_ERROR;
r->upstream->peer.data = &qchp->rrp;
qchp->q_chash_ring = q_chash_ring;
qchp->get_rr_peer = ngx_http_upstream_get_round_robin_peer;
qchp->tries = 0;
qchp->ignore = 0;
qchp->rr_mode = 0;
rc = ngx_http_upstream_init_round_robin_peer(r, us);
if(rc != NGX_OK)
return NGX_ERROR;
r->upstream->peer.get = ngx_http_upstream_get_q_chash_peer;
// calculate the vnode_index
if(q_chash_ring->nr_valid_peers > 1) {
if (ngx_http_script_run(r, &evaluated_key_to_hash, uchscf->lengths->elts, 0, uchscf->values->elts) == NULL)
return NGX_ERROR;
qchp->point = (uint32_t)ngx_crc32_long(evaluated_key_to_hash.data, evaluated_key_to_hash.len);
qchp->vnode_index = q_chash_find(q_chash_ring, qchp->point);
ngx_log_debug(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "q_chash key %V, point %uD, vnode_index %ui", &evaluated_key_to_hash, qchp->point, qchp->vnode_index);
}
return NGX_OK;
}
static ngx_int_t
ngx_http_upstream_init_consistent_hash_peer(ngx_http_request_t *r,
ngx_http_upstream_srv_conf_t *us)
{
ngx_str_t evaluated_key_to_hash;
ngx_http_upstream_consistent_hash_srv_conf_t *uchscf;
ngx_http_upstream_consistent_hash_peer_data_t *uchpd;
uchscf = ngx_http_conf_upstream_srv_conf(us,
ngx_http_upstream_consistent_hash_module);
if (uchscf == NULL) {
return NGX_ERROR;
}
uchpd = ngx_pcalloc(r->pool,
sizeof(ngx_http_upstream_consistent_hash_peer_data_t));
if (uchpd == NULL) {
return NGX_ERROR;
}
r->upstream->peer.data = &uchpd->rrp;
if (ngx_http_upstream_init_round_robin_peer(r, us) != NGX_OK) {
return NGX_ERROR;
}
r->upstream->peer.get = ngx_http_upstream_get_consistent_hash_peer;
uchpd->buckets = uchscf->data;
uchpd->tries = 0;
if (ngx_http_script_run(r, &evaluated_key_to_hash,
uchscf->lengths->elts, 0, uchscf->values->elts) == NULL)
{
return NGX_ERROR;
}
uchpd->point =
ngx_crc32_long(evaluated_key_to_hash.data, evaluated_key_to_hash.len);
uchpd->get_rr_peer = ngx_http_upstream_get_round_robin_peer;
return NGX_OK;
}
static ngx_int_t
ngx_http_upstream_init_dynamic(ngx_conf_t *cf,
ngx_http_upstream_srv_conf_t *us)
{
ngx_uint_t i;
ngx_http_upstream_dynamic_srv_conf_t *dcf;
ngx_http_upstream_server_t *server;
ngx_str_t host;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0,
"init dynamic resolve");
dcf = ngx_http_conf_upstream_srv_conf(us,
ngx_http_upstream_dynamic_module);
if (dcf->original_init_upstream(cf, us) != NGX_OK) {
return NGX_ERROR;
}
if (us->servers) {
server = us->servers->elts;
for (i = 0; i < us->servers->nelts; i++) {
host = server[i].host;
if (ngx_inet_addr(host.data, host.len) == INADDR_NONE) {
break;
}
}
if (i == us->servers->nelts) {
dcf->enabled = 0;
return NGX_OK;
}
}
dcf->original_init_peer = us->peer.init;
us->peer.init = ngx_http_upstream_init_dynamic_peer;
dcf->enabled = 1;
return NGX_OK;
}
static ngx_int_t
ngx_http_upstream_init_keepalive(ngx_conf_t *cf,
ngx_http_upstream_srv_conf_t *us)
{
ngx_uint_t i;
ngx_http_upstream_keepalive_srv_conf_t *kcf;
ngx_http_upstream_keepalive_cache_t *cached;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0,
"init keepalive");
kcf = ngx_http_conf_upstream_srv_conf(us,
ngx_http_upstream_keepalive_module);
// 先执行原始初始化upstream函数（即ngx_http_upstream_init_round_robin），该函数会根据配置的后端地址解析成socket地址，用
//于连接后端。并设置us->peer.init钩子为ngx_http_upstream_init_round_robin_peer
if (kcf->original_init_upstream(cf, us) != NGX_OK) {
return NGX_ERROR;
}
// 保存原钩子，并用keepalive的钩子覆盖旧钩子，初始化后端请求的时候会调用这个新钩子
kcf->original_init_peer = us->peer.init;
us->peer.init = ngx_http_upstream_init_keepalive_peer;
/* allocate cache items and add to free queue */
/* 申请缓存项，并添加到free队列中，后续用从free队列里面取 */
cached = ngx_pcalloc(cf->pool,
sizeof(ngx_http_upstream_keepalive_cache_t) * kcf->max_cached);
if (cached == NULL) {
return NGX_ERROR;
}
ngx_queue_init(&kcf->cache);
ngx_queue_init(&kcf->free);
for (i = 0; i < kcf->max_cached; i++) {
ngx_queue_insert_head(&kcf->free, &cached[i].queue);
cached[i].conf = kcf;
}
return NGX_OK;
}
static ngx_int_t
ngx_http_upstream_init_keepalive(ngx_conf_t *cf,
ngx_http_upstream_srv_conf_t *us)
{
ngx_uint_t i;
ngx_http_upstream_keepalive_srv_conf_t *kcf;
ngx_http_upstream_keepalive_cache_t *cached;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0,
"init keepalive");
kcf = ngx_http_conf_upstream_srv_conf(us,
ngx_http_upstream_keepalive_module);
ngx_conf_init_msec_value(kcf->timeout, 60000);
ngx_conf_init_uint_value(kcf->requests, 100);
if (kcf->original_init_upstream(cf, us) != NGX_OK) {
return NGX_ERROR;
}
kcf->original_init_peer = us->peer.init;
us->peer.init = ngx_http_upstream_init_keepalive_peer;
/* allocate cache items and add to free queue */
cached = ngx_pcalloc(cf->pool,
sizeof(ngx_http_upstream_keepalive_cache_t) * kcf->max_cached);
if (cached == NULL) {
return NGX_ERROR;
}
ngx_queue_init(&kcf->cache);
ngx_queue_init(&kcf->free);
for (i = 0; i < kcf->max_cached; i++) {
ngx_queue_insert_head(&kcf->free, &cached[i].queue);
cached[i].conf = kcf;
}
return NGX_OK;
}
/* TODO same as above */
static char *
max_connections_max_queue_length_command (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_upstream_srv_conf_t *uscf =
ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);
max_connections_srv_conf_t *maxconn_cf =
ngx_http_conf_upstream_srv_conf(uscf, max_connections_module);
ngx_str_t *value = cf->args->elts;
ngx_int_t n = ngx_atoi(value[1].data, value[1].len);
if (n == NGX_ERROR) {
return "invalid number";
}
maxconn_cf->max_queue_length = n;
return NGX_CONF_OK;
}
static ngx_int_t
ngx_http_upstream_init_dynamic_peer(ngx_http_request_t *r,
ngx_http_upstream_srv_conf_t *us)
{
ngx_http_upstream_dynamic_peer_data_t *dp;
ngx_http_upstream_dynamic_srv_conf_t *dcf;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"init dynamic peer");
dcf = ngx_http_conf_upstream_srv_conf(us,
ngx_http_upstream_dynamic_module);
dp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_dynamic_peer_data_t));
if (dp == NULL) {
return NGX_ERROR;
}
if (dcf->original_init_peer(r, us) != NGX_OK) {
return NGX_ERROR;
}
dp->conf = dcf;
dp->upstream = r->upstream;
dp->data = r->upstream->peer.data;
dp->original_get_peer = r->upstream->peer.get;
dp->original_free_peer = r->upstream->peer.free;
dp->request = r;
r->upstream->peer.data = dp;
r->upstream->peer.get = ngx_http_upstream_get_dynamic_peer;
r->upstream->peer.free = ngx_http_upstream_free_dynamic_peer;
#if (NGX_HTTP_SSL)
dp->original_set_session = r->upstream->peer.set_session;
dp->original_save_session = r->upstream->peer.save_session;
r->upstream->peer.set_session = ngx_http_upstream_dynamic_set_session;
r->upstream->peer.save_session = ngx_http_upstream_dynamic_save_session;
#endif
return NGX_OK;
}
static ngx_int_t
ngx_http_upstream_init_keepalive_peer(ngx_http_request_t *r,
ngx_http_upstream_srv_conf_t *us)
{
ngx_http_upstream_keepalive_peer_data_t *kp;
ngx_http_upstream_keepalive_srv_conf_t *kcf;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"init keepalive peer");
kcf = ngx_http_conf_upstream_srv_conf(us,
ngx_http_upstream_keepalive_module);
kp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_keepalive_peer_data_t));
if (kp == NULL) {
return NGX_ERROR;
}
if (kcf->original_init_peer(r, us) != NGX_OK) {
return NGX_ERROR;
}
kp->conf = kcf;
kp->upstream = r->upstream;
kp->data = r->upstream->peer.data;
kp->original_get_peer = r->upstream->peer.get;
kp->original_free_peer = r->upstream->peer.free;
r->upstream->peer.data = kp;
r->upstream->peer.get = ngx_http_upstream_get_keepalive_peer;
r->upstream->peer.free = ngx_http_upstream_free_keepalive_peer;
#if (NGX_HTTP_SSL)
kp->original_set_session = r->upstream->peer.set_session;
kp->original_save_session = r->upstream->peer.save_session;
r->upstream->peer.set_session = ngx_http_upstream_keepalive_set_session;
r->upstream->peer.save_session = ngx_http_upstream_keepalive_save_session;
#endif
return NGX_OK;
}
/* TODO This function is probably not neccesary. Nginx provides a means of
* easily setting scalar time values with ngx_conf_set_msec_slot() in the
* ngx_command_t structure. I couldn't manage to make it work, not knowing
* what I should be using for the two offset parameters.
*/
static char *
max_connections_queue_timeout_command (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_upstream_srv_conf_t *uscf =
ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);
max_connections_srv_conf_t *maxconn_cf =
ngx_http_conf_upstream_srv_conf(uscf, max_connections_module);
ngx_str_t *value;
value = cf->args->elts;
ngx_msec_t ms = ngx_parse_time(&value[1], 0);
if (ms == (ngx_msec_t) NGX_ERROR) {
return "invalid value";
}
maxconn_cf->queue_timeout = ms;
return NGX_CONF_OK;
}
static ngx_int_t
ngx_http_upstream_init_chash_peer(ngx_http_request_t *r,
ngx_http_upstream_srv_conf_t *us)
{
ngx_str_t hash_value;
ngx_http_upstream_chash_srv_conf_t *ucscf;
ngx_http_upstream_chash_peer_data_t *uchpd;
ucscf = ngx_http_conf_upstream_srv_conf(us,
ngx_http_upstream_consistent_hash_module);
if (ucscf == NULL) {
return NGX_ERROR;
}
uchpd = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_chash_peer_data_t));
if (uchpd == NULL) {
return NGX_ERROR;
}
uchpd->ucscf = ucscf;
if (ngx_http_script_run(r, &hash_value,
ucscf->lengths->elts, 0, ucscf->values->elts) == NULL) {
return NGX_ERROR;
}
uchpd->hash = ngx_murmur_hash2(hash_value.data, hash_value.len);
r->upstream->peer.get = ngx_http_upstream_get_chash_peer;
r->upstream->peer.free = ngx_http_upstream_free_chash_peer;
r->upstream->peer.data = uchpd;
#if (NGX_HTTP_SSL)
r->upstream->peer.set_session = ngx_http_upstream_chash_set_peer_session;
r->upstream->peer.save_session = ngx_http_upstream_chash_save_peer_session;
#endif
return NGX_OK;
}
static ngx_int_t
ngx_http_upstream_init_consistent_hash_peer(ngx_http_request_t *r,
ngx_http_upstream_srv_conf_t *us)
{
ngx_str_t evaluated_key_to_hash;
ngx_http_upstream_consistent_hash_srv_conf_t *uchscf;
ngx_http_upstream_consistent_hash_peer_data_t *uchpd;
uchscf = ngx_http_conf_upstream_srv_conf(us,
ngx_http_upstream_consistent_hash_module);
if (uchscf == NULL) {
return NGX_ERROR;
}
uchpd = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_consistent_hash_peer_data_t));
if (uchpd == NULL) {
return NGX_ERROR;
}
r->upstream->peer.data = uchpd->peers;
uchpd->peers = us->peer.data;
if (ngx_http_script_run(r, &evaluated_key_to_hash,
uchscf->lengths->elts, 0, uchscf->values->elts) == NULL)
{
return NGX_ERROR;
}
uchpd->point =
ngx_crc32_long(evaluated_key_to_hash.data, evaluated_key_to_hash.len);
r->upstream->peer.free = ngx_http_upstream_free_consistent_hash_peer;
r->upstream->peer.get = ngx_http_upstream_get_consistent_hash_peer;
r->upstream->peer.data = uchpd;
return NGX_OK;
}
