RepoMirrors
/
haproxy
mirror of http://git.haproxy.org/git/haproxy.git/
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
haproxy/include/proto/proxy.h

159 lines
5.4 KiB
C
Raw Normal View History

[LICENSE] licensing clarifications
2006-06-15 19:48:13 +00:00
/*
[OPTIM] counters: move some max numbers to the counters struct There are a few remaining max values that need to move to counters. Also, the counters are more often used than some config information, so get them closer to the other useful struct members for better cache efficiency.
2009-10-04 21:12:44 +00:00
* include/proto/proxy.h
* This file defines function prototypes for proxy management.
*
[MAJOR] proxy: finally get rid of maintain_proxies() This function is finally not needed anymore, as it has been replaced with a per-proxy task that is scheduled when some limits are encountered on incoming connections or when the process is stopping. The savings should be noticeable on configs with a large number of proxies. The most important point is that the rate limiting is now enforced in a clean and solid way.
2011-07-25 14:33:49 +00:00
* Copyright (C) 2000-2011 Willy Tarreau - w@1wt.eu
[OPTIM] counters: move some max numbers to the counters struct There are a few remaining max values that need to move to counters. Also, the counters are more often used than some config information, so get them closer to the other useful struct members for better cache efficiency.
2009-10-04 21:12:44 +00:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, version 2.1
* exclusively.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
[LICENSE] licensing clarifications
2006-06-15 19:48:13 +00:00
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
#ifndef _PROTO_PROXY_H
#define _PROTO_PROXY_H
[CLEANUP] included common/version.h everywhere
2006-06-29 16:54:54 +00:00
#include <common/config.h>
[MAJOR] convert all expiration timers from timeval to ticks This is the first attempt at moving all internal parts from using struct timeval to integer ticks. Those provides simpler and faster code due to simplified operations, and this change also saved about 64 bytes per session. A new header file has been added : include/common/ticks.h. It is possible that some functions should finally not be inlined because they're used quite a lot (eg: tick_first, tick_add_ifset and tick_is_expired). More measurements are required in order to decide whether this is interesting or not. Some function and variable names are still subject to change for a better overall logics.
2008-07-06 22:09:58 +00:00
#include <common/ticks.h>
[MAJOR] replaced all timeouts with struct timeval The timeout functions were difficult to manipulate because they were rounding results to the millisecond. Thus, it was difficult to compare and to check what expired and what did not. Also, the comparison functions were heavy with multiplies and divides by 1000. Now, all timeouts are stored in timevals, reducing the number of operations for updates and leading to cleaner and more efficient code.
2007-05-12 20:35:00 +00:00
#include <common/time.h>
MINOR: proxy: create new function cli_find_frontend() to find a frontend Several CLI commands require a frontend, so let's have a function to look this one up and prepare the appropriate error message and the appctx's state in case of failure.
2016-11-24 11:02:29 +00:00
#include <types/applet.h>
[MEDIUM] add support for global.maxconnrate to limit the per-process conn rate. This one enforces a per-process connection rate limit, regardless of what may be set per frontend. It can be a way to limit the CPU usage of a process being severely attacked. The side effect is that the global process connection rate is now measured for each incoming connection, so it will be possible to report it.
2011-09-07 13:17:21 +00:00
#include <types/global.h>
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
#include <types/proxy.h>
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 20:58:11 +00:00
#include <types/listener.h>
[MEDIUM] measure and report session rate on frontend, backends and servers With this change, all frontends, backends, and servers maintain a session counter and a timer to compute a session rate over the last second. This value will be very useful because it varies instantly and can be used to check thresholds. This value is also reported in the stats in a new "rate" column.
2009-03-05 17:43:00 +00:00
#include <proto/freq_ctr.h>
[LICENSE] licensing clarifications
2006-06-15 19:48:13 +00:00
MEDIUM: proxy: create a tree to store proxies by name Large configurations can take time to parse when thousands of backends are in use. Let's store all the proxies in trees. findproxy_mode() has been modified to use the tree for lookups, which has divided the parsing time by about 2.5. But many lookups are still present at many places and need to be dealt with.
2014-03-15 06:22:35 +00:00
extern struct proxy *proxy;
extern struct eb_root used_proxy_id; /* list of proxy IDs in use */
extern unsigned int error_snapshot_id; /* global ID assigned to each error then incremented */
extern struct eb_root proxy_by_name; /* tree of proxies sorted by name */
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
int start_proxies(int verbose);
[MAJOR] proxy: finally get rid of maintain_proxies() This function is finally not needed anymore, as it has been replaced with a per-proxy task that is scheduled when some limits are encountered on incoming connections or when the process is stopping. The savings should be noticeable on configs with a large number of proxies. The most important point is that the rate limiting is now enforced in a clean and solid way.
2011-07-25 14:33:49 +00:00
struct task *manage_proxy(struct task *t);
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
void soft_stop(void);
[CLEANUP] proxy: make pause_proxy() perform the required controls and emit the logs It avoids duplicated code in the caller.
2011-09-07 17:14:57 +00:00
int pause_proxy(struct proxy *p);
[MEDIUM] stats: add the ability to enable/disable/shutdown a frontend at runtime The stats socket now allows the admin to disable, enable or shutdown a frontend. This can be used when a bug is discovered in a configuration and it's desirable to fix it but the rules in place don't allow to change a running config. Thus it becomes possible to kill the frontend to release the port and start a new one in a separate process. This can also be used to temporarily make haproxy return TCP resets to incoming requests to pretend the service is not bound. For instance, this may be useful to quickly flush a very deep SYN backlog. The frontend check and lookup code was factored with the "set maxconn" usage.
2011-09-07 20:37:44 +00:00
int resume_proxy(struct proxy *p);
[BUG] ensure that listeners from disabled proxies are correctly unbound. There is a problem when an instance is marked "disabled". Its ports are still bound but will not be unbound upon termination. This causes processes to accumulate during soft restarts, and might even cause failures to restart new ones due to the inability to bind to the same port. The ideal solution would be to bind all ports at the end of the configuration parsing. An acceptable workaround is to unbind all listeners of disabled proxies. This is what the current patch does. (cherry picked from commit a944218e9c1d5ff1aca34609146389dc680335b7) (cherry picked from commit 8cfebbb82b87345bade831920177077e7d25840a)
2008-10-12 10:07:48 +00:00
void stop_proxy(struct proxy *p);
MINOR: proxy: Don't close FDs if not our proxy. When running with multiple process, if some proxies are just assigned to some processes, the other processes will just close the file descriptors for the listening sockets. However, we may still have to provide those sockets when reloading, so instead we just try hard to pretend those proxies are dead, while keeping the sockets opened. A new global option, no-reused-socket", has been added, to restore the old behavior of closing the sockets not bound to this process.
2017-04-05 23:05:05 +00:00
void zombify_proxy(struct proxy *p);
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
void pause_proxies(void);
[MEDIUM] proxy: add a PAUSED state to listeners and move socket tricks out of proxy.c Managing listeners state is difficult because they have their own state and can at the same time have theirs dictated by their proxy. The pause is not done properly, as the proxy code is fiddling with sockets. By introducing new functions such as pause_listener()/resume_listener(), we make it a bit more obvious how/when they're supposed to be used. The listen_proxies() function was also renamed to resume_proxies() since it's only used for pause/resume. This patch is the first in a series aiming at getting rid of the maintain_proxies mess. In the end, proxies should not call enable_listener()/disable_listener() anymore.
2011-07-24 16:28:10 +00:00
void resume_proxies(void);
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 22:22:06 +00:00
int stream_set_backend(struct stream *s, struct proxy *be);
[LICENSE] licensing clarifications
2006-06-15 19:48:13 +00:00
[MINOR] adjust error messages about conflicting proxies It's not easy to report useful information to help the user quickly fix a configuration. This patch : - removes the word "listener" in favor of "proxy" as it has been used since the beginning ; - ensures that the same function (hence the same words) will be used to report capabilities of a proxy being declared and an existing proxy ; - avoid the term "conflicting capabilities" in favor of "overlapping capabilities" which is more exact. - just report that the same name is reused in case of warnings
2007-11-04 06:04:43 +00:00
const char *proxy_cap_str(int cap);
[MEDIUM] Implement and use generic findproxy and relax duplicated proxy check This patch: - adds proxy_mode_str() similar to proxy_type_str() - adds a generic findproxy function used with default_backend/setbe/use_backed - rewrite default_backend/senbe/use_backed to use introduced findproxy() - relaxes duplicated proxy check - changes capabilities displaying from "%X" to "%s" with a call to proxy_type_str()
2007-11-03 22:41:58 +00:00
const char *proxy_mode_str(int mode);
MEDIUM: proxy: create a tree to store proxies by name Large configurations can take time to parse when thousands of backends are in use. Let's store all the proxies in trees. findproxy_mode() has been modified to use the tree for lookups, which has divided the parsing time by about 2.5. But many lookups are still present at many places and need to be dealt with.
2014-03-15 06:22:35 +00:00
void proxy_store_name(struct proxy *px);
MINOR: proxy: add a new function proxy_find_by_id() It does the same as the other one except that it only focuses on the numeric ID and the capabilities. It's used by proxy_find_by_name() for numeric names.
2015-05-26 13:25:32 +00:00
struct proxy *proxy_find_by_id(int id, int cap, int table);
CLEANUP: proxy: make the proxy lookup functions more user-friendly First, findproxy() was renamed proxy_find_by_name() so that its explicit that a name is required for the lookup. Second, we give this function the ability to search for tables if needed. Third we now provide inline wrappers to pass the appropriate PR_CAP_* flags and to explicitly look up a frontend, backend or table.
2015-05-26 09:24:42 +00:00
struct proxy *proxy_find_by_name(const char *name, int cap, int table);
MEDIUM: proxy: add a new proxy_find_best_match() function This function tries to spot a proxy by its name, ID and type, and in case some elements don't match, it tries to determine which ones could be ignored and reports which ones were ignored so that the caller can decide whether or not it wants to pick this proxy. This will be used for maintaining the status across reloads where the config might have changed a bit.
2015-05-27 14:46:26 +00:00
struct proxy *proxy_find_best_match(int cap, const char *name, int id, int *diff);
[MEDIUM] Implement "track [<backend>/]<server>" This patch implements ability to set the current state of one server by tracking another one. It: - adds two variables: *tracknext, *tracked to struct server - implements findserver(), similar to findproxy() - adds "track" keyword accepting both "proxy/server" and "server" (assuming current proxy) - verifies if both checks and tracking is not enabled at the same time - changes set_server_down() to notify tracking server - creates set_server_up(), set_server_disabled(), set_server_enabled() by moving the code from process_chk() and adding notifications - changes stats to show a name of tracked server instead of Chk/Dwn/Dwntime(html) or by adding new variable (csv) Changes from the previuos version: - it is possibile to track independently of the declaration order - one extra comma bug is fixed - new condition to check if there is no disable-on-404 inconsistency
2008-02-18 00:26:35 +00:00
struct server *findserver(const struct proxy *px, const char *name);
[MEDIUM] config: split parser and checker in two functions This is a first step towards support of multiple configuration files. Now readcfgfile() only reads a file in memory and performs very minimal parsing. The checks are performed afterwards.
2009-06-22 13:48:36 +00:00
int proxy_cfg_ensure_no_http(struct proxy *curproxy);
[BUG] proxy: stats frontend and peers were missing many initializers This was revealed with one of the very latest patches which caused the listener_queue not to be initialized on the stats socket frontend. And in fact a number of other ones were missing too. This is getting so boring that now we'll always make use of the same function to initialize any proxy. Doing so has even saved about 500 bytes on the binary due to the avoided code redundancy. No backport is needed.
2011-07-28 23:49:03 +00:00
void init_new_proxy(struct proxy *p);
[MINOR] proxy: provide function to retrieve backend/server pointers int get_backend_server(const char *bk_name, const char *sv_name, struct proxy **bk, struct server **sv); This function scans the list of backends and servers to retrieve the first backend and the first server with the given names, and sets them in both parameters. It returns zero if either is not found, or non-zero and sets the ones it did not found to NULL. If a NULL pointer is passed for the backend, only the pointer to the server will be updated.
2009-10-10 16:35:51 +00:00
int get_backend_server(const char *bk_name, const char *sv_name,
struct proxy **bk, struct server **sv);
MINOR: proxy: create new function cli_find_frontend() to find a frontend Several CLI commands require a frontend, so let's have a function to look this one up and prepare the appropriate error message and the appctx's state in case of failure.
2016-11-24 11:02:29 +00:00
struct proxy *cli_find_frontend(struct appctx *appctx, const char *arg);
MINOR: cli: Let configure the dynamic cookies from the cli. This adds 3 new commands to the cli : enable dynamic-cookie backend <backend> that enables dynamic cookies for a specified backend disable dynamic-cookie backend <backend> that disables dynamic cookies for a specified backend set dynamic-cookie-key backend <backend> that lets one change the dynamic cookie secret key, for a specified backend.
2017-03-14 19:08:46 +00:00
struct proxy *cli_find_frontend(struct appctx *appctx, const char *arg);
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
[MINOR] adjust error messages about conflicting proxies It's not easy to report useful information to help the user quickly fix a configuration. This patch : - removes the word "listener" in favor of "proxy" as it has been used since the beginning ; - ensures that the same function (hence the same words) will be used to report capabilities of a proxy being declared and an existing proxy ; - avoid the term "conflicting capabilities" in favor of "overlapping capabilities" which is more exact. - just report that the same name is reused in case of warnings
2007-11-04 06:04:43 +00:00
/*
* This function returns a string containing the type of the proxy in a format
* suitable for error messages, from its capabilities.
*/
static inline const char *proxy_type_str(struct proxy *proxy)
{
return proxy_cap_str(proxy->cap);
}
CLEANUP: proxy: make the proxy lookup functions more user-friendly First, findproxy() was renamed proxy_find_by_name() so that its explicit that a name is required for the lookup. Second, we give this function the ability to search for tables if needed. Third we now provide inline wrappers to pass the appropriate PR_CAP_* flags and to explicitly look up a frontend, backend or table.
2015-05-26 09:24:42 +00:00
/* Find the frontend having name <name>. The name may also start with a '#' to
* reference a numeric id. NULL is returned if not found.
*/
static inline struct proxy *proxy_fe_by_name(const char *name)
{
return proxy_find_by_name(name, PR_CAP_FE, 0);
}
/* Find the backend having name <name>. The name may also start with a '#' to
* reference a numeric id. NULL is returned if not found.
*/
static inline struct proxy *proxy_be_by_name(const char *name)
{
return proxy_find_by_name(name, PR_CAP_BE, 0);
}
/* Find the table having name <name>. The name may also start with a '#' to
* reference a numeric id. NULL is returned if not found.
*/
static inline struct proxy *proxy_tbl_by_name(const char *name)
{
return proxy_find_by_name(name, 0, 1);
}
[BUG] timeout.check was not pre-set to eternity If timeout.check was not set, check were using 0 as the timeout, causing odd behaviours.
2008-02-15 10:15:34 +00:00
/* this function initializes all timeouts for proxy p */
static inline void proxy_reset_timeouts(struct proxy *proxy)
{
[MAJOR] convert all expiration timers from timeval to ticks This is the first attempt at moving all internal parts from using struct timeval to integer ticks. Those provides simpler and faster code due to simplified operations, and this change also saved about 64 bytes per session. A new header file has been added : include/common/ticks.h. It is possible that some functions should finally not be inlined because they're used quite a lot (eg: tick_first, tick_add_ifset and tick_is_expired). More measurements are required in order to decide whether this is interesting or not. Some function and variable names are still subject to change for a better overall logics.
2008-07-06 22:09:58 +00:00
proxy->timeout.client = TICK_ETERNITY;
proxy->timeout.tarpit = TICK_ETERNITY;
proxy->timeout.queue = TICK_ETERNITY;
proxy->timeout.connect = TICK_ETERNITY;
proxy->timeout.server = TICK_ETERNITY;
proxy->timeout.httpreq = TICK_ETERNITY;
proxy->timeout.check = TICK_ETERNITY;
MEDIUM: session: add support for tunnel timeouts Tunnel timeouts are used when TCP connections are forwarded, or when forwarding upgraded HTTP connections (WebSocket) as well as CONNECT requests to proxies. This timeout allows long-lived sessions to be supported without having to set large timeouts to normal requests.
2012-05-12 10:50:00 +00:00
proxy->timeout.tunnel = TICK_ETERNITY;
[BUG] timeout.check was not pre-set to eternity If timeout.check was not set, check were using 0 as the timeout, causing odd behaviours.
2008-02-15 10:15:34 +00:00
}
[MINOR] session: differenciate between accepted connections and received connections Now we're able to reject connections very early, so we need to use a different counter for the connections that are received and the ones that are accepted and converted into sessions, so that the rate limits can still apply to the accepted ones. The session rate must still be used to compute the rate limit, so that we can reject undesired traffic without affecting the rate.
2010-06-04 18:59:39 +00:00
/* increase the number of cumulated connections received on the designated frontend */
static void inline proxy_inc_fe_conn_ctr(struct listener *l, struct proxy *fe)
[MEDIUM] measure and report session rate on frontend, backends and servers With this change, all frontends, backends, and servers maintain a session counter and a timer to compute a session rate over the last second. This value will be very useful because it varies instantly and can be used to check thresholds. This value is also reported in the stats in a new "rate" column.
2009-03-05 17:43:00 +00:00
{
[MEDIUM] stats: split frontend and backend stats It's very annoying that frontend and backend stats are merged because we don't know what we're observing. For instance, if a "listen" instance makes use of a distinct backend, it's impossible to know what the bytes_out means. Some points take care of not updating counters twice if the backend points to the frontend, indicating a "listen" instance. The thing becomes more complex when we try to add support for server side keep-alive, because we have to maintain a pointer to the backend used for last request, and to update its stats. But we can't perform such comparisons anymore because the counters will not match anymore. So in order to get rid of this situation, let's have both frontend AND backend stats in the "struct proxy". We simply update the relevant ones during activity. Some of them are only accounted for in the backend, while others are just for frontend. Maybe we can improve a bit on that later, but the essential part is that those counters now reflect what they really mean.
2011-03-10 22:25:56 +00:00
fe->fe_counters.cum_conn++;
[MEDIUM] Collect & provide separate statistics for sockets, v2 This patch allows to collect & provide separate statistics for each socket. It can be very useful if you would like to distinguish between traffic generate by local and remote users or between different types of remote clients (peerings, domestic, foreign). Currently no "Session rate" is supported, but adding it should be possible if we found it useful.
2009-10-04 13:43:17 +00:00
if (l->counters)
l->counters->cum_conn++;
[MINOR] session: differenciate between accepted connections and received connections Now we're able to reject connections very early, so we need to use a different counter for the connections that are received and the ones that are accepted and converted into sessions, so that the rate limits can still apply to the accepted ones. The session rate must still be used to compute the rate limit, so that we can reject undesired traffic without affecting the rate.
2010-06-04 18:59:39 +00:00
update_freq_ctr(&fe->fe_conn_per_sec, 1);
[MEDIUM] stats: split frontend and backend stats It's very annoying that frontend and backend stats are merged because we don't know what we're observing. For instance, if a "listen" instance makes use of a distinct backend, it's impossible to know what the bytes_out means. Some points take care of not updating counters twice if the backend points to the frontend, indicating a "listen" instance. The thing becomes more complex when we try to add support for server side keep-alive, because we have to maintain a pointer to the backend used for last request, and to update its stats. But we can't perform such comparisons anymore because the counters will not match anymore. So in order to get rid of this situation, let's have both frontend AND backend stats in the "struct proxy". We simply update the relevant ones during activity. Some of them are only accounted for in the backend, while others are just for frontend. Maybe we can improve a bit on that later, but the essential part is that those counters now reflect what they really mean.
2011-03-10 22:25:56 +00:00
if (fe->fe_conn_per_sec.curr_ctr > fe->fe_counters.cps_max)
fe->fe_counters.cps_max = fe->fe_conn_per_sec.curr_ctr;
[MINOR] session: differenciate between accepted connections and received connections Now we're able to reject connections very early, so we need to use a different counter for the connections that are received and the ones that are accepted and converted into sessions, so that the rate limits can still apply to the accepted ones. The session rate must still be used to compute the rate limit, so that we can reject undesired traffic without affecting the rate.
2010-06-04 18:59:39 +00:00
}
/* increase the number of cumulated connections accepted by the designated frontend */
static void inline proxy_inc_fe_sess_ctr(struct listener *l, struct proxy *fe)
{
[MEDIUM] stats: split frontend and backend stats It's very annoying that frontend and backend stats are merged because we don't know what we're observing. For instance, if a "listen" instance makes use of a distinct backend, it's impossible to know what the bytes_out means. Some points take care of not updating counters twice if the backend points to the frontend, indicating a "listen" instance. The thing becomes more complex when we try to add support for server side keep-alive, because we have to maintain a pointer to the backend used for last request, and to update its stats. But we can't perform such comparisons anymore because the counters will not match anymore. So in order to get rid of this situation, let's have both frontend AND backend stats in the "struct proxy". We simply update the relevant ones during activity. Some of them are only accounted for in the backend, while others are just for frontend. Maybe we can improve a bit on that later, but the essential part is that those counters now reflect what they really mean.
2011-03-10 22:25:56 +00:00
fe->fe_counters.cum_sess++;
[MINOR] session: differenciate between accepted connections and received connections Now we're able to reject connections very early, so we need to use a different counter for the connections that are received and the ones that are accepted and converted into sessions, so that the rate limits can still apply to the accepted ones. The session rate must still be used to compute the rate limit, so that we can reject undesired traffic without affecting the rate.
2010-06-04 18:59:39 +00:00
if (l->counters)
l->counters->cum_sess++;
[MEDIUM] measure and report session rate on frontend, backends and servers With this change, all frontends, backends, and servers maintain a session counter and a timer to compute a session rate over the last second. This value will be very useful because it varies instantly and can be used to check thresholds. This value is also reported in the stats in a new "rate" column.
2009-03-05 17:43:00 +00:00
update_freq_ctr(&fe->fe_sess_per_sec, 1);
[MEDIUM] stats: split frontend and backend stats It's very annoying that frontend and backend stats are merged because we don't know what we're observing. For instance, if a "listen" instance makes use of a distinct backend, it's impossible to know what the bytes_out means. Some points take care of not updating counters twice if the backend points to the frontend, indicating a "listen" instance. The thing becomes more complex when we try to add support for server side keep-alive, because we have to maintain a pointer to the backend used for last request, and to update its stats. But we can't perform such comparisons anymore because the counters will not match anymore. So in order to get rid of this situation, let's have both frontend AND backend stats in the "struct proxy". We simply update the relevant ones during activity. Some of them are only accounted for in the backend, while others are just for frontend. Maybe we can improve a bit on that later, but the essential part is that those counters now reflect what they really mean.
2011-03-10 22:25:56 +00:00
if (fe->fe_sess_per_sec.curr_ctr > fe->fe_counters.sps_max)
fe->fe_counters.sps_max = fe->fe_sess_per_sec.curr_ctr;
[MEDIUM] measure and report session rate on frontend, backends and servers With this change, all frontends, backends, and servers maintain a session counter and a timer to compute a session rate over the last second. This value will be very useful because it varies instantly and can be used to check thresholds. This value is also reported in the stats in a new "rate" column.
2009-03-05 17:43:00 +00:00
}
/* increase the number of cumulated connections on the designated backend */
static void inline proxy_inc_be_ctr(struct proxy *be)
{
[MEDIUM] stats: split frontend and backend stats It's very annoying that frontend and backend stats are merged because we don't know what we're observing. For instance, if a "listen" instance makes use of a distinct backend, it's impossible to know what the bytes_out means. Some points take care of not updating counters twice if the backend points to the frontend, indicating a "listen" instance. The thing becomes more complex when we try to add support for server side keep-alive, because we have to maintain a pointer to the backend used for last request, and to update its stats. But we can't perform such comparisons anymore because the counters will not match anymore. So in order to get rid of this situation, let's have both frontend AND backend stats in the "struct proxy". We simply update the relevant ones during activity. Some of them are only accounted for in the backend, while others are just for frontend. Maybe we can improve a bit on that later, but the essential part is that those counters now reflect what they really mean.
2011-03-10 22:25:56 +00:00
be->be_counters.cum_conn++;
[MEDIUM] measure and report session rate on frontend, backends and servers With this change, all frontends, backends, and servers maintain a session counter and a timer to compute a session rate over the last second. This value will be very useful because it varies instantly and can be used to check thresholds. This value is also reported in the stats in a new "rate" column.
2009-03-05 17:43:00 +00:00
update_freq_ctr(&be->be_sess_per_sec, 1);
[MEDIUM] stats: split frontend and backend stats It's very annoying that frontend and backend stats are merged because we don't know what we're observing. For instance, if a "listen" instance makes use of a distinct backend, it's impossible to know what the bytes_out means. Some points take care of not updating counters twice if the backend points to the frontend, indicating a "listen" instance. The thing becomes more complex when we try to add support for server side keep-alive, because we have to maintain a pointer to the backend used for last request, and to update its stats. But we can't perform such comparisons anymore because the counters will not match anymore. So in order to get rid of this situation, let's have both frontend AND backend stats in the "struct proxy". We simply update the relevant ones during activity. Some of them are only accounted for in the backend, while others are just for frontend. Maybe we can improve a bit on that later, but the essential part is that those counters now reflect what they really mean.
2011-03-10 22:25:56 +00:00
if (be->be_sess_per_sec.curr_ctr > be->be_counters.sps_max)
be->be_counters.sps_max = be->be_sess_per_sec.curr_ctr;
[MEDIUM] measure and report session rate on frontend, backends and servers With this change, all frontends, backends, and servers maintain a session counter and a timer to compute a session rate over the last second. This value will be very useful because it varies instantly and can be used to check thresholds. This value is also reported in the stats in a new "rate" column.
2009-03-05 17:43:00 +00:00
}
[STATS] report HTTP requests (total and rate) in frontends Now that we support keep-alive, it's important to report a separate counter for requests. Right now it just appears in the CSV output.
2010-02-26 09:05:55 +00:00
/* increase the number of cumulated requests on the designated frontend */
static void inline proxy_inc_fe_req_ctr(struct proxy *fe)
{
[MEDIUM] stats: split frontend and backend stats It's very annoying that frontend and backend stats are merged because we don't know what we're observing. For instance, if a "listen" instance makes use of a distinct backend, it's impossible to know what the bytes_out means. Some points take care of not updating counters twice if the backend points to the frontend, indicating a "listen" instance. The thing becomes more complex when we try to add support for server side keep-alive, because we have to maintain a pointer to the backend used for last request, and to update its stats. But we can't perform such comparisons anymore because the counters will not match anymore. So in order to get rid of this situation, let's have both frontend AND backend stats in the "struct proxy". We simply update the relevant ones during activity. Some of them are only accounted for in the backend, while others are just for frontend. Maybe we can improve a bit on that later, but the essential part is that those counters now reflect what they really mean.
2011-03-10 22:25:56 +00:00
fe->fe_counters.p.http.cum_req++;
[STATS] report HTTP requests (total and rate) in frontends Now that we support keep-alive, it's important to report a separate counter for requests. Right now it just appears in the CSV output.
2010-02-26 09:05:55 +00:00
update_freq_ctr(&fe->fe_req_per_sec, 1);
[MEDIUM] stats: split frontend and backend stats It's very annoying that frontend and backend stats are merged because we don't know what we're observing. For instance, if a "listen" instance makes use of a distinct backend, it's impossible to know what the bytes_out means. Some points take care of not updating counters twice if the backend points to the frontend, indicating a "listen" instance. The thing becomes more complex when we try to add support for server side keep-alive, because we have to maintain a pointer to the backend used for last request, and to update its stats. But we can't perform such comparisons anymore because the counters will not match anymore. So in order to get rid of this situation, let's have both frontend AND backend stats in the "struct proxy". We simply update the relevant ones during activity. Some of them are only accounted for in the backend, while others are just for frontend. Maybe we can improve a bit on that later, but the essential part is that those counters now reflect what they really mean.
2011-03-10 22:25:56 +00:00
if (fe->fe_req_per_sec.curr_ctr > fe->fe_counters.p.http.rps_max)
fe->fe_counters.p.http.rps_max = fe->fe_req_per_sec.curr_ctr;
[STATS] report HTTP requests (total and rate) in frontends Now that we support keep-alive, it's important to report a separate counter for requests. Right now it just appears in the CSV output.
2010-02-26 09:05:55 +00:00
}
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
#endif /* _PROTO_PROXY_H */
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/