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:
}
/* 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:
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
*/
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
* 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)));
}
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);
}
/*
*/
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
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;
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 */
* 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)
{
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) {
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;
}
}
}
}
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 {
(!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
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;
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;
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) {
{
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))
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);
{
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))
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)
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)
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);
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);
/* 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 */
/* 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;
}
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)));
}
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);
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. */
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. */
*/
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--;
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)
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) {
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--;
}
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)) {
}
}
} else {
- p->lbprm.tot_wact += srv->eweight;
+ p->lbprm.tot_wact += srv->next_eweight;
p->srv_act++;
}
* 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);
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);
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. */
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);
}
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);
}
}
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) {
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--;
}
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)) {
}
} else {
srv->lb_tree = &p->lbprm.fas.act;
- p->lbprm.tot_wact += srv->eweight;
+ p->lbprm.tot_wact += srv->next_eweight;
p->srv_act++;
}
* 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);
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;
}
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);
}
/* 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);
*/
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);
}
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) {
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--;
}
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)) {
}
} else {
srv->lb_tree = &p->lbprm.fwlc.act;
- p->lbprm.tot_wact += srv->eweight;
+ p->lbprm.tot_wact += srv->next_eweight;
p->srv_act++;
}
* 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);
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;
}
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);
}
/* 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);
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;
srv2 = srv2->next;
} while (srv2 &&
!((srv2->flags & SRV_F_BACKUP) &&
- srv_is_usable(srv2)));
+ srv_willbe_usable(srv2)));
p->lbprm.fbck = srv2;
}
} else {
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;
/* 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:
* 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);
}
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;
*/
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
*/
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;
*/
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;
}
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);
}
/* 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 :
/* 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
* 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;
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;
}
}
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++;
}
}
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 */
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 */
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
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;
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 */
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;
"\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) {
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;
ps = pendconn_from_srv(srv);
pp = pendconn_from_px(px);
/* we want to get the definitive pendconn in <ps> */
- if (!pp || !srv_is_usable(rsrv)) {
+ if (!pp || !srv_currently_usable(rsrv)) {
if (!ps)
return NULL;
} else {
{
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++) {
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;
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);
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;
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;
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,
{
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);
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) {
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);
* 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
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);
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 */
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,
}
}
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);
}
/* 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;
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.
*/
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) {
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);
* 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
"%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) {
"%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);
}
/* 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)
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);
}
}
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);
}
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;
}
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;
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;
* 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 :
* 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,
*/
if (fqdn_set_by_cli) {
srv_set_fqdn(srv, fqdn);
- srv->admin |= SRV_ADMF_HMAINT;
+ srv->next_admin |= SRV_ADMF_HMAINT;
}
}
}
* 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",
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;
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;
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;
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;
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
}
/* Flag as FQDN set from stats socket. */
- server->admin |= SRV_ADMF_HMAINT;
+ server->next_admin |= SRV_ADMF_HMAINT;
out:
if (updater)
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;
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)
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;
/* 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);
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);
/* 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))))) {
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++;
*/
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)) ||
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;
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;
projects / thirdparty / haproxy.git / commitdiff
