upstream/haproxy
1
0
Fork 0
mirror of https://github.com/haproxy/haproxy.git synced 2026-04-15 21:59:41 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
haproxy/include/haproxy/server.h

393 lines
14 KiB
C
Raw Normal View History

[LICENSE] licensing clarifications
2006-06-15 15:48:13 -04:00
/*
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.h
[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 17:12:44 -04:00
* This file defines everything related to servers.
*
* Copyright (C) 2000-2009 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
*/
[LICENSE] licensing clarifications
2006-06-15 15:48:13 -04:00
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
#ifndef _HAPROXY_SERVER_H
#define _HAPROXY_SERVER_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
#include <unistd.h>
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/applet-t.h>
MINOR: server: generalize sni expr parsing Two functions exists for server sni sample expression parsing. This is confusing so this commit aims at clarifying this. Functions are renamed with the following identifiers. First function is named parse_srv_expr() and can be used during parsing. Besides expression parsing, it has ensure sample fetch validity in the context of a server line. Second function is renamed _parse_srv_expr() and is used internally by parse_srv_expr(). It only implements sample parsing without extra checks. It is already use for server instantiation derived from server-template as checks were already performed. Also, it is now used in http-client code as SNI is a fixed string. Finally, both functions are generalized to remove any reference to SNI. This will allow to reuse it to parse other server keywords which use an expression. This will be the case for the future keyword pool-conn-name.
2024-05-23 04:59:20 -04:00
#include <haproxy/arg-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/freq_ctr.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>
MEDIUM: resolvers/dns: split dns.c into dns.c and resolvers.c This patch splits current dns.c into two files: The first dns.c contains code related to DNS message exchange over UDP and in future other TCP. We try to remove depencies to resolving to make it usable by other stuff as DNS load balancing. The new resolvers.c inherit of the code specific to the actual resolvers. Note: It was really difficult to obtain a clean diff dur to the amount of moved code. Note2: Counters and stuff related to stats is not cleany separated because currently counters for both layers are merged and hard to separate for now.
2021-02-12 13:42:55 -05:00
#include <haproxy/resolvers-t.h>
MINOR: server: generalize sni expr parsing Two functions exists for server sni sample expression parsing. This is confusing so this commit aims at clarifying this. Functions are renamed with the following identifiers. First function is named parse_srv_expr() and can be used during parsing. Besides expression parsing, it has ensure sample fetch validity in the context of a server line. Second function is renamed _parse_srv_expr() and is used internally by parse_srv_expr(). It only implements sample parsing without extra checks. It is already use for server instantiation derived from server-template as checks were already performed. Also, it is now used in http-client code as SNI is a fixed string. Finally, both functions are generalized to remove any reference to SNI. This will allow to reuse it to parse other server keywords which use an expression. This will be the case for the future keyword pool-conn-name.
2024-05-23 04:59:20 -04:00
#include <haproxy/sample-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 log.h to haproxy/log{,-t}.h The current state of the logging is a real mess. The main problem is that almost all files include log.h just in order to have access to the alert/warning functions like ha_alert() etc, and don't care about logs. But log.h also deals with real logging as well as log-format and depends on stream.h and various other things. As such it forces a few heavy files like stream.h to be loaded early and to hide missing dependencies depending where it's loaded. Among the missing ones is syslog.h which was often automatically included resulting in no less than 3 users missing it. Among 76 users, only 5 could be removed, and probably 70 don't need the full set of dependencies. A good approach would consist in splitting that file in 3 parts: - one for error output ("errors" ?). - one for log_format processing - and one for actual logging.
2020-06-04 16:01:04 -04:00
#include <haproxy/task.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/thread-t.h>
REORG: include: move time.h from common/ to haproxy/ This one is included almost everywhere and used to rely on a few other .h that are not needed (unistd, stdlib, standard.h). It could possibly make sense to split it into multiple parts to distinguish operations performed on timers and the internal time accounting, but at this point it does not appear much important.
2020-06-01 05:05:15 -04:00
#include <haproxy/time.h>
MINOR: backend: only allow reuse for reverse server A reverse server relies solely on its pool of idle connection to transfer requests which will be populated through a new tcp-request rule 'attach-srv'. Several changes are required on connect_server() to implement this. First, reuse mode is forced to always for this type of server. Then, if no idle connection is found, the request will be aborted. This results with a 503 HTTP error code, similarly to when no server is available.
2023-08-18 10:02:35 -04:00
#include <haproxy/tools.h>
[LICENSE] licensing clarifications
2006-06-15 15:48:13 -04:00
MEDIUM: servers: Reorganize the way idle connections are cleaned. Instead of having one task per thread and per server that does clean the idling connections, have only one global task for every servers. That tasks parses all the servers that currently have idling connections, and remove half of them, to put them in a per-thread list of connections to kill. For each thread that does have connections to kill, wake a task to do so, so that the cleaning will be done in the context of said thread.
2019-02-14 12:29:09 -05:00
CLEANUP: thread: rename __decl_hathreads() to __decl_thread() I can never figure whether it takes an "s" or not, and in the end it's better if it matches the file's naming, so let's call it "__decl_thread".
2020-06-05 02:40:51 -04:00
__decl_thread(extern HA_SPINLOCK_T idle_conn_srv_lock);
MEDIUM: connection: protect idle conn lists with locks This is a preparation work for connection reuse with sni/proxy protocol/specific src-dst addresses. Protect every access to idle conn lists with a lock. This is currently strictly not needed because the access to the list are made with atomic operations. However, to be able to reuse connection with specific parameters, the list storage will be converted to eb-trees. As this structure does not have atomic operation, it is mandatory to protect it with a lock. For this, the takeover lock is reused. Its role was to protect during connection takeover. As it is now extended to general idle conns usage, it is renamed to idle_conns_lock. A new lock section is also instantiated named IDLE_CONNS_LOCK to isolate its impact on performance.
2021-01-11 03:21:52 -05:00
extern struct idle_conns idle_conns[MAX_THREADS];
MEDIUM: servers: Reorganize the way idle connections are cleaned. Instead of having one task per thread and per server that does clean the idling connections, have only one global task for every servers. That tasks parses all the servers that currently have idling connections, and remove half of them, to put them in a per-thread list of connections to kill. For each thread that does have connections to kill, wake a task to do so, so that the cleaning will be done in the context of said thread.
2019-02-14 12:29:09 -05:00
extern struct task *idle_conn_task;
BUG/MEDIUM: server: fix race on servers_list during server deletion Each server is inserted in a global list named servers_list on new_server(). This list is then only used to finalize servers initialization after parsing. On dynamic server creation, there is no issue as new_server() is under thread isolation. However, when a server is deleted after its refcount reached zero, srv_drop() removes it from servers_list without lock protection. In the longterm, this can cause list corruption and crashes, especially if multiple adjacent servers are removed in parallel. To fix this, convert servers_list to a mt_list. This should not impact performance as servers_list is not used during runtime outside of server creation/deletion. This should fix github issue #2733. Thanks to Chris Staite who first found the issue here. This must be backported up to 2.6.
2024-10-23 12:18:48 -04:00
extern struct mt_list servers_list;
MEDIUM: stick-tables: Add srvkey option to stick-table This allows using the address of the server rather than the name of the server for keeping track of servers in a backend for stickiness. The peers code was also extended to support feeding the dictionary using this key instead of the name. Fixes #814
2020-11-20 03:28:26 -05:00
extern struct dict server_key_dict;
MEDIUM: servers: Reorganize the way idle connections are cleaned. Instead of having one task per thread and per server that does clean the idling connections, have only one global task for every servers. That tasks parses all the servers that currently have idling connections, and remove half of them, to put them in a per-thread list of connections to kill. For each thread that does have connections to kill, wake a task to do so, so that the cleaning will be done in the context of said thread.
2019-02-14 12:29:09 -05:00
CLEANUP: Make parameters of srv_downtime and srv_getinter const The parameters of srv_downtime and srv_getinter are not modified and thus may be const. Signed-off-by: Simon Horman <horms@verge.net.au>
2013-11-01 03:46:15 -04:00
int srv_downtime(const struct server *s);
MEDIUM: Paramatise functions over the check of a server Paramatise the following functions over the check of a server * set_server_down * set_server_up * srv_getinter * server_status_printf * set_server_check_status * set_server_disabled * set_server_enabled Generally the server parameter of these functions has been removed. Where it is still needed it is obtained using check->server. This is in preparation for associating a agent check with a server which runs as well as the server's existing check. By paramatising these functions they may act on each of the checks without further significant modification. Explanation of the SSP_O_HCHK portion of this change: * Prior to this patch SSP_O_HCHK serves a single purpose which is to tell server_status_printf() weather it should print the details of the check of a server or not. With the paramatisation that this patch adds there are two cases. 1) Printing the details of the check in which case a valid check parameter is needed. 2) Not printing the details of the check in which case the contents check parameter are unused. In case 1) we could pass SSP_O_HCHK and a valid check and; In case 2) we could pass !SSP_O_HCHK and any value for check including NULL. If NULL is used for case 2) then SSP_O_HCHK becomes supurfulous and as NULL is used for case 2) SSP_O_HCHK has been removed. Signed-off-by: Simon Horman <horms@verge.net.au>
2013-02-23 01:35:38 -05:00
int srv_getinter(const struct check *check);
BUG/MEDIUM: server: fix dynamic servers initial settings Contrary to static servers, dynamic servers does not initialize their settings from a default server instance. As such, _srv_parse_init() was responsible to set a set of minimal values to have a correct behavior. However, some settings were not properly initialized. This caused dynamic servers to not behave as static ones without explicit parameters. Currently, the main issue detected is connection reuse which was completely impossible. This is due to incorrect pool_purge_delay and max_reuse settings incompatible with srv_add_to_idle_list(). To fix the connection reuse, but also more generally to ensure dynamic servers are aligned with other server instances, define a new function srv_settings_init(). This is used to set initial values for both default servers and dynamic servers. For static servers, srv_settings_cpy() is kept instead, using their default server as reference. This patch could have unexpected effects on dynamic servers behavior as it restored proper initial settings. Previously, they were set to 0 via calloc() invocation from new_server(). This should be backported up to 2.6, after a brief period of observation.
2024-02-27 09:33:59 -05:00
void srv_settings_init(struct server *srv);
REORG: server: Export srv_settings_cpy() function This function will be used to init a proxy with settings of the default proxy. It is mandatory to fix a bug. To do so, it must be exposed.
2022-08-03 05:28:08 -04:00
void srv_settings_cpy(struct server *srv, const struct server *src, int srv_tmpl);
REORG: server: use flags for parse_server Modify the API of parse_server function. Use flags to describe the type of the parsed server instead of discrete arguments. These flags can be used to specify if a server/default-server/server-template is parsed. Additional parameters are also specified (parsing of the address required, resolve of a name must be done immediately). It is now unneeded to use strcmp on args[0] in parse_server. Also, the calls to parse_server are more explicit thanks to the flags.
2021-03-08 10:36:46 -05:00
int parse_server(const char *file, int linenum, char **args, struct proxy *curproxy, const struct proxy *defproxy, int parse_flags);
MEDIUM: server: make server_set_inetaddr() updater serializable server_set_inetaddr() updater argument is a simple char * string containing infos about the caller responsible for the update. In this patch, we try to make this argument serializable, that is, make it so that we can easily export it without having to keep the original pointer passed by the caller or having to work with strings of variable lengths. This was a prerequisite for exposing more updater information through SERVER_INETADDR event (upcoming patch). Static strings were simply mapped to a fixed ID that can be converted back to a string when needed using server_inetaddr_updater_by_to_str(). One special case one made for the SERVER_INETADDR_UPDATER_DNS_RESOLVER updater since in this case the updater hint has to be generated from the corresponding resolver id / nameserver id combination. This was achieved by saving the nameserver id within the updater struct. Knowing that the resolver id can be guessed from the server struct directly, it was not exposed through the updater struct. This patch depends on: - "MINOR: resolvers: add unique numeric id to nameservers" No functional change should be expected.
2023-12-11 09:06:43 -05:00
int srv_update_addr(struct server *s, void *ip, int ip_sin_family, struct server_inetaddr_updater updater);
MINOR: server: generalize sni expr parsing Two functions exists for server sni sample expression parsing. This is confusing so this commit aims at clarifying this. Functions are renamed with the following identifiers. First function is named parse_srv_expr() and can be used during parsing. Besides expression parsing, it has ensure sample fetch validity in the context of a server line. Second function is renamed _parse_srv_expr() and is used internally by parse_srv_expr(). It only implements sample parsing without extra checks. It is already use for server instantiation derived from server-template as checks were already performed. Also, it is now used in http-client code as SNI is a fixed string. Finally, both functions are generalized to remove any reference to SNI. This will allow to reuse it to parse other server keywords which use an expression. This will be the case for the future keyword pool-conn-name.
2024-05-23 04:59:20 -04:00
struct sample_expr *_parse_srv_expr(char *expr, struct arg_list *args_px,
const char *file, int linenum, char **err);
MEDIUM: server/ssl: Base the SNI value to the HTTP host header by default For HTTPS outgoing connections, the SNI is now automatically set using the Host header value if no other value is already set (via the "sni" server keyword). It is now the default behavior. It could be disabled with the "no-sni-auto" server keyword. And eventually "sni-auto" server keyword may be used to reset any previous "no-sni-auto" setting. This option can be inherited from "default-server" settings. Finally, if no connection name is set via "pool-conn-name" setting, the selected value is used. The automatic selection of the SNI is enabled by default for all outgoing connections. But it is concretely used for HTTPS connections only. The expression used is "req.hdr(host),host_only". This patch should paritally fix the issue #3081. It only covers the server part. Another patch will add the feature for HTTP health-checks.
2025-09-04 04:12:19 -04:00
int server_parse_exprs(struct server *srv, struct proxy *px, char **err);
MEDIUM: server: make server_set_inetaddr() updater serializable server_set_inetaddr() updater argument is a simple char * string containing infos about the caller responsible for the update. In this patch, we try to make this argument serializable, that is, make it so that we can easily export it without having to keep the original pointer passed by the caller or having to work with strings of variable lengths. This was a prerequisite for exposing more updater information through SERVER_INETADDR event (upcoming patch). Static strings were simply mapped to a fixed ID that can be converted back to a string when needed using server_inetaddr_updater_by_to_str(). One special case one made for the SERVER_INETADDR_UPDATER_DNS_RESOLVER updater since in this case the updater hint has to be generated from the corresponding resolver id / nameserver id combination. This was achieved by saving the nameserver id within the updater struct. Knowing that the resolver id can be guessed from the server struct directly, it was not exposed through the updater struct. This patch depends on: - "MINOR: resolvers: add unique numeric id to nameservers" No functional change should be expected.
2023-12-11 09:06:43 -05:00
int server_set_inetaddr(struct server *s, const struct server_inetaddr *inetaddr, struct server_inetaddr_updater updater, struct buffer *msg);
int server_set_inetaddr_warn(struct server *s, const struct server_inetaddr *inetaddr, struct server_inetaddr_updater updater);
MEDIUM: server: merge srv_update_addr() and srv_update_addr_port() logic Both functions are performing the similar tasks, except that the _port() version is doing a bit more work. In this patch, we add the server_set_inetaddr() function that works like the srv_update_addr_port() but it takes parsed inputs instead of raw strings as arguments. Then, server_set_inetaddr() is used as underlying helper function for both srv_update_addr() and srv_update_addr_port() to make them easier to maintain. Also, helper functions were added: - server_set_inetaddr_warn() -> same as server_set_inetaddr() but report a warning on updates. - server_get_inetaddr() -> fills a struct server_inetaddr from srv Since the feedback message generation part was slightly reworked, some minor changes in the way addr:svc_port updates are reported in the logs or cli messages should be expected (no loss of information though).
2023-12-11 04:23:17 -05:00
void server_get_inetaddr(struct server *s, struct server_inetaddr *inetaddr);
MEDIUM: server: make server_set_inetaddr() updater serializable server_set_inetaddr() updater argument is a simple char * string containing infos about the caller responsible for the update. In this patch, we try to make this argument serializable, that is, make it so that we can easily export it without having to keep the original pointer passed by the caller or having to work with strings of variable lengths. This was a prerequisite for exposing more updater information through SERVER_INETADDR event (upcoming patch). Static strings were simply mapped to a fixed ID that can be converted back to a string when needed using server_inetaddr_updater_by_to_str(). One special case one made for the SERVER_INETADDR_UPDATER_DNS_RESOLVER updater since in this case the updater hint has to be generated from the corresponding resolver id / nameserver id combination. This was achieved by saving the nameserver id within the updater struct. Knowing that the resolver id can be guessed from the server struct directly, it was not exposed through the updater struct. This patch depends on: - "MINOR: resolvers: add unique numeric id to nameservers" No functional change should be expected.
2023-12-11 09:06:43 -05:00
const char *srv_update_addr_port(struct server *s, const char *addr, const char *port, struct server_inetaddr_updater updater);
const char *server_inetaddr_updater_by_to_str(enum server_inetaddr_updater_by by);
REORG: server: Export and rename some functions updating server info Some static functions are now exported and renamed to follow the same pattern of other exported functions. Here is the list : * update_server_fqdn: Renamed to srv_update_fqdn and exported * update_server_check_addr_port: renamed to srv_update_check_addr_port and exported * update_server_agent_addr_port: renamed to srv_update_agent_addr_port and exported * update_server_addr: renamed to srv_update_addr * update_server_addr_potr: renamed to srv_update_addr_port * srv_prepare_for_resolution: exported This change is mandatory to move all functions dealing with the server-state files in a separate file.
2021-02-16 06:07:47 -05:00
const char *srv_update_check_addr_port(struct server *s, const char *addr, const char *port);
const char *srv_update_agent_addr_port(struct server *s, const char *addr, const char *port);
OPTIM: server: ebtree lookups for findserver_unique_* functions 4e5e2664 ("MINOR: proxy: add findserver_unique_id() and findserver_unique_name()") added findserver_unique_id() and findserver_unique_name() functions that were inspired from the historical findserver() function, so unfortunately they don't perform well when used on large backend farms because they scan the whole server list linearly. I was about to provide a patch to optimize such functions when I stumbled on Baptiste's work: 19a106d24 ("MINOR: server: server_find functions: id, name, best_match") It turns out Baptiste already implemented helper functions to supersed the unoptimized findserver() function (at least at runtime when servers have been assigned their final IDs and inserted in the lookup trees): they offer more matching options and rely on eb lookups so they are much more suitable for fast queries. I don't know how I missed that, but they are a perfect base for the server rid matching functions. So in this patch, we essentially revert 4e5e2664 to provide the optimized equivalent functions named server_find_by_id_unique() and server_find_by_name_unique(), then we force existing findserver_unique_*() callers to switch to the new functions. This patch depends on: - "OPTIM: server: eb lookup for server_find_by_name()" This could be backported up to 2.8.
2023-12-04 11:00:18 -05:00
struct server *server_find_by_id_unique(struct proxy *bk, int id, uint32_t rid);
CLEANUP: server: rename findserver() to server_find_by_name() Now it's more logical and matches what is done in the rest of these functions. server_find() now relies on it.
2025-07-10 05:07:51 -04:00
struct server *server_find_by_name(struct proxy *px, const char *name);
CLEANUP: server: add server_find_by_addr() Server lookup by address requires locking and manipulation of the tree from user code. Let's provide server_find_by_addr() which does that for us.
2025-07-10 08:43:28 -04:00
struct server *server_find_by_addr(struct proxy *px, const char *addr);
CLEANUP: server: rename server_find_by_name() to server_find() This function doesn't just look at the name but also the ID when the argument starts with a '#'. So the name is not correct and explains why this function is not always used when the name only is needed, and why the list-based findserver() is used instead. So let's just call the function "server_find()", and rename its generation-id based cousin "server_find_unique()".
2025-07-10 04:59:06 -04:00
struct server *server_find(struct proxy *bk, const char *name);
struct server *server_find_unique(struct proxy *bk, const char *name, uint32_t rid);
MINOR: server: server_find functions: id, name, best_match This patch introduces three new functions which can be used to find a server in a farm using different server information: - server unique id (srv->puid) - server name - find best match using either name or unique id When performing best matching, the following applies: - use the server name first (if provided) - use the server id if provided in any case, the function can update the caller about mismatches encountered.
2015-07-08 16:03:56 -04:00
struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff);
MINOR: config: new backend directives: load-server-state-from-file and server-state-file-name This directive gives HAProxy the ability to use the either the global server-state-file directive or a local one using server-state-file-name to load server states. The state can be saved right before the reload by the init script, using the "show servers state" command on the stats socket redirecting output into a file.
2015-08-19 10:44:03 -04:00
void apply_server_state(void);
BUG/MEDIUM: servers: properly propagate the maintenance states during startup Right now there is an issue with the way the maintenance flags are propagated upon startup. They are not propagate, just copied from the tracked server. This implies that depending on the server's order, some tracking servers may not be marked down. For example this configuration does not work as expected : server s1 1.1.1.1:8000 track s2 server s2 1.1.1.1:8000 track s3 server s3 1.1.1.1:8000 track s4 server s4 wtap:8000 check inter 1s disabled It results in s1/s2 being up, and s3/s4 being down, while all of them should be down. The only clean way to process this is to run through all "root" servers (those not tracking any other server), and to propagate their state down to all their trackers. This is the same algorithm used to propagate the state changes. It has to be done both to compute the IDRAIN flag and the IMAINT flag. However, doing so requires that tracking servers are not marked as inherited maintenance anymore while parsing the configuration (and given that it is wrong, better drop it). This fix also addresses another side effect of the bug above which is that the IDRAIN/IMAINT flags are stored in the state files, and if restored while the tracked server doesn't have the equivalent flag, the servers may end up in a situation where it's impossible to remove these flags. For example in the configuration above, after removing "disabled" on server s4, the other servers would have remained down, and not anymore with this fix. Similarly, the combination of IMAINT or IDRAIN with their respective forced modes was not accepted on reload, which is wrong as well. This bug has been present at least since 1.5, maybe even 1.4 (it came with tracking support). The fix needs to be backported there, though the srv-state parts are irrelevant. This commit relies on previous patch to silence warnings on startup.
2016-11-03 14:22:19 -04:00
void srv_compute_all_admin_states(struct proxy *px);
MAJOR: server: postpone address resolution Server addresses are not resolved anymore upon the first pass so that we don't fail if an address cannot be resolved by the libc. Instead they are processed all at once after the configuration is fully loaded, by the new function srv_init_addr(). This function only acts on the server's address if this address uses an FQDN, which appears in server->hostname. For now the function does two things, to followup with HAProxy's historical default behavior: 1. apply server IP address found in server-state file if runtime DNS resolution is enabled for this server 2. use the DNS resolver provided by the libc If none of the 2 options above can find an IP address, then an error is returned. All of this will be needed to support the new server parameter "init-addr". For now, the biggest user-visible change is that all server resolution errors are dumped at once instead of causing a startup failure one by one.
2016-11-02 10:34:05 -04:00
int srv_set_addr_via_libc(struct server *srv, int *err_code);
int srv_init_addr(void);
MINOR: server: create new function cli_find_server() to find a server Several CLI commands require a server, 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-23 11:15:08 -05:00
struct server *cli_find_server(struct appctx *appctx, char *arg);
MINOR: server: export new_server() function The new_server() function will be useful to create a proxy for the master-worker.
2018-10-26 08:47:32 -04:00
struct server *new_server(struct proxy *proxy);
MEDIUM: server: extend refcount for all servers In a future patch, it will be possible to remove at runtime every servers, both static and dynamic. This requires to extend the server refcount for all instances. First, refcount manipulation functions have been renamed to better express the API usage. * srv_refcount_use -> srv_take The refcount is always initialize to 1 on the server creation in new_server. It's also incremented for each check/agent configured on a server instance. * free_server -> srv_drop This decrements the refcount and if null, the server is freed, so code calling it must not use the server reference after it. As a bonus, this function now returns the next server instance. This is useful when calling on the server loop without having to save the next pointer before each invocation. In these functions, remove the checks that prevent refcount on non-dynamic servers. Each reference to "dynamic" in variable/function naming have been eliminated as well.
2021-08-25 09:34:53 -04:00
void srv_take(struct server *srv);
struct server *srv_drop(struct server *srv);
BUG/MINOR: proxy/server: free default-server on deinit proxy default-server is a specific type of server that is not allocated using new_server(): it is directly stored within the parent proxy structure. However, since it may contain some default config options that may be inherited by regular servers, it is also subject to dynamic members (strings, structures..) that needs to be deallocated when the parent proxy is cleaned up. Unfortunately, srv_drop() may not be used directly from p->defsrv since this function is meant to be used on regular servers only (those created using new_server()). To circumvent this, we're splitting srv_drop() to make a new function called srv_free_params() that takes care of the member cleaning which originally takes place in srv_drop(). This function is exposed through server.h, so it may be called from outside server.c. Thanks to this, calling srv_free_params(&p->defsrv) from free_proxy() prevents any memory leaks due to dynamic parameters allocated when parsing a default-server line from a proxy section. This partially fixes GH #2173 and may be backported to 2.8. [While it could also be relevant for other stable versions, the patch won't apply due to architectural changes / name changes between 2.4 => 2.6 and then 2.6 => 2.8. Considering this is a minor fix that only makes memory analyzers happy during deinit paths (at least for <= 2.8), it might not be worth the trouble to backport them any further?]
2023-06-01 06:07:43 -04:00
void srv_free_params(struct server *srv);
MEDIUM: server: split srv_init() in srv_preinit() + srv_postinit() We actually need more granularity to split srv postparsing init tasks: Some of them are required to be run BEFORE the config is checked, and some of them AFTER the config is checked. Thus we push the logic from 368d0136 ("MEDIUM: server: add and use srv_init() function") a little bit further and split the function in two distinct ones, one of them executed under check_config_validity() and the other one using REGISTER_POST_SERVER_CHECK() hook. SRV_F_CHECKED flag was removed because it is no longer needed, srv_preinit() is only called once, and so is srv_postinit().
2025-08-08 06:22:13 -04:00
int srv_preinit(struct server *srv);
BUG/MEDIUM: server: Use sni as pool connection name for SSL server only By default, for a given server, when no pool-conn-name is specified, the configured sni is used. However, this must only be done when SSL is in-use for the server. Of course, it is uncommon to have a sni expression for now-ssl server. But this may happen. In addition, the SSL may be disabled via the CLI. In that case, the pool-conn-name must be discarded if it was copied from the sni. And, we must of course take care to set it if the ssl is enabled. Finally, when the attac-srv action is checked, we now checked the pool-conn-name expression. This patch should be backported as far as 3.0. It relies on "MINOR: server: Parse sni and pool-conn-name expressions in a dedicated function" which should be backported too.
2025-09-03 09:29:56 -04:00
int srv_set_ssl(struct server *s, int use_ssl);
MINOR: server: change adm_st_chg_cause storage type Even though it doesn't look like it at first glance, this is more like a cleanup than an actual code improvement: Given that srv->adm_st_chg_cause has been used to exclusively store static strings ever since it was implemented, we make the choice to store it as an enum instead of a fixed-size string within server struct. This will allow to save some space in server struct, and will make it more easily exportable (ie: event handlers) because of the reduced memory footprint during handling and the ability to later get the corresponding human-readable message when it's explicitly needed.
2023-04-03 11:40:28 -04:00
const char *srv_adm_st_chg_cause(enum srv_adm_st_chg_cause cause);
MINOR: server: change srv_op_st_chg_cause storage type This one is greatly inspired by "MINOR: server: change adm_st_chg_cause storage type". While looking at current srv_op_st_chg_cause usage, it was clear that the struct needed some cleanup since some leftovers from asynchronous server state change updates were left behind and resulted in some useless code duplication, and making the whole thing harder to maintain. Two observations were made: - by tracking down srv_set_{running, stopped, stopping} usage, we can see that the <reason> argument is always a fixed statically allocated string. - check-related state change context (duration, status, code...) is not used anymore since srv_append_status() directly extracts the values from the server->check. This is pure legacy from when the state changes were applied asynchronously. To prevent code duplication, useless string copies and make the reason/cause more exportable, we store it as an enum now, and we provide srv_op_st_chg_cause() function to fetch the related description string. HEALTH and AGENT causes (check related) are now explicitly identified to make consumers like srv_append_op_chg_cause() able to fetch checks info from the server itself if they need to.
2023-04-04 04:17:40 -04:00
const char *srv_op_st_chg_cause(enum srv_op_st_chg_cause cause);
MINOR: checks/event_hdl: SERVER_CHECK event Adding a new event type: SERVER_CHECK. This event is published when a server's check state ought to be reported. (check status change or check result) SERVER_CHECK event is provided as a server event with additional data carrying relevant check's context such as check's result and health.
2023-03-30 04:19:08 -04:00
void srv_event_hdl_publish_check(struct server *srv, struct check *check);
MINOR: server: split the server deletion code in two parts We'll need to be able to verify whether or not a server may be deleted. For now, both the verification and the action are performed in the same function, at once under thread isolation. The goal here is to extract the verification code into a new function that will perform these checks, return a status between success/recoverable/non-recoverable failure, and will also return a message for the caller.
2024-02-09 13:28:13 -05:00
int srv_check_for_deletion(const char *bename, const char *svname, struct proxy **pb, struct server **ps, const char **pm);
[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
MAJOR: server: add DNS-based server name resolution Relies on the DNS protocol freshly implemented in HAProxy. It performs a server IP addr resolution based on a server hostname.
2015-04-13 19:15:08 -04:00
/* functions related to server name resolution */
REORG: server: Export and rename some functions updating server info Some static functions are now exported and renamed to follow the same pattern of other exported functions. Here is the list : * update_server_fqdn: Renamed to srv_update_fqdn and exported * update_server_check_addr_port: renamed to srv_update_check_addr_port and exported * update_server_agent_addr_port: renamed to srv_update_agent_addr_port and exported * update_server_addr: renamed to srv_update_addr * update_server_addr_potr: renamed to srv_update_addr_port * srv_prepare_for_resolution: exported This change is mandatory to move all functions dealing with the server-state files in a separate file.
2021-02-16 06:07:47 -05:00
int srv_prepare_for_resolution(struct server *srv, const char *hostname);
MEDIUM: server/dns: clear RMAINT when addr resolves again snr_update_srv_status() and srvrq_update_srv_status() will both set or clear the server RMAINT state depending of the result of the current dns resolution. This used to work pretty well in the past, but now that addr:svc_port changes are changed atomically through a dedicated task, the change is performed asynchronously, so this can cause some flapping issues if the server is put out of maintenance while the server's address is still unassigned. To prevent errors, the resolver's code is now only allowed to put the server under maintenance but not to remove it from maintenance: the decision to remove a server from maintenance is performed by the task responsible for updating the server's addr: if the addr resolves again thanks to a valid DNS resolution and the server was previously under RMAINT, then it cleared from RMAINT state. srvrq_update_srv_status() was renamed srvrq_set_srv_down(), since it is only called to put the server in maintenance as a result of a failing SRV entry. snr_update_srv_status() was renamed srv_set_srv_down() and slightly modified so that it only takes care of putting the server under maintenance when needed. The cli command "set server x/y addr" does not need to remove the RMAINT flag anymore.
2023-12-12 08:42:34 -05:00
int srvrq_set_srv_down(struct server *s);
REORG: server: Export and rename some functions updating server info Some static functions are now exported and renamed to follow the same pattern of other exported functions. Here is the list : * update_server_fqdn: Renamed to srv_update_fqdn and exported * update_server_check_addr_port: renamed to srv_update_check_addr_port and exported * update_server_agent_addr_port: renamed to srv_update_agent_addr_port and exported * update_server_addr: renamed to srv_update_addr * update_server_addr_potr: renamed to srv_update_addr_port * srv_prepare_for_resolution: exported This change is mandatory to move all functions dealing with the server-state files in a separate file.
2021-02-16 06:07:47 -05:00
int srv_set_fqdn(struct server *srv, const char *fqdn, int resolv_locked);
const char *srv_update_fqdn(struct server *server, const char *fqdn, const char *updater, int dns_locked);
MINOR: resolvers: renames some resolvers specific types to not use dns prefix This patch applies those changes on names: -struct dns_resolution { +struct resolv_resolution { -struct dns_requester { +struct resolv_requester { -struct dns_srvrq { +struct resolv_srvrq { @@ -185,12 +185,12 @@ struct stream { struct { - struct dns_requester *dns_requester; + struct resolv_requester *requester; ... - } dns_ctx; + } resolv_ctx;
2020-12-23 11:41:43 -05:00
int snr_resolution_cb(struct resolv_requester *requester, struct dns_counters *counters);
BUG/MINOR: resolvers: new callback to properly handle SRV record errors When a SRV record was created, it used to register the regular server name resolution callbacks. That said, SRV records and regular server name resolution don't work the same way, furthermore on error management. This patch introduces a new call back to manage DNS errors related to the SRV queries. this fixes github issue #50. Backport status: 2.3, 2.2, 2.1, 2.0
2020-11-19 16:38:33 -05:00
int srvrq_resolution_error_cb(struct resolv_requester *requester, int error_code);
MINOR: resolvers: renames some resolvers specific types to not use dns prefix This patch applies those changes on names: -struct dns_resolution { +struct resolv_resolution { -struct dns_requester { +struct resolv_requester { -struct dns_srvrq { +struct resolv_srvrq { @@ -185,12 +185,12 @@ struct stream { struct { - struct dns_requester *dns_requester; + struct resolv_requester *requester; ... - } dns_ctx; + } resolv_ctx;
2020-12-23 11:41:43 -05:00
int snr_resolution_error_cb(struct resolv_requester *requester, int error_code);
MINOR: dns: new snr_check_ip_callback function In the process of breaking links between dns_* functions and other structures (mainly server and a bit of resolution), the function dns_get_ip_from_response needs to be reworked: it now can call "callback" functions based on resolution's owner type to allow modifying the way the response is processed. For now, main purpose of the callback function is to check that an IP address is not already affected to an element of the same type. For now, only server type has a callback.
2017-05-03 09:43:12 -04:00
struct server *snr_check_ip_callback(struct server *srv, void *ip, unsigned char *ip_family);
MEDIUM: task: extend the state field to 32 bits It's been too short for quite a while now and is now full. It's still time to extend it to 32-bits since we have room for this without wasting any space, so we now gained 16 new bits for future flags. The values were not reassigned just in case there would be a few hidden u16 or short somewhere in which these flags are placed (as it used to be the case with stream->pending_events). The patch is tagged MEDIUM because this required to update the task's process() prototype to use an int instead of a short, that's quite a bunch of places.
2021-03-02 10:09:26 -05:00
struct task *srv_cleanup_idle_conns(struct task *task, void *ctx, unsigned int state);
REORG: server: uninline the idle conns management functions The following functions are quite heavy and have no reason to be kept inlined: srv_release_conn, srv_lookup_conn, srv_lookup_conn_next, srv_add_to_idle_list They were moved to server.c. It's worth noting that they're a bit at the edge between server and connection and that maybe we could create an idle-conn file for these in the near future.
2021-10-06 12:30:04 -04:00
void srv_release_conn(struct server *srv, struct connection *conn);
struct connection *srv_lookup_conn(struct eb_root *tree, uint64_t hash);
struct connection *srv_lookup_conn_next(struct connection *conn);
MINOR: server: move idle tree insert in a dedicated function Define a new function _srv_add_idle(). This is a simple wrapper to insert a connection in the server idle tree. This is reserved for simple usage and require to idle_conns lock. In most cases, srv_add_to_idle_list() should be used. This patch does not have any functional change. However, it will help with the next patch as idle connection will be always inserted in a list as secondary storage along with idle/safe trees.
2023-08-25 09:48:39 -04:00
void _srv_add_idle(struct server *srv, struct connection *conn, int is_safe);
REORG: server: uninline the idle conns management functions The following functions are quite heavy and have no reason to be kept inlined: srv_release_conn, srv_lookup_conn, srv_lookup_conn_next, srv_add_to_idle_list They were moved to server.c. It's worth noting that they're a bit at the edge between server and connection and that maybe we could create an idle-conn file for these in the near future.
2021-10-06 12:30:04 -04:00
int srv_add_to_idle_list(struct server *srv, struct connection *conn, int is_safe);
MINOR: backend: refactor insertion in avail conns tree Define a new function srv_add_to_avail_list(). This function is used to centralize connection insertion in available tree. It reuses a BUG_ON() statement to ensure the connection is not present in the idle list.
2023-10-25 04:10:14 -04:00
void srv_add_to_avail_list(struct server *srv, struct connection *conn);
MEDIUM: task: extend the state field to 32 bits It's been too short for quite a while now and is now full. It's still time to extend it to 32-bits since we have room for this without wasting any space, so we now gained 16 new bits for future flags. The values were not reassigned just in case there would be a few hidden u16 or short somewhere in which these flags are placed (as it used to be the case with stream->pending_events). The patch is tagged MEDIUM because this required to update the task's process() prototype to use an int instead of a short, that's quite a bunch of places.
2021-03-02 10:09:26 -05:00
struct task *srv_cleanup_toremove_conns(struct task *task, void *context, unsigned int state);
MAJOR: server: add DNS-based server name resolution Relies on the DNS protocol freshly implemented in HAProxy. It performs a server IP addr resolution based on a server hostname.
2015-04-13 19:15:08 -04:00
MINOR: srv: extract tracking server config function Extract the post-config tracking setup in a dedicated function srv_apply_track. This will be useful to implement track support for dynamic servers.
2021-07-13 04:35:23 -04:00
int srv_apply_track(struct server *srv, struct proxy *curproxy);
MINOR: server: add minimal infrastructure to parse keywords Just like with the "bind" lines, we'll switch the "server" line parsing to keyword registration. The code is essentially the same as for bind keywords, with minor changes such as support for the default-server keywords and support for variable argument count.
2012-10-10 02:27:36 -04:00
/*
* Registers the server keyword list <kwl> as a list of valid keywords for next
* parsing sessions.
*/
void srv_register_keywords(struct srv_kw_list *kwl);
/* Return a pointer to the server keyword <kw>, or NULL if not found. */
struct srv_kw *srv_find_kw(const char *kw);
/* Dumps all registered "server" keywords to the <out> string pointer. */
void srv_dump_kws(char **out);
BUG/MAJOR: server: weight calculation fails for map-based algorithms A crash was reported by Igor at owind when changing a server's weight on the CLI. Lukas Tribus could reproduce a related bug where setting a server's weight would result in the new weight being multiplied by the initial one. The two bugs are the same. The incorrect weight calculation results in the total farm weight being larger than what was initially allocated, causing the map index to be out of bounds on some hashes. It's easy to reproduce using "balance url_param" with a variable param, or with "balance static-rr". It appears that the calculation is made at many places and is not always right and not always wrong the same way. Thus, this patch introduces a new function "server_recalc_eweight()" which is dedicated to this task of computing ->eweight from many other elements including uweight and current time (for slowstart), and all users now switch to use this function. The patch is a bit large but the code was not trivially fixable in a way that could guarantee this situation would not occur anymore. The fix is much more readable and has been verified to work with all algorithms, with both consistent and map-based hashes, and even with static-rr. Slowstart was tested as well, just like enable/disable server. The same bug is very likely present in 1.4 as well, so the patch will probably need to be backported eventhough it will not apply as-is. Thanks to Lukas and Igor for the information they provided to reproduce it.
2013-11-21 05:22:01 -05:00
/* Recomputes the server's eweight based on its state, uweight, the current time,
CLEANUP: assorted typo fixes in the code and comments These are mostly comments in the code. A few error messages were fixed and are of low enough importance not to deserve a backport. Some regtests were also fixed.
2020-03-10 03:06:11 -04:00
* and the proxy's algorithm. To be used after updating sv->uweight. The warmup
BUG/MAJOR: server: weight calculation fails for map-based algorithms A crash was reported by Igor at owind when changing a server's weight on the CLI. Lukas Tribus could reproduce a related bug where setting a server's weight would result in the new weight being multiplied by the initial one. The two bugs are the same. The incorrect weight calculation results in the total farm weight being larger than what was initially allocated, causing the map index to be out of bounds on some hashes. It's easy to reproduce using "balance url_param" with a variable param, or with "balance static-rr". It appears that the calculation is made at many places and is not always right and not always wrong the same way. Thus, this patch introduces a new function "server_recalc_eweight()" which is dedicated to this task of computing ->eweight from many other elements including uweight and current time (for slowstart), and all users now switch to use this function. The patch is a bit large but the code was not trivially fixable in a way that could guarantee this situation would not occur anymore. The fix is much more readable and has been verified to work with all algorithms, with both consistent and map-based hashes, and even with static-rr. Slowstart was tested as well, just like enable/disable server. The same bug is very likely present in 1.4 as well, so the patch will probably need to be backported eventhough it will not apply as-is. Thanks to Lukas and Igor for the information they provided to reproduce it.
2013-11-21 05:22:01 -05:00
* state is automatically disabled if the time is elapsed.
*/
MAJOR: server: make server state changes synchronous again Now we try to synchronously push updates as they come using the new rdv point, so that the call to the server update function from the main poll loop is not needed anymore. It further reduces the apparent latency in the health checks as the response time almost always appears as 0 ms, resulting in a slightly higher check rate of ~1960 conn/s. Despite this, the CPU consumption has slightly dropped again to ~32% for the same test. The only trick is that the checks code is built with a bit of recursivity because srv_update_status() calls server_recalc_eweight(), and the latter needs to signal srv_update_status() in case of updates. Thus we added an extra argument to this function to indicate whether or not it must propagate updates (no if it comes from srv_update_status).
2018-08-02 05:48:52 -04:00
void server_recalc_eweight(struct server *sv, int must_update);
BUG/MAJOR: server: weight calculation fails for map-based algorithms A crash was reported by Igor at owind when changing a server's weight on the CLI. Lukas Tribus could reproduce a related bug where setting a server's weight would result in the new weight being multiplied by the initial one. The two bugs are the same. The incorrect weight calculation results in the total farm weight being larger than what was initially allocated, causing the map index to be out of bounds on some hashes. It's easy to reproduce using "balance url_param" with a variable param, or with "balance static-rr". It appears that the calculation is made at many places and is not always right and not always wrong the same way. Thus, this patch introduces a new function "server_recalc_eweight()" which is dedicated to this task of computing ->eweight from many other elements including uweight and current time (for slowstart), and all users now switch to use this function. The patch is a bit large but the code was not trivially fixable in a way that could guarantee this situation would not occur anymore. The fix is much more readable and has been verified to work with all algorithms, with both consistent and map-based hashes, and even with static-rr. Slowstart was tested as well, just like enable/disable server. The same bug is very likely present in 1.4 as well, so the patch will probably need to be backported eventhough it will not apply as-is. Thanks to Lukas and Igor for the information they provided to reproduce it.
2013-11-21 05:22:01 -05:00
MEDIUM: server: Break out set weight processing code Break out set weight processing code. This is in preparation for reusing the code. Also, remove duplicate check in nested if clauses. {px->lbprm.algo & BE_LB_PROP_DYN) is checked by the immediate outer if clause, so there is no need to check it a second time. Signed-off-by: Simon Horman <horms@verge.net.au>
2013-02-11 20:45:51 -05:00
/*
* Parses weight_str and configures sv accordingly.
* Returns NULL on success, error message string otherwise.
*/
const char *server_parse_weight_change_request(struct server *sv,
const char *weight_str);
MINOR: Add ability for agent-check to set server maxconn This is very useful in complex architecture systems where HAproxy is balancing DB connections for example. We want to keep the maxconn high in order to avoid issues with queueing on the LB level when there is slowness on another part of the system. Example is a case of an architecture where each thread opens multiple DB connections, which if get stuck in queue cause a snowball effect (old connections aren't closed, new ones cannot be established). These connections are mostly idle and the DB server has no problem handling thousands of them. Allowing us to dynamically set maxconn depending on the backend usage (LA, CPU, memory, etc.) enables us to have high maxconn for situations like above, but lowering it in case there are real issues where the backend servers become overloaded (cache issues, DB gets hit hard).
2016-04-24 17:10:06 -04:00
/*
* Parses maxconn_str and configures sv accordingly.
* Returns NULL on success, error message string otherwise.
*/
const char *server_parse_maxconn_change_request(struct server *sv,
const char *maxconn_str);
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
/* Shutdown all connections of a server. The caller must pass a termination
REORG/MEDIUM: stream: rename stream flags from SN_* to SF_* This is in order to keep things consistent.
2015-04-02 19:14:29 -04:00
* code in <why>, which must be one of SF_ERR_* indicating the reason for the
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
* shutdown.
*/
BUG/MINOR: server: some prototypes are renamed The commit 87b096 renames the functions srv_shutdown_backup_sessions() and srv_shutdown_sessions() to srv_shutdown_backup_streams() and srv_shutdown_streams(). The header file <proto/servers.h> does not repport these changes. This bug should be repported in the 1.6 branch, even if it is useless because new dev are frozen.
2016-02-22 10:08:58 -05:00
void srv_shutdown_streams(struct server *srv, int why);
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
/* Shutdown all connections of all backup servers of a proxy. The caller must
REORG/MEDIUM: stream: rename stream flags from SN_* to SF_* This is in order to keep things consistent.
2015-04-02 19:14:29 -04:00
* pass a termination code in <why>, which must be one of SF_ERR_* indicating
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
* the reason for the shutdown.
*/
BUG/MINOR: server: some prototypes are renamed The commit 87b096 renames the functions srv_shutdown_backup_sessions() and srv_shutdown_sessions() to srv_shutdown_backup_streams() and srv_shutdown_streams(). The header file <proto/servers.h> does not repport these changes. This bug should be repported in the 1.6 branch, even if it is useless because new dev are frozen.
2016-02-22 10:08:58 -05:00
void srv_shutdown_backup_streams(struct proxy *px, int why);
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
MAJOR: chunks: replace struct chunk with struct buffer Now all the code used to manipulate chunks uses a struct buffer instead. The functions are still called "chunk*", and some of them will progressively move to the generic buffer handling code as they are cleaned up.
2018-07-13 05:56:34 -04:00
void srv_append_status(struct buffer *msg, struct server *s, struct check *,
int xferred, int forced);
BUG/MEDIUM: log: check result details truncated. Fix regression introduced by commit: 'MAJOR: servers: propagate server status changes asynchronously.' The building of the log line was re-worked to be done at the postponed point without lack of data. [wt: this only affects 1.8-dev, no backport needed]
2017-10-19 08:42:30 -04:00
MINOR: server: change srv_op_st_chg_cause storage type This one is greatly inspired by "MINOR: server: change adm_st_chg_cause storage type". While looking at current srv_op_st_chg_cause usage, it was clear that the struct needed some cleanup since some leftovers from asynchronous server state change updates were left behind and resulted in some useless code duplication, and making the whole thing harder to maintain. Two observations were made: - by tracking down srv_set_{running, stopped, stopping} usage, we can see that the <reason> argument is always a fixed statically allocated string. - check-related state change context (duration, status, code...) is not used anymore since srv_append_status() directly extracts the values from the server->check. This is pure legacy from when the state changes were applied asynchronously. To prevent code duplication, useless string copies and make the reason/cause more exportable, we store it as an enum now, and we provide srv_op_st_chg_cause() function to fetch the related description string. HEALTH and AGENT causes (check related) are now explicitly identified to make consumers like srv_append_op_chg_cause() able to fetch checks info from the server itself if they need to.
2023-04-04 04:17:40 -04:00
void srv_set_stopped(struct server *s, enum srv_op_st_chg_cause cause);
void srv_set_running(struct server *s, enum srv_op_st_chg_cause cause);
void srv_set_stopping(struct server *s, enum srv_op_st_chg_cause cause);
MINOR: server: implement srv_set_stopping() This function was taken from check_set_server_drain(). It does not consider health checks at all and only sets a server to stopping provided it's not in maintenance and is not currently stopped. The resulting state will be STOPPING. The state change is propagated to tracked servers. For now the function is not used, but the goal is to split health checks status from server status and to be able to change a server's state regardless of health checks statuses.
2014-05-21 07:54:57 -04:00
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
/* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
* enforce either maint mode or drain mode. It is not allowed to set more than
* one flag at once. The equivalent "inherited" flag is propagated to all
* tracking servers. Maintenance mode disables health checks (but not agent
* checks). When either the flag is already set or no flag is passed, nothing
MINOR: server: make srv_set_admin_state() capable of telling why this happens It will be important to help debugging some DNS resolution issues to know why a server was marked down, so let's make the function support a 3rd argument with an indication of the reason. Passing NULL will keep the message as-is.
2016-11-07 09:53:43 -05:00
* is done. If <cause> is non-null, it will be displayed at the end of the log
* lines to justify the state change.
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
*/
MINOR: server: change adm_st_chg_cause storage type Even though it doesn't look like it at first glance, this is more like a cleanup than an actual code improvement: Given that srv->adm_st_chg_cause has been used to exclusively store static strings ever since it was implemented, we make the choice to store it as an enum instead of a fixed-size string within server struct. This will allow to save some space in server struct, and will make it more easily exportable (ie: event handlers) because of the reduced memory footprint during handling and the ability to later get the corresponding human-readable message when it's explicitly needed.
2023-04-03 11:40:28 -04:00
void srv_set_admin_flag(struct server *s, enum srv_admin mode, enum srv_adm_st_chg_cause cause);
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
/* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
* stop enforcing either maint mode or drain mode. It is not allowed to set more
* than one flag at once. The equivalent "inherited" flag is propagated to all
* tracking servers. Leaving maintenance mode re-enables health checks. When
* either the flag is already cleared or no flag is passed, nothing is done.
*/
void srv_clr_admin_flag(struct server *s, enum srv_admin mode);
CLEANUP: assorted typo fixes in the code and comments This is 33rd iteration of typo fixes
2022-11-30 06:22:42 -05:00
/* Calculates the dynamic persistent cookie for a server, if a secret key has
MINOR: server: Add dynamic session cookies. This adds a new "dynamic" keyword for the cookie option. If set, a cookie will be generated for each server (assuming one isn't already provided on the "server" line), from the IP of the server, the TCP port, and a secret key provided. To provide the secret key, a new keyword as been added, "dynamic-cookie-key", for backends. Example : backend bk_web balance roundrobin dynamic-cookie-key "bla" cookie WEBSRV insert dynamic server s1 127.0.0.1:80 check server s2 192.168.56.1:80 check This is a first step to be able to dynamically add and remove servers, without modifying the configuration file, and still have all the load balancers redirect the traffic to the right server. Provide a way to generate session cookies, based on the IP address of the server, the TCP port, and a secret key provided.
2017-03-14 15:01:29 -04:00
* been provided.
*/
void srv_set_dyncookie(struct server *s);
MEDIUM: server/backend: implement websocket protocol selection Handle properly websocket streams if the server uses an ALPN with both h1 and h2. Add a new field h2_ws in the server structure. If set to off, reuse is automatically disable on backend and ALPN is forced to http1.x if possible. Nothing is done if on. Implement a mechanism to be able to use a different http version for websocket streams. A new server member <ws> represents the algorithm to select the protocol. This can overrides the server <proto> configuration. If the connection uses ALPN for proto selection, it is updated for websocket streams to select the right protocol. Three mode of selection are implemented : - auto : use the same protocol between non-ws and ws streams. If ALPN is use, try to update it to "http/1.1"; this is only done if the server ALPN contains "http/1.1". - h1 : use http/1.1 - h2 : use http/2.0; this requires the server to support RFC8441 or an error will be returned by haproxy.
2021-10-18 08:39:57 -04:00
int srv_check_reuse_ws(struct server *srv);
const struct mux_ops *srv_get_ws_proto(struct server *srv);
MEDIUM: server: introduce srv_alloc()/srv_free() to alloc/free a server It happens that we free servers at various places in the code, both on error paths and at runtime thanks to the "server delete" feature. In order to switch to an aligned struct, we'll need to change the calloc() and free() calls. Let's first spot them and switch them to srv_alloc() and srv_free() instead of using calloc() and either free() or ha_free(). An easy trap to fall into is that some of them are default-server entries. The new srv_free() function also resets the pointer like ha_free() does. This was done by running the following coccinelle script all over the code: @@ struct server *srv; @@ ( - free(srv) + srv_free(&srv) | - ha_free(&srv) + srv_free(&srv) ) @@ struct server *srv; expression e1; expression e2; @@ ( - srv = malloc(e1) + srv = srv_alloc() | - srv = calloc(e1, e2) + srv = srv_alloc() ) This is marked medium because despite spotting all call places, we can never rule out the possibility that some out-of-tree patches would allocate their own servers and continue to use the old API... at their own risk.
2025-08-13 05:52:59 -04:00
/* allocate a new server and return it (or NULL on failure). The structure is
* zeroed.
*/
static inline struct server *srv_alloc(void)
{
MINOR: server: align server struct to 64 bytes Several times recently, it was noticed that some benchmarks would highly vary depending on the position of certain fields in the server struct, and this could even vary between runs. The server struct does have separate areas depending on the user cases and hot/cold aspect of the members stored there, but the areas are artificially kept apart using fixed padding instead of real alignment, which has the first sad effect of artificially inflating the struct, and the second one of misaligning it. Now that we have all the necessary tools to keep them aligned, let's just do it. The struct has shrunk from 4160 to 4032 bytes on 64-bit systems, 152 of which are still holes or padding.
2025-08-13 09:07:55 -04:00
return ha_aligned_zalloc_typed(1, struct server);
MEDIUM: server: introduce srv_alloc()/srv_free() to alloc/free a server It happens that we free servers at various places in the code, both on error paths and at runtime thanks to the "server delete" feature. In order to switch to an aligned struct, we'll need to change the calloc() and free() calls. Let's first spot them and switch them to srv_alloc() and srv_free() instead of using calloc() and either free() or ha_free(). An easy trap to fall into is that some of them are default-server entries. The new srv_free() function also resets the pointer like ha_free() does. This was done by running the following coccinelle script all over the code: @@ struct server *srv; @@ ( - free(srv) + srv_free(&srv) | - ha_free(&srv) + srv_free(&srv) ) @@ struct server *srv; expression e1; expression e2; @@ ( - srv = malloc(e1) + srv = srv_alloc() | - srv = calloc(e1, e2) + srv = srv_alloc() ) This is marked medium because despite spotting all call places, we can never rule out the possibility that some out-of-tree patches would allocate their own servers and continue to use the old API... at their own risk.
2025-08-13 05:52:59 -04:00
}
/* free a previously allocated server an nullifies the pointer */
static inline void srv_free(struct server **srv_ptr)
{
MINOR: server: align server struct to 64 bytes Several times recently, it was noticed that some benchmarks would highly vary depending on the position of certain fields in the server struct, and this could even vary between runs. The server struct does have separate areas depending on the user cases and hot/cold aspect of the members stored there, but the areas are artificially kept apart using fixed padding instead of real alignment, which has the first sad effect of artificially inflating the struct, and the second one of misaligning it. Now that we have all the necessary tools to keep them aligned, let's just do it. The struct has shrunk from 4160 to 4032 bytes on 64-bit systems, 152 of which are still holes or padding.
2025-08-13 09:07:55 -04:00
ha_aligned_free(*srv_ptr);
*srv_ptr = NULL;
MEDIUM: server: introduce srv_alloc()/srv_free() to alloc/free a server It happens that we free servers at various places in the code, both on error paths and at runtime thanks to the "server delete" feature. In order to switch to an aligned struct, we'll need to change the calloc() and free() calls. Let's first spot them and switch them to srv_alloc() and srv_free() instead of using calloc() and either free() or ha_free(). An easy trap to fall into is that some of them are default-server entries. The new srv_free() function also resets the pointer like ha_free() does. This was done by running the following coccinelle script all over the code: @@ struct server *srv; @@ ( - free(srv) + srv_free(&srv) | - ha_free(&srv) + srv_free(&srv) ) @@ struct server *srv; expression e1; expression e2; @@ ( - srv = malloc(e1) + srv = srv_alloc() | - srv = calloc(e1, e2) + srv = srv_alloc() ) This is marked medium because despite spotting all call places, we can never rule out the possibility that some out-of-tree patches would allocate their own servers and continue to use the old API... at their own risk.
2025-08-13 05:52:59 -04:00
}
BUG/MINOR: backend: use cum_sess counters instead of cum_conn This commit is part of a serie to align counters usage between frontends/listeners on one side and backends/servers on the other. "stot" metric refers to the total number of sessions. On backend side, it is interpreted as a number of streams. Previously, this was accounted using <cum_sess> be_counters field for servers, but <cum_conn> instead for backend proxies. Adjust this by using <cum_sess> for both proxies and servers. As such, <cum_conn> field can be removed from be_counters. Note that several diagnostic messages which reports total frontend and backend connections were adjusted to use <cum_sess>. However, this is an outdated and misleading information as it does reports streams count on backend side. These messages should be fixed in a separate commit. This should be backported to all stable releases.
2024-04-04 12:08:46 -04:00
/* increase the number of cumulated streams on the designated server */
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
static inline void srv_inc_sess_ctr(struct server *s)
{
MEDIUM: stats: avoid 1 indirection by storing the shared stats directly in counters struct Between 3.2 and 3.3-dev we noticed a noticeable performance regression due to stats handling. After bisecting, Willy found out that recent work to split stats computing accross multiple thread groups (stats sharding) was responsible for that performance regression. We're looking at roughly 20% performance loss. More precisely, it is the added indirections, multiplied by the number of statistics that are updated for each request, which in the end causes a significant amount of time being spent resolving pointers. We noticed that the fe_counters_shared and be_counters_shared structures which are currently allocated in dedicated memory since a0dcab5c ("MAJOR: counters: add shared counters base infrastructure") are no longer huge since 16eb0fab31 ("MAJOR: counters: dispatch counters over thread groups") because they now essentially hold flags plus the per-thread group id pointer mapping, not the counters themselves. As such we decided to try merging fe_counters_shared and be_counters_shared in their parent structures. The cost is slight memory overhead for the parent structure, but it allows to get rid of one pointer indirection. This patch alone yields visible performance gains and almost restores 3.2 stats performance. counters_fe_shared_get() was renamed to counters_fe_shared_prepare() and now returns either failure or success instead of a pointer because we don't need to retrieve a shared pointer anymore, the function takes care of initializing existing pointer.
2025-07-22 11:15:02 -04:00
_HA_ATOMIC_INC(&s->counters.shared.tg[tgid - 1]->cum_sess);
update_freq_ctr(&s->counters.shared.tg[tgid - 1]->sess_per_sec, 1);
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
HA_ATOMIC_UPDATE_MAX(&s->counters.sps_max,
MINOR: counters: add local-only internal rates to compute some maxes cps_max (max new connections received per second), sps_max (max new sessions per second) and http.rps_max (maximum new http requests per second) all rely on shared counters (namely conn_per_sec, sess_per_sec and http.req_per_sec). The problem is that shared counters are about to be distributed over thread groups, and we cannot afford to compute the total (for all thread groups) each time we update the max counters. Instead, since such max counters (relying on shared counters) are a very few exceptions, let's add internal (sess,conn,req) per sec freq counters that are dedicated to cps_max, sps_max and http.rps_max computing. Thanks to that, related *_max counters shouldn't be negatively impacted by the thread-group distribution, yet they will not benefit from it either. Related internal freq counters are prefixed with "_" to emphasize the fact that they should not be used for other purpose (the shared ones, which are about to be distributed over thread groups in upcoming commits are still available and must be used instead). The internal ones could eventually be removed at any time if we find another way to compute the {cps,sps,http.rps)_max counters.
2025-05-28 06:00:49 -04:00
update_freq_ctr(&s->counters._sess_per_sec, 1));
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
}
/* set the time of last session on the designated server */
static inline void srv_set_sess_last(struct server *s)
{
MEDIUM: stats: avoid 1 indirection by storing the shared stats directly in counters struct Between 3.2 and 3.3-dev we noticed a noticeable performance regression due to stats handling. After bisecting, Willy found out that recent work to split stats computing accross multiple thread groups (stats sharding) was responsible for that performance regression. We're looking at roughly 20% performance loss. More precisely, it is the added indirections, multiplied by the number of statistics that are updated for each request, which in the end causes a significant amount of time being spent resolving pointers. We noticed that the fe_counters_shared and be_counters_shared structures which are currently allocated in dedicated memory since a0dcab5c ("MAJOR: counters: add shared counters base infrastructure") are no longer huge since 16eb0fab31 ("MAJOR: counters: dispatch counters over thread groups") because they now essentially hold flags plus the per-thread group id pointer mapping, not the counters themselves. As such we decided to try merging fe_counters_shared and be_counters_shared in their parent structures. The cost is slight memory overhead for the parent structure, but it allows to get rid of one pointer indirection. This patch alone yields visible performance gains and almost restores 3.2 stats performance. counters_fe_shared_get() was renamed to counters_fe_shared_prepare() and now returns either failure or success instead of a pointer because we don't need to retrieve a shared pointer anymore, the function takes care of initializing existing pointer.
2025-07-22 11:15:02 -04:00
HA_ATOMIC_STORE(&s->counters.shared.tg[tgid - 1]->last_sess, ns_to_sec(now_ns));
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
}
/* returns the current server throttle rate between 0 and 100% */
static inline unsigned int server_throttle_rate(struct server *sv)
{
struct proxy *px = sv->proxy;
/* when uweight is 0, we're in soft-stop so that cannot be a slowstart,
* thus the throttle is 100%.
*/
if (!sv->uweight)
return 100;
return (100U * px->lbprm.wmult * sv->cur_eweight + px->lbprm.wdiv - 1) / (px->lbprm.wdiv * sv->uweight);
}
/*
* Return true if the server has a zero user-weight, meaning it's in draining
* mode (ie: not taking new non-persistent connections).
*/
static inline int server_is_draining(const struct server *s)
{
return !s->uweight || (s->cur_admin & SRV_ADMF_DRAIN);
}
MEDIUM: server: properly support and propagate the maintenance status This change now involves a new flag SRV_ADMF_IMAINT to note that the maintenance status of a server is inherited from another server. Thus, we know at each server level in the chain if it's running, in forced maintenance or in a maintenance status because it tracks another server, or even in both states. Disabling a server propagates this flag down to other servers. Enabling a server flushes the flag down. A server becomes up again once both of its flags are cleared. Two new functions "srv_adm_set_maint()" and "srv_adm_set_ready()" are used to manipulate this maintenance status. They're used by the CLI and the stats page. Now the stats page always says "MAINT" instead of "MAINT(via)" and it's only the chk/down field which reports "via x/y" when the status is inherited from another server, but it doesn't say it when a server was forced into maintenance. The CSV output indicates "MAINT (via x/y)" instead of only "MAINT(via)". This is the most accurate representation. One important thing is that now entering/leaving maintenance for a tracking server correctly follows the state of the tracked server.
2014-05-16 05:25:16 -04:00
/* Puts server <s> into maintenance mode, and propagate that status down to all
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
* tracking servers.
*/
static inline void srv_adm_set_maint(struct server *s)
{
MINOR: server: change adm_st_chg_cause storage type Even though it doesn't look like it at first glance, this is more like a cleanup than an actual code improvement: Given that srv->adm_st_chg_cause has been used to exclusively store static strings ever since it was implemented, we make the choice to store it as an enum instead of a fixed-size string within server struct. This will allow to save some space in server struct, and will make it more easily exportable (ie: event handlers) because of the reduced memory footprint during handling and the ability to later get the corresponding human-readable message when it's explicitly needed.
2023-04-03 11:40:28 -04:00
srv_set_admin_flag(s, SRV_ADMF_FMAINT, SRV_ADM_STCHGC_NONE);
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
srv_clr_admin_flag(s, SRV_ADMF_FDRAIN);
}
/* Puts server <s> into drain mode, and propagate that status down to all
* tracking servers.
*/
static inline void srv_adm_set_drain(struct server *s)
{
MINOR: server: change adm_st_chg_cause storage type Even though it doesn't look like it at first glance, this is more like a cleanup than an actual code improvement: Given that srv->adm_st_chg_cause has been used to exclusively store static strings ever since it was implemented, we make the choice to store it as an enum instead of a fixed-size string within server struct. This will allow to save some space in server struct, and will make it more easily exportable (ie: event handlers) because of the reduced memory footprint during handling and the ability to later get the corresponding human-readable message when it's explicitly needed.
2023-04-03 11:40:28 -04:00
srv_set_admin_flag(s, SRV_ADMF_FDRAIN, SRV_ADM_STCHGC_NONE);
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
srv_clr_admin_flag(s, SRV_ADMF_FMAINT);
}
/* Puts server <s> into ready mode, and propagate that status down to all
* tracking servers.
*/
static inline void srv_adm_set_ready(struct server *s)
{
srv_clr_admin_flag(s, SRV_ADMF_FDRAIN);
srv_clr_admin_flag(s, SRV_ADMF_FMAINT);
}
MEDIUM: server: properly support and propagate the maintenance status This change now involves a new flag SRV_ADMF_IMAINT to note that the maintenance status of a server is inherited from another server. Thus, we know at each server level in the chain if it's running, in forced maintenance or in a maintenance status because it tracks another server, or even in both states. Disabling a server propagates this flag down to other servers. Enabling a server flushes the flag down. A server becomes up again once both of its flags are cleared. Two new functions "srv_adm_set_maint()" and "srv_adm_set_ready()" are used to manipulate this maintenance status. They're used by the CLI and the stats page. Now the stats page always says "MAINT" instead of "MAINT(via)" and it's only the chk/down field which reports "via x/y" when the status is inherited from another server, but it doesn't say it when a server was forced into maintenance. The CSV output indicates "MAINT (via x/y)" instead of only "MAINT(via)". This is the most accurate representation. One important thing is that now entering/leaving maintenance for a tracking server correctly follows the state of the tracked server.
2014-05-16 05:25:16 -04:00
MEDIUM: server: add a new init-addr server line setting This new setting supports a comma-delimited list of methods used to resolve the server's FQDN to an IP address. Currently supported methods are "libc" (use the regular libc's resolver) and "last" (use the last known valid address found in the state file). The list is implemented in a 32-bit integer, because each init-addr method only requires 3 bits. The last one must always be SRV_IADDR_END (0), allowing to store up to 10 methods in a single 32 bit integer. Note: the doc is provided at the end of this series.
2016-09-21 14:26:16 -04:00
/* appends an initaddr method to the existing list. Returns 0 on failure. */
static inline int srv_append_initaddr(unsigned int *list, enum srv_initaddr addr)
{
int shift = 0;
while (shift + 3 < 32 && (*list >> shift))
shift += 3;
if (shift + 3 > 32)
return 0;
*list |= addr << shift;
return 1;
}
MEDIUM: server: make use of init-addr It is now supported. If not set, we default to the legacy methods list which is "last,libc".
2016-11-04 10:10:17 -04:00
/* returns the next initaddr method and removes it from <list> by shifting
* it right (implying that it MUST NOT be the server's. Returns SRV_IADDR_END
* at the end.
*/
static inline enum srv_initaddr srv_get_next_initaddr(unsigned int *list)
{
enum srv_initaddr ret;
ret = *list & 7;
*list >>= 3;
return ret;
}
BUG/MEDIUM: connection: fix srv idle count on conn takeover On server connection migration from one thread to another, the wrong idle thread-specific counter is decremented. This bug was introduced since commit 3d52f0f1f828acb2a74b3f13fcc3fa069106d09f due to the factorization with srv_use_idle_conn. However, this statement is only executed from conn_backend_get. Extract the decrement from srv_use_idle_conn in conn_backend_get and use the correct thread-specific counter. Rename the function to srv_use_conn to better reflect its purpose as it is also used with a newly initialized connection not in the idle list. As a side change, the connection insertion to available list has also been extracted to conn_backend_get. This will be useful to be able to specify an alternative list for protocol subject to HOL risk that should not be shared between several clients. This bug is only present in this release and thus do not need a backport.
2020-10-14 12:17:04 -04:00
static inline void srv_use_conn(struct server *srv, struct connection *conn)
MINOR: server: Factorize code to deal with reuse of server idle connections The srv_use_idle_conn() function is now responsible to update the server counters and the connection flags when an idle connection is reused. The same function is called when a new connection is created. This simplifies a bit the connect_server() function.
2020-07-02 09:45:56 -04:00
{
BUG/MINOR: server/idle: at least use atomic stores when updating max_used_conns In 2.2, some idle conns usage metrics were added by commit cf612a045 ("MINOR: servers: Add a counter for the number of currently used connections."), which mentioned that the operation doesn't need to be atomic since we're not seeking exact values. This is true but at least we should use atomic stores to make sure not to cause invalid values to appear on archs that wouldn't guarantee atomicity when writing an int, such as writing two 16-bit words. This is pretty unlikely on our targets but better keep the code safe against this. This may be backported as far as 2.2.
2022-11-21 08:32:33 -05:00
unsigned int curr, prev;
MINOR: server: don't read curr_used_conns multiple times This one is added atomically and we reread it just after this, causing a second memory load that is visible in the perf profile.
2021-03-03 12:12:11 -05:00
CLEANUP: atomic: add an explicit _FETCH variant for add/sub/and/or Currently our atomic ops return a value but it's never known whether the fetch is done before or after the operation, which causes some confusion each time the value is desired. Let's create an explicit variant of these operations suffixed with _FETCH to explicitly mention that the fetch occurs after the operation, and make use of it at the few call places.
2021-04-06 05:44:07 -04:00
curr = _HA_ATOMIC_ADD_FETCH(&srv->curr_used_conns, 1);
MINOR: server: Factorize code to deal with reuse of server idle connections The srv_use_idle_conn() function is now responsible to update the server counters and the connection flags when an idle connection is reused. The same function is called when a new connection is created. This simplifies a bit the connect_server() function.
2020-07-02 09:45:56 -04:00
BUG/MINOR: server/idle: at least use atomic stores when updating max_used_conns In 2.2, some idle conns usage metrics were added by commit cf612a045 ("MINOR: servers: Add a counter for the number of currently used connections."), which mentioned that the operation doesn't need to be atomic since we're not seeking exact values. This is true but at least we should use atomic stores to make sure not to cause invalid values to appear on archs that wouldn't guarantee atomicity when writing an int, such as writing two 16-bit words. This is pretty unlikely on our targets but better keep the code safe against this. This may be backported as far as 2.2.
2022-11-21 08:32:33 -05:00
MINOR: server: Factorize code to deal with reuse of server idle connections The srv_use_idle_conn() function is now responsible to update the server counters and the connection flags when an idle connection is reused. The same function is called when a new connection is created. This simplifies a bit the connect_server() function.
2020-07-02 09:45:56 -04:00
/* It's ok not to do that atomically, we don't need an
* exact max.
*/
BUG/MINOR: server/idle: at least use atomic stores when updating max_used_conns In 2.2, some idle conns usage metrics were added by commit cf612a045 ("MINOR: servers: Add a counter for the number of currently used connections."), which mentioned that the operation doesn't need to be atomic since we're not seeking exact values. This is true but at least we should use atomic stores to make sure not to cause invalid values to appear on archs that wouldn't guarantee atomicity when writing an int, such as writing two 16-bit words. This is pretty unlikely on our targets but better keep the code safe against this. This may be backported as far as 2.2.
2022-11-21 08:32:33 -05:00
prev = HA_ATOMIC_LOAD(&srv->max_used_conns);
if (prev < curr)
HA_ATOMIC_STORE(&srv->max_used_conns, curr);
MINOR: server: Factorize code to deal with reuse of server idle connections The srv_use_idle_conn() function is now responsible to update the server counters and the connection flags when an idle connection is reused. The same function is called when a new connection is created. This simplifies a bit the connect_server() function.
2020-07-02 09:45:56 -04:00
BUG/MINOR: server/idle: at least use atomic stores when updating max_used_conns In 2.2, some idle conns usage metrics were added by commit cf612a045 ("MINOR: servers: Add a counter for the number of currently used connections."), which mentioned that the operation doesn't need to be atomic since we're not seeking exact values. This is true but at least we should use atomic stores to make sure not to cause invalid values to appear on archs that wouldn't guarantee atomicity when writing an int, such as writing two 16-bit words. This is pretty unlikely on our targets but better keep the code safe against this. This may be backported as far as 2.2.
2022-11-21 08:32:33 -05:00
prev = HA_ATOMIC_LOAD(&srv->est_need_conns);
if (prev < curr)
HA_ATOMIC_STORE(&srv->est_need_conns, curr);
MINOR: server: Factorize code to deal with reuse of server idle connections The srv_use_idle_conn() function is now responsible to update the server counters and the connection flags when an idle connection is reused. The same function is called when a new connection is created. This simplifies a bit the connect_server() function.
2020-07-02 09:45:56 -04:00
}
MINOR: cfgparse/server: move (min/max)conn postparsing logic into dedicated function In check_config_validity() function, we performed some consistency checks to adjust minconn/maxconn attributes for each declared server. We move this logic into a dedicated function named srv_minmax_conn_apply() to be able to perform those checks later in the process life when needed (ie: dynamic servers)
2023-02-08 05:49:02 -05:00
/* checks if minconn and maxconn are consistent to each other
* and automatically adjust them if it is not the case
* This logic was historically implemented in check_config_validity()
* at boot time, but with the introduction of dynamic servers
* this may be used at multiple places in the code now
*/
static inline void srv_minmax_conn_apply(struct server *srv)
{
if (srv->minconn > srv->maxconn) {
/* Only 'minconn' was specified, or it was higher than or equal
* to 'maxconn'. Let's turn this into maxconn and clean it, as
* this will avoid further useless expensive computations.
*/
srv->maxconn = srv->minconn;
} else if (srv->maxconn && !srv->minconn) {
/* minconn was not specified, so we set it to maxconn */
srv->minconn = srv->maxconn;
}
}
MINOR: backend: only allow reuse for reverse server A reverse server relies solely on its pool of idle connection to transfer requests which will be populated through a new tcp-request rule 'attach-srv'. Several changes are required on connect_server() to implement this. First, reuse mode is forced to always for this type of server. Then, if no idle connection is found, the request will be aborted. This results with a 503 HTTP error code, similarly to when no server is available.
2023-08-18 10:02:35 -04:00
/* Returns true if server is used as transparent mode. */
static inline int srv_is_transparent(const struct server *srv)
{
/* A reverse server does not have any address but it is not used as a
* transparent one.
*/
MINOR: rhttp: large renaming to use rhttp prefix Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'. This commits follows this by replacing various custom prefix by 'rhttp_' to make the code uniform. Note that 'reverse_' prefix was kept in connection module. This is because if a new reversable protocol not based on HTTP is implemented, it may be necessary to reused the same connection function which are protocol agnostic.
2023-11-21 05:10:34 -05:00
return (!is_addr(&srv->addr) && !(srv->flags & SRV_F_RHTTP)) ||
MINOR: backend: only allow reuse for reverse server A reverse server relies solely on its pool of idle connection to transfer requests which will be populated through a new tcp-request rule 'attach-srv'. Several changes are required on connect_server() to implement this. First, reuse mode is forced to always for this type of server. Then, if no idle connection is found, the request will be aborted. This results with a 503 HTTP error code, similarly to when no server is available.
2023-08-18 10:02:35 -04:00
(srv->flags & SRV_F_MAPPORTS);
}
MEDIUM: server: automatically add server to proxy list in new_server() while new_server() takes the parent proxy as argument and even assigns srv->proxy to the parent proxy, it didn't actually inserted the server to the parent proxy server list on success. The result is that sometimes we add the server to the list after new_server() is called, and sometimes we don't. This is really error-prone and because of that hooks such as REGISTER_POST_SERVER_CHECK() which as run for all servers listed in all proxies may not be relied upon for servers which are not actually inserted in their parent proxy server list. Plus it feels very strange to have a server that points to a proxy, but then the proxy doesn't know about it because it cannot find it in its server list. To prevent errors and make proxy->srv list reliable, we move the insertion logic directly under new_server(). This requires to know if we are called during parsing or during runtime to either insert or append the server to the parent proxy list. For that we use PR_FL_CHECKED flag from the parent proxy (if the flag is set, then the proxy was checked so we are past the init phase, thus we assume we are called during runtime) This implies that during startup if new_server() has to be cancelled on error paths we need to call srv_detach() (which is now exposed in server.h) before srv_drop(). The consequence of this commit is that REGISTER_POST_SERVER_CHECK() should not run reliably on all servers created using new_server() (without having to manually loop on global servers_list)
2025-05-09 13:24:55 -04:00
/* Detach server from proxy list. It is supported to call this
* even if the server is not yet in the list
* Must be called under thread isolation or when it is safe to assume
* that the parent proxy doesn't is not skimming through the server list
*/
static inline void srv_detach(struct server *srv)
{
struct proxy *px = srv->proxy;
if (px->srv == srv)
px->srv = srv->next;
else {
struct server *prev;
for (prev = px->srv; prev && prev->next != srv; prev = prev->next)
;
BUG_ON(!prev);
prev->next = srv->next;
}
}
CLEANUP: server: simplify server_find_by_id() At a few places we're seeing some open-coding of the same function, likely because it looks overkill for what it's supposed to do, due to extraneous tests that are not needed (e.g. check of the backend's PR_CAP_BE etc). Let's just remove all these superfluous tests and inline it so that it feels more suitable for use everywhere it's needed.
2025-07-09 10:35:27 -04:00
/* Returns a pointer to the first server matching id <id> in backend <bk>.
* NULL is returned if no match is found.
*/
static inline struct server *server_find_by_id(struct proxy *bk, int id)
{
struct eb32_node *eb32;
eb32 = eb32_lookup(&bk->conf.used_server_id, id);
return eb32 ? container_of(eb32, struct server, conf.id) : NULL;
}
MINOR: server: implement helper to identify QUIC servers Define srv_is_quic() which can be used to quickly identified if a server uses QUIC protocol.
2025-06-11 11:28:46 -04:00
static inline int srv_is_quic(const struct server *srv)
{
#ifdef USE_QUIC
return srv->addr_type.proto_type == PROTO_TYPE_DGRAM &&
srv->addr_type.xprt_type == PROTO_TYPE_STREAM;
#else
return 0;
#endif
}
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
#endif /* _HAPROXY_SERVER_H */
BUG/MINOR: server: move the directive #endif to the end of file If a source file includes proto/server.h twice or more, redefinition errors will be triggered for such inline functions as server_throttle_rate(), server_is_draining(), srv_adm_set_maint() and so on. Just move #endif directive to the end of file to solve this issue. Signed-off-by: Godbach <nylzhaowei@gmail.com>
2014-07-28 05:31:57 -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
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/
Reference in a new issue Copy permalink