mirrors/haproxy
1
0
Fork 0
mirror of https://git.haproxy.org/git/haproxy.git/ synced 2025-09-22 06:11:32 +02:00
Code Issues Projects Releases Wiki Activity

[CLEANUP] grouped all timeouts in one structure

Browse Source 
All known timeouts in a proxy have been grouped into a
"timeout" sub-structure.
This commit is contained in:
Willy Tarreau 2007-12-03 01:38:36 +01:00
parent e219db7a46
commit d7c30f9a8c
6 changed files with 88 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/types/proxy.h
View File

@ -169,13 +169,13 @@ struct proxy {
char *monitor_uri; /* a special URI to which we respond with HTTP/200 OK */ char *monitor_uri; /* a special URI to which we respond with HTTP/200 OK */
int monitor_uri_len; /* length of the string above. 0 if unused */ int monitor_uri_len; /* length of the string above. 0 if unused */
struct list mon_fail_cond; /* list of conditions to fail monitoring requests (chained) */ struct list mon_fail_cond; /* list of conditions to fail monitoring requests (chained) */
struct timeval clitimeout; /* client I/O timeout (in milliseconds) */
struct timeval srvtimeout; /* server I/O timeout (in milliseconds) */
struct timeval contimeout; /* connect timeout (in milliseconds) */
struct timeval appsession_timeout;
struct { struct {
struct timeval queue; /* queue timeout, defaults to contimeout if unspecified */ struct timeval client; /* client I/O timeout (in milliseconds) */
struct timeval tarpit; /* tarpit timeout, defaults to contimeout if unspecified */ struct timeval tarpit; /* tarpit timeout, defaults to connect if unspecified */
struct timeval queue; /* queue timeout, defaults to connect if unspecified */
struct timeval connect; /* connect timeout (in milliseconds) */
struct timeval server; /* server I/O timeout (in milliseconds) */
struct timeval appsession;
} timeout; } timeout;
char *id; /* proxy id */ char *id; /* proxy id */
struct list pendconns; /* pending connections with no server assigned yet */ struct list pendconns; /* pending connections with no server assigned yet */

2
src/backend.c
View File

@ -1329,7 +1329,7 @@ int connect_server(struct session *s)
s->srv->cur_sess_max = s->srv->cur_sess; s->srv->cur_sess_max = s->srv->cur_sess;
} }
if (!tv_add_ifset(&s->req->cex, &now, &s->be->contimeout)) if (!tv_add_ifset(&s->req->cex, &now, &s->be->timeout.connect))
tv_eternity(&s->req->cex); tv_eternity(&s->req->cex);
return SN_ERR_NONE; /* connection is OK */ return SN_ERR_NONE; /* connection is OK */
} }

48
src/cfgparse.c
View File

