/*
* this function disables health-check servers so that the process will quickly be ignored
* by load balancers. Note that if a proxy was already in the PAUSED state, then its grace
* time will not be used since it would already not listen anymore to the socket.
*/
void soft_stop(void)
{
struct proxy *p;
struct peers *prs;
stopping = 1;
p = proxy;
tv_update_date(0,1); /* else, the old time before select will be used */
while (p) {
if (p->state != PR_STSTOPPED) {
Warning("Stopping %s %s in %d ms.\n", proxy_cap_str(p->cap), p->id, p->grace);
send_log(p, LOG_WARNING, "Stopping %s %s in %d ms.\n", proxy_cap_str(p->cap), p->id, p->grace);
p->stop_time = tick_add(now_ms, p->grace);
}
if (p->table.size && p->table.sync_task)
task_wakeup(p->table.sync_task, TASK_WOKEN_MSG);
/* wake every proxy task up so that they can handle the stopping */
task_wakeup(p->task, TASK_WOKEN_MSG);
p = p->next;
}
prs = peers;
while (prs) {
stop_proxy((struct proxy *)prs->peers_fe);
prs = prs->next;
}
/* signal zero is used to broadcast the "stopping" event */
signal_handler(0);
}
/*
* this function enables proxies when there are enough free sessions,
* or stops them when the table is full. It is designed to be called from the
* select_loop(). It adjusts the date of next expiration event during stop
* time if appropriate.
*/
void maintain_proxies(int *next)
{
struct proxy *p;
struct listener *l;
unsigned int wait;
p = proxy;
/* if there are enough free sessions, we'll activate proxies */
if (actconn < global.maxconn) {
for (; p; p = p->next) {
/* check the various reasons we may find to block the frontend */
if (p->feconn >= p->maxconn)
goto do_block;
if (p->fe_sps_lim &&
(wait = next_event_delay(&p->fe_sess_per_sec, p->fe_sps_lim, 1))) {
/* we're blocking because a limit was reached on the number of
* requests/s on the frontend. We want to re-check ASAP, which
* means in 1 ms before estimated expiration date, because the
* timer will have settled down. Note that we may already be in
* IDLE state here.
*/
*next = tick_first(*next, tick_add(now_ms, wait));
goto do_block;
}
/* OK we have no reason to block, so let's unblock if we were blocking */
if (p->state == PR_STIDLE) {
for (l = p->listen; l != NULL; l = l->next)
enable_listener(l);
p->state = PR_STRUN;
}
continue;
do_block:
if (p->state == PR_STRUN) {
for (l = p->listen; l != NULL; l = l->next)
disable_listener(l);
p->state = PR_STIDLE;
}
}
}
else { /* block all proxies */
while (p) {
if (p->state == PR_STRUN) {
for (l = p->listen; l != NULL; l = l->next)
disable_listener(l);
p->state = PR_STIDLE;
}
p = p->next;
}
}
if (stopping) {
p = proxy;
while (p) {
if (p->state != PR_STSTOPPED) {
int t;
t = tick_remain(now_ms, p->stop_time);
if (t == 0) {
Warning("Proxy %s stopped (FE: %lld conns, BE: %lld conns).\n",
p->id, p->cum_feconn, p->cum_beconn);
send_log(p, LOG_WARNING, "Proxy %s stopped (FE: %lld conns, BE: %lld conns).\n",
p->id, p->cum_feconn, p->cum_beconn);
stop_proxy(p);
/* try to free more memory */
pool_gc2();
}
else {
*next = tick_first(*next, p->stop_time);
}
}
p = p->next;
}
}
return;
}
static void stopProxy(JNIEnv *env, jclass clazz)
{
LOGE("call stopProxy");
stop_proxy();
}
/*
* This is the proxy management task. It enables proxies when there are enough
* free sessions, or stops them when the table is full. It is designed to be
* called as a task which is woken up upon stopping or when rate limiting must
* be enforced.
*/
struct task *manage_proxy(struct task *t)
{
struct proxy *p = t->context;
int next = TICK_ETERNITY;
unsigned int wait;
/* We should periodically try to enable listeners waiting for a
* global resource here.
*/
/* first, let's check if we need to stop the proxy */
if (unlikely(stopping && p->state != PR_STSTOPPED)) {
int t;
t = tick_remain(now_ms, p->stop_time);
if (t == 0) {
Warning("Proxy %s stopped (FE: %lld conns, BE: %lld conns).\n",
p->id, p->fe_counters.cum_conn, p->be_counters.cum_conn);
send_log(p, LOG_WARNING, "Proxy %s stopped (FE: %lld conns, BE: %lld conns).\n",
p->id, p->fe_counters.cum_conn, p->be_counters.cum_conn);
stop_proxy(p);
/* try to free more memory */
pool_gc2();
}
else {
next = tick_first(next, p->stop_time);
}
}
/* the rest below is just for frontends */
if (!(p->cap & PR_CAP_FE))
goto out;
/* check the various reasons we may find to block the frontend */
if (unlikely(p->feconn >= p->maxconn)) {
if (p->state == PR_STREADY)
p->state = PR_STFULL;
goto out;
}
/* OK we have no reason to block, so let's unblock if we were blocking */
if (p->state == PR_STFULL)
p->state = PR_STREADY;
if (p->fe_sps_lim &&
(wait = next_event_delay(&p->fe_sess_per_sec, p->fe_sps_lim, 0))) {
/* we're blocking because a limit was reached on the number of
* requests/s on the frontend. We want to re-check ASAP, which
* means in 1 ms before estimated expiration date, because the
* timer will have settled down.
*/
next = tick_first(next, tick_add(now_ms, wait));
goto out;
}
/* The proxy is not limited so we can re-enable any waiting listener */
if (!LIST_ISEMPTY(&p->listener_queue))
dequeue_all_listeners(&p->listener_queue);
out:
t->expire = next;
task_queue(t);
return t;
}