From 52a91d3d487350ca7229b849153b193d75efab07 Mon Sep 17 00:00:00 2001 From: Emeric Brun Date: Thu, 31 Aug 2017 14:41:55 +0200 Subject: [PATCH] MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_' --- include/proto/backend.h | 41 +++++------ include/proto/queue.h | 2 +- include/proto/server.h | 4 +- include/types/server.h | 8 +-- src/backend.c | 20 +++--- src/checks.c | 32 ++++----- src/haproxy.c | 2 +- src/hlua.c | 4 +- src/lb_chash.c | 38 +++++------ src/lb_fas.c | 30 ++++---- src/lb_fwlc.c | 32 ++++----- src/lb_fwrr.c | 58 ++++++++-------- src/lb_map.c | 16 ++--- src/proto_http.c | 4 +- src/proxy.c | 2 +- src/queue.c | 6 +- src/server.c | 148 ++++++++++++++++++++-------------------- src/stats.c | 32 ++++----- src/stream.c | 6 +- 19 files changed, 244 insertions(+), 241 deletions(-) diff --git a/include/proto/backend.h b/include/proto/backend.h index 430a6a13e..69ee31c78 100644 --- a/include/proto/backend.h +++ b/include/proto/backend.h @@ -63,18 +63,19 @@ static void inline be_set_sess_last(struct proxy *be) be->be_counters.last_sess = now.tv_sec; } -/* This function returns non-zero if the designated server is usable for LB - * according to its current weight and current state. Otherwise it returns 0. +/* This function returns non-zero if the designated server will be + * usable for LB according to pending weight and state. + * Otherwise it returns 0. */ -static inline int srv_is_usable(const struct server *srv) +static inline int srv_willbe_usable(const struct server *srv) { - enum srv_state state = srv->state; + enum srv_state state = srv->next_state; - if (!srv->eweight) + if (!srv->next_eweight) return 0; - if (srv->admin & SRV_ADMF_MAINT) + if (srv->next_admin & SRV_ADMF_MAINT) return 0; - if (srv->admin & SRV_ADMF_DRAIN) + if (srv->next_admin & SRV_ADMF_DRAIN) return 0; switch (state) { case SRV_ST_STARTING: @@ -88,17 +89,17 @@ static inline int srv_is_usable(const struct server *srv) } /* This function returns non-zero if the designated server was usable for LB - * according to its current weight and previous state. Otherwise it returns 0. + * according to its current weight and state. Otherwise it returns 0. */ -static inline int srv_was_usable(const struct server *srv) +static inline int srv_currently_usable(const struct server *srv) { - enum srv_state state = srv->prev_state; + enum srv_state state = srv->cur_state; - if (!srv->prev_eweight) + if (!srv->cur_eweight) return 0; - if (srv->prev_admin & SRV_ADMF_MAINT) + if (srv->cur_admin & SRV_ADMF_MAINT) return 0; - if (srv->prev_admin & SRV_ADMF_DRAIN) + if (srv->cur_admin & SRV_ADMF_DRAIN) return 0; switch (state) { case SRV_ST_STARTING: @@ -111,14 +112,14 @@ static inline int srv_was_usable(const struct server *srv) return 0; } -/* This function commits the current server state and weight onto the previous +/* This function commits the next server state and weight onto the current * ones in order to detect future changes. */ static inline void srv_lb_commit_status(struct server *srv) { - srv->prev_state = srv->state; - srv->prev_admin = srv->admin; - srv->prev_eweight = srv->eweight; + srv->cur_state = srv->next_state; + srv->cur_admin = srv->next_admin; + srv->cur_eweight = srv->next_eweight; } /* This function returns true when a server has experienced a change since last @@ -126,9 +127,9 @@ static inline void srv_lb_commit_status(struct server *srv) */ static inline int srv_lb_status_changed(const struct server *srv) { - return (srv->state != srv->prev_state || - srv->admin != srv->prev_admin || - srv->eweight != srv->prev_eweight); + return (srv->next_state != srv->cur_state || + srv->next_admin != srv->cur_admin || + srv->next_eweight != srv->cur_eweight); } /* sends a log message when a backend goes down, and also sets last diff --git a/include/proto/queue.h b/include/proto/queue.h index 81b1ddaf2..19212d4a5 100644 --- a/include/proto/queue.h +++ b/include/proto/queue.h @@ -54,7 +54,7 @@ static inline int server_has_room(const struct server *s) { * for and if/else usage. */ static inline int may_dequeue_tasks(const struct server *s, const struct proxy *p) { - return (s && (s->nbpend || (p->nbpend && srv_is_usable(s))) && + return (s && (s->nbpend || (p->nbpend && srv_currently_usable(s))) && (!s->maxconn || s->cur_sess < srv_dynamic_maxconn(s))); } diff --git a/include/proto/server.h b/include/proto/server.h index 666377028..0b238a5c7 100644 --- a/include/proto/server.h +++ b/include/proto/server.h @@ -103,7 +103,7 @@ static inline unsigned int server_throttle_rate(struct server *sv) if (!sv->uweight) return 100; - return (100U * px->lbprm.wmult * sv->eweight + px->lbprm.wdiv - 1) / (px->lbprm.wdiv * sv->uweight); + return (100U * px->lbprm.wmult * sv->cur_eweight + px->lbprm.wdiv - 1) / (px->lbprm.wdiv * sv->uweight); } /* @@ -134,7 +134,7 @@ const char *server_parse_maxconn_change_request(struct server *sv, */ static inline int server_is_draining(const struct server *s) { - return !s->uweight || (s->admin & SRV_ADMF_DRAIN); + return !s->uweight || (s->cur_admin & SRV_ADMF_DRAIN); } /* Shutdown all connections of a server. The caller must pass a termination diff --git a/include/types/server.h b/include/types/server.h index 77263dbbe..75349d736 100644 --- a/include/types/server.h +++ b/include/types/server.h @@ -186,8 +186,8 @@ struct tree_occ { struct server { enum obj_type obj_type; /* object type == OBJ_TYPE_SERVER */ - enum srv_state state, prev_state; /* server state among SRV_ST_* */ - enum srv_admin admin, prev_admin; /* server maintenance status : SRV_ADMF_* */ + enum srv_state next_state, cur_state; /* server state among SRV_ST_* */ + enum srv_admin next_admin, cur_admin; /* server maintenance status : SRV_ADMF_* */ unsigned char pp_opts; /* proxy protocol options (SRV_PP_*) */ unsigned int flags; /* server flags (SRV_F_*) */ struct server *next; @@ -226,9 +226,9 @@ struct server { int slowstart; /* slowstart time in seconds (ms in the conf) */ char *id; /* just for identification */ - unsigned iweight,uweight, eweight; /* initial weight, user-specified weight, and effective weight */ + unsigned iweight,uweight, cur_eweight; /* initial weight, user-specified weight, and effective weight */ unsigned wscore; /* weight score, used during srv map computation */ - unsigned prev_eweight; /* eweight before last change */ + unsigned next_eweight; /* next pending eweight to commit */ unsigned rweight; /* remainer of weight in the current LB tree */ unsigned cumulative_weight; /* weight of servers prior to this one in the same group, for chash balancing */ unsigned npos, lpos; /* next and last positions in the LB tree */ diff --git a/src/backend.c b/src/backend.c index 1dacda2d6..52adab009 100644 --- a/src/backend.c +++ b/src/backend.c @@ -97,6 +97,8 @@ static unsigned int gen_hash(const struct proxy* px, const char* key, unsigned l * This function also recomputes the total active and backup weights. However, * it does not update tot_weight nor tot_used. Use update_backend_weight() for * this. + * This functions is designed to be called before server's weight and state + * commit so it uses 'next' weight and states values. */ void recount_servers(struct proxy *px) { @@ -106,7 +108,7 @@ void recount_servers(struct proxy *px) px->lbprm.tot_wact = px->lbprm.tot_wbck = 0; px->lbprm.fbck = NULL; for (srv = px->srv; srv != NULL; srv = srv->next) { - if (!srv_is_usable(srv)) + if (!srv_willbe_usable(srv)) continue; if (srv->flags & SRV_F_BACKUP) { @@ -115,11 +117,11 @@ void recount_servers(struct proxy *px) px->lbprm.fbck = srv; px->srv_bck++; srv->cumulative_weight = px->lbprm.tot_wbck; - px->lbprm.tot_wbck += srv->eweight; + px->lbprm.tot_wbck += srv->next_eweight; } else { px->srv_act++; srv->cumulative_weight = px->lbprm.tot_wact; - px->lbprm.tot_wact += srv->eweight; + px->lbprm.tot_wact += srv->next_eweight; } } } @@ -136,7 +138,7 @@ void update_backend_weight(struct proxy *px) } else if (px->lbprm.fbck) { /* use only the first backup server */ - px->lbprm.tot_weight = px->lbprm.fbck->eweight; + px->lbprm.tot_weight = px->lbprm.fbck->next_eweight; px->lbprm.tot_used = 1; } else { @@ -567,7 +569,7 @@ int assign_server(struct stream *s) (!s->be->max_ka_queue || server_has_room(__objt_server(conn->target)) || (__objt_server(conn->target)->nbpend + 1) < s->be->max_ka_queue))) && - srv_is_usable(__objt_server(conn->target))) { + srv_currently_usable(__objt_server(conn->target))) { /* This stream was relying on a server in a previous request * and the proxy has "option prefer-last-server" set * and balance algorithm dont tell us to do otherwise, so @@ -1387,7 +1389,7 @@ int tcp_persist_rdp_cookie(struct stream *s, struct channel *req, int an_bit) if (srv->addr.ss_family == AF_INET && port == srv->svc_port && addr == ((struct sockaddr_in *)&srv->addr)->sin_addr.s_addr) { - if ((srv->state != SRV_ST_STOPPED) || (px->options & PR_O_PERSIST)) { + if ((srv->cur_state != SRV_ST_STOPPED) || (px->options & PR_O_PERSIST)) { /* we found the server and it is usable */ s->flags |= SF_DIRECT | SF_ASSIGNED; s->target = &srv->obj_type; @@ -1631,8 +1633,8 @@ smp_fetch_srv_is_up(const struct arg *args, struct sample *smp, const char *kw, smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_BOOL; - if (!(srv->admin & SRV_ADMF_MAINT) && - (!(srv->check.state & CHK_ST_CONFIGURED) || (srv->state != SRV_ST_STOPPED))) + if (!(srv->cur_admin & SRV_ADMF_MAINT) && + (!(srv->check.state & CHK_ST_CONFIGURED) || (srv->cur_state != SRV_ST_STOPPED))) smp->data.u.sint = 1; else smp->data.u.sint = 0; @@ -1653,7 +1655,7 @@ smp_fetch_connslots(const struct arg *args, struct sample *smp, const char *kw, smp->data.u.sint = 0; for (iterator = args->data.prx->srv; iterator; iterator = iterator->next) { - if (iterator->state == SRV_ST_STOPPED) + if (iterator->cur_state == SRV_ST_STOPPED) continue; if (iterator->maxconn == 0 || iterator->maxqueue == 0) { diff --git a/src/checks.c b/src/checks.c index ba783085c..c2746001d 100644 --- a/src/checks.c +++ b/src/checks.c @@ -359,10 +359,10 @@ static void check_notify_success(struct check *check) { struct server *s = check->server; - if (s->admin & SRV_ADMF_MAINT) + if (s->next_admin & SRV_ADMF_MAINT) return; - if (s->track && s->track->state == SRV_ST_STOPPED) + if (s->track && s->track->next_state == SRV_ST_STOPPED) return; if ((s->check.state & CHK_ST_ENABLED) && (s->check.health < s->check.rise)) @@ -371,7 +371,7 @@ static void check_notify_success(struct check *check) if ((s->agent.state & CHK_ST_ENABLED) && (s->agent.health < s->agent.rise)) return; - if ((check->state & CHK_ST_AGENT) && s->state == SRV_ST_STOPPING) + if ((check->state & CHK_ST_AGENT) && s->next_state == SRV_ST_STOPPING) return; srv_set_running(s, (!s->track && !(s->proxy->options2 & PR_O2_LOGHCHKS)) ? check_reason_string(check) : NULL); @@ -387,13 +387,13 @@ static void check_notify_stopping(struct check *check) { struct server *s = check->server; - if (s->admin & SRV_ADMF_MAINT) + if (s->next_admin & SRV_ADMF_MAINT) return; if (check->state & CHK_ST_AGENT) return; - if (s->track && s->track->state == SRV_ST_STOPPED) + if (s->track && s->track->next_state == SRV_ST_STOPPED) return; if ((s->check.state & CHK_ST_ENABLED) && (s->check.health < s->check.rise)) @@ -506,13 +506,13 @@ static int httpchk_build_status_header(struct server *s, char *buffer, int size) if (!(s->check.state & CHK_ST_ENABLED)) sv_state = 6; - else if (s->state != SRV_ST_STOPPED) { + else if (s->cur_state != SRV_ST_STOPPED) { if (s->check.health == s->check.rise + s->check.fall - 1) sv_state = 3; /* UP */ else sv_state = 2; /* going down */ - if (s->state == SRV_ST_STOPPING) + if (s->cur_state == SRV_ST_STOPPING) sv_state += 2; } else { if (s->check.health) @@ -523,8 +523,8 @@ static int httpchk_build_status_header(struct server *s, char *buffer, int size) hlen += snprintf(buffer + hlen, size - hlen, srv_hlt_st[sv_state], - (s->state != SRV_ST_STOPPED) ? (s->check.health - s->check.rise + 1) : (s->check.health), - (s->state != SRV_ST_STOPPED) ? (s->check.fall) : (s->check.rise)); + (s->cur_state != SRV_ST_STOPPED) ? (s->check.health - s->check.rise + 1) : (s->check.health), + (s->cur_state != SRV_ST_STOPPED) ? (s->check.fall) : (s->check.rise)); addr_to_str(&s->addr, addr, sizeof(addr)); if (s->addr.ss_family == AF_INET || s->addr.ss_family == AF_INET6) @@ -535,12 +535,12 @@ static int httpchk_build_status_header(struct server *s, char *buffer, int size) hlen += snprintf(buffer + hlen, size - hlen, "; address=%s; port=%s; name=%s/%s; node=%s; weight=%d/%d; scur=%d/%d; qcur=%d", addr, port, s->proxy->id, s->id, global.node, - (s->eweight * s->proxy->lbprm.wmult + s->proxy->lbprm.wdiv - 1) / s->proxy->lbprm.wdiv, + (s->cur_eweight * s->proxy->lbprm.wmult + s->proxy->lbprm.wdiv - 1) / s->proxy->lbprm.wdiv, (s->proxy->lbprm.tot_weight * s->proxy->lbprm.wmult + s->proxy->lbprm.wdiv - 1) / s->proxy->lbprm.wdiv, s->cur_sess, s->proxy->beconn - s->proxy->nbpend, s->nbpend); - if ((s->state == SRV_ST_STARTING) && + if ((s->cur_state == SRV_ST_STARTING) && now.tv_sec < s->last_change + s->slowstart && now.tv_sec >= s->last_change) { ratio = MAX(1, 100 * (now.tv_sec - s->last_change) / s->slowstart); @@ -879,7 +879,7 @@ static void event_srv_chk_r(struct connection *conn) desc = ltrim(check->bi->data + 12, ' '); if ((s->proxy->options & PR_O_DISABLE404) && - (s->state != SRV_ST_STOPPED) && (check->code == 404)) { + (s->next_state != SRV_ST_STOPPED) && (check->code == 404)) { /* 404 may be accepted as "stopping" only if the server was up */ cut_crlf(desc); set_server_check_status(check, HCHK_STATUS_L7OKCD, desc); @@ -1427,8 +1427,8 @@ static struct task *server_warmup(struct task *t) /* by default, plan on stopping the task */ t->expire = TICK_ETERNITY; - if ((s->admin & SRV_ADMF_MAINT) || - (s->state != SRV_ST_STARTING)) + if ((s->next_admin & SRV_ADMF_MAINT) || + (s->next_state != SRV_ST_STARTING)) return t; /* recalculate the weights and update the state */ @@ -1440,7 +1440,7 @@ static struct task *server_warmup(struct task *t) /* get back there in 1 second or 1/20th of the slowstart interval, * whichever is greater, resulting in small 5% steps. */ - if (s->state == SRV_ST_STARTING) + if (s->next_state == SRV_ST_STARTING) t->expire = tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20))); return t; } @@ -2276,7 +2276,7 @@ static int start_checks() t->process = server_warmup; t->context = s; /* server can be in this state only because of */ - if (s->state == SRV_ST_STARTING) + if (s->next_state == SRV_ST_STARTING) task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, (now.tv_sec - s->last_change)) / 20))); } diff --git a/src/haproxy.c b/src/haproxy.c index fc99225c0..2fa00a4c9 100644 --- a/src/haproxy.c +++ b/src/haproxy.c @@ -732,7 +732,7 @@ static void sig_dump_state(struct sig_handler *sh) chunk_printf(&trash, "SIGHUP: Server %s/%s is %s. Conn: %d act, %d pend, %lld tot.", p->id, s->id, - (s->state != SRV_ST_STOPPED) ? "UP" : "DOWN", + (s->cur_state != SRV_ST_STOPPED) ? "UP" : "DOWN", s->cur_sess, s->nbpend, s->counters.cum_sess); Warning("%s\n", trash.str); send_log(p, LOG_NOTICE, "%s\n", trash.str); diff --git a/src/hlua.c b/src/hlua.c index 594d880ed..24e04f20d 100644 --- a/src/hlua.c +++ b/src/hlua.c @@ -7625,7 +7625,7 @@ void hlua_init(void) LIST_INIT(&socket_tcp.priv_conns); LIST_INIT(&socket_tcp.idle_conns); LIST_INIT(&socket_tcp.safe_conns); - socket_tcp.state = SRV_ST_RUNNING; /* early server setup */ + socket_tcp.next_state = SRV_ST_RUNNING; /* early server setup */ socket_tcp.last_change = 0; socket_tcp.id = "LUA-TCP-CONN"; socket_tcp.check.state &= ~CHK_ST_ENABLED; /* Disable health checks. */ @@ -7671,7 +7671,7 @@ void hlua_init(void) LIST_INIT(&socket_ssl.priv_conns); LIST_INIT(&socket_ssl.idle_conns); LIST_INIT(&socket_ssl.safe_conns); - socket_ssl.state = SRV_ST_RUNNING; /* early server setup */ + socket_ssl.next_state = SRV_ST_RUNNING; /* early server setup */ socket_ssl.last_change = 0; socket_ssl.id = "LUA-SSL-CONN"; socket_ssl.check.state &= ~CHK_ST_ENABLED; /* Disable health checks. */ diff --git a/src/lb_chash.c b/src/lb_chash.c index 2394baa12..82124bc27 100644 --- a/src/lb_chash.c +++ b/src/lb_chash.c @@ -69,7 +69,7 @@ static inline void chash_dequeue_srv(struct server *s) */ static inline void chash_queue_dequeue_srv(struct server *s) { - while (s->lb_nodes_now > s->eweight) { + while (s->lb_nodes_now > s->next_eweight) { if (s->lb_nodes_now >= s->lb_nodes_tot) // should always be false anyway s->lb_nodes_now = s->lb_nodes_tot; s->lb_nodes_now--; @@ -78,7 +78,7 @@ static inline void chash_queue_dequeue_srv(struct server *s) eb32_delete(&s->lb_nodes[s->lb_nodes_now].node); } - while (s->lb_nodes_now < s->eweight) { + while (s->lb_nodes_now < s->next_eweight) { if (s->lb_nodes_now >= s->lb_nodes_tot) // should always be false anyway break; if (s->proxy->lbprm.chash.last == &s->lb_nodes[s->lb_nodes_now].node) @@ -101,15 +101,15 @@ static void chash_set_server_status_down(struct server *srv) if (!srv_lb_status_changed(srv)) return; - if (srv_is_usable(srv)) + if (srv_willbe_usable(srv)) goto out_update_state; - if (!srv_was_usable(srv)) + if (!srv_currently_usable(srv)) /* server was already down */ goto out_update_backend; if (srv->flags & SRV_F_BACKUP) { - p->lbprm.tot_wbck -= srv->prev_eweight; + p->lbprm.tot_wbck -= srv->cur_eweight; p->srv_bck--; if (srv == p->lbprm.fbck) { @@ -121,11 +121,11 @@ static void chash_set_server_status_down(struct server *srv) srv2 = srv2->next; } while (srv2 && !((srv2->flags & SRV_F_BACKUP) && - srv_is_usable(srv2))); + srv_willbe_usable(srv2))); p->lbprm.fbck = srv2; } } else { - p->lbprm.tot_wact -= srv->prev_eweight; + p->lbprm.tot_wact -= srv->cur_eweight; p->srv_act--; } @@ -152,15 +152,15 @@ static void chash_set_server_status_up(struct server *srv) if (!srv_lb_status_changed(srv)) return; - if (!srv_is_usable(srv)) + if (!srv_willbe_usable(srv)) goto out_update_state; - if (srv_was_usable(srv)) + if (srv_currently_usable(srv)) /* server was already up */ goto out_update_backend; if (srv->flags & SRV_F_BACKUP) { - p->lbprm.tot_wbck += srv->eweight; + p->lbprm.tot_wbck += srv->next_eweight; p->srv_bck++; if (!(p->options & PR_O_USE_ALL_BK)) { @@ -180,7 +180,7 @@ static void chash_set_server_status_up(struct server *srv) } } } else { - p->lbprm.tot_wact += srv->eweight; + p->lbprm.tot_wact += srv->next_eweight; p->srv_act++; } @@ -213,8 +213,8 @@ static void chash_update_server_weight(struct server *srv) * possibly a new tree for this server. */ - old_state = srv_was_usable(srv); - new_state = srv_is_usable(srv); + old_state = srv_currently_usable(srv); + new_state = srv_willbe_usable(srv); if (!old_state && !new_state) { srv_lb_commit_status(srv); @@ -233,9 +233,9 @@ static void chash_update_server_weight(struct server *srv) chash_queue_dequeue_srv(srv); if (srv->flags & SRV_F_BACKUP) - p->lbprm.tot_wbck += srv->eweight - srv->prev_eweight; + p->lbprm.tot_wbck += srv->next_eweight - srv->cur_eweight; else - p->lbprm.tot_wact += srv->eweight - srv->prev_eweight; + p->lbprm.tot_wact += srv->next_eweight - srv->cur_eweight; update_backend_weight(p); srv_lb_commit_status(srv); @@ -256,10 +256,10 @@ int chash_server_is_eligible(struct server *s) unsigned remainder = tot_slots % s->proxy->lbprm.tot_weight; /* Allocate a whole number of slots per weight unit... */ - unsigned slots = s->eweight * slots_per_weight; + unsigned slots = s->cur_eweight * slots_per_weight; /* And then distribute the rest among servers proportionally to their weight. */ - slots += ((s->cumulative_weight + s->eweight) * remainder) / s->proxy->lbprm.tot_weight + slots += ((s->cumulative_weight + s->cur_eweight) * remainder) / s->proxy->lbprm.tot_weight - (s->cumulative_weight * remainder) / s->proxy->lbprm.tot_weight; /* But never leave a server with 0. */ @@ -418,7 +418,7 @@ void chash_init_server_tree(struct proxy *p) p->lbprm.wdiv = BE_WEIGHT_SCALE; for (srv = p->srv; srv; srv = srv->next) { - srv->eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult; + srv->next_eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult; srv_lb_commit_status(srv); } @@ -441,7 +441,7 @@ void chash_init_server_tree(struct proxy *p) srv->lb_nodes[node].node.key = full_hash(srv->puid * SRV_EWGHT_RANGE + node); } - if (srv_is_usable(srv)) + if (srv_currently_usable(srv)) chash_queue_dequeue_srv(srv); } } diff --git a/src/lb_fas.c b/src/lb_fas.c index 6027dac1f..f8e739b12 100644 --- a/src/lb_fas.c +++ b/src/lb_fas.c @@ -80,15 +80,15 @@ static void fas_set_server_status_down(struct server *srv) if (!srv_lb_status_changed(srv)) return; - if (srv_is_usable(srv)) + if (srv_willbe_usable(srv)) goto out_update_state; - if (!srv_was_usable(srv)) + if (!srv_currently_usable(srv)) /* server was already down */ goto out_update_backend; if (srv->flags & SRV_F_BACKUP) { - p->lbprm.tot_wbck -= srv->prev_eweight; + p->lbprm.tot_wbck -= srv->cur_eweight; p->srv_bck--; if (srv == p->lbprm.fbck) { @@ -100,11 +100,11 @@ static void fas_set_server_status_down(struct server *srv) srv2 = srv2->next; } while (srv2 && !((srv2->flags & SRV_F_BACKUP) && - srv_is_usable(srv2))); + srv_willbe_usable(srv2))); p->lbprm.fbck = srv2; } } else { - p->lbprm.tot_wact -= srv->prev_eweight; + p->lbprm.tot_wact -= srv->cur_eweight; p->srv_act--; } @@ -132,16 +132,16 @@ static void fas_set_server_status_up(struct server *srv) if (!srv_lb_status_changed(srv)) return; - if (!srv_is_usable(srv)) + if (!srv_willbe_usable(srv)) goto out_update_state; - if (srv_was_usable(srv)) + if (srv_currently_usable(srv)) /* server was already up */ goto out_update_backend; if (srv->flags & SRV_F_BACKUP) { srv->lb_tree = &p->lbprm.fas.bck; - p->lbprm.tot_wbck += srv->eweight; + p->lbprm.tot_wbck += srv->next_eweight; p->srv_bck++; if (!(p->options & PR_O_USE_ALL_BK)) { @@ -162,7 +162,7 @@ static void fas_set_server_status_up(struct server *srv) } } else { srv->lb_tree = &p->lbprm.fas.act; - p->lbprm.tot_wact += srv->eweight; + p->lbprm.tot_wact += srv->next_eweight; p->srv_act++; } @@ -195,8 +195,8 @@ static void fas_update_server_weight(struct server *srv) * possibly a new tree for this server. */ - old_state = srv_was_usable(srv); - new_state = srv_is_usable(srv); + old_state = srv_currently_usable(srv); + new_state = srv_willbe_usable(srv); if (!old_state && !new_state) { srv_lb_commit_status(srv); @@ -215,10 +215,10 @@ static void fas_update_server_weight(struct server *srv) fas_dequeue_srv(srv); if (srv->flags & SRV_F_BACKUP) { - p->lbprm.tot_wbck += srv->eweight - srv->prev_eweight; + p->lbprm.tot_wbck += srv->next_eweight - srv->cur_eweight; srv->lb_tree = &p->lbprm.fas.bck; } else { - p->lbprm.tot_wact += srv->eweight - srv->prev_eweight; + p->lbprm.tot_wact += srv->next_eweight - srv->cur_eweight; srv->lb_tree = &p->lbprm.fas.act; } @@ -245,7 +245,7 @@ void fas_init_server_tree(struct proxy *p) p->lbprm.wdiv = BE_WEIGHT_SCALE; for (srv = p->srv; srv; srv = srv->next) { - srv->eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult; + srv->next_eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult; srv_lb_commit_status(srv); } @@ -257,7 +257,7 @@ void fas_init_server_tree(struct proxy *p) /* queue active and backup servers in two distinct groups */ for (srv = p->srv; srv; srv = srv->next) { - if (!srv_is_usable(srv)) + if (!srv_currently_usable(srv)) continue; srv->lb_tree = (srv->flags & SRV_F_BACKUP) ? &p->lbprm.fas.bck : &p->lbprm.fas.act; fas_queue_srv(srv); diff --git a/src/lb_fwlc.c b/src/lb_fwlc.c index 49be24fc5..589031236 100644 --- a/src/lb_fwlc.c +++ b/src/lb_fwlc.c @@ -43,7 +43,7 @@ static inline void fwlc_dequeue_srv(struct server *s) */ static inline void fwlc_queue_srv(struct server *s) { - s->lb_node.key = s->served * SRV_EWGHT_MAX / s->eweight; + s->lb_node.key = s->served * SRV_EWGHT_MAX / s->next_eweight; eb32_insert(s->lb_tree, &s->lb_node); } @@ -72,15 +72,15 @@ static void fwlc_set_server_status_down(struct server *srv) if (!srv_lb_status_changed(srv)) return; - if (srv_is_usable(srv)) + if (srv_willbe_usable(srv)) goto out_update_state; - if (!srv_was_usable(srv)) + if (!srv_currently_usable(srv)) /* server was already down */ goto out_update_backend; if (srv->flags & SRV_F_BACKUP) { - p->lbprm.tot_wbck -= srv->prev_eweight; + p->lbprm.tot_wbck -= srv->cur_eweight; p->srv_bck--; if (srv == p->lbprm.fbck) { @@ -92,11 +92,11 @@ static void fwlc_set_server_status_down(struct server *srv) srv2 = srv2->next; } while (srv2 && !((srv2->flags & SRV_F_BACKUP) && - srv_is_usable(srv2))); + srv_willbe_usable(srv2))); p->lbprm.fbck = srv2; } } else { - p->lbprm.tot_wact -= srv->prev_eweight; + p->lbprm.tot_wact -= srv->cur_eweight; p->srv_act--; } @@ -124,16 +124,16 @@ static void fwlc_set_server_status_up(struct server *srv) if (!srv_lb_status_changed(srv)) return; - if (!srv_is_usable(srv)) + if (!srv_willbe_usable(srv)) goto out_update_state; - if (srv_was_usable(srv)) + if (srv_currently_usable(srv)) /* server was already up */ goto out_update_backend; if (srv->flags & SRV_F_BACKUP) { srv->lb_tree = &p->lbprm.fwlc.bck; - p->lbprm.tot_wbck += srv->eweight; + p->lbprm.tot_wbck += srv->next_eweight; p->srv_bck++; if (!(p->options & PR_O_USE_ALL_BK)) { @@ -154,7 +154,7 @@ static void fwlc_set_server_status_up(struct server *srv) } } else { srv->lb_tree = &p->lbprm.fwlc.act; - p->lbprm.tot_wact += srv->eweight; + p->lbprm.tot_wact += srv->next_eweight; p->srv_act++; } @@ -187,8 +187,8 @@ static void fwlc_update_server_weight(struct server *srv) * possibly a new tree for this server. */ - old_state = srv_was_usable(srv); - new_state = srv_is_usable(srv); + old_state = srv_currently_usable(srv); + new_state = srv_willbe_usable(srv); if (!old_state && !new_state) { srv_lb_commit_status(srv); @@ -207,10 +207,10 @@ static void fwlc_update_server_weight(struct server *srv) fwlc_dequeue_srv(srv); if (srv->flags & SRV_F_BACKUP) { - p->lbprm.tot_wbck += srv->eweight - srv->prev_eweight; + p->lbprm.tot_wbck += srv->next_eweight - srv->cur_eweight; srv->lb_tree = &p->lbprm.fwlc.bck; } else { - p->lbprm.tot_wact += srv->eweight - srv->prev_eweight; + p->lbprm.tot_wact += srv->next_eweight - srv->cur_eweight; srv->lb_tree = &p->lbprm.fwlc.act; } @@ -237,7 +237,7 @@ void fwlc_init_server_tree(struct proxy *p) p->lbprm.wdiv = BE_WEIGHT_SCALE; for (srv = p->srv; srv; srv = srv->next) { - srv->eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult; + srv->next_eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult; srv_lb_commit_status(srv); } @@ -249,7 +249,7 @@ void fwlc_init_server_tree(struct proxy *p) /* queue active and backup servers in two distinct groups */ for (srv = p->srv; srv; srv = srv->next) { - if (!srv_is_usable(srv)) + if (!srv_currently_usable(srv)) continue; srv->lb_tree = (srv->flags & SRV_F_BACKUP) ? &p->lbprm.fwlc.bck : &p->lbprm.fwlc.act; fwlc_queue_srv(srv); diff --git a/src/lb_fwrr.c b/src/lb_fwrr.c index 78be7ff80..e273a279a 100644 --- a/src/lb_fwrr.c +++ b/src/lb_fwrr.c @@ -42,15 +42,15 @@ static void fwrr_set_server_status_down(struct server *srv) if (!srv_lb_status_changed(srv)) return; - if (srv_is_usable(srv)) + if (srv_willbe_usable(srv)) goto out_update_state; - if (!srv_was_usable(srv)) + if (!srv_currently_usable(srv)) /* server was already down */ goto out_update_backend; grp = (srv->flags & SRV_F_BACKUP) ? &p->lbprm.fwrr.bck : &p->lbprm.fwrr.act; - grp->next_weight -= srv->prev_eweight; + grp->next_weight -= srv->cur_eweight; if (srv->flags & SRV_F_BACKUP) { p->lbprm.tot_wbck = p->lbprm.fwrr.bck.next_weight; @@ -65,7 +65,7 @@ static void fwrr_set_server_status_down(struct server *srv) srv2 = srv2->next; } while (srv2 && !((srv2->flags & SRV_F_BACKUP) && - srv_is_usable(srv2))); + srv_willbe_usable(srv2))); p->lbprm.fbck = srv2; } } else { @@ -98,15 +98,15 @@ static void fwrr_set_server_status_up(struct server *srv) if (!srv_lb_status_changed(srv)) return; - if (!srv_is_usable(srv)) + if (!srv_willbe_usable(srv)) goto out_update_state; - if (srv_was_usable(srv)) + if (srv_currently_usable(srv)) /* server was already up */ goto out_update_backend; grp = (srv->flags & SRV_F_BACKUP) ? &p->lbprm.fwrr.bck : &p->lbprm.fwrr.act; - grp->next_weight += srv->eweight; + grp->next_weight += srv->next_eweight; if (srv->flags & SRV_F_BACKUP) { p->lbprm.tot_wbck = p->lbprm.fwrr.bck.next_weight; @@ -135,7 +135,7 @@ static void fwrr_set_server_status_up(struct server *srv) /* note that eweight cannot be 0 here */ fwrr_get_srv(srv); - srv->npos = grp->curr_pos + (grp->next_weight + grp->curr_weight - grp->curr_pos) / srv->eweight; + srv->npos = grp->curr_pos + (grp->next_weight + grp->curr_weight - grp->curr_pos) / srv->next_eweight; fwrr_queue_srv(srv); out_update_backend: @@ -165,8 +165,8 @@ static void fwrr_update_server_weight(struct server *srv) * possibly a new tree for this server. */ - old_state = srv_was_usable(srv); - new_state = srv_is_usable(srv); + old_state = srv_currently_usable(srv); + new_state = srv_willbe_usable(srv); if (!old_state && !new_state) { srv_lb_commit_status(srv); @@ -182,7 +182,7 @@ static void fwrr_update_server_weight(struct server *srv) } grp = (srv->flags & SRV_F_BACKUP) ? &p->lbprm.fwrr.bck : &p->lbprm.fwrr.act; - grp->next_weight = grp->next_weight - srv->prev_eweight + srv->eweight; + grp->next_weight = grp->next_weight - srv->cur_eweight + srv->next_eweight; p->lbprm.tot_wact = p->lbprm.fwrr.act.next_weight; p->lbprm.tot_wbck = p->lbprm.fwrr.bck.next_weight; @@ -197,7 +197,7 @@ static void fwrr_update_server_weight(struct server *srv) */ fwrr_dequeue_srv(srv); fwrr_get_srv(srv); - srv->npos = grp->curr_pos + (grp->next_weight + grp->curr_weight - grp->curr_pos) / srv->eweight; + srv->npos = grp->curr_pos + (grp->next_weight + grp->curr_weight - grp->curr_pos) / srv->next_eweight; fwrr_queue_srv(srv); } else { /* The server is either active or in the next queue. If it's @@ -206,9 +206,9 @@ static void fwrr_update_server_weight(struct server *srv) */ fwrr_get_srv(srv); - if (srv->eweight > 0) { + if (srv->next_eweight > 0) { int prev_next = srv->npos; - int step = grp->next_weight / srv->eweight; + int step = grp->next_weight / srv->next_eweight; srv->npos = srv->lpos + step; srv->rweight = 0; @@ -245,7 +245,7 @@ static inline void fwrr_remove_from_tree(struct server *s) */ static inline void fwrr_queue_by_weight(struct eb_root *root, struct server *s) { - s->lb_node.key = SRV_EWGHT_MAX - s->eweight; + s->lb_node.key = SRV_EWGHT_MAX - s->next_eweight; eb32_insert(root, &s->lb_node); s->lb_tree = root; } @@ -265,7 +265,7 @@ void fwrr_init_server_groups(struct proxy *p) p->lbprm.wdiv = BE_WEIGHT_SCALE; for (srv = p->srv; srv; srv = srv->next) { - srv->eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult; + srv->next_eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult; srv_lb_commit_status(srv); } @@ -290,7 +290,7 @@ void fwrr_init_server_groups(struct proxy *p) /* queue active and backup servers in two distinct groups */ for (srv = p->srv; srv; srv = srv->next) { - if (!srv_is_usable(srv)) + if (!srv_currently_usable(srv)) continue; fwrr_queue_by_weight((srv->flags & SRV_F_BACKUP) ? p->lbprm.fwrr.bck.init : @@ -319,10 +319,10 @@ static void fwrr_queue_srv(struct server *s) /* Delay everything which does not fit into the window and everything * which does not fit into the theorical new window. */ - if (!srv_is_usable(s)) { + if (!srv_willbe_usable(s)) { fwrr_remove_from_tree(s); } - else if (s->eweight <= 0 || + else if (s->next_eweight <= 0 || s->npos >= 2 * grp->curr_weight || s->npos >= grp->curr_weight + grp->next_weight) { /* put into next tree, and readjust npos in case we could @@ -339,7 +339,7 @@ static void fwrr_queue_srv(struct server *s) * so we can use eb32_insert(). */ s->lb_node.key = SRV_UWGHT_RANGE * s->npos + - (unsigned)(SRV_EWGHT_MAX + s->rweight - s->eweight) / BE_WEIGHT_SCALE; + (unsigned)(SRV_EWGHT_MAX + s->rweight - s->next_eweight) / BE_WEIGHT_SCALE; eb32_insert(&grp->curr, &s->lb_node); s->lb_tree = &grp->curr; @@ -423,7 +423,7 @@ static struct server *fwrr_get_server_from_group(struct fwrr_group *grp) node = node2; s = eb32_entry(node, struct server, lb_node); fwrr_get_srv_init(s); - if (s->eweight == 0) /* FIXME: is it possible at all ? */ + if (s->cur_eweight == 0) /* FIXME: is it possible at all ? */ node = NULL; } } @@ -441,20 +441,20 @@ static inline void fwrr_update_position(struct fwrr_group *grp, struct server *s if (!s->npos) { /* first time ever for this server */ s->lpos = grp->curr_pos; - s->npos = grp->curr_pos + grp->next_weight / s->eweight; - s->rweight += grp->next_weight % s->eweight; + s->npos = grp->curr_pos + grp->next_weight / s->cur_eweight; + s->rweight += grp->next_weight % s->cur_eweight; - if (s->rweight >= s->eweight) { - s->rweight -= s->eweight; + if (s->rweight >= s->cur_eweight) { + s->rweight -= s->cur_eweight; s->npos++; } } else { s->lpos = s->npos; - s->npos += grp->next_weight / s->eweight; - s->rweight += grp->next_weight % s->eweight; + s->npos += grp->next_weight / s->cur_eweight; + s->rweight += grp->next_weight % s->cur_eweight; - if (s->rweight >= s->eweight) { - s->rweight -= s->eweight; + if (s->rweight >= s->cur_eweight) { + s->rweight -= s->cur_eweight; s->npos++; } } diff --git a/src/lb_map.c b/src/lb_map.c index 43d33c6f8..fef16ac2e 100644 --- a/src/lb_map.c +++ b/src/lb_map.c @@ -31,7 +31,7 @@ static void map_set_server_status_down(struct server *srv) if (!srv_lb_status_changed(srv)) return; - if (srv_is_usable(srv)) + if (srv_willbe_usable(srv)) goto out_update_state; /* FIXME: could be optimized since we know what changed */ @@ -50,7 +50,7 @@ static void map_set_server_status_up(struct server *srv) if (!srv_lb_status_changed(srv)) return; - if (!srv_is_usable(srv)) + if (!srv_willbe_usable(srv)) goto out_update_state; /* FIXME: could be optimized since we know what changed */ @@ -100,7 +100,7 @@ void recalc_server_map(struct proxy *px) best = NULL; for (cur = px->srv; cur; cur = cur->next) { if ((cur->flags & SRV_F_BACKUP) == flag && - srv_is_usable(cur)) { + srv_willbe_usable(cur)) { int v; /* If we are forced to return only one server, we don't want to @@ -113,7 +113,7 @@ void recalc_server_map(struct proxy *px) break; } - cur->wscore += cur->eweight; + cur->wscore += cur->next_eweight; v = (cur->wscore + tot) / tot; /* result between 0 and 3 */ if (best == NULL || v > max) { max = v; @@ -175,13 +175,13 @@ void init_server_map(struct proxy *p) act = bck = 0; for (srv = p->srv; srv; srv = srv->next) { - srv->eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult; - srv_lb_commit_status(srv); + srv->next_eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult; if (srv->flags & SRV_F_BACKUP) - bck += srv->eweight; + bck += srv->next_eweight; else - act += srv->eweight; + act += srv->next_eweight; + srv_lb_commit_status(srv); } /* this is the largest map we will ever need for this servers list */ diff --git a/src/proto_http.c b/src/proto_http.c index ffa2f2a05..7bdd19d03 100644 --- a/src/proto_http.c +++ b/src/proto_http.c @@ -7861,12 +7861,12 @@ void manage_client_side_cookies(struct stream *s, struct channel *req) while (srv) { if (srv->cookie && (srv->cklen == delim - val_beg) && !memcmp(val_beg, srv->cookie, delim - val_beg)) { - if ((srv->state != SRV_ST_STOPPED) || + if ((srv->cur_state != SRV_ST_STOPPED) || (s->be->options & PR_O_PERSIST) || (s->flags & SF_FORCE_PRST)) { /* we found the server and we can use it */ txn->flags &= ~TX_CK_MASK; - txn->flags |= (srv->state != SRV_ST_STOPPED) ? TX_CK_VALID : TX_CK_DOWN; + txn->flags |= (srv->cur_state != SRV_ST_STOPPED) ? TX_CK_VALID : TX_CK_DOWN; s->flags |= SF_DIRECT | SF_ASSIGNED; s->target = &srv->obj_type; break; diff --git a/src/proxy.c b/src/proxy.c index bd2031ee9..f9be03fad 100644 --- a/src/proxy.c +++ b/src/proxy.c @@ -1463,7 +1463,7 @@ static int dump_servers_state(struct stream_interface *si, struct chunk *buf) "\n", px->uuid, px->id, srv->puid, srv->id, srv_addr, - srv->state, srv->admin, srv->uweight, srv->iweight, (long int)srv_time_since_last_change, + srv->cur_state, srv->cur_admin, srv->uweight, srv->iweight, (long int)srv_time_since_last_change, srv->check.status, srv->check.result, srv->check.health, srv->check.state, srv->agent.state, bk_f_forced_id, srv_f_forced_id, srv->hostname ? srv->hostname : "-", srv->svc_port); if (bi_putchk(si_ic(si), &trash) == -1) { diff --git a/src/queue.c b/src/queue.c index bd0a137ec..302667aff 100644 --- a/src/queue.c +++ b/src/queue.c @@ -50,7 +50,7 @@ unsigned int srv_dynamic_maxconn(const struct server *s) else max = MAX(s->minconn, s->proxy->beconn * s->maxconn / s->proxy->fullconn); - if ((s->state == SRV_ST_STARTING) && + if ((s->cur_state == SRV_ST_STARTING) && now.tv_sec < s->last_change + s->slowstart && now.tv_sec >= s->last_change) { unsigned int ratio; @@ -107,7 +107,7 @@ static struct stream *pendconn_get_next_strm(struct server *srv, struct proxy *p ps = pendconn_from_srv(srv); pp = pendconn_from_px(px); /* we want to get the definitive pendconn in */ - if (!pp || !srv_is_usable(rsrv)) { + if (!pp || !srv_currently_usable(rsrv)) { if (!ps) return NULL; } else { @@ -226,7 +226,7 @@ int pendconn_grab_from_px(struct server *s) { int xferred; - if (!srv_is_usable(s)) + if (!srv_currently_usable(s)) return 0; for (xferred = 0; !s->maxconn || xferred < srv_dynamic_maxconn(s); xferred++) { diff --git a/src/server.c b/src/server.c index 917ed09a3..c80c98700 100644 --- a/src/server.c +++ b/src/server.c @@ -55,7 +55,7 @@ static struct srv_kw_list srv_keywords = { int srv_downtime(const struct server *s) { - if ((s->state != SRV_ST_STOPPED) && s->last_change < now.tv_sec) // ignore negative time + if ((s->cur_state != SRV_ST_STOPPED) && s->last_change < now.tv_sec) // ignore negative time return s->down_time; return now.tv_sec - s->last_change + s->down_time; @@ -76,7 +76,7 @@ int srv_getinter(const struct check *check) if ((check->state & CHK_ST_CONFIGURED) && (check->health == check->rise + check->fall - 1)) return check->inter; - if ((s->state == SRV_ST_STOPPED) && check->health == 0) + if ((s->next_state == SRV_ST_STOPPED) && check->health == 0) return (check->downinter)?(check->downinter):(check->inter); return (check->fastinter)?(check->fastinter):(check->inter); @@ -317,8 +317,8 @@ static int srv_parse_cookie(char **args, int *cur_arg, static int srv_parse_disabled(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err) { - newsrv->admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT; - newsrv->state = SRV_ST_STOPPED; + newsrv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT; + newsrv->next_state = SRV_ST_STOPPED; newsrv->check.state |= CHK_ST_PAUSED; newsrv->check.health = 0; return 0; @@ -328,8 +328,8 @@ static int srv_parse_disabled(char **args, int *cur_arg, static int srv_parse_enabled(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err) { - newsrv->admin &= ~SRV_ADMF_CMAINT & ~SRV_ADMF_FMAINT; - newsrv->state = SRV_ST_RUNNING; + newsrv->next_admin &= ~SRV_ADMF_CMAINT & ~SRV_ADMF_FMAINT; + newsrv->next_state = SRV_ST_RUNNING; newsrv->check.state &= ~CHK_ST_PAUSED; newsrv->check.health = newsrv->check.rise; return 0; @@ -793,7 +793,7 @@ void srv_append_status(struct chunk *msg, struct server *s, const char *reason, chunk_appendf(msg, " via %s/%s", s->track->proxy->id, s->track->id); if (xferred >= 0) { - if (s->state == SRV_ST_STOPPED) + if (s->next_state == SRV_ST_STOPPED) chunk_appendf(msg, ". %d active and %d backup servers left.%s" " %d sessions active, %d requeued, %d remaining in queue", s->proxy->srv_act, s->proxy->srv_bck, @@ -820,15 +820,15 @@ void srv_set_stopped(struct server *s, const char *reason) { struct server *srv; int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act; - int srv_was_stopping = (s->state == SRV_ST_STOPPING); + int srv_was_stopping = (s->next_state == SRV_ST_STOPPING); int log_level; int xferred; - if ((s->admin & SRV_ADMF_MAINT) || s->state == SRV_ST_STOPPED) + if ((s->next_admin & SRV_ADMF_MAINT) || s->next_state == SRV_ST_STOPPED) return; s->last_change = now.tv_sec; - s->state = SRV_ST_STOPPED; + s->next_state = SRV_ST_STOPPED; if (s->proxy->lbprm.set_server_status_down) s->proxy->lbprm.set_server_status_down(s); @@ -875,10 +875,10 @@ void srv_set_running(struct server *s, const char *reason) struct server *srv; int xferred; - if (s->admin & SRV_ADMF_MAINT) + if (s->next_admin & SRV_ADMF_MAINT) return; - if (s->state == SRV_ST_STARTING || s->state == SRV_ST_RUNNING) + if (s->next_state == SRV_ST_STARTING || s->next_state == SRV_ST_RUNNING) return; if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) { @@ -887,16 +887,16 @@ void srv_set_running(struct server *s, const char *reason) s->proxy->last_change = now.tv_sec; } - if (s->state == SRV_ST_STOPPED && s->last_change < now.tv_sec) // ignore negative times + if (s->next_state == SRV_ST_STOPPED && s->last_change < now.tv_sec) // ignore negative times s->down_time += now.tv_sec - s->last_change; s->last_change = now.tv_sec; - s->state = SRV_ST_STARTING; + s->next_state = SRV_ST_STARTING; if (s->slowstart > 0) task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20)))); else - s->state = SRV_ST_RUNNING; + s->next_state = SRV_ST_RUNNING; server_recalc_eweight(s); @@ -906,7 +906,7 @@ void srv_set_running(struct server *s, const char *reason) * on all backup servers. */ if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) && - !(s->flags & SRV_F_BACKUP) && s->eweight) + !(s->flags & SRV_F_BACKUP) && s->next_eweight) srv_shutdown_backup_streams(s->proxy, SF_ERR_UP); /* check if we can handle some connections queued at the proxy. We @@ -940,14 +940,14 @@ void srv_set_stopping(struct server *s, const char *reason) struct server *srv; int xferred; - if (s->admin & SRV_ADMF_MAINT) + if (s->next_admin & SRV_ADMF_MAINT) return; - if (s->state == SRV_ST_STOPPING) + if (s->next_state == SRV_ST_STOPPING) return; s->last_change = now.tv_sec; - s->state = SRV_ST_STOPPING; + s->next_state = SRV_ST_STOPPING; if (s->proxy->lbprm.set_server_status_down) s->proxy->lbprm.set_server_status_down(s); @@ -991,14 +991,14 @@ void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause return; /* stop going down as soon as we meet a server already in the same state */ - if (s->admin & mode) + if (s->next_admin & mode) return; - s->admin |= mode; + s->next_admin |= mode; /* stop going down if the equivalent flag was already present (forced or inherited) */ - if (((mode & SRV_ADMF_MAINT) && (s->admin & ~mode & SRV_ADMF_MAINT)) || - ((mode & SRV_ADMF_DRAIN) && (s->admin & ~mode & SRV_ADMF_DRAIN))) + if (((mode & SRV_ADMF_MAINT) && (s->next_admin & ~mode & SRV_ADMF_MAINT)) || + ((mode & SRV_ADMF_DRAIN) && (s->next_admin & ~mode & SRV_ADMF_DRAIN))) return; /* Maintenance must also disable health checks */ @@ -1008,7 +1008,7 @@ void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause check->health = 0; } - if (s->state == SRV_ST_STOPPED) { /* server was already down */ + if (s->next_state == SRV_ST_STOPPED) { /* server was already down */ chunk_printf(&trash, "%sServer %s/%s was DOWN and now enters maintenance%s%s%s", s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id, @@ -1022,12 +1022,12 @@ void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause } } else { /* server was still running */ - int srv_was_stopping = (s->state == SRV_ST_STOPPING) || (s->admin & SRV_ADMF_DRAIN); + int srv_was_stopping = (s->next_state == SRV_ST_STOPPING) || (s->next_admin & SRV_ADMF_DRAIN); int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act; check->health = 0; /* failure */ s->last_change = now.tv_sec; - s->state = SRV_ST_STOPPED; + s->next_state = SRV_ST_STOPPED; if (s->proxy->lbprm.set_server_status_down) s->proxy->lbprm.set_server_status_down(s); @@ -1061,7 +1061,7 @@ void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause } /* drain state is applied only if not yet in maint */ - if ((mode & SRV_ADMF_DRAIN) && !(s->admin & SRV_ADMF_MAINT)) { + if ((mode & SRV_ADMF_DRAIN) && !(s->next_admin & SRV_ADMF_MAINT)) { int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act; s->last_change = now.tv_sec; @@ -1115,12 +1115,12 @@ void srv_clr_admin_flag(struct server *s, enum srv_admin mode) return; /* stop going down as soon as we see the flag is not there anymore */ - if (!(s->admin & mode)) + if (!(s->next_admin & mode)) return; - s->admin &= ~mode; + s->next_admin &= ~mode; - if (s->admin & SRV_ADMF_MAINT) { + if (s->next_admin & SRV_ADMF_MAINT) { /* remaining in maintenance mode, let's inform precisely about the * situation. */ @@ -1180,7 +1180,7 @@ void srv_clr_admin_flag(struct server *s, enum srv_admin mode) check->health = check->rise; /* start OK but check immediately */ } - if ((!s->track || s->track->state != SRV_ST_STOPPED) && + if ((!s->track || s->track->next_state != SRV_ST_STOPPED) && (!(s->agent.state & CHK_ST_ENABLED) || (s->agent.health >= s->agent.rise)) && (!(s->check.state & CHK_ST_ENABLED) || (s->check.health >= s->check.rise))) { if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) { @@ -1193,14 +1193,14 @@ void srv_clr_admin_flag(struct server *s, enum srv_admin mode) s->down_time += now.tv_sec - s->last_change; s->last_change = now.tv_sec; - if (s->track && s->track->state == SRV_ST_STOPPING) - s->state = SRV_ST_STOPPING; + if (s->track && s->track->next_state == SRV_ST_STOPPING) + s->next_state = SRV_ST_STOPPING; else { - s->state = SRV_ST_STARTING; + s->next_state = SRV_ST_STARTING; if (s->slowstart > 0) task_schedule(s->warmup, tick_add(now_ms, MS_TO_TICKS(MAX(1000, s->slowstart / 20)))); else - s->state = SRV_ST_RUNNING; + s->next_state = SRV_ST_RUNNING; } server_recalc_eweight(s); @@ -1211,7 +1211,7 @@ void srv_clr_admin_flag(struct server *s, enum srv_admin mode) * on all backup servers. */ if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) && - !(s->flags & SRV_F_BACKUP) && s->eweight) + !(s->flags & SRV_F_BACKUP) && s->next_eweight) srv_shutdown_backup_streams(s->proxy, SF_ERR_UP); /* check if we can handle some connections queued at the proxy. We @@ -1225,30 +1225,30 @@ void srv_clr_admin_flag(struct server *s, enum srv_admin mode) "%sServer %s/%s is %s/%s (leaving forced maintenance)", s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id, - (s->state == SRV_ST_STOPPED) ? "DOWN" : "UP", - (s->admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY"); + (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP", + (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY"); } else if (mode & SRV_ADMF_RMAINT) { chunk_printf(&trash, "%sServer %s/%s ('%s') is %s/%s (resolves again)", s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id, s->hostname, - (s->state == SRV_ST_STOPPED) ? "DOWN" : "UP", - (s->admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY"); + (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP", + (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY"); } else { chunk_printf(&trash, "%sServer %s/%s is %s/%s (leaving maintenance)", s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id, - (s->state == SRV_ST_STOPPED) ? "DOWN" : "UP", - (s->admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY"); + (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP", + (s->next_admin & SRV_ADMF_DRAIN) ? "DRAIN" : "READY"); srv_append_status(&trash, s, NULL, xferred, 0); } Warning("%s.\n", trash.str); send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.str); } - else if ((mode & SRV_ADMF_DRAIN) && (s->admin & SRV_ADMF_DRAIN)) { + else if ((mode & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN)) { /* remaining in drain mode after removing one of its flags */ if (mode & SRV_ADMF_FDRAIN) { @@ -1288,14 +1288,14 @@ void srv_clr_admin_flag(struct server *s, enum srv_admin mode) "%sServer %s/%s is %s (leaving forced drain)", s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id, - (s->state == SRV_ST_STOPPED) ? "DOWN" : "UP"); + (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP"); } else { chunk_printf(&trash, "%sServer %s/%s is %s (leaving drain)", s->flags & SRV_F_BACKUP ? "Backup " : "", s->proxy->id, s->id, - (s->state == SRV_ST_STOPPED) ? "DOWN" : "UP"); + (s->next_state == SRV_ST_STOPPED) ? "DOWN" : "UP"); if (s->track) /* normally it's mandatory here */ chunk_appendf(&trash, " via %s/%s", s->track->proxy->id, s->track->id); @@ -1305,8 +1305,8 @@ void srv_clr_admin_flag(struct server *s, enum srv_admin mode) } /* stop going down if the equivalent flag is still present (forced or inherited) */ - if (((mode & SRV_ADMF_MAINT) && (s->admin & SRV_ADMF_MAINT)) || - ((mode & SRV_ADMF_DRAIN) && (s->admin & SRV_ADMF_DRAIN))) + if (((mode & SRV_ADMF_MAINT) && (s->next_admin & SRV_ADMF_MAINT)) || + ((mode & SRV_ADMF_DRAIN) && (s->next_admin & SRV_ADMF_DRAIN))) return; if (mode & SRV_ADMF_MAINT) @@ -1329,10 +1329,10 @@ static void srv_propagate_admin_state(struct server *srv) return; for (srv2 = srv->trackers; srv2; srv2 = srv2->tracknext) { - if (srv->admin & (SRV_ADMF_MAINT | SRV_ADMF_CMAINT)) + if (srv->next_admin & (SRV_ADMF_MAINT | SRV_ADMF_CMAINT)) srv_set_admin_flag(srv2, SRV_ADMF_IMAINT, NULL); - if (srv->admin & SRV_ADMF_DRAIN) + if (srv->next_admin & SRV_ADMF_DRAIN) srv_set_admin_flag(srv2, SRV_ADMF_IDRAIN, NULL); } } @@ -1405,24 +1405,24 @@ void server_recalc_eweight(struct server *sv) if (now.tv_sec < sv->last_change || now.tv_sec >= sv->last_change + sv->slowstart) { /* go to full throttle if the slowstart interval is reached */ - if (sv->state == SRV_ST_STARTING) - sv->state = SRV_ST_RUNNING; + if (sv->next_state == SRV_ST_STARTING) + sv->next_state = SRV_ST_RUNNING; } /* We must take care of not pushing the server to full throttle during slow starts. * It must also start immediately, at least at the minimal step when leaving maintenance. */ - if ((sv->state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN)) + if ((sv->next_state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN)) w = (px->lbprm.wdiv * (now.tv_sec - sv->last_change) + sv->slowstart) / sv->slowstart; else w = px->lbprm.wdiv; - sv->eweight = (sv->uweight * w + px->lbprm.wmult - 1) / px->lbprm.wmult; + sv->next_eweight = (sv->uweight * w + px->lbprm.wmult - 1) / px->lbprm.wmult; /* now propagate the status change to any LB algorithms */ if (px->lbprm.update_server_eweight) px->lbprm.update_server_eweight(sv); - else if (srv_is_usable(sv)) { + else if (srv_willbe_usable(sv)) { if (px->lbprm.set_server_status_up) px->lbprm.set_server_status_up(sv); } @@ -1791,9 +1791,9 @@ static void srv_settings_cpy(struct server *srv, struct server *src, int srv_tmp srv->check.fall = src->check.fall; /* Here we check if 'disabled' is the default server state */ - if (src->admin & (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT)) { - srv->admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT; - srv->state = SRV_ST_STOPPED; + if (src->next_admin & (SRV_ADMF_CMAINT | SRV_ADMF_FMAINT)) { + srv->next_admin |= SRV_ADMF_CMAINT | SRV_ADMF_FMAINT; + srv->next_state = SRV_ST_STOPPED; srv->check.state |= CHK_ST_PAUSED; srv->check.health = 0; } @@ -1840,7 +1840,7 @@ static struct server *new_server(struct proxy *proxy) LIST_INIT(&srv->idle_conns); LIST_INIT(&srv->safe_conns); - srv->state = SRV_ST_RUNNING; /* early server setup */ + srv->next_state = SRV_ST_RUNNING; /* early server setup */ srv->last_change = now.tv_sec; srv->check.status = HCHK_STATUS_INI; @@ -3115,7 +3115,7 @@ static void srv_update_state(struct server *srv, int version, char **params) srv_set_stopped(srv, "changed from server-state after a reload"); break; case SRV_ST_STARTING: - srv->state = srv_op_state; + srv->next_state = srv_op_state; break; case SRV_ST_STOPPING: srv->check.health = srv->check.rise + srv->check.fall - 1; @@ -3134,21 +3134,21 @@ static void srv_update_state(struct server *srv, int version, char **params) * state is different from new configuration state */ /* configuration has changed */ - if ((srv_admin_state & SRV_ADMF_CMAINT) != (srv->admin & SRV_ADMF_CMAINT)) { - if (srv->admin & SRV_ADMF_CMAINT) + if ((srv_admin_state & SRV_ADMF_CMAINT) != (srv->next_admin & SRV_ADMF_CMAINT)) { + if (srv->next_admin & SRV_ADMF_CMAINT) srv_adm_set_maint(srv); else srv_adm_set_ready(srv); } /* configuration is the same, let's compate old running state and new conf state */ else { - if (srv_admin_state & SRV_ADMF_FMAINT && !(srv->admin & SRV_ADMF_CMAINT)) + if (srv_admin_state & SRV_ADMF_FMAINT && !(srv->next_admin & SRV_ADMF_CMAINT)) srv_adm_set_maint(srv); - else if (!(srv_admin_state & SRV_ADMF_FMAINT) && (srv->admin & SRV_ADMF_CMAINT)) + else if (!(srv_admin_state & SRV_ADMF_FMAINT) && (srv->next_admin & SRV_ADMF_CMAINT)) srv_adm_set_ready(srv); } /* apply drain mode if server is currently enabled */ - if (!(srv->admin & SRV_ADMF_FMAINT) && (srv_admin_state & SRV_ADMF_FDRAIN)) { + if (!(srv->next_admin & SRV_ADMF_FMAINT) && (srv_admin_state & SRV_ADMF_FDRAIN)) { /* The SRV_ADMF_FDRAIN flag is inherited when srv->iweight is 0 * (srv->iweight is the weight set up in configuration). * There are two possible reasons for FDRAIN to have been present : @@ -3220,7 +3220,7 @@ static void srv_update_state(struct server *srv, int version, char **params) * So we must reset the 'set from stats socket FQDN' flag to be consistent with * any futher FQDN modification. */ - srv->admin &= ~SRV_ADMF_HMAINT; + srv->next_admin &= ~SRV_ADMF_HMAINT; } else { /* If the FDQN has been changed from stats socket, @@ -3229,7 +3229,7 @@ static void srv_update_state(struct server *srv, int version, char **params) */ if (fqdn_set_by_cli) { srv_set_fqdn(srv, fqdn); - srv->admin |= SRV_ADMF_HMAINT; + srv->next_admin |= SRV_ADMF_HMAINT; } } } @@ -3827,13 +3827,13 @@ int snr_update_srv_status(struct server *s, int has_no_ip) * server will be turned back on if health check is safe */ if (has_no_ip) { - if (s->admin & SRV_ADMF_RMAINT) + if (s->next_admin & SRV_ADMF_RMAINT) return 1; srv_set_admin_flag(s, SRV_ADMF_RMAINT, "No IP for server "); return (0); } - if (!(s->admin & SRV_ADMF_RMAINT)) + if (!(s->next_admin & SRV_ADMF_RMAINT)) return 1; srv_clr_admin_flag(s, SRV_ADMF_RMAINT); chunk_printf(&trash, "Server %s/%s administratively READY thanks to valid DNS answer", @@ -3846,7 +3846,7 @@ int snr_update_srv_status(struct server *s, int has_no_ip) case RSLV_STATUS_NX: /* stop server if resolution is NX for a long enough period */ if (tick_is_expired(tick_add(resolution->last_status_change, resolvers->hold.nx), now_ms)) { - if (s->admin & SRV_ADMF_RMAINT) + if (s->next_admin & SRV_ADMF_RMAINT) return 1; srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS NX status"); return 0; @@ -3856,7 +3856,7 @@ int snr_update_srv_status(struct server *s, int has_no_ip) case RSLV_STATUS_TIMEOUT: /* stop server if resolution is TIMEOUT for a long enough period */ if (tick_is_expired(tick_add(resolution->last_status_change, resolvers->hold.timeout), now_ms)) { - if (s->admin & SRV_ADMF_RMAINT) + if (s->next_admin & SRV_ADMF_RMAINT) return 1; srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS timeout status"); return 0; @@ -3866,7 +3866,7 @@ int snr_update_srv_status(struct server *s, int has_no_ip) case RSLV_STATUS_REFUSED: /* stop server if resolution is REFUSED for a long enough period */ if (tick_is_expired(tick_add(resolution->last_status_change, resolvers->hold.refused), now_ms)) { - if (s->admin & SRV_ADMF_RMAINT) + if (s->next_admin & SRV_ADMF_RMAINT) return 1; srv_set_admin_flag(s, SRV_ADMF_RMAINT, "DNS refused status"); return 0; @@ -3876,7 +3876,7 @@ int snr_update_srv_status(struct server *s, int has_no_ip) default: /* stop server if resolution is in unmatched error for a long enough period */ if (tick_is_expired(tick_add(resolution->last_status_change, resolvers->hold.other), now_ms)) { - if (s->admin & SRV_ADMF_RMAINT) + if (s->next_admin & SRV_ADMF_RMAINT) return 1; srv_set_admin_flag(s, SRV_ADMF_RMAINT, "unspecified DNS error"); return 0; @@ -4057,7 +4057,7 @@ struct server *snr_check_ip_callback(struct server *srv, void *ip, unsigned char continue; /* If the server has been taken down, don't consider it */ - if (tmpsrv->admin & SRV_ADMF_RMAINT) + if (tmpsrv->next_admin & SRV_ADMF_RMAINT) continue; /* At this point, we have 2 different servers using the same DNS hostname @@ -4315,7 +4315,7 @@ const char *update_server_fqdn(struct server *server, const char *fqdn, const ch } /* Flag as FQDN set from stats socket. */ - server->admin |= SRV_ADMF_HMAINT; + server->next_admin |= SRV_ADMF_HMAINT; out: if (updater) diff --git a/src/stats.c b/src/stats.c index 71230d0ce..4ae6430ca 100644 --- a/src/stats.c +++ b/src/stats.c @@ -1491,7 +1491,7 @@ int stats_fill_sv_stats(struct proxy *px, struct server *sv, int flags, while (ref->track) ref = ref->track; - if (sv->state == SRV_ST_RUNNING || sv->state == SRV_ST_STARTING) { + if (sv->cur_state == SRV_ST_RUNNING || sv->cur_state == SRV_ST_STARTING) { if ((ref->check.state & CHK_ST_ENABLED) && (ref->check.health < ref->check.rise + ref->check.fall - 1)) { state = SRV_STATS_STATE_UP_GOING_DOWN; @@ -1499,7 +1499,7 @@ int stats_fill_sv_stats(struct proxy *px, struct server *sv, int flags, state = SRV_STATS_STATE_UP; } - if (sv->admin & SRV_ADMF_DRAIN) { + if (sv->cur_admin & SRV_ADMF_DRAIN) { if (ref->agent.state & CHK_ST_ENABLED) state = SRV_STATS_STATE_DRAIN_AGENT; else if (state == SRV_STATS_STATE_UP_GOING_DOWN) @@ -1512,7 +1512,7 @@ int stats_fill_sv_stats(struct proxy *px, struct server *sv, int flags, state = SRV_STATS_STATE_NO_CHECK; } } - else if (sv->state == SRV_ST_STOPPING) { + else if (sv->cur_state == SRV_ST_STOPPING) { if ((!(sv->check.state & CHK_ST_ENABLED) && !sv->track) || (ref->check.health == ref->check.rise + ref->check.fall - 1)) { state = SRV_STATS_STATE_NOLB; @@ -1556,21 +1556,21 @@ int stats_fill_sv_stats(struct proxy *px, struct server *sv, int flags, /* status */ fld_status = chunk_newstr(out); - if (sv->admin & SRV_ADMF_RMAINT) + if (sv->cur_admin & SRV_ADMF_RMAINT) chunk_appendf(out, "MAINT (resolution)"); - else if (sv->admin & SRV_ADMF_IMAINT) + else if (sv->cur_admin & SRV_ADMF_IMAINT) chunk_appendf(out, "MAINT (via %s/%s)", via->proxy->id, via->id); - else if (sv->admin & SRV_ADMF_MAINT) + else if (sv->cur_admin & SRV_ADMF_MAINT) chunk_appendf(out, "MAINT"); else chunk_appendf(out, srv_hlt_st[state], - (ref->state != SRV_ST_STOPPED) ? (ref->check.health - ref->check.rise + 1) : (ref->check.health), - (ref->state != SRV_ST_STOPPED) ? (ref->check.fall) : (ref->check.rise)); + (ref->cur_state != SRV_ST_STOPPED) ? (ref->check.health - ref->check.rise + 1) : (ref->check.health), + (ref->cur_state != SRV_ST_STOPPED) ? (ref->check.fall) : (ref->check.rise)); stats[ST_F_STATUS] = mkf_str(FO_STATUS, fld_status); stats[ST_F_LASTCHG] = mkf_u32(FN_AGE, now.tv_sec - sv->last_change); - stats[ST_F_WEIGHT] = mkf_u32(FN_AVG, (sv->eweight * px->lbprm.wmult + px->lbprm.wdiv - 1) / px->lbprm.wdiv); + stats[ST_F_WEIGHT] = mkf_u32(FN_AVG, (sv->cur_eweight * px->lbprm.wmult + px->lbprm.wdiv - 1) / px->lbprm.wdiv); stats[ST_F_ACT] = mkf_u32(FO_STATUS, (sv->flags & SRV_F_BACKUP) ? 0 : 1); stats[ST_F_BCK] = mkf_u32(FO_STATUS, (sv->flags & SRV_F_BACKUP) ? 1 : 0); @@ -1588,7 +1588,7 @@ int stats_fill_sv_stats(struct proxy *px, struct server *sv, int flags, stats[ST_F_IID] = mkf_u32(FO_KEY|FS_SERVICE, px->uuid); stats[ST_F_SID] = mkf_u32(FO_KEY|FS_SERVICE, sv->puid); - if (sv->state == SRV_ST_STARTING && !server_is_draining(sv)) + if (sv->cur_state == SRV_ST_STARTING && !server_is_draining(sv)) stats[ST_F_THROTTLE] = mkf_u32(FN_AVG, server_throttle_rate(sv)); stats[ST_F_LBTOT] = mkf_u64(FN_COUNTER, sv->counters.cum_lbconn); @@ -2088,8 +2088,8 @@ int stats_dump_proxy_to_buffer(struct stream_interface *si, struct proxy *px, st /* do not report servers which are DOWN and not changing state */ if ((appctx->ctx.stats.flags & STAT_HIDE_DOWN) && - ((sv->admin & SRV_ADMF_MAINT) || /* server is in maintenance */ - (sv->state == SRV_ST_STOPPED && /* server is down */ + ((sv->cur_admin & SRV_ADMF_MAINT) || /* server is in maintenance */ + (sv->cur_state == SRV_ST_STOPPED && /* server is down */ (!((svs->agent.state | svs->check.state) & CHK_ST_ENABLED) || ((svs->agent.state & CHK_ST_ENABLED) && !svs->agent.health) || ((svs->check.state & CHK_ST_ENABLED) && !svs->check.health))))) { @@ -2767,28 +2767,28 @@ static int stats_process_http_post(struct stream_interface *si) else if ((sv = findserver(px, value)) != NULL) { switch (action) { case ST_ADM_ACTION_DISABLE: - if (!(sv->admin & SRV_ADMF_FMAINT)) { + if (!(sv->cur_admin & SRV_ADMF_FMAINT)) { altered_servers++; total_servers++; srv_set_admin_flag(sv, SRV_ADMF_FMAINT, "'disable' on stats page"); } break; case ST_ADM_ACTION_ENABLE: - if (sv->admin & SRV_ADMF_FMAINT) { + if (sv->cur_admin & SRV_ADMF_FMAINT) { altered_servers++; total_servers++; srv_clr_admin_flag(sv, SRV_ADMF_FMAINT); } break; case ST_ADM_ACTION_STOP: - if (!(sv->admin & SRV_ADMF_FDRAIN)) { + if (!(sv->cur_admin & SRV_ADMF_FDRAIN)) { srv_set_admin_flag(sv, SRV_ADMF_FDRAIN, "'stop' on stats page"); altered_servers++; total_servers++; } break; case ST_ADM_ACTION_START: - if (sv->admin & SRV_ADMF_FDRAIN) { + if (sv->cur_admin & SRV_ADMF_FDRAIN) { srv_clr_admin_flag(sv, SRV_ADMF_FDRAIN); altered_servers++; total_servers++; diff --git a/src/stream.c b/src/stream.c index d6c12299b..a2c83b069 100644 --- a/src/stream.c +++ b/src/stream.c @@ -696,7 +696,7 @@ static int sess_update_st_cer(struct stream *s) */ if (objt_server(s->target) && (s->be->options & PR_O_REDISP) && !(s->flags & SF_FORCE_PRST) && - ((__objt_server(s->target)->state < SRV_ST_RUNNING) || + ((__objt_server(s->target)->cur_state < SRV_ST_RUNNING) || (((s->be->redispatch_after > 0) && ((s->be->conn_retries - si->conn_retries) % s->be->redispatch_after == 0)) || @@ -1297,7 +1297,7 @@ static int process_server_rules(struct stream *s, struct channel *req, int an_bi if (ret) { struct server *srv = rule->srv.ptr; - if ((srv->state != SRV_ST_STOPPED) || + if ((srv->cur_state != SRV_ST_STOPPED) || (px->options & PR_O_PERSIST) || (s->flags & SF_FORCE_PRST)) { s->flags |= SF_DIRECT | SF_ASSIGNED; @@ -1383,7 +1383,7 @@ static int process_sticking_rules(struct stream *s, struct channel *req, int an_ struct server *srv; srv = container_of(node, struct server, conf.id); - if ((srv->state != SRV_ST_STOPPED) || + if ((srv->cur_state != SRV_ST_STOPPED) || (px->options & PR_O_PERSIST) || (s->flags & SF_FORCE_PRST)) { s->flags |= SF_DIRECT | SF_ASSIGNED;