@ -498,10 +498,10 @@ static void init_default_instance()
defproxy.maxconn = cfg_maxpconn; defproxy.maxconn = cfg_maxpconn;
defproxy.conn_retries = CONN_RETRIES; defproxy.conn_retries = CONN_RETRIES;
defproxy.logfac1 = defproxy.logfac2 = -1; /* log disabled */ defproxy.logfac1 = defproxy.logfac2 = -1; /* log disabled */
tv_eternity(&defproxy.clitimeout); tv_eternity(&defproxy.timeout.client);
tv_eternity(&defproxy.contimeout); tv_eternity(&defproxy.timeout.connect);
tv_eternity(&defproxy.srvtimeout); tv_eternity(&defproxy.timeout.server);
tv_eternity(&defproxy.appsession_timeout); tv_eternity(&defproxy.timeout.appsession);
tv_eternity(&defproxy.timeout.queue); tv_eternity(&defproxy.timeout.queue);
tv_eternity(&defproxy.timeout.tarpit); tv_eternity(&defproxy.timeout.tarpit);
} }
@ -580,10 +580,10 @@ int cfg_parse_listen(const char *file, int linenum, char **args)
/* Timeouts are defined as -1, so we cannot use the zeroed area /* Timeouts are defined as -1, so we cannot use the zeroed area
* as a default value. * as a default value.
*/ */
tv_eternity(&curproxy->clitimeout); tv_eternity(&curproxy->timeout.client);
tv_eternity(&curproxy->srvtimeout); tv_eternity(&curproxy->timeout.server);
tv_eternity(&curproxy->contimeout); tv_eternity(&curproxy->timeout.connect);
tv_eternity(&curproxy->appsession_timeout); tv_eternity(&curproxy->timeout.appsession);
tv_eternity(&curproxy->timeout.queue); tv_eternity(&curproxy->timeout.queue);
tv_eternity(&curproxy->timeout.tarpit); tv_eternity(&curproxy->timeout.tarpit);
@ -643,7 +643,7 @@ int cfg_parse_listen(const char *file, int linenum, char **args)
} }
if (curproxy->cap & PR_CAP_FE) { if (curproxy->cap & PR_CAP_FE) {
curproxy->clitimeout = defproxy.clitimeout; curproxy->timeout.client = defproxy.timeout.client;
curproxy->timeout.tarpit = defproxy.timeout.tarpit; curproxy->timeout.tarpit = defproxy.timeout.tarpit;
curproxy->uri_auth = defproxy.uri_auth; curproxy->uri_auth = defproxy.uri_auth;
curproxy->mon_net = defproxy.mon_net; curproxy->mon_net = defproxy.mon_net;
@ -656,8 +656,8 @@ int cfg_parse_listen(const char *file, int linenum, char **args)
} }
if (curproxy->cap & PR_CAP_BE) { if (curproxy->cap & PR_CAP_BE) {
curproxy->contimeout = defproxy.contimeout; curproxy->timeout.connect = defproxy.timeout.connect;
curproxy->srvtimeout = defproxy.srvtimeout; curproxy->timeout.server = defproxy.timeout.server;
curproxy->timeout.queue = defproxy.timeout.queue; curproxy->timeout.queue = defproxy.timeout.queue;
curproxy->source_addr = defproxy.source_addr; curproxy->source_addr = defproxy.source_addr;
} }
@ -882,9 +882,9 @@ int cfg_parse_listen(const char *file, int linenum, char **args)
return -1; return -1;
} }
if (val > 0) if (val > 0)
__tv_from_ms(&curproxy->appsession_timeout, val); __tv_from_ms(&curproxy->timeout.appsession, val);
else else
tv_eternity(&curproxy->appsession_timeout); tv_eternity(&curproxy->timeout.appsession);
if (appsession_hash_init(&(curproxy->htbl_proxy), destroy) == 0) { if (appsession_hash_init(&(curproxy->htbl_proxy), destroy) == 0) {
Alert("parsing [%s:%d] : out of memory.\n", file, linenum); Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
@ -2682,9 +2682,9 @@ int readcfgfile(const char *file)
} }
if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) && if ((curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HTTP) &&
(((curproxy->cap & PR_CAP_FE) && !tv_isset(&curproxy->clitimeout)) || (((curproxy->cap & PR_CAP_FE) && !tv_isset(&curproxy->timeout.client)) ||
((curproxy->cap & PR_CAP_BE) && (curproxy->srv) && ((curproxy->cap & PR_CAP_BE) && (curproxy->srv) &&
(!tv_isset(&curproxy->contimeout) || !tv_isset(&curproxy->srvtimeout))))) { (!tv_isset(&curproxy->timeout.connect) || !tv_isset(&curproxy->timeout.server))))) {
Warning("parsing %s : missing timeouts for %s '%s'.\n" Warning("parsing %s : missing timeouts for %s '%s'.\n"
" | While not properly invalid, you will certainly encounter various problems\n" " | While not properly invalid, you will certainly encounter various problems\n"
" | with such a configuration. To fix this, please ensure that all following\n" " | with such a configuration. To fix this, please ensure that all following\n"
@ -2705,10 +2705,10 @@ int readcfgfile(const char *file)
*/ */
if (tv_isset(&defproxy.timeout.tarpit)) if (tv_isset(&defproxy.timeout.tarpit))
curproxy->timeout.tarpit = defproxy.timeout.tarpit; curproxy->timeout.tarpit = defproxy.timeout.tarpit;
else if (tv_isset(&curproxy->contimeout)) else if (tv_isset(&curproxy->timeout.connect))
curproxy->timeout.tarpit = curproxy->contimeout; curproxy->timeout.tarpit = curproxy->timeout.connect;
else if (tv_isset(&defproxy.contimeout)) else if (tv_isset(&defproxy.timeout.connect))
curproxy->timeout.tarpit = defproxy.contimeout; curproxy->timeout.tarpit = defproxy.timeout.connect;
} }
if ((curproxy->cap & PR_CAP_BE) && if ((curproxy->cap & PR_CAP_BE) &&
(!tv_isset(&curproxy->timeout.queue) || (!tv_isset(&curproxy->timeout.queue) ||
@ -2718,10 +2718,10 @@ int readcfgfile(const char *file)
*/ */
if (tv_isset(&defproxy.timeout.queue)) if (tv_isset(&defproxy.timeout.queue))
curproxy->timeout.queue = defproxy.timeout.queue; curproxy->timeout.queue = defproxy.timeout.queue;
else if (tv_isset(&curproxy->contimeout)) else if (tv_isset(&curproxy->timeout.connect))
curproxy->timeout.queue = curproxy->contimeout; curproxy->timeout.queue = curproxy->timeout.connect;
else if (tv_isset(&defproxy.contimeout)) else if (tv_isset(&defproxy.timeout.connect))
curproxy->timeout.queue = defproxy.contimeout; curproxy->timeout.queue = defproxy.timeout.connect;
} }
} }
@ -2826,7 +2826,7 @@ int readcfgfile(const char *file)
if (curproxy->options & PR_O_TCP_NOLING) if (curproxy->options & PR_O_TCP_NOLING)
listener->options |= LI_O_NOLINGER; listener->options |= LI_O_NOLINGER;
listener->maxconn = curproxy->maxconn; listener->maxconn = curproxy->maxconn;
listener->timeout = &curproxy->clitimeout; listener->timeout = &curproxy->timeout.client;
listener->accept = event_accept; listener->accept = event_accept;
listener->private = curproxy; listener->private = curproxy;

16
src/client.c
View File

@ -348,17 +348,17 @@ int event_accept(int fd) {
if (s->cli_state == CL_STHEADERS) /* reserve some space for header rewriting */ if (s->cli_state == CL_STHEADERS) /* reserve some space for header rewriting */
s->req->rlim -= MAXREWRITE; s->req->rlim -= MAXREWRITE;
s->req->rto = s->fe->clitimeout; s->req->rto = s->fe->timeout.client;
s->req->wto = s->be->srvtimeout; s->req->wto = s->be->timeout.server;
s->req->cto = s->be->contimeout; s->req->cto = s->be->timeout.connect;
if ((s->rep = pool_alloc2(pool2_buffer)) == NULL) if ((s->rep = pool_alloc2(pool2_buffer)) == NULL)
goto out_fail_rep; /* no memory */ goto out_fail_rep; /* no memory */
buffer_init(s->rep); buffer_init(s->rep);
s->rep->rto = s->be->srvtimeout; s->rep->rto = s->be->timeout.server;
s->rep->wto = s->fe->clitimeout; s->rep->wto = s->fe->timeout.client;
tv_eternity(&s->rep->cto); tv_eternity(&s->rep->cto);
fd_insert(cfd); fd_insert(cfd);
@ -397,13 +397,13 @@ int event_accept(int fd) {
tv_eternity(&s->rep->wex); tv_eternity(&s->rep->wex);
tv_eternity(&t->expire); tv_eternity(&t->expire);
if (tv_isset(&s->fe->clitimeout)) { if (tv_isset(&s->fe->timeout.client)) {
if (EV_FD_ISSET(cfd, DIR_RD)) { if (EV_FD_ISSET(cfd, DIR_RD)) {
tv_add(&s->req->rex, &now, &s->fe->clitimeout); tv_add(&s->req->rex, &now, &s->fe->timeout.client);
t->expire = s->req->rex; t->expire = s->req->rex;
} }
if (EV_FD_ISSET(cfd, DIR_WR)) { if (EV_FD_ISSET(cfd, DIR_WR)) {
tv_add(&s->rep->wex, &now, &s->fe->clitimeout); tv_add(&s->rep->wex, &now, &s->fe->timeout.client);
t->expire = s->rep->wex; t->expire = s->rep->wex;
} }
} }

82
src/proto_http.c
View File

@ -1603,7 +1603,7 @@ int process_cli(struct session *t)
* full. We cannot loop here since stream_sock_read will disable it only if * full. We cannot loop here since stream_sock_read will disable it only if
* req->l == rlim-data * req->l == rlim-data
*/ */
if (!tv_add_ifset(&req->rex, &now, &t->fe->clitimeout)) if (!tv_add_ifset(&req->rex, &now, &t->fe->timeout.client))
tv_eternity(&req->rex); tv_eternity(&req->rex);
} }
return t->cli_state != CL_STHEADERS; return t->cli_state != CL_STHEADERS;
@ -1879,8 +1879,8 @@ int process_cli(struct session *t)
t->be->cum_beconn++; t->be->cum_beconn++;
/* assign new parameters to the session from the new backend */ /* assign new parameters to the session from the new backend */
t->rep->rto = t->req->wto = t->be->srvtimeout; t->rep->rto = t->req->wto = t->be->timeout.server;
t->req->cto = t->be->contimeout; t->req->cto = t->be->timeout.connect;
t->conn_retries = t->be->conn_retries; t->conn_retries = t->be->conn_retries;
t->flags |= SN_BE_ASSIGNED; t->flags |= SN_BE_ASSIGNED;
break; break;
@ -1900,8 +1900,8 @@ int process_cli(struct session *t)
t->be->cum_beconn++; t->be->cum_beconn++;
/* assign new parameters to the session from the new backend */ /* assign new parameters to the session from the new backend */
t->rep->rto = t->req->wto = t->be->srvtimeout; t->rep->rto = t->req->wto = t->be->timeout.server;
t->req->cto = t->be->contimeout; t->req->cto = t->be->timeout.connect;
t->conn_retries = t->be->conn_retries; t->conn_retries = t->be->conn_retries;
t->flags |= SN_BE_ASSIGNED; t->flags |= SN_BE_ASSIGNED;
} }
@ -2024,8 +2024,8 @@ int process_cli(struct session *t)
t->logs.t_request = tv_ms_elapsed(&t->logs.tv_accept, &now); t->logs.t_request = tv_ms_elapsed(&t->logs.tv_accept, &now);
if (!tv_isset(&t->fe->clitimeout) || if (!tv_isset(&t->fe->timeout.client) ||
(t->srv_state < SV_STDATA && tv_isset(&t->be->srvtimeout))) { (t->srv_state < SV_STDATA && tv_isset(&t->be->timeout.server))) {
/* If the client has no timeout, or if the server is not ready yet, /* If the client has no timeout, or if the server is not ready yet,
* and we know for sure that it can expire, then it's cleaner to * and we know for sure that it can expire, then it's cleaner to
* disable the timeout on the client side so that too low values * disable the timeout on the client side so that too low values
@ -2108,7 +2108,7 @@ int process_cli(struct session *t)
/* We must ensure that the read part is still alive when switching /* We must ensure that the read part is still alive when switching
* to shutw */ * to shutw */
EV_FD_SET(t->cli_fd, DIR_RD); EV_FD_SET(t->cli_fd, DIR_RD);
tv_add_ifset(&req->rex, &now, &t->fe->clitimeout); tv_add_ifset(&req->rex, &now, &t->fe->timeout.client);
t->cli_state = CL_STSHUTW; t->cli_state = CL_STSHUTW;
//fprintf(stderr,"%p:%s(%d), c=%d, s=%d\n", t, __FUNCTION__, __LINE__, t->cli_state, t->cli_state); //fprintf(stderr,"%p:%s(%d), c=%d, s=%d\n", t, __FUNCTION__, __LINE__, t->cli_state, t->cli_state);
return 1; return 1;
@ -2138,7 +2138,7 @@ int process_cli(struct session *t)
/* We must ensure that the read part is still alive when switching /* We must ensure that the read part is still alive when switching
* to shutw */ * to shutw */
EV_FD_SET(t->cli_fd, DIR_RD); EV_FD_SET(t->cli_fd, DIR_RD);
tv_add_ifset(&req->rex, &now, &t->fe->clitimeout); tv_add_ifset(&req->rex, &now, &t->fe->timeout.client);
t->cli_state = CL_STSHUTW; t->cli_state = CL_STSHUTW;
if (!(t->flags & SN_ERR_MASK)) if (!(t->flags & SN_ERR_MASK))
@ -2163,8 +2163,8 @@ int process_cli(struct session *t)
} else { } else {
/* there's still some space in the buffer */ /* there's still some space in the buffer */
if (EV_FD_COND_S(t->cli_fd, DIR_RD)) { if (EV_FD_COND_S(t->cli_fd, DIR_RD)) {
if (!tv_isset(&t->fe->clitimeout) || if (!tv_isset(&t->fe->timeout.client) ||
(t->srv_state < SV_STDATA && tv_isset(&t->be->srvtimeout))) (t->srv_state < SV_STDATA && tv_isset(&t->be->timeout.server)))
/* If the client has no timeout, or if the server not ready yet, and we /* If the client has no timeout, or if the server not ready yet, and we
* know for sure that it can expire, then it's cleaner to disable the * know for sure that it can expire, then it's cleaner to disable the
* timeout on the client side so that too low values cannot make the * timeout on the client side so that too low values cannot make the
@ -2172,7 +2172,7 @@ int process_cli(struct session *t)
*/ */
tv_eternity(&req->rex); tv_eternity(&req->rex);
else else
tv_add(&req->rex, &now, &t->fe->clitimeout); tv_add(&req->rex, &now, &t->fe->timeout.client);
} }
} }
@ -2186,7 +2186,7 @@ int process_cli(struct session *t)
/* buffer not empty */ /* buffer not empty */
if (EV_FD_COND_S(t->cli_fd, DIR_WR)) { if (EV_FD_COND_S(t->cli_fd, DIR_WR)) {
/* restart writing */ /* restart writing */
if (tv_add_ifset(&rep->wex, &now, &t->fe->clitimeout)) { if (tv_add_ifset(&rep->wex, &now, &t->fe->timeout.client)) {
/* FIXME: to prevent the client from expiring read timeouts during writes, /* FIXME: to prevent the client from expiring read timeouts during writes,
* we refresh it. */ * we refresh it. */
req->rex = rep->wex; req->rex = rep->wex;
@ -2258,7 +2258,7 @@ int process_cli(struct session *t)
/* buffer not empty */ /* buffer not empty */
if (EV_FD_COND_S(t->cli_fd, DIR_WR)) { if (EV_FD_COND_S(t->cli_fd, DIR_WR)) {
/* restart writing */ /* restart writing */
if (!tv_add_ifset(&rep->wex, &now, &t->fe->clitimeout)) if (!tv_add_ifset(&rep->wex, &now, &t->fe->timeout.client))
tv_eternity(&rep->wex); tv_eternity(&rep->wex);
} }
} }
@ -2318,7 +2318,7 @@ int process_cli(struct session *t)
} else { } else {
/* there's still some space in the buffer */ /* there's still some space in the buffer */
if (EV_FD_COND_S(t->cli_fd, DIR_RD)) { if (EV_FD_COND_S(t->cli_fd, DIR_RD)) {
if (!tv_add_ifset(&req->rex, &now, &t->fe->clitimeout)) if (!tv_add_ifset(&req->rex, &now, &t->fe->timeout.client))
tv_eternity(&req->rex); tv_eternity(&req->rex);
//fprintf(stderr,"%p:%s(%d), c=%d, s=%d\n", t, __FUNCTION__, __LINE__, t->cli_state, t->cli_state); //fprintf(stderr,"%p:%s(%d), c=%d, s=%d\n", t, __FUNCTION__, __LINE__, t->cli_state, t->cli_state);
} }
@ -2357,14 +2357,14 @@ int process_srv(struct session *t)
#if 0 #if 0
fprintf(stderr,"%s:%d fe->clito=%d.%d, fe->conto=%d.%d, fe->srvto=%d.%d\n", fprintf(stderr,"%s:%d fe->clito=%d.%d, fe->conto=%d.%d, fe->srvto=%d.%d\n",
__FUNCTION__, __LINE__, __FUNCTION__, __LINE__,
t->fe->clitimeout.tv_sec, t->fe->clitimeout.tv_usec, t->fe->timeout.client.tv_sec, t->fe->timeout.client.tv_usec,
t->fe->contimeout.tv_sec, t->fe->contimeout.tv_usec, t->fe->timeout.connect.tv_sec, t->fe->timeout.connect.tv_usec,
t->fe->srvtimeout.tv_sec, t->fe->srvtimeout.tv_usec); t->fe->timeout.server.tv_sec, t->fe->timeout.server.tv_usec);
fprintf(stderr,"%s:%d be->clito=%d.%d, be->conto=%d.%d, be->srvto=%d.%d\n", fprintf(stderr,"%s:%d be->clito=%d.%d, be->conto=%d.%d, be->srvto=%d.%d\n",
__FUNCTION__, __LINE__, __FUNCTION__, __LINE__,
t->be->clitimeout.tv_sec, t->be->clitimeout.tv_usec, t->be->timeout.client.tv_sec, t->be->timeout.client.tv_usec,
t->be->contimeout.tv_sec, t->be->contimeout.tv_usec, t->be->timeout.connect.tv_sec, t->be->timeout.connect.tv_usec,
t->be->srvtimeout.tv_sec, t->be->srvtimeout.tv_usec); t->be->timeout.server.tv_sec, t->be->timeout.server.tv_usec);
fprintf(stderr,"%s:%d req->cto=%d.%d, req->rto=%d.%d, req->wto=%d.%d\n", fprintf(stderr,"%s:%d req->cto=%d.%d, req->rto=%d.%d, req->wto=%d.%d\n",
__FUNCTION__, __LINE__, __FUNCTION__, __LINE__,
@ -2543,7 +2543,7 @@ int process_srv(struct session *t)
tv_eternity(&req->wex); tv_eternity(&req->wex);
} else /* need the right to write */ { } else /* need the right to write */ {
EV_FD_SET(t->srv_fd, DIR_WR); EV_FD_SET(t->srv_fd, DIR_WR);
if (tv_add_ifset(&req->wex, &now, &t->be->srvtimeout)) { if (tv_add_ifset(&req->wex, &now, &t->be->timeout.server)) {
/* FIXME: to prevent the server from expiring read timeouts during writes, /* FIXME: to prevent the server from expiring read timeouts during writes,
* we refresh it. */ * we refresh it. */
rep->rex = req->wex; rep->rex = req->wex;
@ -2554,7 +2554,7 @@ int process_srv(struct session *t)
if (t->be->mode == PR_MODE_TCP) { /* let's allow immediate data connection in this case */ if (t->be->mode == PR_MODE_TCP) { /* let's allow immediate data connection in this case */
EV_FD_SET(t->srv_fd, DIR_RD); EV_FD_SET(t->srv_fd, DIR_RD);
if (!tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout)) if (!tv_add_ifset(&rep->rex, &now, &t->be->timeout.server))
tv_eternity(&rep->rex); tv_eternity(&rep->rex);
t->srv_state = SV_STDATA; t->srv_state = SV_STDATA;
@ -2641,7 +2641,7 @@ int process_srv(struct session *t)
* full. We cannot loop here since stream_sock_read will disable it only if * full. We cannot loop here since stream_sock_read will disable it only if
* rep->l == rlim-data * rep->l == rlim-data
*/ */
if (!tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout)) if (!tv_add_ifset(&rep->rex, &now, &t->be->timeout.server))
tv_eternity(&rep->rex); tv_eternity(&rep->rex);
} }
@ -2746,7 +2746,7 @@ int process_srv(struct session *t)
/* We must ensure that the read part is still /* We must ensure that the read part is still
* alive when switching to shutw */ * alive when switching to shutw */
EV_FD_SET(t->srv_fd, DIR_RD); EV_FD_SET(t->srv_fd, DIR_RD);
tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout); tv_add_ifset(&rep->rex, &now, &t->be->timeout.server);
shutdown(t->srv_fd, SHUT_WR); shutdown(t->srv_fd, SHUT_WR);
t->srv_state = SV_STSHUTW; t->srv_state = SV_STSHUTW;
@ -2766,7 +2766,7 @@ int process_srv(struct session *t)
/* We must ensure that the read part is still alive /* We must ensure that the read part is still alive
* when switching to shutw */ * when switching to shutw */
EV_FD_SET(t->srv_fd, DIR_RD); EV_FD_SET(t->srv_fd, DIR_RD);
tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout); tv_add_ifset(&rep->rex, &now, &t->be->timeout.server);
t->srv_state = SV_STSHUTW; t->srv_state = SV_STSHUTW;
if (!(t->flags & SN_ERR_MASK)) if (!(t->flags & SN_ERR_MASK))
@ -2787,7 +2787,7 @@ int process_srv(struct session *t)
else if (likely(req->l)) { else if (likely(req->l)) {
if (EV_FD_COND_S(t->srv_fd, DIR_WR)) { if (EV_FD_COND_S(t->srv_fd, DIR_WR)) {
/* restart writing */ /* restart writing */
if (tv_add_ifset(&req->wex, &now, &t->be->srvtimeout)) { if (tv_add_ifset(&req->wex, &now, &t->be->timeout.server)) {
/* FIXME: to prevent the server from expiring read timeouts during writes, /* FIXME: to prevent the server from expiring read timeouts during writes,
* we refresh it. */ * we refresh it. */
rep->rex = req->wex; rep->rex = req->wex;
@ -3089,7 +3089,7 @@ int process_srv(struct session *t)
/* We must ensure that the read part is still alive when switching /* We must ensure that the read part is still alive when switching
* to shutw */ * to shutw */
EV_FD_SET(t->srv_fd, DIR_RD); EV_FD_SET(t->srv_fd, DIR_RD);
tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout); tv_add_ifset(&rep->rex, &now, &t->be->timeout.server);
shutdown(t->srv_fd, SHUT_WR); shutdown(t->srv_fd, SHUT_WR);
t->srv_state = SV_STSHUTW; t->srv_state = SV_STSHUTW;
@ -3159,7 +3159,7 @@ int process_srv(struct session *t)
/* We must ensure that the read part is still alive when switching /* We must ensure that the read part is still alive when switching
* to shutw */ * to shutw */
EV_FD_SET(t->srv_fd, DIR_RD); EV_FD_SET(t->srv_fd, DIR_RD);
tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout); tv_add_ifset(&rep->rex, &now, &t->be->timeout.server);
t->srv_state = SV_STSHUTW; t->srv_state = SV_STSHUTW;
return 1; return 1;
@ -3183,7 +3183,7 @@ int process_srv(struct session *t)
/* We must ensure that the read part is still alive when switching /* We must ensure that the read part is still alive when switching
* to shutw */ * to shutw */
EV_FD_SET(t->srv_fd, DIR_RD); EV_FD_SET(t->srv_fd, DIR_RD);
tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout); tv_add_ifset(&rep->rex, &now, &t->be->timeout.server);
t->srv_state = SV_STSHUTW; t->srv_state = SV_STSHUTW;
if (!(t->flags & SN_ERR_MASK)) if (!(t->flags & SN_ERR_MASK))
t->flags |= SN_ERR_SRVTO; t->flags |= SN_ERR_SRVTO;
@ -3202,7 +3202,7 @@ int process_srv(struct session *t)
else { /* buffer not empty, there are still data to be transferred */ else { /* buffer not empty, there are still data to be transferred */
if (EV_FD_COND_S(t->srv_fd, DIR_WR)) { if (EV_FD_COND_S(t->srv_fd, DIR_WR)) {
/* restart writing */ /* restart writing */
if (tv_add_ifset(&req->wex, &now, &t->be->srvtimeout)) { if (tv_add_ifset(&req->wex, &now, &t->be->timeout.server)) {
/* FIXME: to prevent the server from expiring read timeouts during writes, /* FIXME: to prevent the server from expiring read timeouts during writes,
* we refresh it. */ * we refresh it. */
rep->rex = req->wex; rep->rex = req->wex;
@ -3220,7 +3220,7 @@ int process_srv(struct session *t)
} }
else { else {
if (EV_FD_COND_S(t->srv_fd, DIR_RD)) { if (EV_FD_COND_S(t->srv_fd, DIR_RD)) {
if (!tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout)) if (!tv_add_ifset(&rep->rex, &now, &t->be->timeout.server))
tv_eternity(&rep->rex); tv_eternity(&rep->rex);
} }
} }
@ -3296,7 +3296,7 @@ int process_srv(struct session *t)
else { /* buffer not empty */ else { /* buffer not empty */
if (EV_FD_COND_S(t->srv_fd, DIR_WR)) { if (EV_FD_COND_S(t->srv_fd, DIR_WR)) {
/* restart writing */ /* restart writing */
if (!tv_add_ifset(&req->wex, &now, &t->be->srvtimeout)) if (!tv_add_ifset(&req->wex, &now, &t->be->timeout.server))
tv_eternity(&req->wex); tv_eternity(&req->wex);
} }
} }
@ -3369,7 +3369,7 @@ int process_srv(struct session *t)
} }
else { else {
if (EV_FD_COND_S(t->srv_fd, DIR_RD)) { if (EV_FD_COND_S(t->srv_fd, DIR_RD)) {
if (!tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout)) if (!tv_add_ifset(&rep->rex, &now, &t->be->timeout.server))
tv_eternity(&rep->rex); tv_eternity(&rep->rex);
} }
} }
@ -3490,8 +3490,8 @@ int apply_filter_to_req_headers(struct session *t, struct buffer *req, struct hd
* frontend, and the beconn will be updated later. * frontend, and the beconn will be updated later.
*/ */
t->rep->rto = t->req->wto = t->be->srvtimeout; t->rep->rto = t->req->wto = t->be->timeout.server;
t->req->cto = t->be->contimeout; t->req->cto = t->be->timeout.connect;
t->conn_retries = t->be->conn_retries; t->conn_retries = t->be->conn_retries;
last_hdr = 1; last_hdr = 1;
break; break;
@ -3611,8 +3611,8 @@ int apply_filter_to_req_line(struct session *t, struct buffer *req, struct hdr_e
* frontend, and the beconn will be updated later. * frontend, and the beconn will be updated later.
*/ */
t->rep->rto = t->req->wto = t->be->srvtimeout; t->rep->rto = t->req->wto = t->be->timeout.server;
t->req->cto = t->be->contimeout; t->req->cto = t->be->timeout.connect;
t->conn_retries = t->be->conn_retries; t->conn_retries = t->be->conn_retries;
done = 1; done = 1;
break; break;
@ -4009,7 +4009,7 @@ void manage_client_side_cookies(struct session *t, struct buffer *req)
}/* end while(srv) */ }/* end while(srv) */
}/* end else if server == NULL */ }/* end else if server == NULL */
tv_add(&asession_temp->expire, &now, &t->be->appsession_timeout); tv_add(&asession_temp->expire, &now, &t->be->timeout.appsession);
}/* end if ((t->proxy->appsession_name != NULL) ... */ }/* end if ((t->proxy->appsession_name != NULL) ... */
} }
@ -4463,7 +4463,7 @@ void manage_server_side_cookies(struct session *t, struct buffer *rtr)
if (asession_temp->serverid[0] == '\0') if (asession_temp->serverid[0] == '\0')
memcpy(asession_temp->serverid, t->srv->id, server_id_len); memcpy(asession_temp->serverid, t->srv->id, server_id_len);
tv_add(&asession_temp->expire, &now, &t->be->appsession_timeout); tv_add(&asession_temp->expire, &now, &t->be->timeout.appsession);
#if defined(DEBUG_HASH) #if defined(DEBUG_HASH)
appsession_hash_dump(&(t->be->htbl_proxy)); appsession_hash_dump(&(t->be->htbl_proxy));
@ -4625,7 +4625,7 @@ void get_srv_from_appsession(struct session *t, const char *begin, int len)
pool_free2(apools.sessid, local_asession.sessid); pool_free2(apools.sessid, local_asession.sessid);
} }
tv_add(&asession_temp->expire, &now, &t->be->appsession_timeout); tv_add(&asession_temp->expire, &now, &t->be->timeout.appsession);
asession_temp->request_count++; asession_temp->request_count++;
#if defined(DEBUG_HASH) #if defined(DEBUG_HASH)

