upstream/haproxy
1
0
Fork 0
mirror of https://github.com/haproxy/haproxy.git synced 2026-03-19 09:02:28 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 12
haproxy/include/haproxy/server.h

287 lines
10 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>
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>
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>
[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;
MINOR: server: add a global list of all known servers It's a real pain not to have access to the list of all registered servers, because whenever there is a need to late adjust their configuration, only those attached to regular proxies are seen, but not the peers, lua, logs nor DNS. What this patch does is that new_server() will automatically add the newly created server to a global list, and it does so as well for the 1 or 2 statically allocated servers created for Lua. This way it will be possible to iterate over all of them.
2021-03-05 04:23:32 -05:00
extern struct 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);
MINOR: stats: Enhancement to stats page to provide information of last session time. Summary: Track and report last session time on the stats page for each server in every backend, as well as the backend. This attempts to address the requirement in the ROADMAP - add a last activity date for each server (req/resp) that will be displayed in the stats. It will be useful with soft stop. The stats page reports this as time elapsed since last session. This change does not adequately address the requirement for long running session (websocket, RDP... etc).
2014-02-03 16:26:46 -05:00
int srv_lastsession(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);
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);
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_update_addr(struct server *s, void *ip, int ip_sin_family, const char *updater);
const char *srv_update_addr_port(struct server *s, const char *addr, const char *port, char *updater);
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);
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_by_id(struct proxy *bk, int id);
struct server *server_find_by_name(struct proxy *bk, const char *name);
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);
CLEANUP: server: a separate function for initializing the per_thr field To avoid repeating the same source code, allocating memory and initializing the per_thr field from the server structure is transferred to a separate function.
2021-06-15 09:33:20 -04:00
int srv_init_per_thr(struct server *srv);
CLEANUP: ssl/server: move ssl_sock_set_srv() to srv_set_ssl() in server.c This one has nothing to do with ssl_sock as it manipulates the struct server only. Let's move it to server.c and remove unneeded dependencies on ssl_sock.h. This further reduces by 10% the number of includes of opensslconf.h and by 0.5% the number of compiled lines.
2021-10-06 05:48:34 -04:00
void srv_set_ssl(struct server *s, int use_ssl);
[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);
MINOR: resolvers: Add function to change the srv status based on SRV resolution srvrq_update_srv_status() update the server status based on result of SRV resolution. For now, it is only used from snr_update_srv_status() when appropriate.
2021-03-11 12:03:21 -05:00
int srvrq_update_srv_status(struct server *s, int has_no_ip);
MINOR: dns: Cache previous DNS answers. As DNS servers may not return all IPs in one answer, we want to cache the previous entries. Those entries are removed when considered obsolete, which happens when the IP hasn't been returned by the DNS server for a time defined in the "hold obsolete" parameter of the resolver section. The default is 30s.
2017-07-06 12:46:47 -04:00
int snr_update_srv_status(struct server *s, int has_no_ip);
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);
int srv_add_to_idle_list(struct server *srv, struct connection *conn, int is_safe);
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);
MEDIUM: server: change server ip address from stats socket New command available on the stats socket to change a server addr using the command "set server <backend>/<server> addr <ip4|ip6>"
2015-04-13 16:54:33 -04:00
/*
MINOR: server: generalize the "updater" source the function server_parse_addr_change_request() contain an hardcoded updater source "stats command". this function can be called from other sources than the "stats command", so this patch make this argument generic.
2016-02-24 02:25:39 -05:00
* Parses addr_str and configures sv accordingly. updater precise
* the source of the change in the associated message log.
MEDIUM: server: change server ip address from stats socket New command available on the stats socket to change a server addr using the command "set server <backend>/<server> addr <ip4|ip6>"
2015-04-13 16:54:33 -04:00
* Returns NULL on success, error message string otherwise.
*/
const char *server_parse_addr_change_request(struct server *sv,
MINOR: server: generalize the "updater" source the function server_parse_addr_change_request() contain an hardcoded updater source "stats command". this function can be called from other sources than the "stats command", so this patch make this argument generic.
2016-02-24 02:25:39 -05:00
const char *addr_str, const char *updater);
MEDIUM: server: change server ip address from stats socket New command available on the stats socket to change a server addr using the command "set server <backend>/<server> addr <ip4|ip6>"
2015-04-13 16:54:33 -04:00
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
void srv_set_stopped(struct server *s, const char *reason, struct check *check);
void srv_set_running(struct server *s, const char *reason, struct check *check);
void srv_set_stopping(struct server *s, const char *reason, struct check *check);
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: 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
void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *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);
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
/* Calculates the dynamic persitent cookie for a server, if a secret key has
* 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);
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
/* increase the number of cumulated connections on the designated server */
static inline void srv_inc_sess_ctr(struct server *s)
{
CLEANUP: atomic/tree-wide: replace single increments/decrements with inc/dec This patch replaces roughly all occurrences of an HA_ATOMIC_ADD(&foo, 1) or HA_ATOMIC_SUB(&foo, 1) with the equivalent HA_ATOMIC_INC(&foo) and HA_ATOMIC_DEC(&foo) respectively. These are 507 changes over 45 files.
2021-04-06 07:53:36 -04:00
_HA_ATOMIC_INC(&s->counters.cum_sess);
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,
update_freq_ctr(&s->sess_per_sec, 1));
}
/* set the time of last session on the designated server */
static inline void srv_set_sess_last(struct server *s)
{
s->counters.last_sess = now.tv_sec;
}
/* 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: 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
srv_set_admin_flag(s, SRV_ADMF_FMAINT, NULL);
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: 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
srv_set_admin_flag(s, SRV_ADMF_FDRAIN, NULL);
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
{
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
unsigned int curr;
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
/* It's ok not to do that atomically, we don't need an
* exact max.
*/
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
if (srv->max_used_conns < curr)
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
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
if (srv->est_need_conns < curr)
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
}
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