upstream/haproxy
1
0
Fork 0
mirror of https://github.com/haproxy/haproxy.git synced 2026-04-26 08:38:20 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
haproxy/include/haproxy/backend.h

167 lines
5.2 KiB
C
Raw Normal View History

[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-25 20:48:02 -04:00
/*
REORG: include: move backend.h to haproxy/backend{,-t}.h The files remained mostly unchanged since they were OK. However, half of the users didn't need to include them, and about as many actually needed to have it and used to find functions like srv_currently_usable() through a long chain that broke when moving the file.
2020-06-04 16:50:02 -04:00
* include/haproxy/backend.h
BUG/MEDIUM: correctly disable servers tracking another disabled servers. In a config where server "s1" is marked disabled and "s2" tracks "s1", s2 appears disabled on the stats but is still inserted into the LB farm because the tracking is resolved too late in the configuration process. We now resolve tracked servers before building LB maps and we also mark the tracking server in maintenance mode, which previously was not done, causing half of the issue. Last point is that we also protect srv_is_usable() against electing a server marked for maintenance. This is not absolutely needed but is a safe choice and makes a lot of sense. This fix must be backported to 1.4.
2012-01-20 07:12:32 -05:00
* Functions prototypes for the backend.
*
* Copyright (C) 2000-2012 Willy Tarreau - w@1wt.eu
*
* 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
*/
[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-25 20:48:02 -04:00
REORG: include: move backend.h to haproxy/backend{,-t}.h The files remained mostly unchanged since they were OK. However, half of the users didn't need to include them, and about as many actually needed to have it and used to find functions like srv_currently_usable() through a long chain that broke when moving the file.
2020-06-04 16:50:02 -04:00
#ifndef _HAPROXY_BACKEND_H
#define _HAPROXY_BACKEND_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-25 20:48:02 -04:00
REORG: include: update all files to use haproxy/api.h or api-t.h if needed All files that were including one of the following include files have been updated to only include haproxy/api.h or haproxy/api-t.h once instead: - common/config.h - common/compat.h - common/compiler.h - common/defaults.h - common/initcall.h - common/tools.h The choice is simple: if the file only requires type definitions, it includes api-t.h, otherwise it includes the full api.h. In addition, in these files, explicit includes for inttypes.h and limits.h were dropped since these are now covered by api.h and api-t.h. No other change was performed, given that this patch is large and affects 201 files. At least one (tools.h) was already freestanding and didn't get the new one added.
2020-05-27 06:58:42 -04:00
#include <haproxy/api.h>
CLEANUP: include: tree-wide alphabetical sort of include files This patch fixes all the leftovers from the include cleanup campaign. There were not that many (~400 entries in ~150 files) but it was definitely worth doing it as it revealed a few duplicates.
2020-06-09 03:07:15 -04:00
#include <haproxy/backend-t.h>
REORG: time: move time-keeping code and variables to clock.c There is currently a problem related to time keeping. We're mixing the functions to perform calculations with the os-dependent code needed to retrieve and adjust the local time. This patch extracts from time.{c,h} the parts that are solely dedicated to time keeping. These are the "now" or "before_poll" variables for example, as well as the various now_*() functions that make use of gettimeofday() and clock_gettime() to retrieve the current time. The "tv_*" functions moved there were also more appropriately renamed to "clock_*". Other parts used to compute stolen time are in other files, they will have to be picked next.
2021-10-08 03:33:24 -04:00
#include <haproxy/clock.h>
REORG: include: move proxy.h to haproxy/proxy{,-t}.h This one is particularly difficult to split because it provides all the functions used to manipulate a proxy state and to retrieve names or IDs for error reporting, and as such, it was included in 73 files (down to 68 after cleanup). It would deserve a small cleanup though the cut points are not obvious at the moment given the number of structs involved in the struct proxy itself.
2020-06-04 16:29:18 -04:00
#include <haproxy/proxy-t.h>
REORG: include: move server.h to haproxy/server{,-t}.h extern struct dict server_name_dict was moved from the type file to the main file. A handful of inlined functions were moved at the bottom of the file. Call places were updated to use server-t.h when relevant, or to simply drop the entry when not needed.
2020-06-04 17:20:13 -04:00
#include <haproxy/server-t.h>
REORG: include: move stream.h to haproxy/stream{,-t}.h This one was not easy because it was embarking many includes with it, which other files would automatically find. At least global.h, arg.h and tools.h were identified. 93 total locations were identified, 8 additional includes had to be added. In the rare files where it was possible to finalize the sorting of includes by adjusting only one or two extra lines, it was done. But all files would need to be rechecked and cleaned up now. It was the last set of files in types/ and proto/ and these directories must not be reused anymore.
2020-06-04 17:46:14 -04:00
#include <haproxy/stream-t.h>
MINOR: clock: do not use now.tv_sec anymore Instead we're using ns_to_sec(tv_to_ns(&now)) which allows the tv_sec part to disappear. At this point, "now" is only used as a timeval in clock.c where it is updated.
2023-04-28 01:39:44 -04:00
#include <haproxy/time.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-25 20:48:02 -04:00
MINOR: backend: export get_server_*() functions This is in preparation for exposing more of the LB internals.
2023-12-27 08:08:08 -05:00
struct server *get_server_sh(struct proxy *px, const char *addr, int len, const struct server *avoid);
struct server *get_server_uh(struct proxy *px, char *uri, int uri_len, const struct server *avoid);
struct server *get_server_ph(struct proxy *px, const char *uri, int uri_len, const struct server *avoid);
struct server *get_server_ph_post(struct stream *s, const struct server *avoid);
struct server *get_server_hh(struct stream *s, const struct server *avoid);
struct server *get_server_rch(struct stream *s, const struct server *avoid);
struct server *get_server_expr(struct stream *s, const struct server *avoid);
struct server *get_server_rnd(struct stream *s, const struct server *avoid);
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 18:22:06 -04:00
int assign_server(struct stream *s);
MAJOR: stream: store the target address into s->target_addr When forcing the outgoing address of a connection, till now we used to allocate this outgoing connection and set the address into it, then set SF_ADDR_SET. With connection reuse this causes a whole lot of issues and difficulties in the code. Thanks to the previous changes, it is now possible to store the target address into the stream instead, and copy the address from the stream to the connection when initializing the connection. assign_server_address() does this and as a result SF_ADDR_SET now reflects the presence of the target address in the stream, not in the connection. The http_proxy mode, the peers and the master's CLI now use the same mechanism. For now the existing connection code was not removed to limit the amount of tricky changes, but the allocated connection is not used anymore. This change also revealed a latent issue that we've been having around option http_proxy : the address was set in the connection but neither the SF_ADDR_SET nor the SF_ASSIGNED flags were set. It looks like the connection could establish only due to the fact that it existed with a non-null destination address.
2019-07-18 09:47:45 -04:00
int assign_server_address(struct stream *s);
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 18:22:06 -04:00
int assign_server_and_queue(struct stream *s);
MINOR: backend: refactor specific source address allocation Refactor alloc_bind_address() function which is used to allocate a sockaddr if a connection to a target server relies on a specific source address setting. The main objective of this change is to be able to use this function outside of backend module, namely for preconnections using a reverse server. As such, this function is now exported globally. For reverse connect, there is no stream instance. As such, the function parts which relied on it were reduced to the minimal. Now, stream is only used if a non-static address is configured which is useful for usesrc client|clientip|hdr_ip. These options have no sense for reverse connect so it should be safe to use the same function.
2023-10-02 11:17:15 -04:00
int alloc_bind_address(struct sockaddr_storage **ss,
struct server *srv, struct proxy *be,
struct stream *s);
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 18:22:06 -04:00
int srv_redispatch_connect(struct stream *t);
REORG: stream/backend: move backend-specific stuff to backend.c For more than a decade we've kept all the sess_update_st_*() functions in stream.c while they're only there to work in relation with what is currently being done in backend.c (srv_redispatch_connect, connect_server, etc). Let's move all this pollution over there and take this opportunity to try to find slightly less confusing names for these old functions whose role is only to handle transitions from one specific stream-int state: sess_update_st_rdy_tcp() -> back_handle_st_rdy() sess_update_st_con_tcp() -> back_handle_st_con() sess_update_st_cer() -> back_handle_st_cer() sess_update_stream_int() -> back_try_conn_req() sess_prepare_conn_req() -> back_handle_st_req() sess_establish() -> back_establish() The last one remained in stream.c because it's more or less a completion function which does all the initialization expected on a connection success or failure, can set analysers and emit logs. The other ones could possibly slightly benefit from being modified to take a stream-int instead since it's really what they're working with, but it's unimportant here.
2020-01-09 12:43:15 -05:00
void back_try_conn_req(struct stream *s);
void back_handle_st_req(struct stream *s);
void back_handle_st_con(struct stream *s);
void back_handle_st_rdy(struct stream *s);
void back_handle_st_cer(struct stream *s);
[MINOR]: stats: add show-legends to report additional informations Supported informations, available via "tr/td title": - cap: capabilities (proxy) - mode: one of tcp, http or health (proxy) - id: SNMP ID (proxy, socket, server) - IP (socket, server) - cookie (backend, server)
2010-01-04 10:03:09 -05:00
const char *backend_lb_algo_str(int algo);
MEDIUM: cfgparse: make backend_parse_balance() use memprintf to report errors Using the new error reporting framework makes it easier to report complex errors.
2012-05-08 12:14:39 -04:00
int backend_parse_balance(const char **args, char **err, struct proxy *curproxy);
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 18:22:06 -04:00
int tcp_persist_rdp_cookie(struct stream *s, struct channel *req, int an_bit);
[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-25 20:48:02 -04:00
[MEDIUM] stats: report server and backend cumulated downtime Hello, This patch implements new statistics for SLA calculation by adding new field 'Dwntime' with total down time since restart (both HTTP/CSV) and extending status field (HTTP) or inserting a new one (CSV) with time showing how long each server/backend is in a current state. Additionaly, down transations are also calculated and displayed for backends, so it is possible to know how many times selected backend was down, generating "No server is available to handle this request." error. New information are presentetd in two different ways: - for HTTP: a "human redable form", one of "100000d 23h", "23h 59m" or "59m 59s" - for CSV: seconds I believe that seconds resolution is enough. As there are more columns in the status page I decided to shrink some names to make more space: - Weight -> Wght - Check -> Chk - Down -> Dwn Making described changes I also made some improvements and fixed some small bugs: - don't increment s->health above 's->rise + s->fall - 1'. Previously it was incremented an then (re)set to 's->rise + s->fall - 1'. - do not set server down if it is down already - do not set server up if it is up already - fix colspan in multiple places (mostly introduced by my previous patch) - add missing "status" header to CSV - fix order of retries/redispatches in server (CSV) - s/Tthen/Then/ - s/server/backend/ in DATA_ST_PX_BE (dumpstats.c) Changes from previous version: - deal with negative time intervales - don't relay on s->state (SRV_RUNNING) - little reworked human_time + compacted format (no spaces). If needed it can be used in the future for other purposes by optionally making "cnt" as an argument - leave set_server_down mostly unchanged - only little reworked "process_chk: 9" - additional fields in CSV are appended to the rigth - fix "SEC" macro - named arguments (human_time, be_downtime, srv_downtime) Hope it is OK. If there are only cosmetic changes needed please fill free to correct it, however if there are some bigger changes required I would like to discuss it first or at last to know what exactly was changed especially since I already put this patch into my production server. :) Thank you, Best regards, Krzysztof Oledzki
2007-10-22 10:21:10 -04:00
int be_downtime(struct proxy *px);
[MINOR] backend: export some functions to recount servers Those functions will be used by new LB algorithms.
2009-10-01 03:17:05 -04:00
void recount_servers(struct proxy *px);
void update_backend_weight(struct proxy *px);
MINOR: stats: Enhancement to stats page to provide information of last session time. Summary: Track and report last session time on the stats page for each server in every backend, as well as the backend. This attempts to address the requirement in the ROADMAP - add a last activity date for each server (req/resp) that will be displayed in the stats. It will be useful with soft stop. The stats page reports this as time elapsed since last session. This change does not adequately address the requirement for long running session (websocket, RDP... etc).
2014-02-03 16:26:46 -05:00
MINOR: Add nbsrv sample converter This is like the nbsrv() sample fetch function except that it works as a converter so it can count the number of available servers of a backend name retrieved using a sample fetch or an environment variable. Signed-off-by: Nenad Merdanovic <nmerdan@haproxy.com>
2017-03-12 16:56:55 -04:00
/* Returns number of usable servers in backend */
static inline int be_usable_srv(struct proxy *be)
{
BUG/MINOR: backend: make be_usable_srv() consistent when stopping When a proxy enters the STOPPED state, it will no longer accept new connections. However, it doesn't mean that it's completely inactive yet: it will still be able to handle already pending / keep-alive connections, thus finishing ongoing work before effectively stopping. be_usable_srv(), which is used by nbsrv converter and sample fetch, will return 0 if the proxy is either stopped or disabled. nbsrv behaves this way since it was originally implemented in b7e7c4720 ("MINOR: Add nbsrv sample converter"). (Since then, multiple refactors were performed around this area, but the current implementation still follows the same logic) It was found that if nbsrv is used in a proxy section to perform routing logic, unexpected decisions are being made when nbsrv is used on a proxy with STOPPED state, since in-flight requests will suffer from nbsrv returning 0 instead of the current number of usable servers which may still process existing connections. For instance, this can happen during process soft-stop, or even when stopping the proxy from the cli / lua. To fix this: we now make sure be_usable_srv() always returns the current number of usable servers, unless the proxy is explicitly disabled (from the config, not at runtime) This could be backported up to 2.6. For older versions, the need for a backport should be evaluated first. -- Note for 2.4: proxy flags did not exist, it was implemented with fd10ab5e ("MINOR: proxy: Introduce proxy flags to replace disabled bitfield") For 2.2: STOPPED and DISABLED states were not separated, so we have no easy way to apply the fix anyway.
2023-03-30 12:03:21 -04:00
if (be->flags & PR_FL_DISABLED)
MINOR: Add nbsrv sample converter This is like the nbsrv() sample fetch function except that it works as a converter so it can count the number of available servers of a backend name retrieved using a sample fetch or an environment variable. Signed-off-by: Nenad Merdanovic <nmerdan@haproxy.com>
2017-03-12 16:56:55 -04:00
return 0;
else if (be->srv_act)
return be->srv_act;
else if (be->lbprm.fbck)
return 1;
else
return be->srv_bck;
}
MINOR: stats: Enhancement to stats page to provide information of last session time. Summary: Track and report last session time on the stats page for each server in every backend, as well as the backend. This attempts to address the requirement in the ROADMAP - add a last activity date for each server (req/resp) that will be displayed in the stats. It will be useful with soft stop. The stats page reports this as time elapsed since last session. This change does not adequately address the requirement for long running session (websocket, RDP... etc).
2014-02-03 16:26:46 -05:00
/* set the time of last session on the backend */
BUILD: address a few cases of "static <type> inline foo()" Older compilers don't like to see "inline" placed after the type in a function declaration, it must be "static inline <type>" only. This patch touches various areas. The warnings were seen with gcc-3.4.
2019-04-15 15:25:03 -04:00
static inline void be_set_sess_last(struct proxy *be)
MINOR: stats: Enhancement to stats page to provide information of last session time. Summary: Track and report last session time on the stats page for each server in every backend, as well as the backend. This attempts to address the requirement in the ROADMAP - add a last activity date for each server (req/resp) that will be displayed in the stats. It will be useful with soft stop. The stats page reports this as time elapsed since last session. This change does not adequately address the requirement for long running session (websocket, RDP... etc).
2014-02-03 16:26:46 -05:00
{
MEDIUM: clock: replace timeval "now" with integer "now_ns" This puts an end to the occasional confusion between the "now" date that is internal, monotonic and not synchronized with the system's date, and "date" which is the system's date and not necessarily monotonic. Variable "now" was removed and replaced with a 64-bit integer "now_ns" which is a counter of nanoseconds. It wraps every 585 years, so if all goes well (i.e. if humanity does not need haproxy anymore in 500 years), it will just never wrap. This implies that now_ns is never nul and that the zero value can reliably be used as "not set yet" for a timestamp if needed. This will also simplify date checks where it becomes possible again to do "date1<date2". All occurrences of "tv_to_ns(&now)" were simply replaced by "now_ns". Due to the intricacies between now, global_now and now_offset, all 3 had to be turned to nanoseconds at once. It's not a problem since all of them were solely used in 3 functions in clock.c, but they make the patch look bigger than it really is. The clock_update_local_date() and clock_update_global_date() functions are now much simpler as there's no need anymore to perform conversions nor to round the timeval up or down. The wrapping continues to happen by presetting the internal offset in the short future so that the 32-bit now_ms continues to wrap 20 seconds after boot. The start_time used to calculate uptime can still be turned to nanoseconds now. One interrogation concerns global_now_ms which is used only for the freq counters. It's unclear whether there's more value in using two variables that need to be synchronized sequentially like today or to just use global_now_ns divided by 1 million. Both approaches will work equally well on modern systems, the difference might come from smaller ones. Better not change anyhting for now. One benefit of the new approach is that we now have an internal date with a resolution of the nanosecond and the precision of the microsecond, which can be useful to extend some measurements given that timestamps also have this resolution.
2023-04-28 03:16:15 -04:00
be->be_counters.last_sess = ns_to_sec(now_ns);
MINOR: stats: Enhancement to stats page to provide information of last session time. Summary: Track and report last session time on the stats page for each server in every backend, as well as the backend. This attempts to address the requirement in the ROADMAP - add a last activity date for each server (req/resp) that will be displayed in the stats. It will be useful with soft stop. The stats page reports this as time elapsed since last session. This change does not adequately address the requirement for long running session (websocket, RDP... etc).
2014-02-03 16:26:46 -05:00
}
[MINOR] backend: export some functions to recount servers Those functions will be used by new LB algorithms.
2009-10-01 03:17:05 -04:00
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
/* This function returns non-zero if the designated server will be
* usable for LB according to pending weight and state.
* Otherwise it returns 0.
[MINOR] backend: export some functions to recount servers Those functions will be used by new LB algorithms.
2009-10-01 03:17:05 -04:00
*/
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
static inline int srv_willbe_usable(const struct server *srv)
[MINOR] backend: export some functions to recount servers Those functions will be used by new LB algorithms.
2009-10-01 03:17:05 -04:00
{
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
enum srv_state state = srv->next_state;
MINOR: server: create srv_was_usable() from srv_is_usable() and use a pointer We used to call srv_is_usable() with either the current state and weights or the previous ones. This causes trouble for future changes, so let's first split it in two variants : - srv_is_usable(srv) considers the current status - srv_was_usable(srv) considers the previous status
2014-05-13 12:51:40 -04:00
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
if (!srv->next_eweight)
MINOR: server: create srv_was_usable() from srv_is_usable() and use a pointer We used to call srv_is_usable() with either the current state and weights or the previous ones. This causes trouble for future changes, so let's first split it in two variants : - srv_is_usable(srv) considers the current status - srv_was_usable(srv) considers the previous status
2014-05-13 12:51:40 -04:00
return 0;
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
if (srv->next_admin & SRV_ADMF_MAINT)
REORG/MEDIUM: server: move the maintenance bits out of the server state Now we introduce srv->admin and srv->prev_admin which are bitfields containing one bit per source of administrative status (maintenance only for now). For the sake of backwards compatibility we implement a single source (ADMF_FMAINT) but the code already checks any source (ADMF_MAINT) where the STF_MAINTAIN bit was previously checked. This will later allow us to add ADMF_IMAINT for maintenance mode inherited from tracked servers. Along doing these changes, it appeared that some places will need to be revisited when implementing the inherited bit, this concerns all those modifying the ADMF_FMAINT bit (enable/disable actions on the CLI or stats page), and the checks to report "via" on the stats page. But currently the code is harmless.
2014-05-13 13:44:56 -04:00
return 0;
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
if (srv->next_admin & SRV_ADMF_DRAIN)
MAJOR: checks: add support for a new "drain" administrative mode This patch adds support for a new "drain" mode. So now we have 3 admin modes for a server : - READY - DRAIN - MAINT The drain mode disables load balancing but leaves the server up. It can coexist with maint, except that maint has precedence. It is also inherited from tracked servers, so just like maint, it's represented with 2 bits. New functions were designed to set/clear each flag and to propagate the changes to tracking servers when relevant, and to log the changes. Existing functions srv_set_adm_maint() and srv_set_adm_ready() were replaced to make use of the new functions. Currently the drain mode is not yet used, however the whole logic was tested with all combinations of set/clear of both flags in various orders to catch all corner cases.
2014-05-22 10:14:34 -04:00
return 0;
MAJOR: server: use states instead of flags to store the server state Servers used to have 3 flags to store a state, now they have 4 states instead. This avoids lots of confusion for the 4 remaining undefined states. The encoding from the previous to the new states can be represented this way : SRV_STF_RUNNING | SRV_STF_GOINGDOWN | | SRV_STF_WARMINGUP | | | 0 x x SRV_ST_STOPPED 1 0 0 SRV_ST_RUNNING 1 0 1 SRV_ST_STARTING 1 1 x SRV_ST_STOPPING Note that the case where all bits were set used to exist and was randomly dealt with. For example, the task was not stopped, the throttle value was still updated and reported in the stats and in the http_server_state header. It was the same if the server was stopped by the agent or for maintenance. It's worth noting that the internal function names are still quite confusing.
2014-05-13 17:41:20 -04:00
switch (state) {
case SRV_ST_STARTING:
case SRV_ST_RUNNING:
return 1;
case SRV_ST_STOPPING:
case SRV_ST_STOPPED:
MINOR: server: create srv_was_usable() from srv_is_usable() and use a pointer We used to call srv_is_usable() with either the current state and weights or the previous ones. This causes trouble for future changes, so let's first split it in two variants : - srv_is_usable(srv) considers the current status - srv_was_usable(srv) considers the previous status
2014-05-13 12:51:40 -04:00
return 0;
MAJOR: server: use states instead of flags to store the server state Servers used to have 3 flags to store a state, now they have 4 states instead. This avoids lots of confusion for the 4 remaining undefined states. The encoding from the previous to the new states can be represented this way : SRV_STF_RUNNING | SRV_STF_GOINGDOWN | | SRV_STF_WARMINGUP | | | 0 x x SRV_ST_STOPPED 1 0 0 SRV_ST_RUNNING 1 0 1 SRV_ST_STARTING 1 1 x SRV_ST_STOPPING Note that the case where all bits were set used to exist and was randomly dealt with. For example, the task was not stopped, the throttle value was still updated and reported in the stats and in the http_server_state header. It was the same if the server was stopped by the agent or for maintenance. It's worth noting that the internal function names are still quite confusing.
2014-05-13 17:41:20 -04:00
}
return 0;
MINOR: server: create srv_was_usable() from srv_is_usable() and use a pointer We used to call srv_is_usable() with either the current state and weights or the previous ones. This causes trouble for future changes, so let's first split it in two variants : - srv_is_usable(srv) considers the current status - srv_was_usable(srv) considers the previous status
2014-05-13 12:51:40 -04:00
}
/* This function returns non-zero if the designated server was usable for LB
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
* according to its current weight and state. Otherwise it returns 0.
MINOR: server: create srv_was_usable() from srv_is_usable() and use a pointer We used to call srv_is_usable() with either the current state and weights or the previous ones. This causes trouble for future changes, so let's first split it in two variants : - srv_is_usable(srv) considers the current status - srv_was_usable(srv) considers the previous status
2014-05-13 12:51:40 -04:00
*/
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
static inline int srv_currently_usable(const struct server *srv)
MINOR: server: create srv_was_usable() from srv_is_usable() and use a pointer We used to call srv_is_usable() with either the current state and weights or the previous ones. This causes trouble for future changes, so let's first split it in two variants : - srv_is_usable(srv) considers the current status - srv_was_usable(srv) considers the previous status
2014-05-13 12:51:40 -04:00
{
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
enum srv_state state = srv->cur_state;
MINOR: server: create srv_was_usable() from srv_is_usable() and use a pointer We used to call srv_is_usable() with either the current state and weights or the previous ones. This causes trouble for future changes, so let's first split it in two variants : - srv_is_usable(srv) considers the current status - srv_was_usable(srv) considers the previous status
2014-05-13 12:51:40 -04:00
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
if (!srv->cur_eweight)
[MINOR] backend: export some functions to recount servers Those functions will be used by new LB algorithms.
2009-10-01 03:17:05 -04:00
return 0;
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
if (srv->cur_admin & SRV_ADMF_MAINT)
REORG/MEDIUM: server: move the maintenance bits out of the server state Now we introduce srv->admin and srv->prev_admin which are bitfields containing one bit per source of administrative status (maintenance only for now). For the sake of backwards compatibility we implement a single source (ADMF_FMAINT) but the code already checks any source (ADMF_MAINT) where the STF_MAINTAIN bit was previously checked. This will later allow us to add ADMF_IMAINT for maintenance mode inherited from tracked servers. Along doing these changes, it appeared that some places will need to be revisited when implementing the inherited bit, this concerns all those modifying the ADMF_FMAINT bit (enable/disable actions on the CLI or stats page), and the checks to report "via" on the stats page. But currently the code is harmless.
2014-05-13 13:44:56 -04:00
return 0;
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
if (srv->cur_admin & SRV_ADMF_DRAIN)
MAJOR: checks: add support for a new "drain" administrative mode This patch adds support for a new "drain" mode. So now we have 3 admin modes for a server : - READY - DRAIN - MAINT The drain mode disables load balancing but leaves the server up. It can coexist with maint, except that maint has precedence. It is also inherited from tracked servers, so just like maint, it's represented with 2 bits. New functions were designed to set/clear each flag and to propagate the changes to tracking servers when relevant, and to log the changes. Existing functions srv_set_adm_maint() and srv_set_adm_ready() were replaced to make use of the new functions. Currently the drain mode is not yet used, however the whole logic was tested with all combinations of set/clear of both flags in various orders to catch all corner cases.
2014-05-22 10:14:34 -04:00
return 0;
MAJOR: server: use states instead of flags to store the server state Servers used to have 3 flags to store a state, now they have 4 states instead. This avoids lots of confusion for the 4 remaining undefined states. The encoding from the previous to the new states can be represented this way : SRV_STF_RUNNING | SRV_STF_GOINGDOWN | | SRV_STF_WARMINGUP | | | 0 x x SRV_ST_STOPPED 1 0 0 SRV_ST_RUNNING 1 0 1 SRV_ST_STARTING 1 1 x SRV_ST_STOPPING Note that the case where all bits were set used to exist and was randomly dealt with. For example, the task was not stopped, the throttle value was still updated and reported in the stats and in the http_server_state header. It was the same if the server was stopped by the agent or for maintenance. It's worth noting that the internal function names are still quite confusing.
2014-05-13 17:41:20 -04:00
switch (state) {
case SRV_ST_STARTING:
case SRV_ST_RUNNING:
return 1;
case SRV_ST_STOPPING:
case SRV_ST_STOPPED:
[MINOR] backend: export some functions to recount servers Those functions will be used by new LB algorithms.
2009-10-01 03:17:05 -04:00
return 0;
MAJOR: server: use states instead of flags to store the server state Servers used to have 3 flags to store a state, now they have 4 states instead. This avoids lots of confusion for the 4 remaining undefined states. The encoding from the previous to the new states can be represented this way : SRV_STF_RUNNING | SRV_STF_GOINGDOWN | | SRV_STF_WARMINGUP | | | 0 x x SRV_ST_STOPPED 1 0 0 SRV_ST_RUNNING 1 0 1 SRV_ST_STARTING 1 1 x SRV_ST_STOPPING Note that the case where all bits were set used to exist and was randomly dealt with. For example, the task was not stopped, the throttle value was still updated and reported in the stats and in the http_server_state header. It was the same if the server was stopped by the agent or for maintenance. It's worth noting that the internal function names are still quite confusing.
2014-05-13 17:41:20 -04:00
}
return 0;
[MINOR] backend: export some functions to recount servers Those functions will be used by new LB algorithms.
2009-10-01 03:17:05 -04: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-25 20:48:02 -04:00
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
/* This function commits the next server state and weight onto the current
BUG/MAJOR: lb/threads: fix insufficient locking on round-robin LB Maksim Kupriianov reported very strange crashes in fwrr_update_position() which didn't make sense because of an apparent divide overflow except that the value was not null in the core. It happens that while the locking is correct in all the functions' call graph, the uppermost one (fwrr_get_next_server()) incorrectly expected that its target server was already locked when called. This stupid assumption causd the server lock not to be held when calling the other ones, explaining how it was possible to change the server's eweight by calling srv_lb_commit_status() under the server lock yet collide with its unprotected usage. This commit makes sure that fwrr_get_server_from_group() retrieves a locked server and that fwrr_get_next_server() is responsible for unlocking the server before returning it. There is one subtlety in this function which is that it builds a list of avoided servers that were full while scanning the tree, and all of them are queued in a full state so they must be unlocked upon return. Many thanks to Maksim for providing detailed info allowing to narrow down this bug. This fix must be backported to 1.9. In 1.8 the lock seems much wider and changes to the server's state are performed under the rendez-vous point so this it doesn't seem possible that it happens there.
2019-04-16 05:21:14 -04:00
* ones in order to detect future changes. The server's lock is expected to
* be held when calling this function.
MINOR: server: use functions to detect state changes and to update them Detecting that a server's status has changed is a bit messy, as well as it is to commit the status changes. We'll have to add new conditions soon and we'd better avoid to multiply the number of touched locations with the high risk of forgetting them. This commit introduces : - srv_lb_status_changed() to report if the status changed from the previously committed one ; - svr_lb_commit_status() to commit the current status The function is now used by all load-balancing algorithms.
2014-05-13 13:27:31 -04:00
*/
static inline void srv_lb_commit_status(struct server *srv)
{
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
srv->cur_state = srv->next_state;
srv->cur_admin = srv->next_admin;
srv->cur_eweight = srv->next_eweight;
MINOR: server: use functions to detect state changes and to update them Detecting that a server's status has changed is a bit messy, as well as it is to commit the status changes. We'll have to add new conditions soon and we'd better avoid to multiply the number of touched locations with the high risk of forgetting them. This commit introduces : - srv_lb_status_changed() to report if the status changed from the previously committed one ; - svr_lb_commit_status() to commit the current status The function is now used by all load-balancing algorithms.
2014-05-13 13:27:31 -04:00
}
/* This function returns true when a server has experienced a change since last
* commit on its state or weight, otherwise zero.
*/
static inline int srv_lb_status_changed(const struct server *srv)
{
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
return (srv->next_state != srv->cur_state ||
srv->next_admin != srv->cur_admin ||
srv->next_eweight != srv->cur_eweight);
MINOR: server: use functions to detect state changes and to update them Detecting that a server's status has changed is a bit messy, as well as it is to commit the status changes. We'll have to add new conditions soon and we'd better avoid to multiply the number of touched locations with the high risk of forgetting them. This commit introduces : - srv_lb_status_changed() to report if the status changed from the previously committed one ; - svr_lb_commit_status() to commit the current status The function is now used by all load-balancing algorithms.
2014-05-13 13:27:31 -04:00
}
REORG: checks: put the functions in the appropriate files ! Checks.c has become a total mess. A number of proxy or server maintenance and queue management functions were put there probably because they were used there, but that makes the code untouchable. And that's without saying that their names does not always relate to what they really do! So let's do a first pass by moving these ones : - set_backend_down() => backend.c - redistribute_pending() => queue.c:pendconn_redistribute() - check_for_pending() => queue.c:pendconn_grab_from_px() - shutdown_sessions => server.c:srv_shutdown_sessions() - shutdown_backup_sessions => server.c:srv_shutdown_backup_sessions() All of them were moved at once.
2014-05-16 05:48:10 -04:00
/* sends a log message when a backend goes down, and also sets last
* change date.
*/
void set_backend_down(struct proxy *be);
MEDIUM: log/balance: support for the "hash" lb algorithm hash lb algorithm can be configured with the "log-balance hash <cnv_list>" directive. With this algorithm, the user specifies a converter list with <cnv_list>. The produced log message will be passed as-is to the provided converter list, and the resulting hash will be used to select the log server that will receive the log message.
2023-09-19 04:51:53 -04:00
unsigned int gen_hash(const struct proxy* px, const char* key, unsigned long len);
REORG: include: move backend.h to haproxy/backend{,-t}.h The files remained mostly unchanged since they were OK. However, half of the users didn't need to include them, and about as many actually needed to have it and used to find functions like srv_currently_usable() through a long chain that broke when moving the file.
2020-06-04 16:50:02 -04:00
#endif /* _HAPROXY_BACKEND_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-25 20:48:02 -04:00
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/
Reference in a new issue Copy permalink