16
src/proxy.c
View File

@ -97,8 +97,8 @@ int proxy_parse_timeout(const char **args, struct proxy *proxy,
name = args[0]; name = args[0];
if (!strcmp(args[0], "client") || !strcmp(args[0], "clitimeout")) { if (!strcmp(args[0], "client") || !strcmp(args[0], "clitimeout")) {
name = "client"; name = "client";
tv = &proxy->clitimeout; tv = &proxy->timeout.client;
td = &defpx->clitimeout; td = &defpx->timeout.client;
cap = PR_CAP_FE; cap = PR_CAP_FE;
} else if (!strcmp(args[0], "tarpit")) { } else if (!strcmp(args[0], "tarpit")) {
tv = &proxy->timeout.tarpit; tv = &proxy->timeout.tarpit;
@ -106,17 +106,17 @@ int proxy_parse_timeout(const char **args, struct proxy *proxy,
cap = PR_CAP_FE; cap = PR_CAP_FE;
} else if (!strcmp(args[0], "server") || !strcmp(args[0], "srvtimeout")) { } else if (!strcmp(args[0], "server") || !strcmp(args[0], "srvtimeout")) {
name = "server"; name = "server";
tv = &proxy->srvtimeout; tv = &proxy->timeout.server;
td = &defpx->srvtimeout; td = &defpx->timeout.server;
cap = PR_CAP_BE; cap = PR_CAP_BE;
} else if (!strcmp(args[0], "connect") || !strcmp(args[0], "contimeout")) { } else if (!strcmp(args[0], "connect") || !strcmp(args[0], "contimeout")) {
name = "connect"; name = "connect";
tv = &proxy->contimeout; tv = &proxy->timeout.connect;
td = &defpx->contimeout; td = &defpx->timeout.connect;
cap = PR_CAP_BE; cap = PR_CAP_BE;
} else if (!strcmp(args[0], "appsession")) { } else if (!strcmp(args[0], "appsession")) {
tv = &proxy->appsession_timeout; tv = &proxy->timeout.appsession;
td = &defpx->appsession_timeout; td = &defpx->timeout.appsession;
cap = PR_CAP_BE; cap = PR_CAP_BE;
} else if (!strcmp(args[0], "queue")) { } else if (!strcmp(args[0], "queue")) {
tv = &proxy->timeout.queue; tv = &proxy->timeout.queue;