upstream/haproxy
1
0
Fork 0
mirror of https://github.com/haproxy/haproxy.git synced 2026-02-26 11:20:31 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 12
haproxy/src/proxy.c

1812 lines
53 KiB
C
Raw Normal View History

[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
/*
* Proxy variables and functions.
*
[MEDIUM] implement "rate-limit sessions" for the frontend The new "rate-limit sessions" statement sets a limit on the number of new connections per second on the frontend. As it is extremely accurate (about 0.1%), it is efficient at limiting resource abuse or DoS.
2009-03-05 17:48:25 -05:00
* Copyright 2000-2009 Willy Tarreau <w@1wt.eu>
[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
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*
*/
#include <fcntl.h>
#include <unistd.h>
[BUILD] fix 2 minor issues on AIX AIX does not know about MSG_DONTWAIT. Fortunately, nearly all sockets are already set to O_NONBLOCK, so it's not even required to change the code. It was only necessary to add this fcntl to the log socket which lacked it. The MSG_DONTWAIT value has been defined to zero when unset in order to make the code cleaner and more portable. Also, on AIX, "hz" is defined, which causes a problem with one function parameter in time.c. It's enough to rename the parameter there. Last, fix a missing #include <string.h> in proxy.c.
2007-11-30 12:38:35 -05:00
#include <string.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 <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
[CLEANUP] renamed include/haproxy to include/common
2006-06-29 11:53:05 -04:00
#include <common/defaults.h>
[MEDIUM] modularize the "timeout" keyword configuration parser The "timeout" keyword already relied on an external parser, let's make use of the new keyword registration mechanism.
2008-07-09 14:34:27 -04:00
#include <common/cfgparse.h>
[CLEANUP] renamed include/haproxy to include/common
2006-06-29 11:53:05 -04:00
#include <common/compat.h>
[CLEANUP] included common/version.h everywhere
2006-06-29 12:54:54 -04:00
#include <common/config.h>
[MINOR] move error codes to common/errors.h It's useful to be able to share error codes between C files, so move the codes currently only used in protocols to a generic file.
2007-10-28 06:14:07 -04:00
#include <common/errors.h>
[MAJOR] call garbage collector when doing soft stop When we're interrupted by another instance, it is very likely that the other one will need some memory. Now we know how to free what is not used, so let's do it. Also only free non-null pointers. Previously, pool_destroy() did implicitly check for this case which was incidentely needed.
2007-05-13 18:39:29 -04:00
#include <common/memory.h>
[CLEANUP] renamed include/haproxy to include/common
2006-06-29 11:53:05 -04:00
#include <common/time.h>
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
MEDIUM: proxy: make findproxy() use trees to look up proxies Both proxy IDs and names are now looked up from the trees.
2014-03-15 02:43:51 -04:00
#include <eb32tree.h>
#include <ebistree.h>
MINOR: proxy: custom capture declaration This patch adds a new keyword called "declare". This keyword allow to declare some capture slots in requests and response. It is useful for sharing capture between frontend and backends.
2015-05-26 11:44:32 -04:00
#include <types/capture.h>
MINOR: proxy: create new function cli_find_frontend() to find a frontend Several CLI commands require a frontend, so let's have a function to look this one up and prepare the appropriate error message and the appctx's state in case of failure.
2016-11-24 06:02:29 -05:00
#include <types/cli.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 <types/global.h>
MAJOR: connection: replace struct target with a pointer to an enum Instead of storing a couple of (int, ptr) in the struct connection and the struct session, we use a different method : we only store a pointer to an integer which is stored inside the target object and which contains a unique type identifier. That way, the pointer allows us to retrieve the object type (by dereferencing it) and the object's address (by computing the displacement in the target structure). The NULL pointer always corresponds to OBJ_TYPE_NONE. This reduces the size of the connection and session structs. It also simplifies target assignment and compare. In order to improve the generated code, we try to put the obj_type element at the beginning of all the structs (listener, server, proxy, si_applet), so that the original and target pointers are always equal. A lot of code was touched by massive replaces, but the changes are not that important.
2012-11-11 18:42:33 -05:00
#include <types/obj_type.h>
[MEDIUM] Manage soft stop on peers proxy
2010-09-23 12:44:36 -04:00
#include <types/peers.h>
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
#include <types/stats.h>
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
#include <proto/applet.h>
#include <proto/cli.h>
[MINOR] add the "nolinger" option to disable data lingering The following patch will give the ability to tweak socket linger mode. You can use this option with "option nolinger" inside fronted or backend configuration declaration. This will help in environments where lots of FIN_WAIT sockets are encountered.
2007-10-11 14:48:58 -04:00
#include <proto/backend.h>
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
#include <proto/fd.h>
MAJOR: filters: Add filters support This patch adds the support of filters in HAProxy. The main idea is to have a way to "easely" extend HAProxy by adding some "modules", called filters, that will be able to change HAProxy behavior in a programmatic way. To do so, many entry points has been added in code to let filters to hook up to different steps of the processing. A filter must define a flt_ops sutrctures (see include/types/filters.h for details). This structure contains all available callbacks that a filter can define: struct flt_ops { /* * Callbacks to manage the filter lifecycle */ int (*init) (struct proxy *p); void (*deinit)(struct proxy *p); int (*check) (struct proxy *p); /* * Stream callbacks */ void (*stream_start) (struct stream *s); void (*stream_accept) (struct stream *s); void (*session_establish)(struct stream *s); void (*stream_stop) (struct stream *s); /* * HTTP callbacks */ int (*http_start) (struct stream *s, struct http_msg *msg); int (*http_start_body) (struct stream *s, struct http_msg *msg); int (*http_start_chunk) (struct stream *s, struct http_msg *msg); int (*http_data) (struct stream *s, struct http_msg *msg); int (*http_last_chunk) (struct stream *s, struct http_msg *msg); int (*http_end_chunk) (struct stream *s, struct http_msg *msg); int (*http_chunk_trailers)(struct stream *s, struct http_msg *msg); int (*http_end_body) (struct stream *s, struct http_msg *msg); void (*http_end) (struct stream *s, struct http_msg *msg); void (*http_reset) (struct stream *s, struct http_msg *msg); int (*http_pre_process) (struct stream *s, struct http_msg *msg); int (*http_post_process) (struct stream *s, struct http_msg *msg); void (*http_reply) (struct stream *s, short status, const struct chunk *msg); }; To declare and use a filter, in the configuration, the "filter" keyword must be used in a listener/frontend section: frontend test ... filter <FILTER-NAME> [OPTIONS...] The filter referenced by the <FILTER-NAME> must declare a configuration parser on its own name to fill flt_ops and filter_conf field in the proxy's structure. An exemple will be provided later to make it perfectly clear. For now, filters cannot be used in backend section. But this is only a matter of time. Documentation will also be added later. This is the first commit of a long list about filters. It is possible to have several filters on the same listener/frontend. These filters are stored in an array of at most MAX_FILTERS elements (define in include/types/filters.h). Again, this will be replaced later by a list of filters. The filter API has been highly refactored. Main changes are: * Now, HA supports an infinite number of filters per proxy. To do so, filters are stored in list. * Because filters are stored in list, filters state has been moved from the channel structure to the filter structure. This is cleaner because there is no more info about filters in channel structure. * It is possible to defined filters on backends only. For such filters, stream_start/stream_stop callbacks are not called. Of course, it is possible to mix frontend and backend filters. * Now, TCP streams are also filtered. All callbacks without the 'http_' prefix are called for all kind of streams. In addition, 2 new callbacks were added to filter data exchanged through a TCP stream: - tcp_data: it is called when new data are available or when old unprocessed data are still waiting. - tcp_forward_data: it is called when some data can be consumed. * New callbacks attached to channel were added: - channel_start_analyze: it is called when a filter is ready to process data exchanged through a channel. 2 new analyzers (a frontend and a backend) are attached to channels to call this callback. For a frontend filter, it is called before any other analyzer. For a backend filter, it is called when a backend is attached to a stream. So some processing cannot be filtered in that case. - channel_analyze: it is called before each analyzer attached to a channel, expects analyzers responsible for data sending. - channel_end_analyze: it is called when all other analyzers have finished their processing. A new analyzers is attached to channels to call this callback. For a TCP stream, this is always the last one called. For a HTTP one, the callback is called when a request/response ends, so it is called one time for each request/response. * 'session_established' callback has been removed. Everything that is done in this callback can be handled by 'channel_start_analyze' on the response channel. * 'http_pre_process' and 'http_post_process' callbacks have been replaced by 'channel_analyze'. * 'http_start' callback has been replaced by 'http_headers'. This new one is called just before headers sending and parsing of the body. * 'http_end' callback has been replaced by 'channel_end_analyze'. * It is possible to set a forwarder for TCP channels. It was already possible to do it for HTTP ones. * Forwarders can partially consumed forwardable data. For this reason a new HTTP message state was added before HTTP_MSG_DONE : HTTP_MSG_ENDING. Now all filters can define corresponding callbacks (http_forward_data and tcp_forward_data). Each filter owns 2 offsets relative to buf->p, next and forward, to track, respectively, input data already parsed but not forwarded yet by the filter and parsed data considered as forwarded by the filter. A any time, we have the warranty that a filter cannot parse or forward more input than previous ones. And, of course, it cannot forward more input than it has parsed. 2 macros has been added to retrieve these offets: FLT_NXT and FLT_FWD. In addition, 2 functions has been added to change the 'next size' and the 'forward size' of a filter. When a filter parses input data, it can alter these data, so the size of these data can vary. This action has an effet on all previous filters that must be handled. To do so, the function 'filter_change_next_size' must be called, passing the size variation. In the same spirit, if a filter alter forwarded data, it must call the function 'filter_change_forward_size'. 'filter_change_next_size' can be called in 'http_data' and 'tcp_data' callbacks and only these ones. And 'filter_change_forward_size' can be called in 'http_forward_data' and 'tcp_forward_data' callbacks and only these ones. The data changes are the filter responsability, but with some limitation. It must not change already parsed/forwarded data or data that previous filters have not parsed/forwarded yet. Because filters can be used on backends, when we the backend is set for a stream, we add filters defined for this backend in the filter list of the stream. But we must only do that when the backend and the frontend of the stream are not the same. Else same filters are added a second time leading to undefined behavior. The HTTP compression code had to be moved. So it simplifies http_response_forward_body function. To do so, the way the data are forwarded has changed. Now, a filter (and only one) can forward data. In a commit to come, this limitation will be removed to let all filters take part to data forwarding. There are 2 new functions that filters should use to deal with this feature: * flt_set_http_data_forwarder: This function sets the filter (using its id) that will forward data for the specified HTTP message. It is possible if it was not already set by another filter _AND_ if no data was yet forwarded (msg->msg_state <= HTTP_MSG_BODY). It returns -1 if an error occurs. * flt_http_data_forwarder: This function returns the filter id that will forward data for the specified HTTP message. If there is no forwarder set, it returns -1. When an HTTP data forwarder is set for the response, the HTTP compression is disabled. Of course, this is not definitive.
2015-04-30 05:48:27 -04:00
#include <proto/filters.h>
[MEDIUM] allow a TCP frontend to switch to an HTTP backend This patch allows a TCP frontend to switch to an HTTP backend. During the switch, missing structures are automatically allocated. The HTTP parser is enabled so that the backend first waits for a full HTTP request.
2009-07-12 03:47:04 -04:00
#include <proto/hdr_idx.h>
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
#include <proto/listener.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 <proto/log.h>
[MAJOR] create proto_tcp and move initialization of proxy listeners Proxy listeners were very special and not very easy to manipulate. A proto_tcp file has been created with all that is required to manage TCPv4/TCPv6 as raw protocols, and provide generic listeners. The code of start_proxies() and maintain_proxies() now looks less like spaghetti. Also, event_accept will need a serious lifting in order to use more of the information provided by the listener.
2007-10-28 20:09:36 -04:00
#include <proto/proto_tcp.h>
[BUG] http: the transaction must be initialized even in TCP mode (part 2) Commit 4605e3b641cebbdbb2ee5726e5bbc3c03a2d7b5e was not enough, because connections passing from a TCP frontend to an HTTP backend without any ACL and via a "default_backend" statement were still working on non-initialized data. An initialization was missing in the session_set_backend() function, next to the initialization of hdr_idx.
2010-05-31 11:01:36 -04:00
#include <proto/proto_http.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 <proto/proxy.h>
MINOR: cli: Let configure the dynamic cookies from the cli. This adds 3 new commands to the cli : enable dynamic-cookie backend <backend> that enables dynamic cookies for a specified backend disable dynamic-cookie backend <backend> that disables dynamic cookies for a specified backend set dynamic-cookie-key backend <backend> that lets one change the dynamic cookie secret key, for a specified backend.
2017-03-14 15:08:46 -04:00
#include <proto/server.h>
[MEDIUM] signals: support redistribution of signal zero when stopping Signal zero is never delivered by the system. However having a signal to which functions and tasks can subscribe to be notified of a stopping event is useful. So this patch does two things : 1) allow signal zero to be delivered from any function of signal handler 2) make soft_stop() deliver this signal so that tasks can be notified of a stopping condition.
2010-08-27 12:26:11 -04:00
#include <proto/signal.h>
MEDIUM: stream: move the listener's pointer to the session The listener is session-specific, move it there.
2015-04-03 08:46:27 -04:00
#include <proto/stream.h>
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
#include <proto/stream_interface.h>
[MEDIUM] Manage soft stop on peers proxy
2010-09-23 12:44:36 -04:00
#include <proto/task.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
[MAJOR] proxy: finally get rid of maintain_proxies() This function is finally not needed anymore, as it has been replaced with a per-proxy task that is scheduled when some limits are encountered on incoming connections or when the process is stopping. The savings should be noticeable on configs with a large number of proxies. The most important point is that the rate limiting is now enforced in a clean and solid way.
2011-07-25 10:33:49 -04:00
int listeners; /* # of proxy listeners, set by cfgparse */
MINOR/CLEANUP: proxy: rename "proxy" to "proxies_list" Rename the global variable "proxy" to "proxies_list". There's been multiple proxies in haproxy for quite some time, and "proxy" is a potential source of bugs, a number of functions have a "proxy" argument, and some code used "proxy" when it really meant "px" or "curproxy". It worked by pure luck, because it usually happened while parsing the config, and thus "proxy" pointed to the currently parsed proxy, but we should probably not rely on this. [wt: some of these are definitely fixes that are worth backporting]
2017-11-24 10:54:05 -05:00
struct proxy *proxies_list = NULL; /* list of all existing proxies */
[MEDIUM] config: automatically find unused IDs for proxies, servers and listeners Until now it was required that every custom ID was above 1000 in order to avoid conflicts. Now we have the list of all assigned IDs and can automatically pick the first unused one. This means that it is perfectly possible to interleave automatic IDs with persistent IDs and the parser will automatically allocate unused values starting with 1.
2009-10-04 17:04:08 -04:00
struct eb_root used_proxy_id = EB_ROOT; /* list of proxy IDs in use */
MEDIUM: proxy: create a tree to store proxies by name Large configurations can take time to parse when thousands of backends are in use. Let's store all the proxies in trees. findproxy_mode() has been modified to use the tree for lookups, which has divided the parsing time by about 2.5. But many lookups are still present at many places and need to be dealt with.
2014-03-15 02:22:35 -04:00
struct eb_root proxy_by_name = EB_ROOT; /* tree of proxies sorted by name */
[MINOR] stats: add global event ID and count This counter will help quickly spot whether there are new errors or not. It is also assigned to each capture so that a script can keep trace of which capture was taken when.
2010-12-12 08:00:34 -05:00
unsigned int error_snapshot_id = 0; /* global ID assigned to each error then incremented */
[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] distinguish between frontend, backend, ruleset and listen The notion of capabilities has been added to the proxy so that we know whether a proxy supports frontend, backend, or rulesets. Given this, some parameters are optionnal, some are ignored with a warning and others are forbidden. It is now possible to write valid two level configs without binding to dummy address/ports.
2006-12-29 08:19:17 -05:00
/*
[MINOR] adjust error messages about conflicting proxies It's not easy to report useful information to help the user quickly fix a configuration. This patch : - removes the word "listener" in favor of "proxy" as it has been used since the beginning ; - ensures that the same function (hence the same words) will be used to report capabilities of a proxy being declared and an existing proxy ; - avoid the term "conflicting capabilities" in favor of "overlapping capabilities" which is more exact. - just report that the same name is reused in case of warnings
2007-11-04 01:04:43 -05:00
* This function returns a string containing a name describing capabilities to
* report comprehensible error messages. Specifically, it will return the words
CLEANUP: remove last references to 'ruleset' section
2016-10-26 05:06:28 -04:00
* "frontend", "backend" when appropriate, or "proxy" for all other
[MINOR] adjust error messages about conflicting proxies It's not easy to report useful information to help the user quickly fix a configuration. This patch : - removes the word "listener" in favor of "proxy" as it has been used since the beginning ; - ensures that the same function (hence the same words) will be used to report capabilities of a proxy being declared and an existing proxy ; - avoid the term "conflicting capabilities" in favor of "overlapping capabilities" which is more exact. - just report that the same name is reused in case of warnings
2007-11-04 01:04:43 -05:00
* cases including the proxies declared in "listen" mode.
[MAJOR] distinguish between frontend, backend, ruleset and listen The notion of capabilities has been added to the proxy so that we know whether a proxy supports frontend, backend, or rulesets. Given this, some parameters are optionnal, some are ignored with a warning and others are forbidden. It is now possible to write valid two level configs without binding to dummy address/ports.
2006-12-29 08:19:17 -05:00
*/
[MINOR] adjust error messages about conflicting proxies It's not easy to report useful information to help the user quickly fix a configuration. This patch : - removes the word "listener" in favor of "proxy" as it has been used since the beginning ; - ensures that the same function (hence the same words) will be used to report capabilities of a proxy being declared and an existing proxy ; - avoid the term "conflicting capabilities" in favor of "overlapping capabilities" which is more exact. - just report that the same name is reused in case of warnings
2007-11-04 01:04:43 -05:00
const char *proxy_cap_str(int cap)
[MAJOR] distinguish between frontend, backend, ruleset and listen The notion of capabilities has been added to the proxy so that we know whether a proxy supports frontend, backend, or rulesets. Given this, some parameters are optionnal, some are ignored with a warning and others are forbidden. It is now possible to write valid two level configs without binding to dummy address/ports.
2006-12-29 08:19:17 -05:00
{
[MINOR] adjust error messages about conflicting proxies It's not easy to report useful information to help the user quickly fix a configuration. This patch : - removes the word "listener" in favor of "proxy" as it has been used since the beginning ; - ensures that the same function (hence the same words) will be used to report capabilities of a proxy being declared and an existing proxy ; - avoid the term "conflicting capabilities" in favor of "overlapping capabilities" which is more exact. - just report that the same name is reused in case of warnings
2007-11-04 01:04:43 -05:00
if ((cap & PR_CAP_LISTEN) != PR_CAP_LISTEN) {
if (cap & PR_CAP_FE)
return "frontend";
else if (cap & PR_CAP_BE)
return "backend";
}
return "proxy";
[MAJOR] distinguish between frontend, backend, ruleset and listen The notion of capabilities has been added to the proxy so that we know whether a proxy supports frontend, backend, or rulesets. Given this, some parameters are optionnal, some are ignored with a warning and others are forbidden. It is now possible to write valid two level configs without binding to dummy address/ports.
2006-12-29 08:19:17 -05:00
}
[MEDIUM] Implement and use generic findproxy and relax duplicated proxy check This patch: - adds proxy_mode_str() similar to proxy_type_str() - adds a generic findproxy function used with default_backend/setbe/use_backed - rewrite default_backend/senbe/use_backed to use introduced findproxy() - relaxes duplicated proxy check - changes capabilities displaying from "%X" to "%s" with a call to proxy_type_str()
2007-11-03 18:41:58 -04:00
/*
* This function returns a string containing the mode of the proxy in a format
* suitable for error messages.
*/
const char *proxy_mode_str(int mode) {
if (mode == PR_MODE_TCP)
return "tcp";
else if (mode == PR_MODE_HTTP)
return "http";
else if (mode == PR_MODE_HEALTH)
return "health";
else
return "unknown";
}
[MINOR] proxy: provide function to retrieve backend/server pointers int get_backend_server(const char *bk_name, const char *sv_name, struct proxy **bk, struct server **sv); This function scans the list of backends and servers to retrieve the first backend and the first server with the given names, and sets them in both parameters. It returns zero if either is not found, or non-zero and sets the ones it did not found to NULL. If a NULL pointer is passed for the backend, only the pointer to the server will be updated.
2009-10-10 12:35:51 -04:00
/*
* This function scans the list of backends and servers to retrieve the first
* backend and the first server with the given names, and sets them in both
* parameters. It returns zero if either is not found, or non-zero and sets
* the ones it did not found to NULL. If a NULL pointer is passed for the
* backend, only the pointer to the server will be updated.
*/
int get_backend_server(const char *bk_name, const char *sv_name,
struct proxy **bk, struct server **sv)
{
struct proxy *p;
struct server *s;
MEDIUM: proxy: make get_backend_server() use findproxy() to lookup proxies This one is used by stats to look up proxy and server names in server state manipulation. Get rid of the linear search.
2014-03-15 02:57:11 -04:00
int sid;
[MINOR] proxy: provide function to retrieve backend/server pointers int get_backend_server(const char *bk_name, const char *sv_name, struct proxy **bk, struct server **sv); This function scans the list of backends and servers to retrieve the first backend and the first server with the given names, and sets them in both parameters. It returns zero if either is not found, or non-zero and sets the ones it did not found to NULL. If a NULL pointer is passed for the backend, only the pointer to the server will be updated.
2009-10-10 12:35:51 -04:00
*sv = NULL;
MEDIUM: proxy: add the global frontend to the list of normal proxies Since recent changes on the global frontend, it was not possible anymore to soft-reload a process which had a stats socket because the socket would not be disabled upon reload. The only solution to this endless madness is to have the global frontend part of normal proxies. Since we don't want to get an ID that shifts all other proxies and causes trouble in deployed environments, we assign it ID #0 which other proxies can't grab, and we don't report it in the stats pages.
2012-10-04 02:47:34 -04:00
sid = -1;
[MINOR] stats: add support for numeric IDs in set weight/get weight Krzysztof reported that using names only for get weight/set weight was not enough because it's still possible to have multiple servers with the same name (and my test config is one of those). He suggested to be able to designate them by their unique numeric IDs by prefixing the ID with a dash. That way we can have : set weight #120/#2 as well as get weight static/srv1 10
2009-10-10 16:33:08 -04:00
if (*sv_name == '#')
sid = atoi(sv_name + 1);
CLEANUP: proxy: make the proxy lookup functions more user-friendly First, findproxy() was renamed proxy_find_by_name() so that its explicit that a name is required for the lookup. Second, we give this function the ability to search for tables if needed. Third we now provide inline wrappers to pass the appropriate PR_CAP_* flags and to explicitly look up a frontend, backend or table.
2015-05-26 05:24:42 -04:00
p = proxy_be_by_name(bk_name);
[MINOR] proxy: provide function to retrieve backend/server pointers int get_backend_server(const char *bk_name, const char *sv_name, struct proxy **bk, struct server **sv); This function scans the list of backends and servers to retrieve the first backend and the first server with the given names, and sets them in both parameters. It returns zero if either is not found, or non-zero and sets the ones it did not found to NULL. If a NULL pointer is passed for the backend, only the pointer to the server will be updated.
2009-10-10 12:35:51 -04:00
if (bk)
*bk = p;
if (!p)
return 0;
for (s = p->srv; s; s = s->next)
BUG: proxy: fix server name lookup in get_backend_server() The lookup was broken by commit 050536d5. The server ID is initialized to a negative value but unfortunately not all the tests were converted. Thanks to Igor at owind for reporting it.
2012-11-14 18:15:18 -05:00
if ((sid >= 0 && s->puid == sid) ||
(sid < 0 && strcmp(s->id, sv_name) == 0))
[MINOR] proxy: provide function to retrieve backend/server pointers int get_backend_server(const char *bk_name, const char *sv_name, struct proxy **bk, struct server **sv); This function scans the list of backends and servers to retrieve the first backend and the first server with the given names, and sets them in both parameters. It returns zero if either is not found, or non-zero and sets the ones it did not found to NULL. If a NULL pointer is passed for the backend, only the pointer to the server will be updated.
2009-10-10 12:35:51 -04:00
break;
*sv = s;
if (!s)
return 0;
return 1;
}
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
/* This function parses a "timeout" statement in a proxy section. It returns
* -1 if there is any error, 1 for a warning, otherwise zero. If it does not
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
* return zero, it will write an error or warning message into a preallocated
* buffer returned at <err>. The trailing is not be written. The function must
* be called with <args> pointing to the first command line word, with <proxy>
* pointing to the proxy being parsed, and <defpx> to the default proxy or NULL.
* As a special case for compatibility with older configs, it also accepts
* "{cli|srv|con}timeout" in args[0].
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
*/
[MEDIUM] modularize the "timeout" keyword configuration parser The "timeout" keyword already relied on an external parser, let's make use of the new keyword registration mechanism.
2008-07-09 14:34:27 -04:00
static int proxy_parse_timeout(char **args, int section, struct proxy *proxy,
MINOR: config: pass the file and line to config keyword parsers This will be needed when we need to create bind config settings.
2012-09-18 14:02:48 -04:00
struct proxy *defpx, const char *file, int line,
char **err)
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
{
unsigned timeout;
int retval, cap;
const char *res, *name;
[MAJOR] convert all expiration timers from timeval to ticks This is the first attempt at moving all internal parts from using struct timeval to integer ticks. Those provides simpler and faster code due to simplified operations, and this change also saved about 64 bytes per session. A new header file has been added : include/common/ticks.h. It is possible that some functions should finally not be inlined because they're used quite a lot (eg: tick_first, tick_add_ifset and tick_is_expired). More measurements are required in order to decide whether this is interesting or not. Some function and variable names are still subject to change for a better overall logics.
2008-07-06 18:09:58 -04:00
int *tv = NULL;
int *td = NULL;
MEDIUM: config: warn that '{cli,con,srv}timeout' are deprecated It's been like this since version 1.3 in 2007. It's time to clean up configurations. The warning explains what to use depending on the timeout name.
2014-04-28 16:56:38 -04:00
int warn = 0;
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
retval = 0;
[MEDIUM] modularize the "timeout" keyword configuration parser The "timeout" keyword already relied on an external parser, let's make use of the new keyword registration mechanism.
2008-07-09 14:34:27 -04:00
/* simply skip "timeout" but remain compatible with old form */
if (strcmp(args[0], "timeout") == 0)
args++;
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
name = args[0];
MEDIUM: config: warn that '{cli,con,srv}timeout' are deprecated It's been like this since version 1.3 in 2007. It's time to clean up configurations. The warning explains what to use depending on the timeout name.
2014-04-28 16:56:38 -04:00
if (!strcmp(args[0], "client") || (!strcmp(args[0], "clitimeout") && (warn = WARN_CLITO_DEPRECATED))) {
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
name = "client";
[CLEANUP] grouped all timeouts in one structure All known timeouts in a proxy have been grouped into a "timeout" sub-structure.
2007-12-02 19:38:36 -05:00
tv = &proxy->timeout.client;
td = &defpx->timeout.client;
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
cap = PR_CAP_FE;
} else if (!strcmp(args[0], "tarpit")) {
tv = &proxy->timeout.tarpit;
td = &defpx->timeout.tarpit;
[MINOR] tarpit timeout is also allowed in backends Since the tarpit action may be set in backends too, its timeout must be configurable there.
2008-01-06 07:40:03 -05:00
cap = PR_CAP_FE | PR_CAP_BE;
[MINOR] http: add a separate "http-keep-alive" timeout This one is used to wait for next request after a response was sent to the client.
2010-01-10 08:46:16 -05:00
} else if (!strcmp(args[0], "http-keep-alive")) {
tv = &proxy->timeout.httpka;
td = &defpx->timeout.httpka;
cap = PR_CAP_FE | PR_CAP_BE;
[MEDIUM] introduce "timeout http-request" in frontends In order to offer DoS protection, it may be required to lower the maximum accepted time to receive a complete HTTP request without affecting the client timeout. This helps protecting against established connections on which nothing is sent. The client timeout cannot offer a good protection against this abuse because it is an inactivity timeout, which means that if the attacker sends one character every now and then, the timeout will not trigger. With the HTTP request timeout, no matter what speed the client types, the request will be aborted if it does not complete in time.
2008-01-06 07:24:40 -05:00
} else if (!strcmp(args[0], "http-request")) {
tv = &proxy->timeout.httpreq;
td = &defpx->timeout.httpreq;
[MINOR] http: take http request timeout from the backend Since we can now switch from TCP to HTTP, we need to be able to apply the HTTP request timeout after switching. That means we need to take it from the backend and not from the frontend. Since the backend points to the frontend before switching, that changes nothing for the normal case.
2009-07-12 04:03:17 -04:00
cap = PR_CAP_FE | PR_CAP_BE;
MEDIUM: config: warn that '{cli,con,srv}timeout' are deprecated It's been like this since version 1.3 in 2007. It's time to clean up configurations. The warning explains what to use depending on the timeout name.
2014-04-28 16:56:38 -04:00
} else if (!strcmp(args[0], "server") || (!strcmp(args[0], "srvtimeout") && (warn = WARN_SRVTO_DEPRECATED))) {
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
name = "server";
[CLEANUP] grouped all timeouts in one structure All known timeouts in a proxy have been grouped into a "timeout" sub-structure.
2007-12-02 19:38:36 -05:00
tv = &proxy->timeout.server;
td = &defpx->timeout.server;
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
cap = PR_CAP_BE;
MEDIUM: config: warn that '{cli,con,srv}timeout' are deprecated It's been like this since version 1.3 in 2007. It's time to clean up configurations. The warning explains what to use depending on the timeout name.
2014-04-28 16:56:38 -04:00
} else if (!strcmp(args[0], "connect") || (!strcmp(args[0], "contimeout") && (warn = WARN_CONTO_DEPRECATED))) {
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
name = "connect";
[CLEANUP] grouped all timeouts in one structure All known timeouts in a proxy have been grouped into a "timeout" sub-structure.
2007-12-02 19:38:36 -05:00
tv = &proxy->timeout.connect;
td = &defpx->timeout.connect;
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
cap = PR_CAP_BE;
[MEDIUM]: rework checks handling This patch adds two new variables: fastinter and downinter. When server state is: - non-transitionally UP -> inter (no change) - transitionally UP (going down), unchecked or transitionally DOWN (going up) -> fastinter - down -> downinter It allows to set something like: server sr6 127.0.51.61:80 cookie s6 check inter 10000 downinter 20000 fastinter 500 fall 3 weight 40 In the above example haproxy uses 10000ms between checks but as soon as one check fails fastinter (500ms) is used. If server is down downinter (20000) is used or fastinter (500ms) if one check pass. Fastinter is also used when haproxy starts. New "timeout.check" variable was added, if set haproxy uses it as an additional read timeout, but only after a connection has been already established. I was thinking about using "timeout.server" here but most people set this with an addition reserve but still want checks to kick out laggy servers. Please also note that in most cases check request is much simpler and faster to handle than normal requests so this timeout should be smaller. I also changed the timeout used for check connections establishing. Changes from the previous version: - use tv_isset() to check if the timeout is set, - use min("timeout connect", "inter") but only if "timeout check" is set as this min alone may be to short for full (connect + read) check, - debug code (fprintf) commented/removed - documentation Compile tested only (sorry!) as I'm currently traveling but changes are rather small and trivial.
2008-01-20 19:54:06 -05:00
} else if (!strcmp(args[0], "check")) {
tv = &proxy->timeout.check;
td = &defpx->timeout.check;
cap = PR_CAP_BE;
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
} else if (!strcmp(args[0], "queue")) {
tv = &proxy->timeout.queue;
td = &defpx->timeout.queue;
cap = PR_CAP_BE;
MEDIUM: session: add support for tunnel timeouts Tunnel timeouts are used when TCP connections are forwarded, or when forwarding upgraded HTTP connections (WebSocket) as well as CONNECT requests to proxies. This timeout allows long-lived sessions to be supported without having to set large timeouts to normal requests.
2012-05-12 06:50:00 -04:00
} else if (!strcmp(args[0], "tunnel")) {
tv = &proxy->timeout.tunnel;
td = &defpx->timeout.tunnel;
cap = PR_CAP_BE;
MEDIUM: session: implement half-closed timeouts (client-fin and server-fin) Long-lived sessions are often subject to half-closed sessions resulting in a lot of sessions appearing in FIN_WAIT state in the system tables, and no way for haproxy to get rid of them. This typically happens because clients suddenly disconnect without sending any packet (eg: FIN or RST was lost in the path), and while the server detects this using an applicative heart beat, haproxy does not close the connection. This patch adds two new timeouts : "timeout client-fin" and "timeout server-fin". The former allows one to override the client-facing timeout when a FIN has been received or sent. The latter does the same for server-facing connections, which is less useful.
2014-05-10 08:30:07 -04:00
} else if (!strcmp(args[0], "client-fin")) {
tv = &proxy->timeout.clientfin;
td = &defpx->timeout.clientfin;
cap = PR_CAP_FE;
} else if (!strcmp(args[0], "server-fin")) {
tv = &proxy->timeout.serverfin;
td = &defpx->timeout.serverfin;
cap = PR_CAP_BE;
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
} else {
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
memprintf(err,
"'timeout' supports 'client', 'server', 'connect', 'check', "
MEDIUM: session: implement half-closed timeouts (client-fin and server-fin) Long-lived sessions are often subject to half-closed sessions resulting in a lot of sessions appearing in FIN_WAIT state in the system tables, and no way for haproxy to get rid of them. This typically happens because clients suddenly disconnect without sending any packet (eg: FIN or RST was lost in the path), and while the server detects this using an applicative heart beat, haproxy does not close the connection. This patch adds two new timeouts : "timeout client-fin" and "timeout server-fin". The former allows one to override the client-facing timeout when a FIN has been received or sent. The latter does the same for server-facing connections, which is less useful.
2014-05-10 08:30:07 -04:00
"'queue', 'http-keep-alive', 'http-request', 'tunnel', 'tarpit', "
"'client-fin' and 'server-fin' (got '%s')",
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
args[0]);
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
return -1;
}
if (*args[1] == 0) {
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
memprintf(err, "'timeout %s' expects an integer value (in milliseconds)", name);
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
return -1;
}
res = parse_time_err(args[1], &timeout, TIME_UNIT_MS);
if (res) {
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
memprintf(err, "unexpected character '%c' in 'timeout %s'", *res, name);
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
return -1;
}
if (!(proxy->cap & cap)) {
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
memprintf(err, "'timeout %s' will be ignored because %s '%s' has no %s capability",
name, proxy_type_str(proxy), proxy->id,
(cap & PR_CAP_BE) ? "backend" : "frontend");
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
retval = 1;
}
[MAJOR] convert all expiration timers from timeval to ticks This is the first attempt at moving all internal parts from using struct timeval to integer ticks. Those provides simpler and faster code due to simplified operations, and this change also saved about 64 bytes per session. A new header file has been added : include/common/ticks.h. It is possible that some functions should finally not be inlined because they're used quite a lot (eg: tick_first, tick_add_ifset and tick_is_expired). More measurements are required in order to decide whether this is interesting or not. Some function and variable names are still subject to change for a better overall logics.
2008-07-06 18:09:58 -04:00
else if (defpx && *tv != *td) {
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
memprintf(err, "overwriting 'timeout %s' which was already specified", name);
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
retval = 1;
}
MEDIUM: config: warn that '{cli,con,srv}timeout' are deprecated It's been like this since version 1.3 in 2007. It's time to clean up configurations. The warning explains what to use depending on the timeout name.
2014-04-28 16:56:38 -04:00
else if (warn) {
if (!already_warned(warn)) {
memprintf(err, "the '%s' directive is now deprecated in favor of 'timeout %s', and will not be supported in future versions.",
args[0], name);
retval = 1;
}
}
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
MEDIUM: proxy: make timeout parser a bit stricter Twice in a week I found people were surprized by a "conditional timeout" not being respected, because they add "if <cond>" after a timeout, and since they don't see any error nor read the doc, the expect it to work. Let's make the timeout parser reject extra arguments to avoid these situations.
2014-05-22 02:24:46 -04:00
if (*args[2] != 0) {
memprintf(err, "'timeout %s' : unexpected extra argument '%s' after value '%s'.", name, args[2], args[1]);
retval = -1;
}
[MAJOR] convert all expiration timers from timeval to ticks This is the first attempt at moving all internal parts from using struct timeval to integer ticks. Those provides simpler and faster code due to simplified operations, and this change also saved about 64 bytes per session. A new header file has been added : include/common/ticks.h. It is possible that some functions should finally not be inlined because they're used quite a lot (eg: tick_first, tick_add_ifset and tick_is_expired). More measurements are required in order to decide whether this is interesting or not. Some function and variable names are still subject to change for a better overall logics.
2008-07-06 18:09:58 -04:00
*tv = MS_TO_TICKS(timeout);
[MEDIUM] introduce the "timeout" keyword A new "timeout" keyword replaces old "{con|cli|srv}timeout", and provides the ability to independantly set the following timeouts : - client - tarpit - queue - connect - server - appsession Additionally, the "clitimeout", "contimeout" and "srvtimeout" values are supported but deprecated. No warning is emitted yet when they are used since the option is very new. Other timeouts should follow soon now.
2007-12-02 19:30:13 -05:00
return retval;
}
[MEDIUM] implement "rate-limit sessions" for the frontend The new "rate-limit sessions" statement sets a limit on the number of new connections per second on the frontend. As it is extremely accurate (about 0.1%), it is efficient at limiting resource abuse or DoS.
2009-03-05 17:48:25 -05:00
/* This function parses a "rate-limit" statement in a proxy section. It returns
* -1 if there is any error, 1 for a warning, otherwise zero. If it does not
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
* return zero, it will write an error or warning message into a preallocated
* buffer returned at <err>. The function must be called with <args> pointing
* to the first command line word, with <proxy> pointing to the proxy being
* parsed, and <defpx> to the default proxy or NULL.
[MEDIUM] implement "rate-limit sessions" for the frontend The new "rate-limit sessions" statement sets a limit on the number of new connections per second on the frontend. As it is extremely accurate (about 0.1%), it is efficient at limiting resource abuse or DoS.
2009-03-05 17:48:25 -05:00
*/
static int proxy_parse_rate_limit(char **args, int section, struct proxy *proxy,
MINOR: config: pass the file and line to config keyword parsers This will be needed when we need to create bind config settings.
2012-09-18 14:02:48 -04:00
struct proxy *defpx, const char *file, int line,
char **err)
[MEDIUM] implement "rate-limit sessions" for the frontend The new "rate-limit sessions" statement sets a limit on the number of new connections per second on the frontend. As it is extremely accurate (about 0.1%), it is efficient at limiting resource abuse or DoS.
2009-03-05 17:48:25 -05:00
{
int retval, cap;
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
char *res;
[MEDIUM] implement "rate-limit sessions" for the frontend The new "rate-limit sessions" statement sets a limit on the number of new connections per second on the frontend. As it is extremely accurate (about 0.1%), it is efficient at limiting resource abuse or DoS.
2009-03-05 17:48:25 -05:00
unsigned int *tv = NULL;
unsigned int *td = NULL;
unsigned int val;
retval = 0;
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
if (strcmp(args[1], "sessions") == 0) {
[MINOR] compute the max of sessions/s on fe/be/srv Some users want to keep the max sessions/s seen on servers, frontends and backends for capacity planning. It's easy to grab it while the session count is updated, so let's keep it.
2009-05-10 12:52:49 -04:00
tv = &proxy->fe_sps_lim;
td = &defpx->fe_sps_lim;
[MEDIUM] implement "rate-limit sessions" for the frontend The new "rate-limit sessions" statement sets a limit on the number of new connections per second on the frontend. As it is extremely accurate (about 0.1%), it is efficient at limiting resource abuse or DoS.
2009-03-05 17:48:25 -05:00
cap = PR_CAP_FE;
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
}
else {
memprintf(err, "'%s' only supports 'sessions' (got '%s')", args[0], args[1]);
[MEDIUM] implement "rate-limit sessions" for the frontend The new "rate-limit sessions" statement sets a limit on the number of new connections per second on the frontend. As it is extremely accurate (about 0.1%), it is efficient at limiting resource abuse or DoS.
2009-03-05 17:48:25 -05:00
return -1;
}
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
if (*args[2] == 0) {
memprintf(err, "'%s %s' expects expects an integer value (in sessions/second)", args[0], args[1]);
[MEDIUM] implement "rate-limit sessions" for the frontend The new "rate-limit sessions" statement sets a limit on the number of new connections per second on the frontend. As it is extremely accurate (about 0.1%), it is efficient at limiting resource abuse or DoS.
2009-03-05 17:48:25 -05:00
return -1;
}
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
val = strtoul(args[2], &res, 0);
[MEDIUM] implement "rate-limit sessions" for the frontend The new "rate-limit sessions" statement sets a limit on the number of new connections per second on the frontend. As it is extremely accurate (about 0.1%), it is efficient at limiting resource abuse or DoS.
2009-03-05 17:48:25 -05:00
if (*res) {
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
memprintf(err, "'%s %s' : unexpected character '%c' in integer value '%s'", args[0], args[1], *res, args[2]);
[MEDIUM] implement "rate-limit sessions" for the frontend The new "rate-limit sessions" statement sets a limit on the number of new connections per second on the frontend. As it is extremely accurate (about 0.1%), it is efficient at limiting resource abuse or DoS.
2009-03-05 17:48:25 -05:00
return -1;
}
if (!(proxy->cap & cap)) {
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
memprintf(err, "%s %s will be ignored because %s '%s' has no %s capability",
args[0], args[1], proxy_type_str(proxy), proxy->id,
[MEDIUM] implement "rate-limit sessions" for the frontend The new "rate-limit sessions" statement sets a limit on the number of new connections per second on the frontend. As it is extremely accurate (about 0.1%), it is efficient at limiting resource abuse or DoS.
2009-03-05 17:48:25 -05:00
(cap & PR_CAP_BE) ? "backend" : "frontend");
retval = 1;
}
else if (defpx && *tv != *td) {
MEDIUM: cfgparse: use the new error reporting framework for remaining cfg_keywords All keywords registered using a cfg_kw_list now make use of the new error reporting framework. This allows easier and more precise error reporting without having to deal with complex buffer allocation issues.
2012-05-08 13:47:01 -04:00
memprintf(err, "overwriting %s %s which was already specified", args[0], args[1]);
[MEDIUM] implement "rate-limit sessions" for the frontend The new "rate-limit sessions" statement sets a limit on the number of new connections per second on the frontend. As it is extremely accurate (about 0.1%), it is efficient at limiting resource abuse or DoS.
2009-03-05 17:48:25 -05:00
retval = 1;
}
*tv = val;
return retval;
}
MINOR: http: implement the max-keep-alive-queue setting Finn Arne Gangstad suggested that we should have the ability to break keep-alive when the target server has reached its maxconn and that a number of connections are present in the queue. After some discussion around his proposed patch, the following solution was suggested : have a per-proxy setting to fix a limit to the number of queued connections on a server after which we break keep-alive. This ensures that even in high latency networks where keep-alive is beneficial, we try to find a different server. This patch is partially based on his original proposal and implements this configurable threshold.
2014-04-25 07:58:37 -04:00
/* This function parses a "max-keep-alive-queue" statement in a proxy section.
* It returns -1 if there is any error, 1 for a warning, otherwise zero. If it
* does not return zero, it will write an error or warning message into a
* preallocated buffer returned at <err>. The function must be called with
* <args> pointing to the first command line word, with <proxy> pointing to
* the proxy being parsed, and <defpx> to the default proxy or NULL.
*/
static int proxy_parse_max_ka_queue(char **args, int section, struct proxy *proxy,
struct proxy *defpx, const char *file, int line,
char **err)
{
int retval;
char *res;
unsigned int val;
retval = 0;
if (*args[1] == 0) {
memprintf(err, "'%s' expects expects an integer value (or -1 to disable)", args[0]);
return -1;
}
val = strtol(args[1], &res, 0);
if (*res) {
memprintf(err, "'%s' : unexpected character '%c' in integer value '%s'", args[0], *res, args[1]);
return -1;
}
if (!(proxy->cap & PR_CAP_BE)) {
memprintf(err, "%s will be ignored because %s '%s' has no backend capability",
args[0], proxy_type_str(proxy), proxy->id);
retval = 1;
}
/* we store <val+1> so that a user-facing value of -1 is stored as zero (default) */
proxy->max_ka_queue = val + 1;
return retval;
}
MINOR: proxy: custom capture declaration This patch adds a new keyword called "declare". This keyword allow to declare some capture slots in requests and response. It is useful for sharing capture between frontend and backends.
2015-05-26 11:44:32 -04:00
/* This function parses a "declare" statement in a proxy section. It returns -1
* if there is any error, 1 for warning, otherwise 0. If it does not return zero,
* it will write an error or warning message into a preallocated buffer returned
* at <err>. The function must be called with <args> pointing to the first command
* line word, with <proxy> pointing to the proxy being parsed, and <defpx> to the
* default proxy or NULL.
*/
static int proxy_parse_declare(char **args, int section, struct proxy *curpx,
struct proxy *defpx, const char *file, int line,
char **err)
{
/* Capture keyword wannot be declared in a default proxy. */
if (curpx == defpx) {
memprintf(err, "'%s' not avalaible in default section", args[0]);
return -1;
}
/* Capture keywork is only avalaible in frontend. */
if (!(curpx->cap & PR_CAP_FE)) {
memprintf(err, "'%s' only avalaible in frontend or listen section", args[0]);
return -1;
}
/* Check mandatory second keyword. */
if (!args[1] || !*args[1]) {
memprintf(err, "'%s' needs a second keyword that specify the type of declaration ('capture')", args[0]);
return -1;
}
/* Actually, declare is only avalaible for declaring capture
* slot, but in the future it can declare maps or variables.
* So, this section permits to check and switch acording with
* the second keyword.
*/
if (strcmp(args[1], "capture") == 0) {
char *error = NULL;
long len;
struct cap_hdr *hdr;
/* Check the next keyword. */
if (!args[2] || !*args[2] ||
(strcmp(args[2], "response") != 0 &&
strcmp(args[2], "request") != 0)) {
memprintf(err, "'%s %s' requires a direction ('request' or 'response')", args[0], args[1]);
return -1;
}
/* Check the 'len' keyword. */
if (!args[3] || !*args[3] || strcmp(args[3], "len") != 0) {
memprintf(err, "'%s %s' requires a capture length ('len')", args[0], args[1]);
return -1;
}
/* Check the length value. */
if (!args[4] || !*args[4]) {
memprintf(err, "'%s %s': 'len' requires a numeric value that represents the "
"capture length",
args[0], args[1]);
return -1;
}
/* convert the length value. */
len = strtol(args[4], &error, 10);
if (*error != '\0') {
memprintf(err, "'%s %s': cannot parse the length '%s'.",
args[0], args[1], args[3]);
return -1;
}
/* check length. */
if (len <= 0) {
memprintf(err, "length must be > 0");
return -1;
}
/* register the capture. */
CLEANUP: uniformize last argument of malloc/calloc Instead of repeating the type of the LHS argument (sizeof(struct ...)) in calls to malloc/calloc, we directly use the pointer name (sizeof(*...)). The following Coccinelle patch was used: @@ type T; T *x; @@ x = malloc( - sizeof(T) + sizeof(*x) ) @@ type T; T *x; @@ x = calloc(1, - sizeof(T) + sizeof(*x) ) When the LHS is not just a variable name, no change is made. Moreover, the following patch was used to ensure that "1" is consistently used as a first argument of calloc, not the last one: @@ @@ calloc( + 1, ... - ,1 )
2016-04-03 07:48:43 -04:00
hdr = calloc(1, sizeof(*hdr));
MINOR: proxy: custom capture declaration This patch adds a new keyword called "declare". This keyword allow to declare some capture slots in requests and response. It is useful for sharing capture between frontend and backends.
2015-05-26 11:44:32 -04:00
hdr->name = NULL; /* not a header capture */
hdr->namelen = 0;
hdr->len = len;
hdr->pool = create_pool("caphdr", hdr->len + 1, MEM_F_SHARED);
if (strcmp(args[2], "request") == 0) {
hdr->next = curpx->req_cap;
hdr->index = curpx->nb_req_cap++;
curpx->req_cap = hdr;
}
if (strcmp(args[2], "response") == 0) {
hdr->next = curpx->rsp_cap;
hdr->index = curpx->nb_rsp_cap++;
curpx->rsp_cap = hdr;
}
return 0;
}
else {
memprintf(err, "unknown declaration type '%s' (supports 'capture')", args[1]);
return -1;
}
}
MEDIUM: proxy: create a tree to store proxies by name Large configurations can take time to parse when thousands of backends are in use. Let's store all the proxies in trees. findproxy_mode() has been modified to use the tree for lookups, which has divided the parsing time by about 2.5. But many lookups are still present at many places and need to be dealt with.
2014-03-15 02:22:35 -04:00
/* This function inserts proxy <px> into the tree of known proxies. The proxy's
* name is used as the storing key so it must already have been initialized.
*/
void proxy_store_name(struct proxy *px)
{
px->conf.by_name.key = px->id;
ebis_insert(&proxy_by_name, &px->conf.by_name);
}
MINOR: proxy: add a new function proxy_find_by_id() It does the same as the other one except that it only focuses on the numeric ID and the capabilities. It's used by proxy_find_by_name() for numeric names.
2015-05-26 09:25:32 -04:00
/* Returns a pointer to the first proxy matching capabilities <cap> and id
* <id>. NULL is returned if no match is found. If <table> is non-zero, it
* only considers proxies having a table.
[MINOR] proxy: make findproxy() return proxies from numeric IDs too Sometimes it's useful to be able to search a proxy by its numeric ID, so let's add support for names such as #<id>.
2011-08-02 05:25:54 -04:00
*/
MINOR: proxy: add a new function proxy_find_by_id() It does the same as the other one except that it only focuses on the numeric ID and the capabilities. It's used by proxy_find_by_name() for numeric names.
2015-05-26 09:25:32 -04:00
struct proxy *proxy_find_by_id(int id, int cap, int table)
CLEANUP: proxy: make the proxy lookup functions more user-friendly First, findproxy() was renamed proxy_find_by_name() so that its explicit that a name is required for the lookup. Second, we give this function the ability to search for tables if needed. Third we now provide inline wrappers to pass the appropriate PR_CAP_* flags and to explicitly look up a frontend, backend or table.
2015-05-26 05:24:42 -04:00
{
MINOR: proxy: add a new function proxy_find_by_id() It does the same as the other one except that it only focuses on the numeric ID and the capabilities. It's used by proxy_find_by_name() for numeric names.
2015-05-26 09:25:32 -04:00
struct eb32_node *n;
[MINOR] proxy: make findproxy() return proxies from numeric IDs too Sometimes it's useful to be able to search a proxy by its numeric ID, so let's add support for names such as #<id>.
2011-08-02 05:25:54 -04:00
MINOR: proxy: add a new function proxy_find_by_id() It does the same as the other one except that it only focuses on the numeric ID and the capabilities. It's used by proxy_find_by_name() for numeric names.
2015-05-26 09:25:32 -04:00
for (n = eb32_lookup(&used_proxy_id, id); n; n = eb32_next(n)) {
struct proxy *px = container_of(n, struct proxy, conf.id);
MEDIUM: proxy: make findproxy() use trees to look up proxies Both proxy IDs and names are now looked up from the trees.
2014-03-15 02:43:51 -04:00
MINOR: proxy: add a new function proxy_find_by_id() It does the same as the other one except that it only focuses on the numeric ID and the capabilities. It's used by proxy_find_by_name() for numeric names.
2015-05-26 09:25:32 -04:00
if (px->uuid != id)
break;
[MINOR] server tracking: don't care about the tracked server's mode Right now, an HTTP server cannot track a TCP server and vice-versa. This patch enables proxy tracking without relying on the proxy's mode (tcp/http/health). It only requires a matching proxy name to exist. The original function was renamed to findproxy_mode().
2009-11-01 21:27:13 -05:00
MINOR: proxy: add a new function proxy_find_by_id() It does the same as the other one except that it only focuses on the numeric ID and the capabilities. It's used by proxy_find_by_name() for numeric names.
2015-05-26 09:25:32 -04:00
if ((px->cap & cap) != cap)
continue;
MEDIUM: proxy: make findproxy() use trees to look up proxies Both proxy IDs and names are now looked up from the trees.
2014-03-15 02:43:51 -04:00
MINOR: proxy: add a new function proxy_find_by_id() It does the same as the other one except that it only focuses on the numeric ID and the capabilities. It's used by proxy_find_by_name() for numeric names.
2015-05-26 09:25:32 -04:00
if (table && !px->table.size)
continue;
MEDIUM: proxy: make findproxy() use trees to look up proxies Both proxy IDs and names are now looked up from the trees.
2014-03-15 02:43:51 -04:00
MINOR: proxy: add a new function proxy_find_by_id() It does the same as the other one except that it only focuses on the numeric ID and the capabilities. It's used by proxy_find_by_name() for numeric names.
2015-05-26 09:25:32 -04:00
return px;
}
return NULL;
}
MEDIUM: proxy: make findproxy() use trees to look up proxies Both proxy IDs and names are now looked up from the trees.
2014-03-15 02:43:51 -04:00
MINOR: proxy: add a new function proxy_find_by_id() It does the same as the other one except that it only focuses on the numeric ID and the capabilities. It's used by proxy_find_by_name() for numeric names.
2015-05-26 09:25:32 -04:00
/* Returns a pointer to the first proxy matching either name <name>, or id
* <name> if <name> begins with a '#'. NULL is returned if no match is found.
* If <table> is non-zero, it only considers proxies having a table.
*/
struct proxy *proxy_find_by_name(const char *name, int cap, int table)
{
struct proxy *curproxy;
CLEANUP: proxy: make the proxy lookup functions more user-friendly First, findproxy() was renamed proxy_find_by_name() so that its explicit that a name is required for the lookup. Second, we give this function the ability to search for tables if needed. Third we now provide inline wrappers to pass the appropriate PR_CAP_* flags and to explicitly look up a frontend, backend or table.
2015-05-26 05:24:42 -04:00
MINOR: proxy: add a new function proxy_find_by_id() It does the same as the other one except that it only focuses on the numeric ID and the capabilities. It's used by proxy_find_by_name() for numeric names.
2015-05-26 09:25:32 -04:00
if (*name == '#') {
curproxy = proxy_find_by_id(atoi(name + 1), cap, table);
if (curproxy)
MINOR: proxy: simply ignore duplicates in proxy name lookups Now that we can't have duplicate proxies with similar capabilities, we can remove some painful check. The first one is the check that made the lookup function return NULL when a duplicate is found, as it prevented it from being used in the config parser to detect duplicates.
2015-05-26 05:35:41 -04:00
return curproxy;
[MINOR] server tracking: don't care about the tracked server's mode Right now, an HTTP server cannot track a TCP server and vice-versa. This patch enables proxy tracking without relying on the proxy's mode (tcp/http/health). It only requires a matching proxy name to exist. The original function was renamed to findproxy_mode().
2009-11-01 21:27:13 -05:00
}
MEDIUM: proxy: make findproxy() use trees to look up proxies Both proxy IDs and names are now looked up from the trees.
2014-03-15 02:43:51 -04:00
else {
struct ebpt_node *node;
for (node = ebis_lookup(&proxy_by_name, name); node; node = ebpt_next(node)) {
curproxy = container_of(node, struct proxy, conf.by_name);
if (strcmp(curproxy->id, name) != 0)
break;
if ((curproxy->cap & cap) != cap)
continue;
[MINOR] server tracking: don't care about the tracked server's mode Right now, an HTTP server cannot track a TCP server and vice-versa. This patch enables proxy tracking without relying on the proxy's mode (tcp/http/health). It only requires a matching proxy name to exist. The original function was renamed to findproxy_mode().
2009-11-01 21:27:13 -05:00
CLEANUP: proxy: make the proxy lookup functions more user-friendly First, findproxy() was renamed proxy_find_by_name() so that its explicit that a name is required for the lookup. Second, we give this function the ability to search for tables if needed. Third we now provide inline wrappers to pass the appropriate PR_CAP_* flags and to explicitly look up a frontend, backend or table.
2015-05-26 05:24:42 -04:00
if (table && !curproxy->table.size)
continue;
MINOR: proxy: simply ignore duplicates in proxy name lookups Now that we can't have duplicate proxies with similar capabilities, we can remove some painful check. The first one is the check that made the lookup function return NULL when a duplicate is found, as it prevented it from being used in the config parser to detect duplicates.
2015-05-26 05:35:41 -04:00
return curproxy;
MEDIUM: proxy: make findproxy() use trees to look up proxies Both proxy IDs and names are now looked up from the trees.
2014-03-15 02:43:51 -04:00
}
}
MINOR: proxy: simply ignore duplicates in proxy name lookups Now that we can't have duplicate proxies with similar capabilities, we can remove some painful check. The first one is the check that made the lookup function return NULL when a duplicate is found, as it prevented it from being used in the config parser to detect duplicates.
2015-05-26 05:35:41 -04:00
return NULL;
[MINOR] server tracking: don't care about the tracked server's mode Right now, an HTTP server cannot track a TCP server and vice-versa. This patch enables proxy tracking without relying on the proxy's mode (tcp/http/health). It only requires a matching proxy name to exist. The original function was renamed to findproxy_mode().
2009-11-01 21:27:13 -05:00
}
MEDIUM: proxy: add a new proxy_find_best_match() function This function tries to spot a proxy by its name, ID and type, and in case some elements don't match, it tries to determine which ones could be ignored and reports which ones were ignored so that the caller can decide whether or not it wants to pick this proxy. This will be used for maintaining the status across reloads where the config might have changed a bit.
2015-05-27 10:46:26 -04:00
/* Finds the best match for a proxy with capabilities <cap>, name <name> and id
* <id>. At most one of <id> or <name> may be different provided that <cap> is
* valid. Either <id> or <name> may be left unspecified (0). The purpose is to
* find a proxy based on some information from a previous configuration, across
* reloads or during information exchange between peers.
*
* Names are looked up first if present, then IDs are compared if present. In
* case of an inexact match whatever is forced in the configuration has
* precedence in the following order :
* - 1) forced ID (proves a renaming / change of proxy type)
* - 2) proxy name+type (may indicate a move if ID differs)
* - 3) automatic ID+type (may indicate a renaming)
*
* Depending on what is found, we can end up in the following situations :
*
* name id cap | possible causes
* -------------+-----------------
* -- -- -- | nothing found
* -- -- ok | nothing found
* -- ok -- | proxy deleted, ID points to next one
* -- ok ok | proxy renamed, or deleted with ID pointing to next one
* ok -- -- | proxy deleted, but other half with same name still here (before)
* ok -- ok | proxy's ID changed (proxy moved in the config file)
* ok ok -- | proxy deleted, but other half with same name still here (after)
* ok ok ok | perfect match
*
* Upon return if <diff> is not NULL, it is zeroed then filled with up to 3 bits :
MINOR: proxy: bit field for proxy_find_best_match diff status function proxy_find_best_match can update the caller by updating an int provided in argument. For now, proxy_find_best_match hardcode bit values 0x01, 0x02 and 0x04, which is not understandable when reading a code exploiting them. This patch defines 3 macros with a more explicit wording, so further reading of a code exploiting the magic bit values will be understandable more easily.
2015-07-03 05:03:33 -04:00
* - PR_FBM_MISMATCH_ID : proxy was found but ID differs
* (and ID was not zero)
* - PR_FBM_MISMATCH_NAME : proxy was found by ID but name differs
* (and name was not NULL)
* - PR_FBM_MISMATCH_PROXYTYPE : a proxy of different type was found with
* the same name and/or id
MEDIUM: proxy: add a new proxy_find_best_match() function This function tries to spot a proxy by its name, ID and type, and in case some elements don't match, it tries to determine which ones could be ignored and reports which ones were ignored so that the caller can decide whether or not it wants to pick this proxy. This will be used for maintaining the status across reloads where the config might have changed a bit.
2015-05-27 10:46:26 -04:00
*
* Only a valid proxy is returned. If capabilities do not match, NULL is
* returned. The caller can check <diff> to report detailed warnings / errors,
* and decide whether or not to use what was found.
*/
struct proxy *proxy_find_best_match(int cap, const char *name, int id, int *diff)
{
struct proxy *byname;
struct proxy *byid;
if (!name && !id)
return NULL;
if (diff)
*diff = 0;
byname = byid = NULL;
if (name) {
byname = proxy_find_by_name(name, cap, 0);
if (byname && (!id || byname->uuid == id))
return byname;
}
/* remaining possiblities :
* - name not set
* - name set but not found
* - name found, but ID doesn't match.
*/
if (id) {
byid = proxy_find_by_id(id, cap, 0);
if (byid) {
if (byname) {
/* id+type found, name+type found, but not all 3.
* ID wins only if forced, otherwise name wins.
*/
if (byid->options & PR_O_FORCED_ID) {
if (diff)
MINOR: proxy: bit field for proxy_find_best_match diff status function proxy_find_best_match can update the caller by updating an int provided in argument. For now, proxy_find_best_match hardcode bit values 0x01, 0x02 and 0x04, which is not understandable when reading a code exploiting them. This patch defines 3 macros with a more explicit wording, so further reading of a code exploiting the magic bit values will be understandable more easily.
2015-07-03 05:03:33 -04:00
*diff |= PR_FBM_MISMATCH_NAME;
MEDIUM: proxy: add a new proxy_find_best_match() function This function tries to spot a proxy by its name, ID and type, and in case some elements don't match, it tries to determine which ones could be ignored and reports which ones were ignored so that the caller can decide whether or not it wants to pick this proxy. This will be used for maintaining the status across reloads where the config might have changed a bit.
2015-05-27 10:46:26 -04:00
return byid;
}
else {
if (diff)
MINOR: proxy: bit field for proxy_find_best_match diff status function proxy_find_best_match can update the caller by updating an int provided in argument. For now, proxy_find_best_match hardcode bit values 0x01, 0x02 and 0x04, which is not understandable when reading a code exploiting them. This patch defines 3 macros with a more explicit wording, so further reading of a code exploiting the magic bit values will be understandable more easily.
2015-07-03 05:03:33 -04:00
*diff |= PR_FBM_MISMATCH_ID;
MEDIUM: proxy: add a new proxy_find_best_match() function This function tries to spot a proxy by its name, ID and type, and in case some elements don't match, it tries to determine which ones could be ignored and reports which ones were ignored so that the caller can decide whether or not it wants to pick this proxy. This will be used for maintaining the status across reloads where the config might have changed a bit.
2015-05-27 10:46:26 -04:00
return byname;
}
}
/* remaining possiblities :
* - name not set
* - name set but not found
*/
if (name && diff)
MINOR: proxy: bit field for proxy_find_best_match diff status function proxy_find_best_match can update the caller by updating an int provided in argument. For now, proxy_find_best_match hardcode bit values 0x01, 0x02 and 0x04, which is not understandable when reading a code exploiting them. This patch defines 3 macros with a more explicit wording, so further reading of a code exploiting the magic bit values will be understandable more easily.
2015-07-03 05:03:33 -04:00
*diff |= PR_FBM_MISMATCH_NAME;
MEDIUM: proxy: add a new proxy_find_best_match() function This function tries to spot a proxy by its name, ID and type, and in case some elements don't match, it tries to determine which ones could be ignored and reports which ones were ignored so that the caller can decide whether or not it wants to pick this proxy. This will be used for maintaining the status across reloads where the config might have changed a bit.
2015-05-27 10:46:26 -04:00
return byid;
}
/* ID not found */
if (byname) {
if (diff)
MINOR: proxy: bit field for proxy_find_best_match diff status function proxy_find_best_match can update the caller by updating an int provided in argument. For now, proxy_find_best_match hardcode bit values 0x01, 0x02 and 0x04, which is not understandable when reading a code exploiting them. This patch defines 3 macros with a more explicit wording, so further reading of a code exploiting the magic bit values will be understandable more easily.
2015-07-03 05:03:33 -04:00
*diff |= PR_FBM_MISMATCH_ID;
MEDIUM: proxy: add a new proxy_find_best_match() function This function tries to spot a proxy by its name, ID and type, and in case some elements don't match, it tries to determine which ones could be ignored and reports which ones were ignored so that the caller can decide whether or not it wants to pick this proxy. This will be used for maintaining the status across reloads where the config might have changed a bit.
2015-05-27 10:46:26 -04:00
return byname;
}
}
/* All remaining possiblities will lead to NULL. If we can report more
* detailed information to the caller about changed types and/or name,
* we'll do it. For example, we could detect that "listen foo" was
* split into "frontend foo_ft" and "backend foo_bk" if IDs are forced.
* - name not set, ID not found
* - name not found, ID not set
* - name not found, ID not found
*/
if (!diff)
return NULL;
if (name) {
byname = proxy_find_by_name(name, 0, 0);
if (byname && (!id || byname->uuid == id))
MINOR: proxy: bit field for proxy_find_best_match diff status function proxy_find_best_match can update the caller by updating an int provided in argument. For now, proxy_find_best_match hardcode bit values 0x01, 0x02 and 0x04, which is not understandable when reading a code exploiting them. This patch defines 3 macros with a more explicit wording, so further reading of a code exploiting the magic bit values will be understandable more easily.
2015-07-03 05:03:33 -04:00
*diff |= PR_FBM_MISMATCH_PROXYTYPE;
MEDIUM: proxy: add a new proxy_find_best_match() function This function tries to spot a proxy by its name, ID and type, and in case some elements don't match, it tries to determine which ones could be ignored and reports which ones were ignored so that the caller can decide whether or not it wants to pick this proxy. This will be used for maintaining the status across reloads where the config might have changed a bit.
2015-05-27 10:46:26 -04:00
}
if (id) {
byid = proxy_find_by_id(id, 0, 0);
if (byid) {
if (!name)
MINOR: proxy: bit field for proxy_find_best_match diff status function proxy_find_best_match can update the caller by updating an int provided in argument. For now, proxy_find_best_match hardcode bit values 0x01, 0x02 and 0x04, which is not understandable when reading a code exploiting them. This patch defines 3 macros with a more explicit wording, so further reading of a code exploiting the magic bit values will be understandable more easily.
2015-07-03 05:03:33 -04:00
*diff |= PR_FBM_MISMATCH_PROXYTYPE; /* only type changed */
MEDIUM: proxy: add a new proxy_find_best_match() function This function tries to spot a proxy by its name, ID and type, and in case some elements don't match, it tries to determine which ones could be ignored and reports which ones were ignored so that the caller can decide whether or not it wants to pick this proxy. This will be used for maintaining the status across reloads where the config might have changed a bit.
2015-05-27 10:46:26 -04:00
else if (byid->options & PR_O_FORCED_ID)
MINOR: proxy: bit field for proxy_find_best_match diff status function proxy_find_best_match can update the caller by updating an int provided in argument. For now, proxy_find_best_match hardcode bit values 0x01, 0x02 and 0x04, which is not understandable when reading a code exploiting them. This patch defines 3 macros with a more explicit wording, so further reading of a code exploiting the magic bit values will be understandable more easily.
2015-07-03 05:03:33 -04:00
*diff |= PR_FBM_MISMATCH_NAME | PR_FBM_MISMATCH_PROXYTYPE; /* name and type changed */
MEDIUM: proxy: add a new proxy_find_best_match() function This function tries to spot a proxy by its name, ID and type, and in case some elements don't match, it tries to determine which ones could be ignored and reports which ones were ignored so that the caller can decide whether or not it wants to pick this proxy. This will be used for maintaining the status across reloads where the config might have changed a bit.
2015-05-27 10:46:26 -04:00
/* otherwise it's a different proxy that was returned */
}
}
return NULL;
}
[MEDIUM] Implement "track [<backend>/]<server>" This patch implements ability to set the current state of one server by tracking another one. It: - adds two variables: *tracknext, *tracked to struct server - implements findserver(), similar to findproxy() - adds "track" keyword accepting both "proxy/server" and "server" (assuming current proxy) - verifies if both checks and tracking is not enabled at the same time - changes set_server_down() to notify tracking server - creates set_server_up(), set_server_disabled(), set_server_enabled() by moving the code from process_chk() and adding notifications - changes stats to show a name of tracked server instead of Chk/Dwn/Dwntime(html) or by adding new variable (csv) Changes from the previuos version: - it is possibile to track independently of the declaration order - one extra comma bug is fixed - new condition to check if there is no disable-on-404 inconsistency
2008-02-17 19:26:35 -05:00
/*
* This function finds a server with matching name within selected proxy.
* It also checks if there are more matching servers with
* requested name as this often leads into unexpected situations.
*/
struct server *findserver(const struct proxy *px, const char *name) {
struct server *cursrv, *target = NULL;
if (!px)
return NULL;
for (cursrv = px->srv; cursrv; cursrv = cursrv->next) {
if (strcmp(cursrv->id, name))
continue;
if (!target) {
target = cursrv;
continue;
}
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_alert("Refusing to use duplicated server '%s' found in proxy: %s!\n",
name, px->id);
[MEDIUM] Implement "track [<backend>/]<server>" This patch implements ability to set the current state of one server by tracking another one. It: - adds two variables: *tracknext, *tracked to struct server - implements findserver(), similar to findproxy() - adds "track" keyword accepting both "proxy/server" and "server" (assuming current proxy) - verifies if both checks and tracking is not enabled at the same time - changes set_server_down() to notify tracking server - creates set_server_up(), set_server_disabled(), set_server_enabled() by moving the code from process_chk() and adding notifications - changes stats to show a name of tracked server instead of Chk/Dwn/Dwntime(html) or by adding new variable (csv) Changes from the previuos version: - it is possibile to track independently of the declaration order - one extra comma bug is fixed - new condition to check if there is no disable-on-404 inconsistency
2008-02-17 19:26:35 -05:00
return NULL;
}
return target;
}
[MINOR] cfgparse: some cleanups in the consistency checks Check for servers in health mode, for health mode in pure-backends. Some code have been refactored for better organization.
2009-03-15 08:46:16 -04:00
/* This function checks that the designated proxy has no http directives
* enabled. It will output a warning if there are, and will fix some of them.
* It returns the number of fatal errors encountered. This should be called
* at the end of the configuration parsing if the proxy is not in http mode.
* The <file> argument is used to construct the error message.
*/
[MEDIUM] config: split parser and checker in two functions This is a first step towards support of multiple configuration files. Now readcfgfile() only reads a file in memory and performs very minimal parsing. The checks are performed afterwards.
2009-06-22 09:48:36 -04:00
int proxy_cfg_ensure_no_http(struct proxy *curproxy)
[MINOR] cfgparse: some cleanups in the consistency checks Check for servers in health mode, for health mode in pure-backends. Some code have been refactored for better organization.
2009-03-15 08:46:16 -04:00
{
if (curproxy->cookie_name != NULL) {
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("config : cookie will be ignored for %s '%s' (needs 'mode http').\n",
proxy_type_str(curproxy), curproxy->id);
[MINOR] cfgparse: some cleanups in the consistency checks Check for servers in health mode, for health mode in pure-backends. Some code have been refactored for better organization.
2009-03-15 08:46:16 -04:00
}
if (curproxy->rsp_exp != NULL) {
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("config : server regular expressions will be ignored for %s '%s' (needs 'mode http').\n",
proxy_type_str(curproxy), curproxy->id);
[MINOR] cfgparse: some cleanups in the consistency checks Check for servers in health mode, for health mode in pure-backends. Some code have been refactored for better organization.
2009-03-15 08:46:16 -04:00
}
if (curproxy->req_exp != NULL) {
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("config : client regular expressions will be ignored for %s '%s' (needs 'mode http').\n",
proxy_type_str(curproxy), curproxy->id);
[MINOR] cfgparse: some cleanups in the consistency checks Check for servers in health mode, for health mode in pure-backends. Some code have been refactored for better organization.
2009-03-15 08:46:16 -04:00
}
if (curproxy->monitor_uri != NULL) {
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("config : monitor-uri will be ignored for %s '%s' (needs 'mode http').\n",
proxy_type_str(curproxy), curproxy->id);
[MINOR] cfgparse: some cleanups in the consistency checks Check for servers in health mode, for health mode in pure-backends. Some code have been refactored for better organization.
2009-03-15 08:46:16 -04:00
}
[MINOR] backend: separate declarations of LB algos from their lookup method LB algo macros were composed of the LB algo by itself without any indication of the method to use to look up a server (the lb function itself). This method was implied by the LB algo, which was not very convenient to add more algorithms. Now we have several fields in the LB macros, some to describe what to look for in the requests, some to describe how to transform that (kind of algo) and some to describe what lookup function to use. The next patch will make it possible to factor out some code for all algos which rely on a map.
2009-10-03 06:21:20 -04:00
if (curproxy->lbprm.algo & BE_LB_NEED_HTTP) {
[MINOR] cfgparse: some cleanups in the consistency checks Check for servers in health mode, for health mode in pure-backends. Some code have been refactored for better organization.
2009-03-15 08:46:16 -04:00
curproxy->lbprm.algo &= ~BE_LB_ALGO;
curproxy->lbprm.algo |= BE_LB_ALGO_RR;
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("config : Layer 7 hash not possible for %s '%s' (needs 'mode http'). Falling back to round robin.\n",
proxy_type_str(curproxy), curproxy->id);
[MINOR] cfgparse: some cleanups in the consistency checks Check for servers in health mode, for health mode in pure-backends. Some code have been refactored for better organization.
2009-03-15 08:46:16 -04:00
}
[BUG] config: disable 'option httplog' on TCP proxies Gabriel Sosa reported that logs were appearing with BADREQ when 'option httplog' was used with a TCP proxy (eg: inherited via a default instance). This patch detects it and falls back to tcplog after emitting a warning. (cherry picked from commit 5f0bd6537f8b56b643ef485d7a3c96d996d9b01a)
2009-11-09 15:27:51 -05:00
if (curproxy->to_log & (LW_REQ | LW_RESP)) {
curproxy->to_log &= ~(LW_REQ | LW_RESP);
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("parsing [%s:%d] : HTTP log/header format not usable with %s '%s' (needs 'mode http').\n",
curproxy->conf.lfs_file, curproxy->conf.lfs_line,
proxy_type_str(curproxy), curproxy->id);
[BUG] config: disable 'option httplog' on TCP proxies Gabriel Sosa reported that logs were appearing with BADREQ when 'option httplog' was used with a TCP proxy (eg: inherited via a default instance). This patch detects it and falls back to tcplog after emitting a warning. (cherry picked from commit 5f0bd6537f8b56b643ef485d7a3c96d996d9b01a)
2009-11-09 15:27:51 -05:00
}
BUG/MEDIUM: log: fix regression on log-format handling Commit a4312fa2 merged into dev18 improved log-format management by processing "log-format" and "unique-id-format" where they were declared, so that the faulty args could be reported with their correct line numbers. Unfortunately, the log-format parser considers the proxy mode (TCP/HTTP) and now if the directive is set before the "mode" statement, it can be rejected and report warnings. So we really need to parse these directives at the end of a section at least. Right now we do not have an "end of section" event, so we need to store the file name and line number for each of these directives, and take care of them at the end. One of the benefits is that now the line numbers can be inherited from the line passing "option httplog" even if it's in a defaults section. Future improvements should be performed to report line numbers in every log-format processed by the parser.
2013-04-12 12:13:46 -04:00
if (curproxy->conf.logformat_string == default_http_log_format ||
curproxy->conf.logformat_string == clf_http_log_format) {
/* Note: we don't change the directive's file:line number */
curproxy->conf.logformat_string = default_tcp_log_format;
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("parsing [%s:%d] : 'option httplog' not usable with %s '%s' (needs 'mode http'). Falling back to 'option tcplog'.\n",
curproxy->conf.lfs_file, curproxy->conf.lfs_line,
proxy_type_str(curproxy), curproxy->id);
BUG/MINOR: fix option httplog validation with TCP frontends Option httplog needs to be checked only once the proxy has been validated, so that its final mode (tcp/http) can be used. Also we need to check for httplog before checking the log format, so that we can report a warning about this specific option and not about the format it implies.
2012-05-31 13:30:26 -04:00
}
[MINOR] cfgparse: some cleanups in the consistency checks Check for servers in health mode, for health mode in pure-backends. Some code have been refactored for better organization.
2009-03-15 08:46:16 -04:00
return 0;
}
[BUG] proxy: stats frontend and peers were missing many initializers This was revealed with one of the very latest patches which caused the listener_queue not to be initialized on the stats socket frontend. And in fact a number of other ones were missing too. This is getting so boring that now we'll always make use of the same function to initialize any proxy. Doing so has even saved about 500 bytes on the binary due to the avoided code redundancy. No backport is needed.
2011-07-28 19:49:03 -04:00
/* Perform the most basic initialization of a proxy :
* memset(), list_init(*), reset_timeouts(*).
[BUG] peers: the peer frontend must not emit any log Peers' frontends must have logging disabled by default, which was not the case, so logs were randomly emitted upon restart, sometimes causing a new process to fail to replace the old one.
2011-09-07 12:41:08 -04:00
* Any new proxy or peer should be initialized via this function.
[BUG] proxy: stats frontend and peers were missing many initializers This was revealed with one of the very latest patches which caused the listener_queue not to be initialized on the stats socket frontend. And in fact a number of other ones were missing too. This is getting so boring that now we'll always make use of the same function to initialize any proxy. Doing so has even saved about 500 bytes on the binary due to the avoided code redundancy. No backport is needed.
2011-07-28 19:49:03 -04:00
*/
void init_new_proxy(struct proxy *p)
{
memset(p, 0, sizeof(struct proxy));
MAJOR: connection: replace struct target with a pointer to an enum Instead of storing a couple of (int, ptr) in the struct connection and the struct session, we use a different method : we only store a pointer to an integer which is stored inside the target object and which contains a unique type identifier. That way, the pointer allows us to retrieve the object type (by dereferencing it) and the object's address (by computing the displacement in the target structure). The NULL pointer always corresponds to OBJ_TYPE_NONE. This reduces the size of the connection and session structs. It also simplifies target assignment and compare. In order to improve the generated code, we try to put the obj_type element at the beginning of all the structs (listener, server, proxy, si_applet), so that the original and target pointers are always equal. A lot of code was touched by massive replaces, but the changes are not that important.
2012-11-11 18:42:33 -05:00
p->obj_type = OBJ_TYPE_PROXY;
[BUG] proxy: stats frontend and peers were missing many initializers This was revealed with one of the very latest patches which caused the listener_queue not to be initialized on the stats socket frontend. And in fact a number of other ones were missing too. This is getting so boring that now we'll always make use of the same function to initialize any proxy. Doing so has even saved about 500 bytes on the binary due to the avoided code redundancy. No backport is needed.
2011-07-28 19:49:03 -04:00
LIST_INIT(&p->pendconns);
LIST_INIT(&p->acl);
LIST_INIT(&p->http_req_rules);
MEDIUM: http: add a new "http-response" ruleset Some actions were clearly missing to process response headers. This patch adds a new "http-response" ruleset which provides the following actions : - allow : stop evaluating http-response rules - deny : stop and reject the response with a 502 - add-header : add a header in log-format mode - set-header : set a header in log-format mode
2013-06-11 10:06:12 -04:00
LIST_INIT(&p->http_res_rules);
CLEANUP: proxy: rename "block_cond" to "block_rules" Next patch will make them real rules, not only conditions. This separate patch makes the next one more readable.
2014-04-28 16:05:31 -04:00
LIST_INIT(&p->block_rules);
[BUG] proxy: stats frontend and peers were missing many initializers This was revealed with one of the very latest patches which caused the listener_queue not to be initialized on the stats socket frontend. And in fact a number of other ones were missing too. This is getting so boring that now we'll always make use of the same function to initialize any proxy. Doing so has even saved about 500 bytes on the binary due to the avoided code redundancy. No backport is needed.
2011-07-28 19:49:03 -04:00
LIST_INIT(&p->redirect_rules);
LIST_INIT(&p->mon_fail_cond);
LIST_INIT(&p->switching_rules);
MEDIUM: session: implement the "use-server" directive Sometimes it is desirable to forward a particular request to a specific server without having to declare a dedicated backend for this server. This can be achieved using the "use-server" rules. These rules are evaluated after the "redirect" rules and before evaluating cookies, and they have precedence on them. There may be as many "use-server" rules as desired. All of these rules are evaluated in their declaration order, and the first one which matches will assign the server.
2012-04-05 15:09:48 -04:00
LIST_INIT(&p->server_rules);
[BUG] proxy: stats frontend and peers were missing many initializers This was revealed with one of the very latest patches which caused the listener_queue not to be initialized on the stats socket frontend. And in fact a number of other ones were missing too. This is getting so boring that now we'll always make use of the same function to initialize any proxy. Doing so has even saved about 500 bytes on the binary due to the avoided code redundancy. No backport is needed.
2011-07-28 19:49:03 -04:00
LIST_INIT(&p->persist_rules);
LIST_INIT(&p->sticking_rules);
LIST_INIT(&p->storersp_rules);
LIST_INIT(&p->tcp_req.inspect_rules);
LIST_INIT(&p->tcp_rep.inspect_rules);
LIST_INIT(&p->tcp_req.l4_rules);
MEDIUM: tcp: add registration and processing of TCP L5 rules This commit introduces "tcp-request session" rules. These are very much like "tcp-request connection" rules except that they're processed after the handshake, so it is possible to consider SSL information and addresses rewritten by the proxy protocol header in actions. This is particularly useful to track proxied sources as this was not possible before, given that tcp-request content rules are processed after each HTTP request. Similarly it is possible to assign the proxied source address or the client's cert to a variable.
2016-10-21 10:37:51 -04:00
LIST_INIT(&p->tcp_req.l5_rules);
[BUG] proxy: stats frontend and peers were missing many initializers This was revealed with one of the very latest patches which caused the listener_queue not to be initialized on the stats socket frontend. And in fact a number of other ones were missing too. This is getting so boring that now we'll always make use of the same function to initialize any proxy. Doing so has even saved about 500 bytes on the binary due to the avoided code redundancy. No backport is needed.
2011-07-28 19:49:03 -04:00
LIST_INIT(&p->req_add);
LIST_INIT(&p->rsp_add);
LIST_INIT(&p->listener_queue);
MEDIUM: log: Use linked lists for loggers This patch settles the 2 loggers limitation. Loggers are now stored in linked lists. Using "global log", the global loggers list content is added at the end of the current proxy list. Each "log" entries are added at the end of the proxy list. "no log" flush a logger list.
2011-10-12 11:50:54 -04:00
LIST_INIT(&p->logsrvs);
MINOR: config: Parse the string of the log-format config keyword parse_logformat_string: parse the string, detect the type: text, separator or variable parse_logformat_var: dectect variable name parse_logformat_var_args: parse arguments and flags add_to_logformat_list: add to the logformat linked list
2012-02-08 10:37:49 -05:00
LIST_INIT(&p->logformat);
MEDIUM: logs: add a new RFC5424 log-format for the structured-data This patch adds a new RFC5424-specific log-format for the structured-data that is automatically send by __send_log() when the sender is in RFC5424 mode. A new statement "log-format-sd" should be used in order to set log-format for the structured-data part in RFC5424 formatted syslog messages. Example: log-format-sd [exampleSDID@1234\ bytes=\"%B\"\ status=\"%ST\"]
2015-09-25 13:17:44 -04:00
LIST_INIT(&p->logformat_sd);
MEDIUM: log: Unique ID The Unique ID, is an ID generated with several informations. You can use a log-format string to customize it, with the "unique-id-format" keyword, and insert it in the request header, with the "unique-id-header" keyword.
2012-03-12 07:48:57 -04:00
LIST_INIT(&p->format_unique_id);
MEDIUM: config: replace ssl_conf by bind_conf Some settings need to be merged per-bind config line and are not necessarily SSL-specific. It becomes quite inconvenient to have this ssl_conf SSL-specific, so let's replace it with something more generic.
2012-09-13 11:54:29 -04:00
LIST_INIT(&p->conf.bind);
MAJOR: listeners: use dual-linked lists to chain listeners with frontends Navigating through listeners was very inconvenient and error-prone. Not to mention that listeners were linked in reverse order and reverted afterwards. In order to definitely get rid of these issues, we now do the following : - frontends have a dual-linked list of bind_conf - frontends have a dual-linked list of listeners - bind_conf have a dual-linked list of listeners - listeners have a pointer to their bind_conf This way we can now navigate from anywhere to anywhere and always find the proper bind_conf for a given listener, as well as find the list of listeners for a current bind_conf.
2012-09-20 10:48:07 -04:00
LIST_INIT(&p->conf.listeners);
MAJOR: sample: maintain a per-proxy list of the fetch args to resolve While ACL args were resolved after all the config was parsed, it was not the case with sample fetch args because they're almost everywhere now. The issue is that ACLs now solely rely on sample fetches, so their args resolving doesn't work anymore. And many fetches involving a server, a proxy or a userlist don't work at all. The real issue is that at the bottom layers we have no information about proxies, line numbers, even ACLs in order to report understandable errors, and that at the top layers we have no visibility over the locations where fetches are referenced (think log node). After failing multiple unsatisfying solutions attempts, we now have a new concept of args list. The principle is that every proxy has a list head which contains a number of indications such as the config keyword, the context where it's used, the file and line number, etc... and a list of arguments. This list head is of the same type as the elements, so it serves as a template for adding new elements. This way, it is filled from top to bottom by the callers with the information they have (eg: line numbers, ACL name, ...) and the lower layers just have to duplicate it and add an element when they face an argument they cannot resolve yet. Then at the end of the configuration parsing, a loop passes over each proxy's list and resolves all the args in sequence. And this way there is all necessary information to report verbose errors. The first immediate benefit is that for the first time we got very precise location of issues (arg number in a keyword in its context, ...). Second, in order to do this we had to parse log-format and unique-id-format a bit earlier, so that was a great opportunity for doing so when the directives are encountered (unless it's a default section). This way, the recorded line numbers for these args are the ones of the place where the log format is declared, not the end of the file. Userlists report slightly more information now. They're the only remaining ones in the ACL resolving function.
2013-04-02 10:34:32 -04:00
LIST_INIT(&p->conf.args.list);
MEDIUM: checks: add send/expect tcp based check This is a generic health check which can be used to match a banner or send a request and analyse a server response. It works in a send/expect ways and many exchange can be done between HAProxy and a server to decide the server status, making HAProxy able to speak the server's protocol. It can send arbitrary regular or binary strings and match content as a regular or binary string or a regex. Signed-off-by: Baptiste Assmann <bedis9@gmail.com>
2013-10-06 17:24:13 -04:00
LIST_INIT(&p->tcpcheck_rules);
MINOR: filters: Extract proxy stuff from the struct filter Now, filter's configuration (.id, .conf and .ops fields) is stored in the structure 'flt_conf'. So proxies own a flt_conf list instead of a filter list. When a filter is attached to a stream, it gets a pointer on its configuration. This avoids mixing the filter's context (owns by a stream) and its configuration (owns by a proxy). It also saves 2 pointers per filter instance.
2016-02-04 07:40:26 -05:00
LIST_INIT(&p->filter_configs);
[BUG] proxy: stats frontend and peers were missing many initializers This was revealed with one of the very latest patches which caused the listener_queue not to be initialized on the stats socket frontend. And in fact a number of other ones were missing too. This is getting so boring that now we'll always make use of the same function to initialize any proxy. Doing so has even saved about 500 bytes on the binary due to the avoided code redundancy. No backport is needed.
2011-07-28 19:49:03 -04:00
/* Timeouts are defined as -1 */
proxy_reset_timeouts(p);
p->tcp_rep.inspect_delay = TICK_ETERNITY;
MEDIUM: proxy: add the global frontend to the list of normal proxies Since recent changes on the global frontend, it was not possible anymore to soft-reload a process which had a stats socket because the socket would not be disabled upon reload. The only solution to this endless madness is to have the global frontend part of normal proxies. Since we don't want to get an ID that shifts all other proxies and causes trouble in deployed environments, we assign it ID #0 which other proxies can't grab, and we don't report it in the stats pages.
2012-10-04 02:47:34 -04:00
/* initial uuid is unassigned (-1) */
p->uuid = -1;
MEDIUM: threads/proxy: Add a lock per proxy and atomically update proxy vars Now, each proxy contains a lock that must be used when necessary to protect it. Moreover, all proxy's counters are now updated using atomic operations.
2017-06-02 09:33:24 -04:00
BUILD: threads: Rename SPIN/RWLOCK macros using HA_ prefix This remove any name conflicts, especially on Solaris.
2017-11-07 04:42:54 -05:00
HA_SPIN_INIT(&p->lock);
[BUG] proxy: stats frontend and peers were missing many initializers This was revealed with one of the very latest patches which caused the listener_queue not to be initialized on the stats socket frontend. And in fact a number of other ones were missing too. This is getting so boring that now we'll always make use of the same function to initialize any proxy. Doing so has even saved about 500 bytes on the binary due to the avoided code redundancy. No backport is needed.
2011-07-28 19:49:03 -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
/*
[MAJOR] delay registering of listener sockets at startup Some pollers such as kqueue lose their FD across fork(), meaning that the registered file descriptors are lost too. Now when the proxies are started by start_proxies(), the file descriptors are not registered yet, leaving enough time for the fork() to take place and to get a new pollfd. It will be the first call to maintain_proxies that will register them.
2007-04-09 13:29:56 -04:00
* This function creates all proxy sockets. It should be done very early,
* typically before privileges are dropped. The sockets will be registered
* but not added to any fd_set, in order not to loose them across the fork().
[CLEANUP] proxy: rename a few proxy states (PR_STIDLE and PR_STRUN) Those states have been replaced with PR_STFULL and PR_STREADY respectively, as it is what matches them the best now. Also, two occurrences of PR_STIDLE in peers.c have been removed as this did not provide any form of error recovery anyway.
2011-07-25 02:11:52 -04:00
* The proxies also start in READY state because they all have their listeners
[MEDIUM] listeners: don't change listeners states anymore in maintain_proxies Now maintain_proxies() only changes proxies states and does not affect their listeners anymore since they are autonomous. A proxy will switch between the PR_STIDLE and PR_STRUN states depending whether it's saturated or not. Next step will consist in renaming PR_STIDLE to PR_STFULL. This state is now only used to report the proxy state in the stats.
2011-07-25 01:37:28 -04:00
* bound.
[MAJOR] delay registering of listener sockets at startup Some pollers such as kqueue lose their FD across fork(), meaning that the registered file descriptors are lost too. Now when the proxies are started by start_proxies(), the file descriptors are not registered yet, leaving enough time for the fork() to take place and to get a new pollfd. It will be the first call to maintain_proxies that will register them.
2007-04-09 13:29:56 -04:00
*
* Its return value is composed from ERR_NONE, ERR_RETRYABLE and ERR_FATAL.
* Retryable errors will only be printed if <verbose> is not zero.
[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
*/
int start_proxies(int verbose)
{
struct proxy *curproxy;
struct listener *listener;
[MAJOR] create proto_tcp and move initialization of proxy listeners Proxy listeners were very special and not very easy to manipulate. A proto_tcp file has been created with all that is required to manage TCPv4/TCPv6 as raw protocols, and provide generic listeners. The code of start_proxies() and maintain_proxies() now looks less like spaghetti. Also, event_accept will need a serious lifting in order to use more of the information provided by the listener.
2007-10-28 20:09:36 -04:00
int lerr, err = ERR_NONE;
int pxerr;
char msg[100];
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
MINOR/CLEANUP: proxy: rename "proxy" to "proxies_list" Rename the global variable "proxy" to "proxies_list". There's been multiple proxies in haproxy for quite some time, and "proxy" is a potential source of bugs, a number of functions have a "proxy" argument, and some code used "proxy" when it really meant "px" or "curproxy". It worked by pure luck, because it usually happened while parsing the config, and thus "proxy" pointed to the currently parsed proxy, but we should probably not rely on this. [wt: some of these are definitely fixes that are worth backporting]
2017-11-24 10:54:05 -05:00
for (curproxy = proxies_list; curproxy != NULL; curproxy = curproxy->next) {
[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
if (curproxy->state != PR_STNEW)
continue; /* already initialized */
pxerr = 0;
MAJOR: listeners: use dual-linked lists to chain listeners with frontends Navigating through listeners was very inconvenient and error-prone. Not to mention that listeners were linked in reverse order and reverted afterwards. In order to definitely get rid of these issues, we now do the following : - frontends have a dual-linked list of bind_conf - frontends have a dual-linked list of listeners - bind_conf have a dual-linked list of listeners - listeners have a pointer to their bind_conf This way we can now navigate from anywhere to anywhere and always find the proper bind_conf for a given listener, as well as find the list of listeners for a current bind_conf.
2012-09-20 10:48:07 -04:00
list_for_each_entry(listener, &curproxy->conf.listeners, by_fe) {
[MAJOR] create proto_tcp and move initialization of proxy listeners Proxy listeners were very special and not very easy to manipulate. A proto_tcp file has been created with all that is required to manage TCPv4/TCPv6 as raw protocols, and provide generic listeners. The code of start_proxies() and maintain_proxies() now looks less like spaghetti. Also, event_accept will need a serious lifting in order to use more of the information provided by the listener.
2007-10-28 20:09:36 -04:00
if (listener->state != LI_ASSIGNED)
continue; /* already started */
[MEDIUM] Enhance message errors management on binds
2010-10-22 10:06:11 -04:00
lerr = listener->proto->bind(listener, msg, sizeof(msg));
[MAJOR] create proto_tcp and move initialization of proxy listeners Proxy listeners were very special and not very easy to manipulate. A proto_tcp file has been created with all that is required to manage TCPv4/TCPv6 as raw protocols, and provide generic listeners. The code of start_proxies() and maintain_proxies() now looks less like spaghetti. Also, event_accept will need a serious lifting in order to use more of the information provided by the listener.
2007-10-28 20:09:36 -04:00
/* errors are reported if <verbose> is set or if they are fatal */
if (verbose || (lerr & (ERR_FATAL | ERR_ABORT))) {
if (lerr & ERR_ALERT)
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_alert("Starting %s %s: %s\n",
proxy_type_str(curproxy), curproxy->id, msg);
[MAJOR] create proto_tcp and move initialization of proxy listeners Proxy listeners were very special and not very easy to manipulate. A proto_tcp file has been created with all that is required to manage TCPv4/TCPv6 as raw protocols, and provide generic listeners. The code of start_proxies() and maintain_proxies() now looks less like spaghetti. Also, event_accept will need a serious lifting in order to use more of the information provided by the listener.
2007-10-28 20:09:36 -04:00
else if (lerr & ERR_WARN)
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("Starting %s %s: %s\n",
proxy_type_str(curproxy), curproxy->id, msg);
[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] create proto_tcp and move initialization of proxy listeners Proxy listeners were very special and not very easy to manipulate. A proto_tcp file has been created with all that is required to manage TCPv4/TCPv6 as raw protocols, and provide generic listeners. The code of start_proxies() and maintain_proxies() now looks less like spaghetti. Also, event_accept will need a serious lifting in order to use more of the information provided by the listener.
2007-10-28 20:09:36 -04:00
err |= lerr;
if (lerr & (ERR_ABORT | ERR_FATAL)) {
[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
pxerr |= 1;
break;
}
[MAJOR] create proto_tcp and move initialization of proxy listeners Proxy listeners were very special and not very easy to manipulate. A proto_tcp file has been created with all that is required to manage TCPv4/TCPv6 as raw protocols, and provide generic listeners. The code of start_proxies() and maintain_proxies() now looks less like spaghetti. Also, event_accept will need a serious lifting in order to use more of the information provided by the listener.
2007-10-28 20:09:36 -04:00
else if (lerr & ERR_CODE) {
[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
pxerr |= 1;
continue;
}
}
if (!pxerr) {
[CLEANUP] proxy: rename a few proxy states (PR_STIDLE and PR_STRUN) Those states have been replaced with PR_STFULL and PR_STREADY respectively, as it is what matches them the best now. Also, two occurrences of PR_STIDLE in peers.c have been removed as this did not provide any form of error recovery anyway.
2011-07-25 02:11:52 -04:00
curproxy->state = PR_STREADY;
[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
send_log(curproxy, LOG_NOTICE, "Proxy %s started.\n", curproxy->id);
}
[MAJOR] create proto_tcp and move initialization of proxy listeners Proxy listeners were very special and not very easy to manipulate. A proto_tcp file has been created with all that is required to manage TCPv4/TCPv6 as raw protocols, and provide generic listeners. The code of start_proxies() and maintain_proxies() now looks less like spaghetti. Also, event_accept will need a serious lifting in order to use more of the information provided by the listener.
2007-10-28 20:09:36 -04:00
if (err & ERR_ABORT)
break;
[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
}
return err;
}
/*
[MAJOR] proxy: finally get rid of maintain_proxies() This function is finally not needed anymore, as it has been replaced with a per-proxy task that is scheduled when some limits are encountered on incoming connections or when the process is stopping. The savings should be noticeable on configs with a large number of proxies. The most important point is that the rate limiting is now enforced in a clean and solid way.
2011-07-25 10:33:49 -04:00
* This is the proxy management task. It enables proxies when there are enough
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 18:22:06 -04:00
* free streams, or stops them when the table is full. It is designed to be
[MAJOR] proxy: finally get rid of maintain_proxies() This function is finally not needed anymore, as it has been replaced with a per-proxy task that is scheduled when some limits are encountered on incoming connections or when the process is stopping. The savings should be noticeable on configs with a large number of proxies. The most important point is that the rate limiting is now enforced in a clean and solid way.
2011-07-25 10:33:49 -04:00
* called as a task which is woken up upon stopping or when rate limiting must
* be enforced.
[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] proxy: finally get rid of maintain_proxies() This function is finally not needed anymore, as it has been replaced with a per-proxy task that is scheduled when some limits are encountered on incoming connections or when the process is stopping. The savings should be noticeable on configs with a large number of proxies. The most important point is that the rate limiting is now enforced in a clean and solid way.
2011-07-25 10:33:49 -04:00
struct task *manage_proxy(struct task *t)
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
{
[MAJOR] proxy: finally get rid of maintain_proxies() This function is finally not needed anymore, as it has been replaced with a per-proxy task that is scheduled when some limits are encountered on incoming connections or when the process is stopping. The savings should be noticeable on configs with a large number of proxies. The most important point is that the rate limiting is now enforced in a clean and solid way.
2011-07-25 10:33:49 -04:00
struct proxy *p = t->context;
int next = TICK_ETERNITY;
[OPTIM] rate-limit: cleaner behaviour on low rates and reduce consumption The rate-limit was applied to the smoothed value which does a special case for frequencies below 2 events per period. This caused irregular limitations when set to 1 session per second. The proper way to handle this is to compute the number of remaining events that can occur without reaching the limit. This is what has been added. It also has the benefit that the frequency calculation is now done once when entering event_accept(), before the accept() loop, and not once per accept() loop anymore, thus saving a few CPU cycles during very high loads. With this fix, rate limits of 1/s are perfectly respected.
2009-03-06 03:18:27 -05:00
unsigned int wait;
[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] proxy: finally get rid of maintain_proxies() This function is finally not needed anymore, as it has been replaced with a per-proxy task that is scheduled when some limits are encountered on incoming connections or when the process is stopping. The savings should be noticeable on configs with a large number of proxies. The most important point is that the rate limiting is now enforced in a clean and solid way.
2011-07-25 10:33:49 -04:00
/* We should periodically try to enable listeners waiting for a
* global resource here.
*/
/* first, let's check if we need to stop the proxy */
if (unlikely(stopping && p->state != PR_STSTOPPED)) {
int t;
t = tick_remain(now_ms, p->stop_time);
if (t == 0) {
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("Proxy %s stopped (FE: %lld conns, BE: %lld conns).\n",
p->id, p->fe_counters.cum_conn, p->be_counters.cum_conn);
[MAJOR] proxy: finally get rid of maintain_proxies() This function is finally not needed anymore, as it has been replaced with a per-proxy task that is scheduled when some limits are encountered on incoming connections or when the process is stopping. The savings should be noticeable on configs with a large number of proxies. The most important point is that the rate limiting is now enforced in a clean and solid way.
2011-07-25 10:33:49 -04:00
send_log(p, LOG_WARNING, "Proxy %s stopped (FE: %lld conns, BE: %lld conns).\n",
p->id, p->fe_counters.cum_conn, p->be_counters.cum_conn);
stop_proxy(p);
/* try to free more memory */
CLEANUP: pools: rename all pool functions and pointers to remove this "2" During the migration to the second version of the pools, the new functions and pool pointers were all called "pool_something2()" and "pool2_something". Now there's no more pool v1 code and it's a real pain to still have to deal with this. Let's clean this up now by removing the "2" everywhere, and by renaming the pool heads "pool_head_something".
2017-11-24 11:34:44 -05:00
pool_gc(NULL);
[MAJOR] proxy: finally get rid of maintain_proxies() This function is finally not needed anymore, as it has been replaced with a per-proxy task that is scheduled when some limits are encountered on incoming connections or when the process is stopping. The savings should be noticeable on configs with a large number of proxies. The most important point is that the rate limiting is now enforced in a clean and solid way.
2011-07-25 10:33:49 -04:00
}
else {
next = tick_first(next, p->stop_time);
}
}
[CLEANUP] proxy: merge maintain_proxies() operation inside a single loop This will help transforming the processing into per-proxy tasks.
2011-07-25 05:54:17 -04:00
MEDIUM: stick-tables: flush old entries upon soft-stop When a process with large stick tables is replaced by a new one and remains present until the last connection finishes, it keeps these data in memory for nothing since they will never be used anymore by incoming connections, except during syncing with the new process. This is especially problematic when dealing with long session protocols such as WebSocket as it becomes possible to stack many processes and eat a lot of memory. So the idea here is to know if a table still needs to be synced or not, and to purge all unused entries once the sync is complete. This means that after a few hundred milliseconds when everything has been synchronized with the new process, only a few entries will remain allocated (only the ones held by sessions during the restart) and all the remaining memory will be freed. Note that we carefully do that only after the grace period is expired so as not to impact a possible proxy that needs to accept a few more connections before leaving. Doing this required to add a sync counter to the stick tables, to know how many peer sync sessions are still in progress in order not to flush the entries until all synchronizations are completed.
2013-09-04 11:54:01 -04:00
/* If the proxy holds a stick table, we need to purge all unused
* entries. These are all the ones in the table with ref_cnt == 0
* and all the ones in the pool used to allocate new entries. Any
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 18:22:06 -04:00
* entry attached to an existing stream waiting for a store will
MEDIUM: stick-tables: flush old entries upon soft-stop When a process with large stick tables is replaced by a new one and remains present until the last connection finishes, it keeps these data in memory for nothing since they will never be used anymore by incoming connections, except during syncing with the new process. This is especially problematic when dealing with long session protocols such as WebSocket as it becomes possible to stack many processes and eat a lot of memory. So the idea here is to know if a table still needs to be synced or not, and to purge all unused entries once the sync is complete. This means that after a few hundred milliseconds when everything has been synchronized with the new process, only a few entries will remain allocated (only the ones held by sessions during the restart) and all the remaining memory will be freed. Note that we carefully do that only after the grace period is expired so as not to impact a possible proxy that needs to accept a few more connections before leaving. Doing this required to add a sync counter to the stick tables, to know how many peer sync sessions are still in progress in order not to flush the entries until all synchronizations are completed.
2013-09-04 11:54:01 -04:00
* be in neither list. Any entry being dumped will have ref_cnt > 0.
* However we protect tables that are being synced to peers.
*/
if (unlikely(stopping && p->state == PR_STSTOPPED && p->table.current)) {
if (!p->table.syncing) {
stktable_trash_oldest(&p->table, p->table.current);
CLEANUP: pools: rename all pool functions and pointers to remove this "2" During the migration to the second version of the pools, the new functions and pool pointers were all called "pool_something2()" and "pool2_something". Now there's no more pool v1 code and it's a real pain to still have to deal with this. Let's clean this up now by removing the "2" everywhere, and by renaming the pool heads "pool_head_something".
2017-11-24 11:34:44 -05:00
pool_gc(NULL);
MEDIUM: stick-tables: flush old entries upon soft-stop When a process with large stick tables is replaced by a new one and remains present until the last connection finishes, it keeps these data in memory for nothing since they will never be used anymore by incoming connections, except during syncing with the new process. This is especially problematic when dealing with long session protocols such as WebSocket as it becomes possible to stack many processes and eat a lot of memory. So the idea here is to know if a table still needs to be synced or not, and to purge all unused entries once the sync is complete. This means that after a few hundred milliseconds when everything has been synchronized with the new process, only a few entries will remain allocated (only the ones held by sessions during the restart) and all the remaining memory will be freed. Note that we carefully do that only after the grace period is expired so as not to impact a possible proxy that needs to accept a few more connections before leaving. Doing this required to add a sync counter to the stick tables, to know how many peer sync sessions are still in progress in order not to flush the entries until all synchronizations are completed.
2013-09-04 11:54:01 -04:00
}
if (p->table.current) {
/* some entries still remain, let's recheck in one second */
next = tick_first(next, tick_add(now_ms, 1000));
}
}
[MAJOR] proxy: finally get rid of maintain_proxies() This function is finally not needed anymore, as it has been replaced with a per-proxy task that is scheduled when some limits are encountered on incoming connections or when the process is stopping. The savings should be noticeable on configs with a large number of proxies. The most important point is that the rate limiting is now enforced in a clean and solid way.
2011-07-25 10:33:49 -04:00
/* the rest below is just for frontends */
if (!(p->cap & PR_CAP_FE))
goto out;
[MEDIUM] listeners: don't change listeners states anymore in maintain_proxies Now maintain_proxies() only changes proxies states and does not affect their listeners anymore since they are autonomous. A proxy will switch between the PR_STIDLE and PR_STRUN states depending whether it's saturated or not. Next step will consist in renaming PR_STIDLE to PR_STFULL. This state is now only used to report the proxy state in the stats.
2011-07-25 01:37:28 -04:00
[MAJOR] proxy: finally get rid of maintain_proxies() This function is finally not needed anymore, as it has been replaced with a per-proxy task that is scheduled when some limits are encountered on incoming connections or when the process is stopping. The savings should be noticeable on configs with a large number of proxies. The most important point is that the rate limiting is now enforced in a clean and solid way.
2011-07-25 10:33:49 -04:00
/* check the various reasons we may find to block the frontend */
if (unlikely(p->feconn >= p->maxconn)) {
if (p->state == PR_STREADY)
p->state = PR_STFULL;
goto out;
}
[MEDIUM] listeners: don't change listeners states anymore in maintain_proxies Now maintain_proxies() only changes proxies states and does not affect their listeners anymore since they are autonomous. A proxy will switch between the PR_STIDLE and PR_STRUN states depending whether it's saturated or not. Next step will consist in renaming PR_STIDLE to PR_STFULL. This state is now only used to report the proxy state in the stats.
2011-07-25 01:37:28 -04:00
[MAJOR] proxy: finally get rid of maintain_proxies() This function is finally not needed anymore, as it has been replaced with a per-proxy task that is scheduled when some limits are encountered on incoming connections or when the process is stopping. The savings should be noticeable on configs with a large number of proxies. The most important point is that the rate limiting is now enforced in a clean and solid way.
2011-07-25 10:33:49 -04:00
/* OK we have no reason to block, so let's unblock if we were blocking */
if (p->state == PR_STFULL)
p->state = PR_STREADY;
[MEDIUM] implement "rate-limit sessions" for the frontend The new "rate-limit sessions" statement sets a limit on the number of new connections per second on the frontend. As it is extremely accurate (about 0.1%), it is efficient at limiting resource abuse or DoS.
2009-03-05 17:48:25 -05:00
[MAJOR] proxy: finally get rid of maintain_proxies() This function is finally not needed anymore, as it has been replaced with a per-proxy task that is scheduled when some limits are encountered on incoming connections or when the process is stopping. The savings should be noticeable on configs with a large number of proxies. The most important point is that the rate limiting is now enforced in a clean and solid way.
2011-07-25 10:33:49 -04:00
if (p->fe_sps_lim &&
(wait = next_event_delay(&p->fe_sess_per_sec, p->fe_sps_lim, 0))) {
/* we're blocking because a limit was reached on the number of
* requests/s on the frontend. We want to re-check ASAP, which
* means in 1 ms before estimated expiration date, because the
* timer will have settled down.
*/
next = tick_first(next, tick_add(now_ms, wait));
goto out;
[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] proxy: finally get rid of maintain_proxies() This function is finally not needed anymore, as it has been replaced with a per-proxy task that is scheduled when some limits are encountered on incoming connections or when the process is stopping. The savings should be noticeable on configs with a large number of proxies. The most important point is that the rate limiting is now enforced in a clean and solid way.
2011-07-25 10:33:49 -04:00
/* The proxy is not limited so we can re-enable any waiting listener */
if (!LIST_ISEMPTY(&p->listener_queue))
dequeue_all_listeners(&p->listener_queue);
out:
t->expire = next;
task_queue(t);
return t;
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
}
MEDIUM: global: add a 'hard-stop-after' option to cap the soft-stop time When SIGUSR1 is received, haproxy enters in soft-stop and quits when no connection remains. It can happen that the instance remains alive for a long time, depending on timeouts and traffic. This option ensures that soft-stop won't run for too long. Example: global hard-stop-after 30s # Once in soft-stop, the instance will remain # alive for at most 30 seconds.
2017-03-23 17:44:13 -04:00
static int proxy_parse_hard_stop_after(char **args, int section_type, struct proxy *curpx,
struct proxy *defpx, const char *file, int line,
char **err)
{
const char *res;
if (!*args[1]) {
memprintf(err, "'%s' expects <time> as argument.\n", args[0]);
return -1;
}
res = parse_time_err(args[1], &global.hard_stop_after, TIME_UNIT_MS);
if (res) {
memprintf(err, "unexpected character '%c' in argument to <%s>.\n", *res, args[0]);
return -1;
}
return 0;
}
struct task *hard_stop(struct task *t)
{
struct proxy *p;
struct stream *s;
if (killed) {
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("Some tasks resisted to hard-stop, exiting now.\n");
MEDIUM: global: add a 'hard-stop-after' option to cap the soft-stop time When SIGUSR1 is received, haproxy enters in soft-stop and quits when no connection remains. It can happen that the instance remains alive for a long time, depending on timeouts and traffic. This option ensures that soft-stop won't run for too long. Example: global hard-stop-after 30s # Once in soft-stop, the instance will remain # alive for at most 30 seconds.
2017-03-23 17:44:13 -04:00
send_log(NULL, LOG_WARNING, "Some tasks resisted to hard-stop, exiting now.\n");
/* Do some cleanup and explicitely quit */
deinit();
exit(0);
}
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("soft-stop running for too long, performing a hard-stop.\n");
MEDIUM: global: add a 'hard-stop-after' option to cap the soft-stop time When SIGUSR1 is received, haproxy enters in soft-stop and quits when no connection remains. It can happen that the instance remains alive for a long time, depending on timeouts and traffic. This option ensures that soft-stop won't run for too long. Example: global hard-stop-after 30s # Once in soft-stop, the instance will remain # alive for at most 30 seconds.
2017-03-23 17:44:13 -04:00
send_log(NULL, LOG_WARNING, "soft-stop running for too long, performing a hard-stop.\n");
MINOR/CLEANUP: proxy: rename "proxy" to "proxies_list" Rename the global variable "proxy" to "proxies_list". There's been multiple proxies in haproxy for quite some time, and "proxy" is a potential source of bugs, a number of functions have a "proxy" argument, and some code used "proxy" when it really meant "px" or "curproxy". It worked by pure luck, because it usually happened while parsing the config, and thus "proxy" pointed to the currently parsed proxy, but we should probably not rely on this. [wt: some of these are definitely fixes that are worth backporting]
2017-11-24 10:54:05 -05:00
p = proxies_list;
MEDIUM: global: add a 'hard-stop-after' option to cap the soft-stop time When SIGUSR1 is received, haproxy enters in soft-stop and quits when no connection remains. It can happen that the instance remains alive for a long time, depending on timeouts and traffic. This option ensures that soft-stop won't run for too long. Example: global hard-stop-after 30s # Once in soft-stop, the instance will remain # alive for at most 30 seconds.
2017-03-23 17:44:13 -04:00
while (p) {
if ((p->cap & PR_CAP_FE) && (p->feconn > 0)) {
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("Proxy %s hard-stopped (%d remaining conns will be closed).\n",
p->id, p->feconn);
MEDIUM: global: add a 'hard-stop-after' option to cap the soft-stop time When SIGUSR1 is received, haproxy enters in soft-stop and quits when no connection remains. It can happen that the instance remains alive for a long time, depending on timeouts and traffic. This option ensures that soft-stop won't run for too long. Example: global hard-stop-after 30s # Once in soft-stop, the instance will remain # alive for at most 30 seconds.
2017-03-23 17:44:13 -04:00
send_log(p, LOG_WARNING, "Proxy %s hard-stopped (%d remaining conns will be closed).\n",
p->id, p->feconn);
}
p = p->next;
}
list_for_each_entry(s, &streams, list) {
stream_shutdown(s, SF_ERR_KILLED);
}
killed = 1;
t->expire = tick_add(now_ms, MS_TO_TICKS(1000));
return t;
}
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
/*
* this function disables health-check servers so that the process will quickly be ignored
* by load balancers. Note that if a proxy was already in the PAUSED state, then its grace
* time will not be used since it would already not listen anymore to the socket.
*/
void soft_stop(void)
{
struct proxy *p;
[BUG] proxy: peers must only be stopped once, not upon every call to maintain_proxies Peers were stopped on every call to maintain_proxies when stopping=1, while they should only be stopped once upon call to soft_stop(). This bug has little impact, mostly increased CPU usage. It's not needed to backport it.
2011-07-25 05:16:24 -04:00
struct peers *prs;
MEDIUM: global: add a 'hard-stop-after' option to cap the soft-stop time When SIGUSR1 is received, haproxy enters in soft-stop and quits when no connection remains. It can happen that the instance remains alive for a long time, depending on timeouts and traffic. This option ensures that soft-stop won't run for too long. Example: global hard-stop-after 30s # Once in soft-stop, the instance will remain # alive for at most 30 seconds.
2017-03-23 17:44:13 -04:00
struct task *task;
[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
stopping = 1;
MEDIUM: global: add a 'hard-stop-after' option to cap the soft-stop time When SIGUSR1 is received, haproxy enters in soft-stop and quits when no connection remains. It can happen that the instance remains alive for a long time, depending on timeouts and traffic. This option ensures that soft-stop won't run for too long. Example: global hard-stop-after 30s # Once in soft-stop, the instance will remain # alive for at most 30 seconds.
2017-03-23 17:44:13 -04:00
if (tick_isset(global.hard_stop_after)) {
MAJOR: threads/task: handle multithread on task scheduler 2 global locks have been added to protect, respectively, the run queue and the wait queue. And a process mask has been added on each task. Like for FDs, this mask is used to know which threads are allowed to process a task. For many tasks, all threads are granted. And this must be your first intension when you create a new task, else you have a good reason to make a task sticky on some threads. This is then the responsibility to the process callback to lock what have to be locked in the task context. Nevertheless, all tasks linked to a session must be sticky on the thread creating the session. It is important that I/O handlers processing session FDs and these tasks run on the same thread to avoid conflicts.
2017-09-27 08:59:38 -04:00
task = task_new(MAX_THREADS_MASK);
MEDIUM: global: add a 'hard-stop-after' option to cap the soft-stop time When SIGUSR1 is received, haproxy enters in soft-stop and quits when no connection remains. It can happen that the instance remains alive for a long time, depending on timeouts and traffic. This option ensures that soft-stop won't run for too long. Example: global hard-stop-after 30s # Once in soft-stop, the instance will remain # alive for at most 30 seconds.
2017-03-23 17:44:13 -04:00
if (task) {
task->process = hard_stop;
task_schedule(task, tick_add(now_ms, global.hard_stop_after));
}
else {
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_alert("out of memory trying to allocate the hard-stop task.\n");
MEDIUM: global: add a 'hard-stop-after' option to cap the soft-stop time When SIGUSR1 is received, haproxy enters in soft-stop and quits when no connection remains. It can happen that the instance remains alive for a long time, depending on timeouts and traffic. This option ensures that soft-stop won't run for too long. Example: global hard-stop-after 30s # Once in soft-stop, the instance will remain # alive for at most 30 seconds.
2017-03-23 17:44:13 -04:00
}
}
MINOR/CLEANUP: proxy: rename "proxy" to "proxies_list" Rename the global variable "proxy" to "proxies_list". There's been multiple proxies in haproxy for quite some time, and "proxy" is a potential source of bugs, a number of functions have a "proxy" argument, and some code used "proxy" when it really meant "px" or "curproxy". It worked by pure luck, because it usually happened while parsing the config, and thus "proxy" pointed to the currently parsed proxy, but we should probably not rely on this. [wt: some of these are definitely fixes that are worth backporting]
2017-11-24 10:54:05 -05:00
p = proxies_list;
[MEDIUM] further improve monotonic clock by check forward jumps The first implementation of the monotonic clock did not verify forward jumps. The consequence is that a fast changing time may expire a lot of tasks. While it does seem minor, in fact it is problematic because most machines which boot with a wrong date are in the past and suddenly see their time jump by several years in the future. The solution is to check if we spent more apparent time in a poller than allowed (with a margin applied). The margin is currently set to 1000 ms. It should be large enough for any poll() to complete. Tests with randomly jumping clock show that the result is quite accurate (error less than 1 second at every change of more than one second).
2008-06-23 08:00:57 -04:00
tv_update_date(0,1); /* else, the old time before select will be used */
[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
while (p) {
MINOR: proxy: Don't close FDs if not our proxy. When running with multiple process, if some proxies are just assigned to some processes, the other processes will just close the file descriptors for the listening sockets. However, we may still have to provide those sockets when reloading, so instead we just try hard to pretend those proxies are dead, while keeping the sockets opened. A new global option, no-reused-socket", has been added, to restore the old behavior of closing the sockets not bound to this process.
2017-04-05 19:05:05 -04:00
/* Zombie proxy, let's close the file descriptors */
if (p->state == PR_STSTOPPED &&
!LIST_ISEMPTY(&p->conf.listeners) &&
LIST_ELEM(p->conf.listeners.n,
struct listener *, by_fe)->state >= LI_ZOMBIE) {
struct listener *l;
list_for_each_entry(l, &p->conf.listeners, by_fe) {
if (l->state >= LI_ZOMBIE)
close(l->fd);
l->state = LI_INIT;
}
}
[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
if (p->state != PR_STSTOPPED) {
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("Stopping %s %s in %d ms.\n", proxy_cap_str(p->cap), p->id, p->grace);
[BUG] do not try to pause backends during reload During a configuration reload, haproxy tried to pause all proxies. Unfortunately, it also tried to pause backends, which would fail and cause trouble to the new process since the port was still bound. (backported from commit eab5c70f93c0a44223f706f6c120ad8d59f28796) (cherry picked from commit ac1ca38e9b07422e21b5b4778918d243768e5498)
2008-10-10 11:51:34 -04:00
send_log(p, LOG_WARNING, "Stopping %s %s in %d ms.\n", proxy_cap_str(p->cap), p->id, p->grace);
[MAJOR] convert all expiration timers from timeval to ticks This is the first attempt at moving all internal parts from using struct timeval to integer ticks. Those provides simpler and faster code due to simplified operations, and this change also saved about 64 bytes per session. A new header file has been added : include/common/ticks.h. It is possible that some functions should finally not be inlined because they're used quite a lot (eg: tick_first, tick_add_ifset and tick_is_expired). More measurements are required in order to decide whether this is interesting or not. Some function and variable names are still subject to change for a better overall logics.
2008-07-06 18:09:58 -04:00
p->stop_time = tick_add(now_ms, p->grace);
[MEDIUM] Manage soft stop on peers proxy
2010-09-23 12:44:36 -04:00
BUG/MEDIUM: proxy: do not wake stopped proxies' tasks during soft_stop() When performing a soft stop, we used to wake up every proxy's task and each of their table's task. The problem is that since we're able to stop proxies and peers not bound to a specific process, we may end up calling random junk by doing so of the proxy we're waking up is already stopped. This causes a segfault to appear during soft reloads for old processes not bound to a peers section if such a section exists in other processes. Let's only consider proxies that are not stopped when doing this. This fix must be backported to 1.5 which also has the same issue.
2015-09-28 10:35:04 -04:00
/* Note: do not wake up stopped proxies' task nor their tables'
* tasks as these ones might point to already released entries.
*/
if (p->table.size && p->table.sync_task)
task_wakeup(p->table.sync_task, TASK_WOKEN_MSG);
if (p->task)
task_wakeup(p->task, TASK_WOKEN_MSG);
}
[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
p = p->next;
}
[BUG] proxy: peers must only be stopped once, not upon every call to maintain_proxies Peers were stopped on every call to maintain_proxies when stopping=1, while they should only be stopped once upon call to soft_stop(). This bug has little impact, mostly increased CPU usage. It's not needed to backport it.
2011-07-25 05:16:24 -04:00
BUG/MINOR: peers: peer synchronization issue (with several peers sections). When several stick-tables were configured with several peers sections, only a part of them could be synchronized: the ones attached to the last parsed 'peers' section. This was due to the fact that, at least, the peer I/O handler refered to the wrong peer section list, in fact always the same: the last one parsed. The fact that the global peer section list was named "struct peers *peers" lead to this issue. This variable name is dangerous ;). So this patch renames global 'peers' variable to 'cfg_peers' to ensure that no such wrong references are still in use, then all the functions wich used old 'peers' variable have been modified to refer to the correct peer list. Must be backported to 1.6 and 1.7.
2017-07-13 03:07:09 -04:00
prs = cfg_peers;
[BUG] proxy: peers must only be stopped once, not upon every call to maintain_proxies Peers were stopped on every call to maintain_proxies when stopping=1, while they should only be stopped once upon call to soft_stop(). This bug has little impact, mostly increased CPU usage. It's not needed to backport it.
2011-07-25 05:16:24 -04:00
while (prs) {
BUG/MEDIUM: proxy: ignore stopped peers Since commit f83d3fe ("MEDIUM: init: stop any peers section not bound to the correct process"), it is possible to stop unused peers on certain processes. The problem is that the pause/resume/stop functions are not aware of this and will pass a NULL proxy pointer to the respective functions, resulting in segfaults in unbound processes during soft restarts. Properly check that the peers' frontend is still valid before calling them. This bug also affects 1.5 so the fix must be backported. Note that this fix is not enough to completely get rid of the segfault, the next one is needed as well.
2015-09-28 10:27:44 -04:00
if (prs->peers_fe)
stop_proxy(prs->peers_fe);
[BUG] proxy: peers must only be stopped once, not upon every call to maintain_proxies Peers were stopped on every call to maintain_proxies when stopping=1, while they should only be stopped once upon call to soft_stop(). This bug has little impact, mostly increased CPU usage. It's not needed to backport it.
2011-07-25 05:16:24 -04:00
prs = prs->next;
}
[MEDIUM] signals: support redistribution of signal zero when stopping Signal zero is never delivered by the system. However having a signal to which functions and tasks can subscribe to be notified of a stopping event is useful. So this patch does two things : 1) allow signal zero to be delivered from any function of signal handler 2) make soft_stop() deliver this signal so that tasks can be notified of a stopping condition.
2010-08-27 12:26:11 -04:00
/* signal zero is used to broadcast the "stopping" event */
signal_handler(0);
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
}
[MEDIUM] proxy: add a PAUSED state to listeners and move socket tricks out of proxy.c Managing listeners state is difficult because they have their own state and can at the same time have theirs dictated by their proxy. The pause is not done properly, as the proxy code is fiddling with sockets. By introducing new functions such as pause_listener()/resume_listener(), we make it a bit more obvious how/when they're supposed to be used. The listen_proxies() function was also renamed to resume_proxies() since it's only used for pause/resume. This patch is the first in a series aiming at getting rid of the maintain_proxies mess. In the end, proxies should not call enable_listener()/disable_listener() anymore.
2011-07-24 12:28:10 -04:00
/* Temporarily disables listening on all of the proxy's listeners. Upon
* success, the proxy enters the PR_PAUSED state. If disabling at least one
* listener returns an error, then the proxy state is set to PR_STERROR
[CLEANUP] proxy: make pause_proxy() perform the required controls and emit the logs It avoids duplicated code in the caller.
2011-09-07 13:14:57 -04:00
* because we don't know how to resume from this. The function returns 0
* if it fails, or non-zero on success.
[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
*/
[CLEANUP] proxy: make pause_proxy() perform the required controls and emit the logs It avoids duplicated code in the caller.
2011-09-07 13:14:57 -04:00
int pause_proxy(struct proxy *p)
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
{
struct listener *l;
[CLEANUP] proxy: make pause_proxy() perform the required controls and emit the logs It avoids duplicated code in the caller.
2011-09-07 13:14:57 -04:00
if (!(p->cap & PR_CAP_FE) || p->state == PR_STERROR ||
p->state == PR_STSTOPPED || p->state == PR_STPAUSED)
return 1;
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("Pausing %s %s.\n", proxy_cap_str(p->cap), p->id);
[CLEANUP] proxy: make pause_proxy() perform the required controls and emit the logs It avoids duplicated code in the caller.
2011-09-07 13:14:57 -04:00
send_log(p, LOG_WARNING, "Pausing %s %s.\n", proxy_cap_str(p->cap), p->id);
MAJOR: listeners: use dual-linked lists to chain listeners with frontends Navigating through listeners was very inconvenient and error-prone. Not to mention that listeners were linked in reverse order and reverted afterwards. In order to definitely get rid of these issues, we now do the following : - frontends have a dual-linked list of bind_conf - frontends have a dual-linked list of listeners - bind_conf have a dual-linked list of listeners - listeners have a pointer to their bind_conf This way we can now navigate from anywhere to anywhere and always find the proper bind_conf for a given listener, as well as find the list of listeners for a current bind_conf.
2012-09-20 10:48:07 -04:00
list_for_each_entry(l, &p->conf.listeners, by_fe) {
[MEDIUM] proxy: add a PAUSED state to listeners and move socket tricks out of proxy.c Managing listeners state is difficult because they have their own state and can at the same time have theirs dictated by their proxy. The pause is not done properly, as the proxy code is fiddling with sockets. By introducing new functions such as pause_listener()/resume_listener(), we make it a bit more obvious how/when they're supposed to be used. The listen_proxies() function was also renamed to resume_proxies() since it's only used for pause/resume. This patch is the first in a series aiming at getting rid of the maintain_proxies mess. In the end, proxies should not call enable_listener()/disable_listener() anymore.
2011-07-24 12:28:10 -04:00
if (!pause_listener(l))
[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
p->state = PR_STERROR;
}
[CLEANUP] proxy: make pause_proxy() perform the required controls and emit the logs It avoids duplicated code in the caller.
2011-09-07 13:14:57 -04:00
if (p->state == PR_STERROR) {
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("%s %s failed to enter pause mode.\n", proxy_cap_str(p->cap), p->id);
[CLEANUP] proxy: make pause_proxy() perform the required controls and emit the logs It avoids duplicated code in the caller.
2011-09-07 13:14:57 -04:00
send_log(p, LOG_WARNING, "%s %s failed to enter pause mode.\n", proxy_cap_str(p->cap), p->id);
return 0;
}
p->state = PR_STPAUSED;
return 1;
[BUG] ensure that listeners from disabled proxies are correctly unbound. There is a problem when an instance is marked "disabled". Its ports are still bound but will not be unbound upon termination. This causes processes to accumulate during soft restarts, and might even cause failures to restart new ones due to the inability to bind to the same port. The ideal solution would be to bind all ports at the end of the configuration parsing. An acceptable workaround is to unbind all listeners of disabled proxies. This is what the current patch does. (cherry picked from commit a944218e9c1d5ff1aca34609146389dc680335b7) (cherry picked from commit 8cfebbb82b87345bade831920177077e7d25840a)
2008-10-12 06:07:48 -04:00
}
MINOR: proxy: Don't close FDs if not our proxy. When running with multiple process, if some proxies are just assigned to some processes, the other processes will just close the file descriptors for the listening sockets. However, we may still have to provide those sockets when reloading, so instead we just try hard to pretend those proxies are dead, while keeping the sockets opened. A new global option, no-reused-socket", has been added, to restore the old behavior of closing the sockets not bound to this process.
2017-04-05 19:05:05 -04:00
/* This function makes the proxy unusable, but keeps the listening sockets
* opened, so that if any process requests them, we are able to serve them.
* This should only be called early, before we started accepting requests.
*/
void zombify_proxy(struct proxy *p)
{
struct listener *l;
struct listener *first_to_listen = NULL;
list_for_each_entry(l, &p->conf.listeners, by_fe) {
enum li_state oldstate = l->state;
unbind_listener_no_close(l);
if (l->state >= LI_ASSIGNED) {
delete_listener(l);
}
/*
* Pretend we're still up and running so that the fd
* will be sent if asked.
*/
l->state = LI_ZOMBIE;
if (!first_to_listen && oldstate >= LI_LISTEN)
first_to_listen = l;
}
/* Quick hack : at stop time, to know we have to close the sockets
* despite the proxy being marked as stopped, make the first listener
* of the listener list an active one, so that we don't have to
* parse the whole list to be sure.
*/
if (first_to_listen && LIST_ELEM(p->conf.listeners.n,
struct listener *, by_fe) != first_to_listen) {
LIST_DEL(&l->by_fe);
LIST_ADD(&p->conf.listeners, &l->by_fe);
}
p->state = PR_STSTOPPED;
}
[BUG] ensure that listeners from disabled proxies are correctly unbound. There is a problem when an instance is marked "disabled". Its ports are still bound but will not be unbound upon termination. This causes processes to accumulate during soft restarts, and might even cause failures to restart new ones due to the inability to bind to the same port. The ideal solution would be to bind all ports at the end of the configuration parsing. An acceptable workaround is to unbind all listeners of disabled proxies. This is what the current patch does. (cherry picked from commit a944218e9c1d5ff1aca34609146389dc680335b7) (cherry picked from commit 8cfebbb82b87345bade831920177077e7d25840a)
2008-10-12 06:07:48 -04:00
/*
* This function completely stops a proxy and releases its listeners. It has
* to be called when going down in order to release the ports so that another
* process may bind to them. It must also be called on disabled proxies at the
* end of start-up. When all listeners are closed, the proxy is set to the
* PR_STSTOPPED state.
*/
void stop_proxy(struct proxy *p)
{
struct listener *l;
MAJOR: listeners: use dual-linked lists to chain listeners with frontends Navigating through listeners was very inconvenient and error-prone. Not to mention that listeners were linked in reverse order and reverted afterwards. In order to definitely get rid of these issues, we now do the following : - frontends have a dual-linked list of bind_conf - frontends have a dual-linked list of listeners - bind_conf have a dual-linked list of listeners - listeners have a pointer to their bind_conf This way we can now navigate from anywhere to anywhere and always find the proper bind_conf for a given listener, as well as find the list of listeners for a current bind_conf.
2012-09-20 10:48:07 -04:00
list_for_each_entry(l, &p->conf.listeners, by_fe) {
[BUG] ensure that listeners from disabled proxies are correctly unbound. There is a problem when an instance is marked "disabled". Its ports are still bound but will not be unbound upon termination. This causes processes to accumulate during soft restarts, and might even cause failures to restart new ones due to the inability to bind to the same port. The ideal solution would be to bind all ports at the end of the configuration parsing. An acceptable workaround is to unbind all listeners of disabled proxies. This is what the current patch does. (cherry picked from commit a944218e9c1d5ff1aca34609146389dc680335b7) (cherry picked from commit 8cfebbb82b87345bade831920177077e7d25840a)
2008-10-12 06:07:48 -04:00
unbind_listener(l);
if (l->state >= LI_ASSIGNED) {
delete_listener(l);
}
}
p->state = PR_STSTOPPED;
[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
}
[BUG] peers: ensure the peers are resumed if they were paused Upon an incoming soft restart request, we first pause all frontends and peers. If the caller changes its mind and asks us to resume (eg: failed binding), we must resume all the frontends and peers. Unfortunately the peers were not resumed. The code was arranged to avoid code duplication (which used to hide the issue till now).
2011-09-07 15:33:14 -04:00
/* This function resumes listening on the specified proxy. It scans all of its
* listeners and tries to enable them all. If any of them fails, the proxy is
* put back to the paused state. It returns 1 upon success, or zero if an error
* is encountered.
*/
int resume_proxy(struct proxy *p)
{
struct listener *l;
int fail;
if (p->state != PR_STPAUSED)
return 1;
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("Enabling %s %s.\n", proxy_cap_str(p->cap), p->id);
[BUG] peers: ensure the peers are resumed if they were paused Upon an incoming soft restart request, we first pause all frontends and peers. If the caller changes its mind and asks us to resume (eg: failed binding), we must resume all the frontends and peers. Unfortunately the peers were not resumed. The code was arranged to avoid code duplication (which used to hide the issue till now).
2011-09-07 15:33:14 -04:00
send_log(p, LOG_WARNING, "Enabling %s %s.\n", proxy_cap_str(p->cap), p->id);
fail = 0;
MAJOR: listeners: use dual-linked lists to chain listeners with frontends Navigating through listeners was very inconvenient and error-prone. Not to mention that listeners were linked in reverse order and reverted afterwards. In order to definitely get rid of these issues, we now do the following : - frontends have a dual-linked list of bind_conf - frontends have a dual-linked list of listeners - bind_conf have a dual-linked list of listeners - listeners have a pointer to their bind_conf This way we can now navigate from anywhere to anywhere and always find the proper bind_conf for a given listener, as well as find the list of listeners for a current bind_conf.
2012-09-20 10:48:07 -04:00
list_for_each_entry(l, &p->conf.listeners, by_fe) {
[BUG] peers: ensure the peers are resumed if they were paused Upon an incoming soft restart request, we first pause all frontends and peers. If the caller changes its mind and asks us to resume (eg: failed binding), we must resume all the frontends and peers. Unfortunately the peers were not resumed. The code was arranged to avoid code duplication (which used to hide the issue till now).
2011-09-07 15:33:14 -04:00
if (!resume_listener(l)) {
int port;
port = get_host_port(&l->addr);
if (port) {
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("Port %d busy while trying to enable %s %s.\n",
port, proxy_cap_str(p->cap), p->id);
[BUG] peers: ensure the peers are resumed if they were paused Upon an incoming soft restart request, we first pause all frontends and peers. If the caller changes its mind and asks us to resume (eg: failed binding), we must resume all the frontends and peers. Unfortunately the peers were not resumed. The code was arranged to avoid code duplication (which used to hide the issue till now).
2011-09-07 15:33:14 -04:00
send_log(p, LOG_WARNING, "Port %d busy while trying to enable %s %s.\n",
port, proxy_cap_str(p->cap), p->id);
}
else {
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("Bind on socket %d busy while trying to enable %s %s.\n",
l->luid, proxy_cap_str(p->cap), p->id);
[BUG] peers: ensure the peers are resumed if they were paused Upon an incoming soft restart request, we first pause all frontends and peers. If the caller changes its mind and asks us to resume (eg: failed binding), we must resume all the frontends and peers. Unfortunately the peers were not resumed. The code was arranged to avoid code duplication (which used to hide the issue till now).
2011-09-07 15:33:14 -04:00
send_log(p, LOG_WARNING, "Bind on socket %d busy while trying to enable %s %s.\n",
l->luid, proxy_cap_str(p->cap), p->id);
}
/* Another port might have been enabled. Let's stop everything. */
fail = 1;
break;
}
}
p->state = PR_STREADY;
if (fail) {
pause_proxy(p);
return 0;
}
return 1;
}
[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
/*
* This function temporarily disables listening so that another new instance
* can start listening. It is designed to be called upon reception of a
* SIGTTOU, after which either a SIGUSR1 can be sent to completely stop
* the proxy, or a SIGTTIN can be sent to listen again.
*/
void pause_proxies(void)
{
int err;
struct proxy *p;
[MEDIUM] Manage soft stop on peers proxy
2010-09-23 12:44:36 -04:00
struct peers *prs;
[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
err = 0;
MINOR/CLEANUP: proxy: rename "proxy" to "proxies_list" Rename the global variable "proxy" to "proxies_list". There's been multiple proxies in haproxy for quite some time, and "proxy" is a potential source of bugs, a number of functions have a "proxy" argument, and some code used "proxy" when it really meant "px" or "curproxy". It worked by pure luck, because it usually happened while parsing the config, and thus "proxy" pointed to the currently parsed proxy, but we should probably not rely on this. [wt: some of these are definitely fixes that are worth backporting]
2017-11-24 10:54:05 -05:00
p = proxies_list;
[MEDIUM] further improve monotonic clock by check forward jumps The first implementation of the monotonic clock did not verify forward jumps. The consequence is that a fast changing time may expire a lot of tasks. While it does seem minor, in fact it is problematic because most machines which boot with a wrong date are in the past and suddenly see their time jump by several years in the future. The solution is to check if we spent more apparent time in a poller than allowed (with a margin applied). The margin is currently set to 1000 ms. It should be large enough for any poll() to complete. Tests with randomly jumping clock show that the result is quite accurate (error less than 1 second at every change of more than one second).
2008-06-23 08:00:57 -04:00
tv_update_date(0,1); /* else, the old time before select will be used */
[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
while (p) {
[CLEANUP] proxy: make pause_proxy() perform the required controls and emit the logs It avoids duplicated code in the caller.
2011-09-07 13:14:57 -04:00
err |= !pause_proxy(p);
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
p = p->next;
}
[MEDIUM] Manage soft stop on peers proxy
2010-09-23 12:44:36 -04:00
BUG/MINOR: peers: peer synchronization issue (with several peers sections). When several stick-tables were configured with several peers sections, only a part of them could be synchronized: the ones attached to the last parsed 'peers' section. This was due to the fact that, at least, the peer I/O handler refered to the wrong peer section list, in fact always the same: the last one parsed. The fact that the global peer section list was named "struct peers *peers" lead to this issue. This variable name is dangerous ;). So this patch renames global 'peers' variable to 'cfg_peers' to ensure that no such wrong references are still in use, then all the functions wich used old 'peers' variable have been modified to refer to the correct peer list. Must be backported to 1.6 and 1.7.
2017-07-13 03:07:09 -04:00
prs = cfg_peers;
[MEDIUM] Manage soft stop on peers proxy
2010-09-23 12:44:36 -04:00
while (prs) {
BUG/MEDIUM: proxy: ignore stopped peers Since commit f83d3fe ("MEDIUM: init: stop any peers section not bound to the correct process"), it is possible to stop unused peers on certain processes. The problem is that the pause/resume/stop functions are not aware of this and will pass a NULL proxy pointer to the respective functions, resulting in segfaults in unbound processes during soft restarts. Properly check that the peers' frontend is still valid before calling them. This bug also affects 1.5 so the fix must be backported. Note that this fix is not enough to completely get rid of the segfault, the next one is needed as well.
2015-09-28 10:27:44 -04:00
if (prs->peers_fe)
err |= !pause_proxy(prs->peers_fe);
[CLEANUP] proxy: make pause_proxy() perform the required controls and emit the logs It avoids duplicated code in the caller.
2011-09-07 13:14:57 -04:00
prs = prs->next;
[MEDIUM] Manage soft stop on peers proxy
2010-09-23 12:44:36 -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
if (err) {
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("Some proxies refused to pause, performing soft stop now.\n");
[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
send_log(p, LOG_WARNING, "Some proxies refused to pause, performing soft stop now.\n");
soft_stop();
}
}
/*
* This function reactivates listening. This can be used after a call to
* sig_pause(), for example when a new instance has failed starting up.
* It is designed to be called upon reception of a SIGTTIN.
*/
[MEDIUM] proxy: add a PAUSED state to listeners and move socket tricks out of proxy.c Managing listeners state is difficult because they have their own state and can at the same time have theirs dictated by their proxy. The pause is not done properly, as the proxy code is fiddling with sockets. By introducing new functions such as pause_listener()/resume_listener(), we make it a bit more obvious how/when they're supposed to be used. The listen_proxies() function was also renamed to resume_proxies() since it's only used for pause/resume. This patch is the first in a series aiming at getting rid of the maintain_proxies mess. In the end, proxies should not call enable_listener()/disable_listener() anymore.
2011-07-24 12:28:10 -04:00
void resume_proxies(void)
[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
{
[BUG] peers: ensure the peers are resumed if they were paused Upon an incoming soft restart request, we first pause all frontends and peers. If the caller changes its mind and asks us to resume (eg: failed binding), we must resume all the frontends and peers. Unfortunately the peers were not resumed. The code was arranged to avoid code duplication (which used to hide the issue till now).
2011-09-07 15:33:14 -04:00
int err;
[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
struct proxy *p;
[BUG] peers: ensure the peers are resumed if they were paused Upon an incoming soft restart request, we first pause all frontends and peers. If the caller changes its mind and asks us to resume (eg: failed binding), we must resume all the frontends and peers. Unfortunately the peers were not resumed. The code was arranged to avoid code duplication (which used to hide the issue till now).
2011-09-07 15:33:14 -04:00
struct peers *prs;
[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
[BUG] peers: ensure the peers are resumed if they were paused Upon an incoming soft restart request, we first pause all frontends and peers. If the caller changes its mind and asks us to resume (eg: failed binding), we must resume all the frontends and peers. Unfortunately the peers were not resumed. The code was arranged to avoid code duplication (which used to hide the issue till now).
2011-09-07 15:33:14 -04:00
err = 0;
MINOR/CLEANUP: proxy: rename "proxy" to "proxies_list" Rename the global variable "proxy" to "proxies_list". There's been multiple proxies in haproxy for quite some time, and "proxy" is a potential source of bugs, a number of functions have a "proxy" argument, and some code used "proxy" when it really meant "px" or "curproxy". It worked by pure luck, because it usually happened while parsing the config, and thus "proxy" pointed to the currently parsed proxy, but we should probably not rely on this. [wt: some of these are definitely fixes that are worth backporting]
2017-11-24 10:54:05 -05:00
p = proxies_list;
[MEDIUM] further improve monotonic clock by check forward jumps The first implementation of the monotonic clock did not verify forward jumps. The consequence is that a fast changing time may expire a lot of tasks. While it does seem minor, in fact it is problematic because most machines which boot with a wrong date are in the past and suddenly see their time jump by several years in the future. The solution is to check if we spent more apparent time in a poller than allowed (with a margin applied). The margin is currently set to 1000 ms. It should be large enough for any poll() to complete. Tests with randomly jumping clock show that the result is quite accurate (error less than 1 second at every change of more than one second).
2008-06-23 08:00:57 -04:00
tv_update_date(0,1); /* else, the old time before select will be used */
[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
while (p) {
[BUG] peers: ensure the peers are resumed if they were paused Upon an incoming soft restart request, we first pause all frontends and peers. If the caller changes its mind and asks us to resume (eg: failed binding), we must resume all the frontends and peers. Unfortunately the peers were not resumed. The code was arranged to avoid code duplication (which used to hide the issue till now).
2011-09-07 15:33:14 -04:00
err |= !resume_proxy(p);
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
p = p->next;
}
[BUG] peers: ensure the peers are resumed if they were paused Upon an incoming soft restart request, we first pause all frontends and peers. If the caller changes its mind and asks us to resume (eg: failed binding), we must resume all the frontends and peers. Unfortunately the peers were not resumed. The code was arranged to avoid code duplication (which used to hide the issue till now).
2011-09-07 15:33:14 -04:00
BUG/MINOR: peers: peer synchronization issue (with several peers sections). When several stick-tables were configured with several peers sections, only a part of them could be synchronized: the ones attached to the last parsed 'peers' section. This was due to the fact that, at least, the peer I/O handler refered to the wrong peer section list, in fact always the same: the last one parsed. The fact that the global peer section list was named "struct peers *peers" lead to this issue. This variable name is dangerous ;). So this patch renames global 'peers' variable to 'cfg_peers' to ensure that no such wrong references are still in use, then all the functions wich used old 'peers' variable have been modified to refer to the correct peer list. Must be backported to 1.6 and 1.7.
2017-07-13 03:07:09 -04:00
prs = cfg_peers;
[BUG] peers: ensure the peers are resumed if they were paused Upon an incoming soft restart request, we first pause all frontends and peers. If the caller changes its mind and asks us to resume (eg: failed binding), we must resume all the frontends and peers. Unfortunately the peers were not resumed. The code was arranged to avoid code duplication (which used to hide the issue till now).
2011-09-07 15:33:14 -04:00
while (prs) {
BUG/MEDIUM: proxy: ignore stopped peers Since commit f83d3fe ("MEDIUM: init: stop any peers section not bound to the correct process"), it is possible to stop unused peers on certain processes. The problem is that the pause/resume/stop functions are not aware of this and will pass a NULL proxy pointer to the respective functions, resulting in segfaults in unbound processes during soft restarts. Properly check that the peers' frontend is still valid before calling them. This bug also affects 1.5 so the fix must be backported. Note that this fix is not enough to completely get rid of the segfault, the next one is needed as well.
2015-09-28 10:27:44 -04:00
if (prs->peers_fe)
err |= !resume_proxy(prs->peers_fe);
[BUG] peers: ensure the peers are resumed if they were paused Upon an incoming soft restart request, we first pause all frontends and peers. If the caller changes its mind and asks us to resume (eg: failed binding), we must resume all the frontends and peers. Unfortunately the peers were not resumed. The code was arranged to avoid code duplication (which used to hide the issue till now).
2011-09-07 15:33:14 -04:00
prs = prs->next;
}
if (err) {
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("Some proxies refused to resume, a restart is probably needed to resume safe operations.\n");
[BUG] peers: ensure the peers are resumed if they were paused Upon an incoming soft restart request, we first pause all frontends and peers. If the caller changes its mind and asks us to resume (eg: failed binding), we must resume all the frontends and peers. Unfortunately the peers were not resumed. The code was arranged to avoid code duplication (which used to hide the issue till now).
2011-09-07 15:33:14 -04:00
send_log(p, LOG_WARNING, "Some proxies refused to resume, a restart is probably needed to resume safe operations.\n");
}
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-25 20:48:02 -04:00
}
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 18:22:06 -04:00
/* Set current stream's backend to <be>. Nothing is done if the
* stream already had a backend assigned, which is indicated by
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
* s->flags & SF_BE_ASSIGNED.
[MAJOR] http: complete splitting of the remaining stages The HTTP processing has been splitted into 7 steps, one of which is not anymore HTTP-specific (content-switching). That way, it becomes possible to use "use_backend" rules in TCP mode. A new "use_server" directive should follow soon.
2009-07-07 09:10:31 -04:00
* All flags, stats and counters which need be updated are updated.
[MINOR] prepare callers of session_set_backend to handle errors session_set_backend will soon have to allocate areas for HTTP headers. We must ensure that the callers can handle an allocation error.
2009-07-12 02:27:39 -04:00
* Returns 1 if done, 0 in case of internal error, eg: lack of resource.
[MAJOR] http: complete splitting of the remaining stages The HTTP processing has been splitted into 7 steps, one of which is not anymore HTTP-specific (content-switching). That way, it becomes possible to use "use_backend" rules in TCP mode. A new "use_server" directive should follow soon.
2009-07-07 09:10:31 -04:00
*/
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 18:22:06 -04:00
int stream_set_backend(struct stream *s, struct proxy *be)
[MAJOR] http: complete splitting of the remaining stages The HTTP processing has been splitted into 7 steps, one of which is not anymore HTTP-specific (content-switching). That way, it becomes possible to use "use_backend" rules in TCP mode. A new "use_server" directive should follow soon.
2009-07-07 09:10:31 -04:00
{
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
if (s->flags & SF_BE_ASSIGNED)
[MINOR] prepare callers of session_set_backend to handle errors session_set_backend will soon have to allocate areas for HTTP headers. We must ensure that the callers can handle an allocation error.
2009-07-12 02:27:39 -04:00
return 1;
MINOR: filters: Call stream_set_backend callbacks before updating backend stats So if an internal error is returned, the number of cumulated connections on the backend is not incremented.
2016-06-21 05:54:52 -04:00
if (flt_set_stream_backend(s, be) < 0)
return 0;
[MAJOR] http: complete splitting of the remaining stages The HTTP processing has been splitted into 7 steps, one of which is not anymore HTTP-specific (content-switching). That way, it becomes possible to use "use_backend" rules in TCP mode. A new "use_server" directive should follow soon.
2009-07-07 09:10:31 -04:00
s->be = be;
MEDIUM: threads/proxy: Add a lock per proxy and atomically update proxy vars Now, each proxy contains a lock that must be used when necessary to protect it. Moreover, all proxy's counters are now updated using atomic operations.
2017-06-02 09:33:24 -04:00
HA_ATOMIC_UPDATE_MAX(&be->be_counters.conn_max,
HA_ATOMIC_ADD(&be->beconn, 1));
[MAJOR] http: complete splitting of the remaining stages The HTTP processing has been splitted into 7 steps, one of which is not anymore HTTP-specific (content-switching). That way, it becomes possible to use "use_backend" rules in TCP mode. A new "use_server" directive should follow soon.
2009-07-07 09:10:31 -04:00
proxy_inc_be_ctr(be);
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 18:22:06 -04:00
/* assign new parameters to the stream from the new backend */
[MEDIUM] new option "independant-streams" to stop updating read timeout on writes By default, when data is sent over a socket, both the write timeout and the read timeout for that socket are refreshed, because we consider that there is activity on that socket, and we have no other means of guessing if we should receive data or not. While this default behaviour is desirable for almost all applications, there exists a situation where it is desirable to disable it, and only refresh the read timeout if there are incoming data. This happens on sessions with large timeouts and low amounts of exchanged data such as telnet session. If the server suddenly disappears, the output data accumulates in the system's socket buffers, both timeouts are correctly refreshed, and there is no way to know the server does not receive them, so we don't timeout. However, when the underlying protocol always echoes sent data, it would be enough by itself to detect the issue using the read timeout. Note that this problem does not happen with more verbose protocols because data won't accumulate long in the socket buffers. When this option is set on the frontend, it will disable read timeout updates on data sent to the client. There probably is little use of this case. When the option is set on the backend, it will disable read timeout updates on data sent to the server. Doing so will typically break large HTTP posts from slow lines, so use it with caution.
2009-10-03 16:01:18 -04:00
s->si[1].flags &= ~SI_FL_INDEP_STR;
if (be->options2 & PR_O2_INDEPSTR)
s->si[1].flags |= SI_FL_INDEP_STR;
BUG/MEDIUM: stream: fix client-fin/server-fin handling A tcp half connection can cause 100% CPU on expiration. First reproduced with this haproxy configuration : global tune.bufsize 10485760 defaults timeout server-fin 90s timeout client-fin 90s backend node2 mode tcp timeout server 900s timeout connect 10s server def 127.0.0.1:3333 frontend fe_api mode tcp timeout client 900s bind :1990 use_backend node2 Ie timeout server-fin shorter than timeout server, the backend server sends data, this package is left in the cache of haproxy, the backend server continue sending fin package, haproxy recv fin package. this time the session information is as follows: time the session information is as follows: 0x2373470: proto=tcpv4 src=127.0.0.1:39513 fe=fe_api be=node2 srv=def ts=08 age=1s calls=3 rq[f=848000h,i=0,an=00h,rx=14m58s,wx=,ax=] rp[f=8004c020h,i=0,an=00h,rx=,wx=14m58s,ax=] s0=[7,0h,fd=6,ex=] s1=[7,18h,fd=7,ex=] exp=14m58s rp has set the CF_SHUTR state, next, the client sends the fin package, session information is as follows: 0x2373470: proto=tcpv4 src=127.0.0.1:39513 fe=fe_api be=node2 srv=def ts=08 age=38s calls=4 rq[f=84a020h,i=0,an=00h,rx=,wx=,ax=] rp[f=8004c020h,i=0,an=00h,rx=1m11s,wx=14m21s,ax=] s0=[7,0h,fd=6,ex=] s1=[9,10h,fd=7,ex=] exp=1m11s After waiting 90s, session information is as follows: 0x2373470: proto=tcpv4 src=127.0.0.1:39513 fe=fe_api be=node2 srv=def ts=04 age=4m11s calls=718074391 rq[f=84a020h,i=0,an=00h,rx=,wx=,ax=] rp[f=8004c020h,i=0,an=00h,rx=?,wx=10m49s,ax=] s0=[7,0h,fd=6,ex=] s1=[9,10h,fd=7,ex=] exp=? run(nice=0) cpu information: 6899 root 20 0 112224 21408 4260 R 100.0 0.7 3:04.96 haproxy Buffering is set to ensure that there is data in the haproxy buffer, and haproxy can receive the fin package, set the CF_SHUTR flag, If the CF_SHUTR flag has been set, The following code does not clear the timeout message, causing cpu 100%: stream.c:process_stream: if (unlikely((res->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) { if (si_b->flags & SI_FL_NOHALF) si_b->flags |= SI_FL_NOLINGER; si_shutr(si_b); } If you have closed the read, set the read timeout does not make sense. With or without cf_shutr, read timeout is set: if (tick_isset(s->be->timeout.serverfin)) { res->rto = s->be->timeout.serverfin; res->rex = tick_add(now_ms, res->rto); } After discussion on the mailing list, setting half-closed timeouts the hard way here doesn't make sense. They should be set only at the moment the shutdown() is performed. It will also solve a special case which was already reported of some half-closed timeouts not working when the shutw() is performed directly at the stream-interface layer (no analyser involved). Since the stream interface layer cannot know the timeout values, we'll have to store them directly in the stream interface so that they are used upon shutw(). This patch does this, fixing the problem. An easier reproducer to validate the fix is to keep the huge buffer and shorten all timeouts, then call it under tcploop server and client, and wait 3 seconds to see haproxy run at 100% CPU : global tune.bufsize 10485760 listen px bind :1990 timeout client 90s timeout server 90s timeout connect 1s timeout server-fin 3s timeout client-fin 3s server def 127.0.0.1:3333 $ tcploop 3333 L W N20 A P100 F P10000 & $ tcploop 127.0.0.1:1990 C S10000000 F
2017-03-10 12:41:51 -05:00
if (tick_isset(be->timeout.serverfin))
s->si[1].hcto = be->timeout.serverfin;
MEDIUM: http: add a new option http-buffer-request It is sometimes desirable to wait for the body of an HTTP request before taking a decision. This is what is being done by "balance url_param" for example. The first use case is to buffer requests from slow clients before connecting to the server. Another use case consists in taking the routing decision based on the request body's contents. This option placed in a frontend or backend forces the HTTP processing to wait until either the whole body is received, or the request buffer is full, or the first chunk is complete in case of chunked encoding. It can have undesired side effects with some applications abusing HTTP by expecting unbufferred transmissions between the frontend and the backend, so this should definitely not be used by default. Note that it would not work for the response because we don't reset the message state before starting to forward. For the response we need to 1) reset the message state to MSG_100_SENT or BODY , and 2) to reset body_len in case of chunked encoding to avoid counting it twice.
2015-05-01 16:42:08 -04:00
/* We want to enable the backend-specific analysers except those which
* were already run as part of the frontend/listener. Note that it would
* be more reliable to store the list of analysers that have been run,
* but what we do here is OK for now.
*/
BUG/MINOR: stream: Fix how backend-specific analyzers are set on a stream When the stream's backend was defined, the request's analyzers flag was always set to 0 if the stream had no listener. This bug was introduced with the filter API but never triggered (I think so). Because of the commit 5820a366, it is now possible to encountered it. For example, this happens when the trace filter is enabled on a SPOE backend. The fix is pretty trivial. This fix must be backported to 1.7.
2017-01-09 10:33:19 -05:00
s->req.analysers |= be->be_req_ana & ~(strm_li(s) ? strm_li(s)->analysers : 0);
MEDIUM: http: add a new option http-buffer-request It is sometimes desirable to wait for the body of an HTTP request before taking a decision. This is what is being done by "balance url_param" for example. The first use case is to buffer requests from slow clients before connecting to the server. Another use case consists in taking the routing decision based on the request body's contents. This option placed in a frontend or backend forces the HTTP processing to wait until either the whole body is received, or the request buffer is full, or the first chunk is complete in case of chunked encoding. It can have undesired side effects with some applications abusing HTTP by expecting unbufferred transmissions between the frontend and the backend, so this should definitely not be used by default. Note that it would not work for the response because we don't reset the message state before starting to forward. For the response we need to 1) reset the message state to MSG_100_SENT or BODY , and 2) to reset body_len in case of chunked encoding to avoid counting it twice.
2015-05-01 16:42:08 -04:00
[MEDIUM] allow a TCP frontend to switch to an HTTP backend This patch allows a TCP frontend to switch to an HTTP backend. During the switch, missing structures are automatically allocated. The HTTP parser is enabled so that the backend first waits for a full HTTP request.
2009-07-12 03:47:04 -04:00
/* If the target backend requires HTTP processing, we have to allocate
MAJOR: http: move http_txn out of struct stream Now this one is dynamically allocated. It means that 280 bytes of memory are saved per TCP stream, but more importantly that it will become possible to remove the l7 pointer from fetches and converters since it will be deduced from the stream and will support being null. A lot of care was taken because it's easy to forget a test somewhere, and the previous code used to always trust s->txn for being valid, but all places seem to have been visited. All HTTP fetch functions check the txn first so we shouldn't have any issue there even when called from TCP. When branching from a TCP frontend to an HTTP backend, the txn is properly allocated at the same time as the hdr_idx.
2015-04-03 17:46:31 -04:00
* the HTTP transaction and hdr_idx if we did not have one.
[MEDIUM] allow a TCP frontend to switch to an HTTP backend This patch allows a TCP frontend to switch to an HTTP backend. During the switch, missing structures are automatically allocated. The HTTP parser is enabled so that the backend first waits for a full HTTP request.
2009-07-12 03:47:04 -04:00
*/
MAJOR: http: move http_txn out of struct stream Now this one is dynamically allocated. It means that 280 bytes of memory are saved per TCP stream, but more importantly that it will become possible to remove the l7 pointer from fetches and converters since it will be deduced from the stream and will support being null. A lot of care was taken because it's easy to forget a test somewhere, and the previous code used to always trust s->txn for being valid, but all places seem to have been visited. All HTTP fetch functions check the txn first so we shouldn't have any issue there even when called from TCP. When branching from a TCP frontend to an HTTP backend, the txn is properly allocated at the same time as the hdr_idx.
2015-04-03 17:46:31 -04:00
if (unlikely(!s->txn && be->http_needed)) {
if (unlikely(!http_alloc_txn(s)))
[MEDIUM] allow a TCP frontend to switch to an HTTP backend This patch allows a TCP frontend to switch to an HTTP backend. During the switch, missing structures are automatically allocated. The HTTP parser is enabled so that the backend first waits for a full HTTP request.
2009-07-12 03:47:04 -04:00
return 0; /* not enough memory */
[BUG] http: the transaction must be initialized even in TCP mode (part 2) Commit 4605e3b641cebbdbb2ee5726e5bbc3c03a2d7b5e was not enough, because connections passing from a TCP frontend to an HTTP backend without any ACL and via a "default_backend" statement were still working on non-initialized data. An initialization was missing in the session_set_backend() function, next to the initialization of hdr_idx.
2010-05-31 11:01:36 -04:00
/* and now initialize the HTTP transaction state */
http_init_txn(s);
[MEDIUM] allow a TCP frontend to switch to an HTTP backend This patch allows a TCP frontend to switch to an HTTP backend. During the switch, missing structures are automatically allocated. The HTTP parser is enabled so that the backend first waits for a full HTTP request.
2009-07-12 03:47:04 -04:00
}
MEDIUM: filters: Replace filter_http_headers callback by an analyzer This new analyzer will be called for each HTTP request/response, before the parsing of the body. It is identified by AN_FLT_HTTP_HDRS. Special care was taken about the following condition : * the frontend is a TCP proxy * filters are defined in the frontend section * the selected backend is a HTTP proxy So, this patch explicitly add AN_FLT_HTTP_HDRS analyzer on the request and the response channels when the backend is a HTTP proxy and when there are filters attatched on the stream. This patch simplifies http_request_forward_body and http_response_forward_body functions.
2015-12-02 03:57:32 -05:00
/* Be sure to filter request headers if the backend is an HTTP proxy and
* if there are filters attached to the stream. */
if (s->be->mode == PR_MODE_HTTP && HAS_FILTERS(s))
BUG/MAJOR: channel: Fix the definition order of channel analyzers It is important to defined analyzers (AN_REQ_* and AN_RES_*) in the same order they are evaluated in process_stream. This order is really important because during analyzers evaluation, we run them in the order of the lower bit to the higher one. This way, when an analyzer adds/removes another one during its evaluation, we know if it is located before or after it. So, when it adds an analyzer which is located before it, we can switch to it immediately, even if it has already been called once but removed since. With the time, and introduction of new analyzers, this order was broken up. the main problems come from the filter analyzers. We used values not related with their evaluation order. Furthermore, we used same values for request and response analyzers. So, to fix the bug, filter analyzers have been splitted in 2 distinct lists to have different analyzers for the request channel than those for the response channel. And of course, we have moved them to the right place. Some other analyzers have been reordered to respect the evaluation order: * AN_REQ_HTTP_TARPIT has been moved just before AN_REQ_SRV_RULES * AN_REQ_PRST_RDP_COOKIE has been moved just before AN_REQ_STICKING_RULES * AN_RES_STORE_RULES has been moved just after AN_RES_WAIT_HTTP Note today we have 29 analyzers, all stored into a 32 bits bitfield. So we can still add 4 more analyzers before having a problem. A good way to fend off the problem for a while could be to have a different bitfield for request and response analyzers. [wt: all of this must be backported to 1.7, and part of it must be backported to 1.6 and 1.5]
2017-01-05 08:06:34 -05:00
s->req.analysers |= AN_REQ_FLT_HTTP_HDRS;
MEDIUM: filters: Replace filter_http_headers callback by an analyzer This new analyzer will be called for each HTTP request/response, before the parsing of the body. It is identified by AN_FLT_HTTP_HDRS. Special care was taken about the following condition : * the frontend is a TCP proxy * filters are defined in the frontend section * the selected backend is a HTTP proxy So, this patch explicitly add AN_FLT_HTTP_HDRS analyzer on the request and the response channels when the backend is a HTTP proxy and when there are filters attatched on the stream. This patch simplifies http_request_forward_body and http_response_forward_body functions.
2015-12-02 03:57:32 -05:00
MAJOR: http: move http_txn out of struct stream Now this one is dynamically allocated. It means that 280 bytes of memory are saved per TCP stream, but more importantly that it will become possible to remove the l7 pointer from fetches and converters since it will be deduced from the stream and will support being null. A lot of care was taken because it's easy to forget a test somewhere, and the previous code used to always trust s->txn for being valid, but all places seem to have been visited. All HTTP fetch functions check the txn first so we shouldn't have any issue there even when called from TCP. When branching from a TCP frontend to an HTTP backend, the txn is properly allocated at the same time as the hdr_idx.
2015-04-03 17:46:31 -04:00
if (s->txn) {
if (be->options2 & PR_O2_RSPBUG_OK)
s->txn->rsp.err_pos = -1; /* let buggy responses pass */
BUG/MEDIUM: http: don't start to forward request data before the connect Currently, "balance url_param check_post" randomly works. If the client sends chunked data and there's another chunk after the one containing the data, http_request_forward_body() will advance msg->sov and move the start of data to the beginning of the last chunk, and get_server_ph_post() will not find the data. In order to avoid this, we add an HTTP_MSGF_WAIT_CONN flag whose goal is to prevent the forwarding code from parsing until the connection is confirmed, so that we're certain not to fail on a redispatch. Note that we need to force channel_auto_connect() since the output buffer is empty and a previous analyser might have stopped auto-connect. The flag is currently set whenever some L7 POST analysis is needed for a connect() so that it correctly addresses all corner cases involving a possible rewind of the buffer, waiting for a better fix. Note that this has been broken for a very long time. Even all 1.4 versions seem broken but differently, with ->sov pointing to the end of the arguments. So the fix should be considered for backporting to all stable releases, possibly including 1.3 which works differently.
2014-03-12 05:41:13 -04:00
MAJOR: http: move http_txn out of struct stream Now this one is dynamically allocated. It means that 280 bytes of memory are saved per TCP stream, but more importantly that it will become possible to remove the l7 pointer from fetches and converters since it will be deduced from the stream and will support being null. A lot of care was taken because it's easy to forget a test somewhere, and the previous code used to always trust s->txn for being valid, but all places seem to have been visited. All HTTP fetch functions check the txn first so we shouldn't have any issue there even when called from TCP. When branching from a TCP frontend to an HTTP backend, the txn is properly allocated at the same time as the hdr_idx.
2015-04-03 17:46:31 -04:00
/* If we chain to an HTTP backend running a different HTTP mode, we
* have to re-adjust the desired keep-alive/close mode to accommodate
* both the frontend's and the backend's modes.
*/
MINOR: stream: provide a few helpers to retrieve frontend, listener and origin Expressions are quite long when using strm_sess(strm)->whatever, so let's provide a few helpers : strm_fe(), strm_li(), strm_orig().
2015-04-03 20:10:38 -04:00
if (strm_fe(s)->mode == PR_MODE_HTTP && be->mode == PR_MODE_HTTP &&
((strm_fe(s)->options & PR_O_HTTP_MODE) != (be->options & PR_O_HTTP_MODE)))
MAJOR: http: move http_txn out of struct stream Now this one is dynamically allocated. It means that 280 bytes of memory are saved per TCP stream, but more importantly that it will become possible to remove the l7 pointer from fetches and converters since it will be deduced from the stream and will support being null. A lot of care was taken because it's easy to forget a test somewhere, and the previous code used to always trust s->txn for being valid, but all places seem to have been visited. All HTTP fetch functions check the txn first so we shouldn't have any issue there even when called from TCP. When branching from a TCP frontend to an HTTP backend, the txn is properly allocated at the same time as the hdr_idx.
2015-04-03 17:46:31 -04:00
http_adjust_conn_mode(s, s->txn, &s->txn->req);
/* If an LB algorithm needs to access some pre-parsed body contents,
* we must not start to forward anything until the connection is
* confirmed otherwise we'll lose the pointer to these data and
* prevent the hash from being doable again after a redispatch.
*/
if (be->mode == PR_MODE_HTTP &&
(be->lbprm.algo & (BE_LB_KIND | BE_LB_PARM)) == (BE_LB_KIND_HI | BE_LB_HASH_PRM))
s->txn->req.flags |= HTTP_MSGF_WAIT_CONN;
MEDIUM: http: add a new option http-buffer-request It is sometimes desirable to wait for the body of an HTTP request before taking a decision. This is what is being done by "balance url_param" for example. The first use case is to buffer requests from slow clients before connecting to the server. Another use case consists in taking the routing decision based on the request body's contents. This option placed in a frontend or backend forces the HTTP processing to wait until either the whole body is received, or the request buffer is full, or the first chunk is complete in case of chunked encoding. It can have undesired side effects with some applications abusing HTTP by expecting unbufferred transmissions between the frontend and the backend, so this should definitely not be used by default. Note that it would not work for the response because we don't reset the message state before starting to forward. For the response we need to 1) reset the message state to MSG_100_SENT or BODY , and 2) to reset body_len in case of chunked encoding to avoid counting it twice.
2015-05-01 16:42:08 -04:00
/* we may request to parse a request body */
if ((be->options & PR_O_WREQ_BODY) &&
(s->txn->req.body_len || (s->txn->req.flags & HTTP_MSGF_TE_CHNK)))
s->req.analysers |= AN_REQ_HTTP_BODY;
MAJOR: http: move http_txn out of struct stream Now this one is dynamically allocated. It means that 280 bytes of memory are saved per TCP stream, but more importantly that it will become possible to remove the l7 pointer from fetches and converters since it will be deduced from the stream and will support being null. A lot of care was taken because it's easy to forget a test somewhere, and the previous code used to always trust s->txn for being valid, but all places seem to have been visited. All HTTP fetch functions check the txn first so we shouldn't have any issue there even when called from TCP. When branching from a TCP frontend to an HTTP backend, the txn is properly allocated at the same time as the hdr_idx.
2015-04-03 17:46:31 -04:00
}
s->flags |= SF_BE_ASSIGNED;
[MEDIUM] http: add support for "http-no-delay" There are some very rare server-to-server applications that abuse the HTTP protocol and expect the payload phase to be highly interactive, with many interleaved data chunks in both directions within a single request. This is absolutely not supported by the HTTP specification and will not work across most proxies or servers. When such applications attempt to do this through haproxy, it works but they will experience high delays due to the network optimizations which favor performance by instructing the system to wait for enough data to be available in order to only send full packets. Typical delays are around 200 ms per round trip. Note that this only happens with abnormal uses. Normal uses such as CONNECT requests nor WebSockets are not affected. When "option http-no-delay" is present in either the frontend or the backend used by a connection, all such optimizations will be disabled in order to make the exchanges as fast as possible. Of course this offers no guarantee on the functionality, as it may break at any other place. But if it works via HAProxy, it will work as fast as possible. This option should never be used by default, and should never be used at all unless such a buggy application is discovered. The impact of using this option is an increase of bandwidth usage and CPU usage, which may significantly lower performance in high latency environments. This change should be backported to 1.4 since the first report of such a misuse was in 1.4. Next patch will also be needed.
2011-05-30 12:10:30 -04:00
if (be->options2 & PR_O2_NODELAY) {
REORG/MAJOR: move session's req and resp channels back into the session The channels were pointers to outside structs and this is not needed anymore since the buffers have moved, but this complicates operations. Move them back into the session so that both channels and stream interfaces are always allocated for a session. Some places (some early sample fetch functions) used to validate that a channel was NULL prior to dereferencing it. Now instead we check if chn->buf is NULL and we force it to remain NULL until the channel is initialized.
2014-11-27 14:45:39 -05:00
s->req.flags |= CF_NEVER_WAIT;
s->res.flags |= CF_NEVER_WAIT;
[MEDIUM] http: add support for "http-no-delay" There are some very rare server-to-server applications that abuse the HTTP protocol and expect the payload phase to be highly interactive, with many interleaved data chunks in both directions within a single request. This is absolutely not supported by the HTTP specification and will not work across most proxies or servers. When such applications attempt to do this through haproxy, it works but they will experience high delays due to the network optimizations which favor performance by instructing the system to wait for enough data to be available in order to only send full packets. Typical delays are around 200 ms per round trip. Note that this only happens with abnormal uses. Normal uses such as CONNECT requests nor WebSockets are not affected. When "option http-no-delay" is present in either the frontend or the backend used by a connection, all such optimizations will be disabled in order to make the exchanges as fast as possible. Of course this offers no guarantee on the functionality, as it may break at any other place. But if it works via HAProxy, it will work as fast as possible. This option should never be used by default, and should never be used at all unless such a buggy application is discovered. The impact of using this option is an increase of bandwidth usage and CPU usage, which may significantly lower performance in high latency environments. This change should be backported to 1.4 since the first report of such a misuse was in 1.4. Next patch will also be needed.
2011-05-30 12:10:30 -04:00
}
[MINOR] prepare callers of session_set_backend to handle errors session_set_backend will soon have to allocate areas for HTTP headers. We must ensure that the callers can handle an allocation error.
2009-07-12 02:27:39 -04:00
return 1;
[MAJOR] http: complete splitting of the remaining stages The HTTP processing has been splitted into 7 steps, one of which is not anymore HTTP-specific (content-switching). That way, it becomes possible to use "use_backend" rules in TCP mode. A new "use_server" directive should follow soon.
2009-07-07 09:10:31 -04:00
}
BUG/MEDIUM: prevent gcc from moving empty keywords lists into BSS Benoit Dolez reported a failure to start haproxy 1.5-dev19. The process would immediately report an internal error with missing fetches from some crap instead of ACL names. The cause is that some versions of gcc seem to trim static structs containing a variable array when moving them to BSS, and only keep the fixed size, which is just a list head for all ACL and sample fetch keywords. This was confirmed at least with gcc 3.4.6. And we can't move these structs to const because they contain a list element which is needed to link all of them together during the parsing. The bug indeed appeared with 1.5-dev19 because it's the first one to have some empty ACL keyword lists. One solution is to impose -fno-zero-initialized-in-bss to everyone but this is not really nice. Another solution consists in ensuring the struct is never empty so that it does not move there. The easy solution consists in having a non-null list head since it's not yet initialized. A new "ILH" list head type was thus created for this purpose : create an Initialized List Head so that gcc cannot move the struct to BSS. This fixes the issue for this version of gcc and does not create any burden for the declarations.
2013-06-21 17:16:39 -04:00
static struct cfg_kw_list cfg_kws = {ILH, {
MEDIUM: global: add a 'hard-stop-after' option to cap the soft-stop time When SIGUSR1 is received, haproxy enters in soft-stop and quits when no connection remains. It can happen that the instance remains alive for a long time, depending on timeouts and traffic. This option ensures that soft-stop won't run for too long. Example: global hard-stop-after 30s # Once in soft-stop, the instance will remain # alive for at most 30 seconds.
2017-03-23 17:44:13 -04:00
{ CFG_GLOBAL, "hard-stop-after", proxy_parse_hard_stop_after },
[MEDIUM] modularize the "timeout" keyword configuration parser The "timeout" keyword already relied on an external parser, let's make use of the new keyword registration mechanism.
2008-07-09 14:34:27 -04:00
{ CFG_LISTEN, "timeout", proxy_parse_timeout },
{ CFG_LISTEN, "clitimeout", proxy_parse_timeout },
{ CFG_LISTEN, "contimeout", proxy_parse_timeout },
{ CFG_LISTEN, "srvtimeout", proxy_parse_timeout },
[MEDIUM] implement "rate-limit sessions" for the frontend The new "rate-limit sessions" statement sets a limit on the number of new connections per second on the frontend. As it is extremely accurate (about 0.1%), it is efficient at limiting resource abuse or DoS.
2009-03-05 17:48:25 -05:00
{ CFG_LISTEN, "rate-limit", proxy_parse_rate_limit },
MINOR: http: implement the max-keep-alive-queue setting Finn Arne Gangstad suggested that we should have the ability to break keep-alive when the target server has reached its maxconn and that a number of connections are present in the queue. After some discussion around his proposed patch, the following solution was suggested : have a per-proxy setting to fix a limit to the number of queued connections on a server after which we break keep-alive. This ensures that even in high latency networks where keep-alive is beneficial, we try to find a different server. This patch is partially based on his original proposal and implements this configurable threshold.
2014-04-25 07:58:37 -04:00
{ CFG_LISTEN, "max-keep-alive-queue", proxy_parse_max_ka_queue },
MINOR: proxy: custom capture declaration This patch adds a new keyword called "declare". This keyword allow to declare some capture slots in requests and response. It is useful for sharing capture between frontend and backends.
2015-05-26 11:44:32 -04:00
{ CFG_LISTEN, "declare", proxy_parse_declare },
[MEDIUM] modularize the "timeout" keyword configuration parser The "timeout" keyword already relied on an external parser, let's make use of the new keyword registration mechanism.
2008-07-09 14:34:27 -04:00
{ 0, NULL, NULL },
}};
MINOR: proxy: create new function cli_find_frontend() to find a frontend Several CLI commands require a frontend, so let's have a function to look this one up and prepare the appropriate error message and the appctx's state in case of failure.
2016-11-24 06:02:29 -05:00
/* Expects to find a frontend named <arg> and returns it, otherwise displays various
* adequate error messages and returns NULL. This function is designed to be used by
* functions requiring a frontend on the CLI.
*/
struct proxy *cli_find_frontend(struct appctx *appctx, const char *arg)
{
struct proxy *px;
if (!*arg) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_ERR;
MINOR: proxy: create new function cli_find_frontend() to find a frontend Several CLI commands require a frontend, so let's have a function to look this one up and prepare the appropriate error message and the appctx's state in case of failure.
2016-11-24 06:02:29 -05:00
appctx->ctx.cli.msg = "A frontend name is expected.\n";
CLEANUP: cli: rename STAT_CLI_* to CLI_ST_* These are in CLI states, not stats states anymore. STAT_CLI_O_CUSTOM was more appropriately renamed CLI_ST_CALLBACK.
2016-11-24 09:53:53 -05:00
appctx->st0 = CLI_ST_PRINT;
MINOR: proxy: create new function cli_find_frontend() to find a frontend Several CLI commands require a frontend, so let's have a function to look this one up and prepare the appropriate error message and the appctx's state in case of failure.
2016-11-24 06:02:29 -05:00
return NULL;
}
px = proxy_fe_by_name(arg);
if (!px) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_ERR;
MINOR: proxy: create new function cli_find_frontend() to find a frontend Several CLI commands require a frontend, so let's have a function to look this one up and prepare the appropriate error message and the appctx's state in case of failure.
2016-11-24 06:02:29 -05:00
appctx->ctx.cli.msg = "No such frontend.\n";
CLEANUP: cli: rename STAT_CLI_* to CLI_ST_* These are in CLI states, not stats states anymore. STAT_CLI_O_CUSTOM was more appropriately renamed CLI_ST_CALLBACK.
2016-11-24 09:53:53 -05:00
appctx->st0 = CLI_ST_PRINT;
MINOR: proxy: create new function cli_find_frontend() to find a frontend Several CLI commands require a frontend, so let's have a function to look this one up and prepare the appropriate error message and the appctx's state in case of failure.
2016-11-24 06:02:29 -05:00
return NULL;
}
return px;
}
MINOR: cli: Let configure the dynamic cookies from the cli. This adds 3 new commands to the cli : enable dynamic-cookie backend <backend> that enables dynamic cookies for a specified backend disable dynamic-cookie backend <backend> that disables dynamic cookies for a specified backend set dynamic-cookie-key backend <backend> that lets one change the dynamic cookie secret key, for a specified backend.
2017-03-14 15:08:46 -04:00
/* Expects to find a backend named <arg> and returns it, otherwise displays various
* adequate error messages and returns NULL. This function is designed to be used by
* functions requiring a frontend on the CLI.
*/
struct proxy *cli_find_backend(struct appctx *appctx, const char *arg)
{
struct proxy *px;
if (!*arg) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_ERR;
MINOR: cli: Let configure the dynamic cookies from the cli. This adds 3 new commands to the cli : enable dynamic-cookie backend <backend> that enables dynamic cookies for a specified backend disable dynamic-cookie backend <backend> that disables dynamic cookies for a specified backend set dynamic-cookie-key backend <backend> that lets one change the dynamic cookie secret key, for a specified backend.
2017-03-14 15:08:46 -04:00
appctx->ctx.cli.msg = "A backend name is expected.\n";
appctx->st0 = CLI_ST_PRINT;
return NULL;
}
px = proxy_be_by_name(arg);
if (!px) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_ERR;
MINOR: cli: Let configure the dynamic cookies from the cli. This adds 3 new commands to the cli : enable dynamic-cookie backend <backend> that enables dynamic cookies for a specified backend disable dynamic-cookie backend <backend> that disables dynamic cookies for a specified backend set dynamic-cookie-key backend <backend> that lets one change the dynamic cookie secret key, for a specified backend.
2017-03-14 15:08:46 -04:00
appctx->ctx.cli.msg = "No such backend.\n";
appctx->st0 = CLI_ST_PRINT;
return NULL;
}
return px;
}
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
/* parse a "show servers" CLI line, returns 0 if it wants to start the dump or
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
* 1 if it stops immediately. If an argument is specified, it will set the proxy
* pointer into cli.p0 and its ID into cli.i0.
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
*/
MEDIUM: cli: Add payload support In order to use arbitrary data in the CLI (multiple lines or group of words that must be considered as a whole, for example), it is now possible to add a payload to the commands. To do so, the first line needs to end with a special pattern: <<\n. Everything that follows will be left untouched by the CLI parser and will be passed to the commands parsers. Per-command support will need to be added to take advantage of this feature. Signed-off-by: Aurlien Nephtali <aurelien.nephtali@corp.ovh.com>
2018-04-18 07:26:46 -04:00
static int cli_parse_show_servers(char **args, char *payload, struct appctx *appctx, void *private)
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
{
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
struct proxy *px;
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
/* check if a backend name has been provided */
if (*args[3]) {
/* read server state from local file */
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
px = proxy_be_by_name(args[3]);
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
if (!px) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_ERR;
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
appctx->ctx.cli.msg = "Can't find backend.\n";
CLEANUP: cli: rename STAT_CLI_* to CLI_ST_* These are in CLI states, not stats states anymore. STAT_CLI_O_CUSTOM was more appropriately renamed CLI_ST_CALLBACK.
2016-11-24 09:53:53 -05:00
appctx->st0 = CLI_ST_PRINT;
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
return 1;
}
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
appctx->ctx.cli.p0 = px;
appctx->ctx.cli.i0 = px->uuid;
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
}
return 0;
}
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
/* dumps server state information into <buf> for all the servers found in backend cli.p0.
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
* These information are all the parameters which may change during HAProxy runtime.
* By default, we only export to the last known server state file format.
* These information can be used at next startup to recover same level of server state.
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
* It uses the proxy pointer from cli.p0, the proxy's id from cli.i0 and the server's
* pointer from cli.p1.
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
*/
static int dump_servers_state(struct stream_interface *si, struct chunk *buf)
{
struct appctx *appctx = __objt_appctx(si->end);
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
struct proxy *px = appctx->ctx.cli.p0;
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
struct server *srv;
char srv_addr[INET6_ADDRSTRLEN + 1];
time_t srv_time_since_last_change;
int bk_f_forced_id, srv_f_forced_id;
/* we don't want to report any state if the backend is not enabled on this process */
CLEANUP: global: introduce variable pid_bit to avoid shifts with relative_pid At a number of places, bitmasks are used for process affinity and to map listeners to processes. Every time 1UL<<(relative_pid-1) is used. Let's create a "pid_bit" variable corresponding to this value to clean this up.
2017-11-10 13:08:14 -05:00
if (px->bind_proc && !(px->bind_proc & pid_bit))
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
return 1;
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
if (!appctx->ctx.cli.p1)
appctx->ctx.cli.p1 = px->srv;
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
for (; appctx->ctx.cli.p1 != NULL; appctx->ctx.cli.p1 = srv->next) {
srv = appctx->ctx.cli.p1;
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
srv_addr[0] = '\0';
switch (srv->addr.ss_family) {
case AF_INET:
inet_ntop(srv->addr.ss_family, &((struct sockaddr_in *)&srv->addr)->sin_addr,
srv_addr, INET_ADDRSTRLEN + 1);
break;
case AF_INET6:
inet_ntop(srv->addr.ss_family, &((struct sockaddr_in6 *)&srv->addr)->sin6_addr,
srv_addr, INET6_ADDRSTRLEN + 1);
break;
}
srv_time_since_last_change = now.tv_sec - srv->last_change;
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
bk_f_forced_id = px->options & PR_O_FORCED_ID ? 1 : 0;
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
srv_f_forced_id = srv->flags & SRV_F_FORCED_ID ? 1 : 0;
chunk_appendf(buf,
"%d %s "
"%d %s %s "
"%d %d %d %d %ld "
"%d %d %d %d %d "
MINOR: Add server port field to server state file. This patch adds server ports to server state file at the end of each line for backward compatibility.
2017-08-01 02:47:19 -04:00
"%d %d %s %u"
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
"\n",
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
px->uuid, px->id,
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
srv->puid, srv->id, srv_addr,
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 08:41:55 -04:00
srv->cur_state, srv->cur_admin, srv->uweight, srv->iweight, (long int)srv_time_since_last_change,
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
srv->check.status, srv->check.result, srv->check.health, srv->check.state, srv->agent.state,
MINOR: Add server port field to server state file. This patch adds server ports to server state file at the end of each line for backward compatibility.
2017-08-01 02:47:19 -04:00
bk_f_forced_id, srv_f_forced_id, srv->hostname ? srv->hostname : "-", srv->svc_port);
REORG: channel: finally rename the last bi_* / bo_* functions For HTTP/2 we'll need some buffer-only equivalent functions to some of the ones applying to channels and still squatting the bi_* / bo_* namespace. Since these names have kept being misleading for quite some time now and are really getting annoying, it's time to rename them. This commit will use "ci/co" as the prefix (for "channel in", "channel out") instead of "bi/bo". The following ones were renamed : bi_getblk_nc, bi_getline_nc, bi_putblk, bi_putchr, bo_getblk, bo_getblk_nc, bo_getline, bo_getline_nc, bo_inject, bi_putchk, bi_putstr, bo_getchr, bo_skip, bi_swpbuf
2017-10-19 08:32:15 -04:00
if (ci_putchk(si_ic(si), &trash) == -1) {
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
si_applet_cant_put(si);
return 0;
}
}
return 1;
}
/* Parses backend list or simply use backend name provided by the user to return
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
* states of servers to stdout. It dumps proxy <cli.p0> and stops if <cli.i0> is
* non-null.
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
*/
static int cli_io_handler_servers_state(struct appctx *appctx)
{
struct stream_interface *si = appctx->owner;
struct proxy *curproxy;
chunk_reset(&trash);
if (appctx->st2 == STAT_ST_INIT) {
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
if (!appctx->ctx.cli.p0)
MINOR/CLEANUP: proxy: rename "proxy" to "proxies_list" Rename the global variable "proxy" to "proxies_list". There's been multiple proxies in haproxy for quite some time, and "proxy" is a potential source of bugs, a number of functions have a "proxy" argument, and some code used "proxy" when it really meant "px" or "curproxy". It worked by pure luck, because it usually happened while parsing the config, and thus "proxy" pointed to the currently parsed proxy, but we should probably not rely on this. [wt: some of these are definitely fixes that are worth backporting]
2017-11-24 10:54:05 -05:00
appctx->ctx.cli.p0 = proxies_list;
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
appctx->st2 = STAT_ST_HEAD;
}
if (appctx->st2 == STAT_ST_HEAD) {
chunk_printf(&trash, "%d\n# %s\n", SRV_STATE_FILE_VERSION, SRV_STATE_FILE_FIELD_NAMES);
REORG: channel: finally rename the last bi_* / bo_* functions For HTTP/2 we'll need some buffer-only equivalent functions to some of the ones applying to channels and still squatting the bi_* / bo_* namespace. Since these names have kept being misleading for quite some time now and are really getting annoying, it's time to rename them. This commit will use "ci/co" as the prefix (for "channel in", "channel out") instead of "bi/bo". The following ones were renamed : bi_getblk_nc, bi_getline_nc, bi_putblk, bi_putchr, bo_getblk, bo_getblk_nc, bo_getline, bo_getline_nc, bo_inject, bi_putchk, bi_putstr, bo_getchr, bo_skip, bi_swpbuf
2017-10-19 08:32:15 -04:00
if (ci_putchk(si_ic(si), &trash) == -1) {
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
si_applet_cant_put(si);
return 0;
}
appctx->st2 = STAT_ST_INFO;
}
/* STAT_ST_INFO */
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
for (; appctx->ctx.cli.p0 != NULL; appctx->ctx.cli.p0 = curproxy->next) {
curproxy = appctx->ctx.cli.p0;
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
/* servers are only in backends */
if (curproxy->cap & PR_CAP_BE) {
if (!dump_servers_state(si, &trash))
return 0;
}
/* only the selected proxy is dumped */
MINOR: appctx/cli: remove the "server_state" entry from the appctx union This one now migrates to the general purpose cli.p0 for the proxy pointer, cli.p1 for the server pointer, and cli.i0 for the proxy's instance if only one has to be dumped.
2016-12-16 12:23:39 -05:00
if (appctx->ctx.cli.i0)
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
break;
}
return 1;
}
MINOR: appctx/cli: remove the "be" entry from the appctx union This one now migrates to the general purpose cli.p0. The parsing function was removed since it was only used to set the pointer to NULL.
2016-12-16 12:01:15 -05:00
/* Parses backend list and simply report backend names. It keeps the proxy
* pointer in cli.p0.
*/
REORG: cli: move 'show backend' to proxy.c Move 'show backend' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-22 06:34:16 -05:00
static int cli_io_handler_show_backend(struct appctx *appctx)
{
struct stream_interface *si = appctx->owner;
struct proxy *curproxy;
chunk_reset(&trash);
MINOR: appctx/cli: remove the "be" entry from the appctx union This one now migrates to the general purpose cli.p0. The parsing function was removed since it was only used to set the pointer to NULL.
2016-12-16 12:01:15 -05:00
if (!appctx->ctx.cli.p0) {
REORG: cli: move 'show backend' to proxy.c Move 'show backend' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-22 06:34:16 -05:00
chunk_printf(&trash, "# name\n");
REORG: channel: finally rename the last bi_* / bo_* functions For HTTP/2 we'll need some buffer-only equivalent functions to some of the ones applying to channels and still squatting the bi_* / bo_* namespace. Since these names have kept being misleading for quite some time now and are really getting annoying, it's time to rename them. This commit will use "ci/co" as the prefix (for "channel in", "channel out") instead of "bi/bo". The following ones were renamed : bi_getblk_nc, bi_getline_nc, bi_putblk, bi_putchr, bo_getblk, bo_getblk_nc, bo_getline, bo_getline_nc, bo_inject, bi_putchk, bi_putstr, bo_getchr, bo_skip, bi_swpbuf
2017-10-19 08:32:15 -04:00
if (ci_putchk(si_ic(si), &trash) == -1) {
REORG: cli: move 'show backend' to proxy.c Move 'show backend' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-22 06:34:16 -05:00
si_applet_cant_put(si);
return 0;
}
MINOR/CLEANUP: proxy: rename "proxy" to "proxies_list" Rename the global variable "proxy" to "proxies_list". There's been multiple proxies in haproxy for quite some time, and "proxy" is a potential source of bugs, a number of functions have a "proxy" argument, and some code used "proxy" when it really meant "px" or "curproxy". It worked by pure luck, because it usually happened while parsing the config, and thus "proxy" pointed to the currently parsed proxy, but we should probably not rely on this. [wt: some of these are definitely fixes that are worth backporting]
2017-11-24 10:54:05 -05:00
appctx->ctx.cli.p0 = proxies_list;
REORG: cli: move 'show backend' to proxy.c Move 'show backend' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-22 06:34:16 -05:00
}
MINOR: appctx/cli: remove the "be" entry from the appctx union This one now migrates to the general purpose cli.p0. The parsing function was removed since it was only used to set the pointer to NULL.
2016-12-16 12:01:15 -05:00
for (; appctx->ctx.cli.p0 != NULL; appctx->ctx.cli.p0 = curproxy->next) {
curproxy = appctx->ctx.cli.p0;
REORG: cli: move 'show backend' to proxy.c Move 'show backend' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-22 06:34:16 -05:00
/* looking for backends only */
if (!(curproxy->cap & PR_CAP_BE))
continue;
/* we don't want to list a backend which is bound to this process */
CLEANUP: global: introduce variable pid_bit to avoid shifts with relative_pid At a number of places, bitmasks are used for process affinity and to map listeners to processes. Every time 1UL<<(relative_pid-1) is used. Let's create a "pid_bit" variable corresponding to this value to clean this up.
2017-11-10 13:08:14 -05:00
if (curproxy->bind_proc && !(curproxy->bind_proc & pid_bit))
REORG: cli: move 'show backend' to proxy.c Move 'show backend' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-22 06:34:16 -05:00
continue;
chunk_appendf(&trash, "%s\n", curproxy->id);
REORG: channel: finally rename the last bi_* / bo_* functions For HTTP/2 we'll need some buffer-only equivalent functions to some of the ones applying to channels and still squatting the bi_* / bo_* namespace. Since these names have kept being misleading for quite some time now and are really getting annoying, it's time to rename them. This commit will use "ci/co" as the prefix (for "channel in", "channel out") instead of "bi/bo". The following ones were renamed : bi_getblk_nc, bi_getline_nc, bi_putblk, bi_putchr, bo_getblk, bo_getblk_nc, bo_getline, bo_getline_nc, bo_inject, bi_putchk, bi_putstr, bo_getchr, bo_skip, bi_swpbuf
2017-10-19 08:32:15 -04:00
if (ci_putchk(si_ic(si), &trash) == -1) {
REORG: cli: move 'show backend' to proxy.c Move 'show backend' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-22 06:34:16 -05:00
si_applet_cant_put(si);
return 0;
}
}
return 1;
}
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
MINOR: cli: Let configure the dynamic cookies from the cli. This adds 3 new commands to the cli : enable dynamic-cookie backend <backend> that enables dynamic cookies for a specified backend disable dynamic-cookie backend <backend> that disables dynamic cookies for a specified backend set dynamic-cookie-key backend <backend> that lets one change the dynamic cookie secret key, for a specified backend.
2017-03-14 15:08:46 -04:00
/* Parses the "enable dynamic-cookies backend" directive, it always returns 1 */
MEDIUM: cli: Add payload support In order to use arbitrary data in the CLI (multiple lines or group of words that must be considered as a whole, for example), it is now possible to add a payload to the commands. To do so, the first line needs to end with a special pattern: <<\n. Everything that follows will be left untouched by the CLI parser and will be passed to the commands parsers. Per-command support will need to be added to take advantage of this feature. Signed-off-by: Aurlien Nephtali <aurelien.nephtali@corp.ovh.com>
2018-04-18 07:26:46 -04:00
static int cli_parse_enable_dyncookie_backend(char **args, char *payload, struct appctx *appctx, void *private)
MINOR: cli: Let configure the dynamic cookies from the cli. This adds 3 new commands to the cli : enable dynamic-cookie backend <backend> that enables dynamic cookies for a specified backend disable dynamic-cookie backend <backend> that disables dynamic cookies for a specified backend set dynamic-cookie-key backend <backend> that lets one change the dynamic cookie secret key, for a specified backend.
2017-03-14 15:08:46 -04:00
{
struct proxy *px;
struct server *s;
if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
return 1;
px = cli_find_backend(appctx, args[3]);
if (!px)
return 1;
px->ck_opts |= PR_CK_DYNAMIC;
for (s = px->srv; s != NULL; s = s->next)
srv_set_dyncookie(s);
return 1;
}
/* Parses the "disable dynamic-cookies backend" directive, it always returns 1 */
MEDIUM: cli: Add payload support In order to use arbitrary data in the CLI (multiple lines or group of words that must be considered as a whole, for example), it is now possible to add a payload to the commands. To do so, the first line needs to end with a special pattern: <<\n. Everything that follows will be left untouched by the CLI parser and will be passed to the commands parsers. Per-command support will need to be added to take advantage of this feature. Signed-off-by: Aurlien Nephtali <aurelien.nephtali@corp.ovh.com>
2018-04-18 07:26:46 -04:00
static int cli_parse_disable_dyncookie_backend(char **args, char *payload, struct appctx *appctx, void *private)
MINOR: cli: Let configure the dynamic cookies from the cli. This adds 3 new commands to the cli : enable dynamic-cookie backend <backend> that enables dynamic cookies for a specified backend disable dynamic-cookie backend <backend> that disables dynamic cookies for a specified backend set dynamic-cookie-key backend <backend> that lets one change the dynamic cookie secret key, for a specified backend.
2017-03-14 15:08:46 -04:00
{
struct proxy *px;
struct server *s;
if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
return 1;
px = cli_find_backend(appctx, args[3]);
if (!px)
return 1;
px->ck_opts &= ~PR_CK_DYNAMIC;
for (s = px->srv; s != NULL; s = s->next) {
if (!(s->flags & SRV_F_COOKIESET)) {
free(s->cookie);
s->cookie = NULL;
}
}
return 1;
}
/* Parses the "set dynamic-cookie-key backend" directive, it always returns 1 */
MEDIUM: cli: Add payload support In order to use arbitrary data in the CLI (multiple lines or group of words that must be considered as a whole, for example), it is now possible to add a payload to the commands. To do so, the first line needs to end with a special pattern: <<\n. Everything that follows will be left untouched by the CLI parser and will be passed to the commands parsers. Per-command support will need to be added to take advantage of this feature. Signed-off-by: Aurlien Nephtali <aurelien.nephtali@corp.ovh.com>
2018-04-18 07:26:46 -04:00
static int cli_parse_set_dyncookie_key_backend(char **args, char *payload, struct appctx *appctx, void *private)
MINOR: cli: Let configure the dynamic cookies from the cli. This adds 3 new commands to the cli : enable dynamic-cookie backend <backend> that enables dynamic cookies for a specified backend disable dynamic-cookie backend <backend> that disables dynamic cookies for a specified backend set dynamic-cookie-key backend <backend> that lets one change the dynamic cookie secret key, for a specified backend.
2017-03-14 15:08:46 -04:00
{
struct proxy *px;
struct server *s;
char *newkey;
if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
return 1;
px = cli_find_backend(appctx, args[3]);
if (!px)
return 1;
if (!*args[4]) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_ERR;
MINOR: cli: Let configure the dynamic cookies from the cli. This adds 3 new commands to the cli : enable dynamic-cookie backend <backend> that enables dynamic cookies for a specified backend disable dynamic-cookie backend <backend> that disables dynamic cookies for a specified backend set dynamic-cookie-key backend <backend> that lets one change the dynamic cookie secret key, for a specified backend.
2017-03-14 15:08:46 -04:00
appctx->ctx.cli.msg = "String value expected.\n";
appctx->st0 = CLI_ST_PRINT;
return 1;
}
newkey = strdup(args[4]);
if (!newkey) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_ERR;
MINOR: cli: Let configure the dynamic cookies from the cli. This adds 3 new commands to the cli : enable dynamic-cookie backend <backend> that enables dynamic cookies for a specified backend disable dynamic-cookie backend <backend> that disables dynamic cookies for a specified backend set dynamic-cookie-key backend <backend> that lets one change the dynamic cookie secret key, for a specified backend.
2017-03-14 15:08:46 -04:00
appctx->ctx.cli.msg = "Failed to allocate memory.\n";
appctx->st0 = CLI_ST_PRINT;
return 1;
}
free(px->dyncookie_key);
px->dyncookie_key = newkey;
for (s = px->srv; s != NULL; s = s->next)
srv_set_dyncookie(s);
return 1;
}
REORG: cli: move "set maxconn frontend" to proxy.c And get rid of the last specific "set maxconn" case.
2016-11-23 10:22:04 -05:00
/* Parses the "set maxconn frontend" directive, it always returns 1 */
MEDIUM: cli: Add payload support In order to use arbitrary data in the CLI (multiple lines or group of words that must be considered as a whole, for example), it is now possible to add a payload to the commands. To do so, the first line needs to end with a special pattern: <<\n. Everything that follows will be left untouched by the CLI parser and will be passed to the commands parsers. Per-command support will need to be added to take advantage of this feature. Signed-off-by: Aurlien Nephtali <aurelien.nephtali@corp.ovh.com>
2018-04-18 07:26:46 -04:00
static int cli_parse_set_maxconn_frontend(char **args, char *payload, struct appctx *appctx, void *private)
REORG: cli: move "set maxconn frontend" to proxy.c And get rid of the last specific "set maxconn" case.
2016-11-23 10:22:04 -05:00
{
struct proxy *px;
struct listener *l;
int v;
if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
return 1;
px = cli_find_frontend(appctx, args[3]);
if (!px)
return 1;
if (!*args[4]) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_ERR;
REORG: cli: move "set maxconn frontend" to proxy.c And get rid of the last specific "set maxconn" case.
2016-11-23 10:22:04 -05:00
appctx->ctx.cli.msg = "Integer value expected.\n";
CLEANUP: cli: rename STAT_CLI_* to CLI_ST_* These are in CLI states, not stats states anymore. STAT_CLI_O_CUSTOM was more appropriately renamed CLI_ST_CALLBACK.
2016-11-24 09:53:53 -05:00
appctx->st0 = CLI_ST_PRINT;
REORG: cli: move "set maxconn frontend" to proxy.c And get rid of the last specific "set maxconn" case.
2016-11-23 10:22:04 -05:00
return 1;
}
v = atoi(args[4]);
if (v < 0) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_ERR;
REORG: cli: move "set maxconn frontend" to proxy.c And get rid of the last specific "set maxconn" case.
2016-11-23 10:22:04 -05:00
appctx->ctx.cli.msg = "Value out of range.\n";
CLEANUP: cli: rename STAT_CLI_* to CLI_ST_* These are in CLI states, not stats states anymore. STAT_CLI_O_CUSTOM was more appropriately renamed CLI_ST_CALLBACK.
2016-11-24 09:53:53 -05:00
appctx->st0 = CLI_ST_PRINT;
REORG: cli: move "set maxconn frontend" to proxy.c And get rid of the last specific "set maxconn" case.
2016-11-23 10:22:04 -05:00
return 1;
}
/* OK, the value is fine, so we assign it to the proxy and to all of
* its listeners. The blocked ones will be dequeued.
*/
px->maxconn = v;
list_for_each_entry(l, &px->conf.listeners, by_fe) {
l->maxconn = v;
if (l->state == LI_FULL)
resume_listener(l);
}
if (px->maxconn > px->feconn && !LIST_ISEMPTY(&px->listener_queue))
dequeue_all_listeners(&px->listener_queue);
return 1;
}
REORG: cli: move "shutdown frontend" to proxy.c Now we don't have any "shutdown" commands left in cli.c.
2016-11-24 05:13:06 -05:00
/* Parses the "shutdown frontend" directive, it always returns 1 */
MEDIUM: cli: Add payload support In order to use arbitrary data in the CLI (multiple lines or group of words that must be considered as a whole, for example), it is now possible to add a payload to the commands. To do so, the first line needs to end with a special pattern: <<\n. Everything that follows will be left untouched by the CLI parser and will be passed to the commands parsers. Per-command support will need to be added to take advantage of this feature. Signed-off-by: Aurlien Nephtali <aurelien.nephtali@corp.ovh.com>
2018-04-18 07:26:46 -04:00
static int cli_parse_shutdown_frontend(char **args, char *payload, struct appctx *appctx, void *private)
REORG: cli: move "shutdown frontend" to proxy.c Now we don't have any "shutdown" commands left in cli.c.
2016-11-24 05:13:06 -05:00
{
struct proxy *px;
if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
return 1;
px = cli_find_frontend(appctx, args[2]);
if (!px)
return 1;
if (px->state == PR_STSTOPPED) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_NOTICE;
REORG: cli: move "shutdown frontend" to proxy.c Now we don't have any "shutdown" commands left in cli.c.
2016-11-24 05:13:06 -05:00
appctx->ctx.cli.msg = "Frontend was already shut down.\n";
CLEANUP: cli: rename STAT_CLI_* to CLI_ST_* These are in CLI states, not stats states anymore. STAT_CLI_O_CUSTOM was more appropriately renamed CLI_ST_CALLBACK.
2016-11-24 09:53:53 -05:00
appctx->st0 = CLI_ST_PRINT;
REORG: cli: move "shutdown frontend" to proxy.c Now we don't have any "shutdown" commands left in cli.c.
2016-11-24 05:13:06 -05:00
return 1;
}
CLEANUP: log: Rename Alert/Warning in ha_alert/ha_warning
2017-11-24 10:50:31 -05:00
ha_warning("Proxy %s stopped (FE: %lld conns, BE: %lld conns).\n",
px->id, px->fe_counters.cum_conn, px->be_counters.cum_conn);
REORG: cli: move "shutdown frontend" to proxy.c Now we don't have any "shutdown" commands left in cli.c.
2016-11-24 05:13:06 -05:00
send_log(px, LOG_WARNING, "Proxy %s stopped (FE: %lld conns, BE: %lld conns).\n",
px->id, px->fe_counters.cum_conn, px->be_counters.cum_conn);
stop_proxy(px);
return 1;
}
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
/* Parses the "disable frontend" directive, it always returns 1 */
MEDIUM: cli: Add payload support In order to use arbitrary data in the CLI (multiple lines or group of words that must be considered as a whole, for example), it is now possible to add a payload to the commands. To do so, the first line needs to end with a special pattern: <<\n. Everything that follows will be left untouched by the CLI parser and will be passed to the commands parsers. Per-command support will need to be added to take advantage of this feature. Signed-off-by: Aurlien Nephtali <aurelien.nephtali@corp.ovh.com>
2018-04-18 07:26:46 -04:00
static int cli_parse_disable_frontend(char **args, char *payload, struct appctx *appctx, void *private)
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
{
struct proxy *px;
if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
return 1;
px = cli_find_frontend(appctx, args[2]);
if (!px)
return 1;
if (px->state == PR_STSTOPPED) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_NOTICE;
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
appctx->ctx.cli.msg = "Frontend was previously shut down, cannot disable.\n";
CLEANUP: cli: rename STAT_CLI_* to CLI_ST_* These are in CLI states, not stats states anymore. STAT_CLI_O_CUSTOM was more appropriately renamed CLI_ST_CALLBACK.
2016-11-24 09:53:53 -05:00
appctx->st0 = CLI_ST_PRINT;
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
return 1;
}
if (px->state == PR_STPAUSED) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_NOTICE;
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
appctx->ctx.cli.msg = "Frontend is already disabled.\n";
CLEANUP: cli: rename STAT_CLI_* to CLI_ST_* These are in CLI states, not stats states anymore. STAT_CLI_O_CUSTOM was more appropriately renamed CLI_ST_CALLBACK.
2016-11-24 09:53:53 -05:00
appctx->st0 = CLI_ST_PRINT;
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
return 1;
}
if (!pause_proxy(px)) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_ERR;
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
appctx->ctx.cli.msg = "Failed to pause frontend, check logs for precise cause.\n";
CLEANUP: cli: rename STAT_CLI_* to CLI_ST_* These are in CLI states, not stats states anymore. STAT_CLI_O_CUSTOM was more appropriately renamed CLI_ST_CALLBACK.
2016-11-24 09:53:53 -05:00
appctx->st0 = CLI_ST_PRINT;
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
return 1;
}
return 1;
}
/* Parses the "enable frontend" directive, it always returns 1 */
MEDIUM: cli: Add payload support In order to use arbitrary data in the CLI (multiple lines or group of words that must be considered as a whole, for example), it is now possible to add a payload to the commands. To do so, the first line needs to end with a special pattern: <<\n. Everything that follows will be left untouched by the CLI parser and will be passed to the commands parsers. Per-command support will need to be added to take advantage of this feature. Signed-off-by: Aurlien Nephtali <aurelien.nephtali@corp.ovh.com>
2018-04-18 07:26:46 -04:00
static int cli_parse_enable_frontend(char **args, char *payload, struct appctx *appctx, void *private)
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
{
struct proxy *px;
if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
return 1;
px = cli_find_frontend(appctx, args[2]);
if (!px)
return 1;
if (px->state == PR_STSTOPPED) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_ERR;
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
appctx->ctx.cli.msg = "Frontend was previously shut down, cannot enable.\n";
CLEANUP: cli: rename STAT_CLI_* to CLI_ST_* These are in CLI states, not stats states anymore. STAT_CLI_O_CUSTOM was more appropriately renamed CLI_ST_CALLBACK.
2016-11-24 09:53:53 -05:00
appctx->st0 = CLI_ST_PRINT;
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
return 1;
}
if (px->state != PR_STPAUSED) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_NOTICE;
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
appctx->ctx.cli.msg = "Frontend is already enabled.\n";
CLEANUP: cli: rename STAT_CLI_* to CLI_ST_* These are in CLI states, not stats states anymore. STAT_CLI_O_CUSTOM was more appropriately renamed CLI_ST_CALLBACK.
2016-11-24 09:53:53 -05:00
appctx->st0 = CLI_ST_PRINT;
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
return 1;
}
if (!resume_proxy(px)) {
MINOR: add severity information to cli feedback messages
2017-07-20 10:49:14 -04:00
appctx->ctx.cli.severity = LOG_ERR;
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
appctx->ctx.cli.msg = "Failed to resume frontend, check logs for precise cause (port conflict?).\n";
CLEANUP: cli: rename STAT_CLI_* to CLI_ST_* These are in CLI states, not stats states anymore. STAT_CLI_O_CUSTOM was more appropriately renamed CLI_ST_CALLBACK.
2016-11-24 09:53:53 -05:00
appctx->st0 = CLI_ST_PRINT;
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
return 1;
}
return 1;
}
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
/* register cli keywords */
static struct cli_kw_list cli_kws = {{ },{
REORG: cli: move "{enable|disable} frontend" to proxy.c These are the last frontend-specific actions on the CLI. The function expect_frontend_admin() which is not used anymore was removed.
2016-11-24 05:55:28 -05:00
{ { "disable", "frontend", NULL }, "disable frontend : temporarily disable specific frontend", cli_parse_disable_frontend, NULL, NULL },
{ { "enable", "frontend", NULL }, "enable frontend : re-enable specific frontend", cli_parse_enable_frontend, NULL, NULL },
REORG: cli: move "set maxconn frontend" to proxy.c And get rid of the last specific "set maxconn" case.
2016-11-23 10:22:04 -05:00
{ { "set", "maxconn", "frontend", NULL }, "set maxconn frontend : change a frontend's maxconn setting", cli_parse_set_maxconn_frontend, NULL },
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
{ { "show","servers", "state", NULL }, "show servers state [id]: dump volatile server information (for backend <id>)", cli_parse_show_servers, cli_io_handler_servers_state },
MINOR: appctx/cli: remove the "be" entry from the appctx union This one now migrates to the general purpose cli.p0. The parsing function was removed since it was only used to set the pointer to NULL.
2016-12-16 12:01:15 -05:00
{ { "show", "backend", NULL }, "show backend : list backends in the current running config", NULL, cli_io_handler_show_backend },
REORG: cli: move "shutdown frontend" to proxy.c Now we don't have any "shutdown" commands left in cli.c.
2016-11-24 05:13:06 -05:00
{ { "shutdown", "frontend", NULL }, "shutdown frontend : stop a specific frontend", cli_parse_shutdown_frontend, NULL, NULL },
MINOR: cli: Let configure the dynamic cookies from the cli. This adds 3 new commands to the cli : enable dynamic-cookie backend <backend> that enables dynamic cookies for a specified backend disable dynamic-cookie backend <backend> that disables dynamic cookies for a specified backend set dynamic-cookie-key backend <backend> that lets one change the dynamic cookie secret key, for a specified backend.
2017-03-14 15:08:46 -04:00
{ { "set", "dynamic-cookie-key", "backend", NULL }, "set dynamic-cookie-key backend : change a backend secret key for dynamic cookies", cli_parse_set_dyncookie_key_backend, NULL },
{ { "enable", "dynamic-cookie", "backend", NULL }, "enable dynamic-cookie backend : enable dynamic cookies on a specific backend", cli_parse_enable_dyncookie_backend, NULL },
{ { "disable", "dynamic-cookie", "backend", NULL }, "disable dynamic-cookie backend : disable dynamic cookies on a specific backend", cli_parse_disable_dyncookie_backend, NULL },
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
{{},}
}};
[MEDIUM] modularize the "timeout" keyword configuration parser The "timeout" keyword already relied on an external parser, let's make use of the new keyword registration mechanism.
2008-07-09 14:34:27 -04:00
__attribute__((constructor))
static void __proxy_module_init(void)
{
cfg_register_keywords(&cfg_kws);
REORG: cli: move 'show servers' to proxy.c Move 'show servers' CLI functions to proxy.c and use the cli keyword API to register it on the CLI.
2016-11-18 20:25:36 -05:00
cli_register_kw(&cli_kws);
[MEDIUM] modularize the "timeout" keyword configuration parser The "timeout" keyword already relied on an external parser, let's make use of the new keyword registration mechanism.
2008-07-09 14:34:27 -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