code, comments and doc actually.
- continue to send pull requests after having been explained why they are not
welcome.
- - give wrong advices to people asking for help, or sending them patches to
+ - give wrong advice to people asking for help, or sending them patches to
try which make no sense, waste their time, and give them a bad impression
of the people working on the project.
* Add section description as label for all metrics
It is possible to set a description in global and proxy sections, via the
-"description" directive. The global descrption is exposed if it is define via
+"description" directive. The global description is exposed if it is define via
the "haproxy_process_description" metric. But the descriptions provided in proxy
sections are not dumped. However, it is possible to add it as a label for all
metrics of the corresponding section, including the global one. To do so,
# returns $node filled with the first node of ebroot $arg0
define ebtree_first
- # browse ebtree left until encoutering leaf
+ # browse ebtree left until encountering leaf
set $node = (struct eb_node *)$arg0->b[0]
while 1
_ebtree_set_tag_node $node
# returns $node filled with the first node of ebroot $arg0
define ebsctree_first
- # browse ebsctree left until encoutering leaf
+ # browse ebsctree left until encountering leaf
set $node = (struct eb32sc_node *)$arg0->b[0]
while 1
_ebsctree_set_tag_node $node
thread groups.
This mapping is normally performed using the "cpu-map" directive, though it
- can be particularly difficult to maintain on heterogenous systems.
+ can be particularly difficult to maintain on heterogeneous systems.
The "cpu-policy" directive chooses between a small number of allocation
policies which one to use instead, when "cpu-map" is not used. The following
cpu-demanding actions (e.g.: actions that work on content) may create thread
contention as all the rules from a given ruleset are evaluated under the same
polling loop if the evaluation is not interrupted. This option ensures that no
- more than <number> number of rules may be excecuted under the same polling
+ more than <number> number of rules may be executed under the same polling
loop for content-oriented rulesets (those that already support yielding due
to content inspection). What it does is that it forces the evaluating function
to yield, so that it comes back on the next polling loop to continues the
very powerful tool to diagnose issues. Traces can be dynamically configured via
the CLI. It is also possible to predefined some settings in the configuration
file, in dedicated "traces" sections. More details about traces can be found in
-the management guide. It remains a developper tools used during complex
+the management guide. It remains a developer tools used during complex
debugging sessions. It is pretty verbose and have a cost, so use it with
-caution. And because it is a developper tool, there is no warranty about the
+caution. And because it is a developer tool, there is no warranty about the
backward compatibility of this section.
traces
sections marked with "(!)" are only supported in named defaults sections, not
anonymous ones.
-Note: Some dangerous and not recommanded directives are intentionnaly not
+Note: Some dangerous and not recommended directives are intentionnaly not
listed in the following matrix. It is on purpose. These directives are
documentated. But by not listing them below is one more way to discourage
anyone to use it.
The following values can be specified:
- - "always" : this is the default stategy. A stream is assigned to a
+ - "always" : this is the default strategy. A stream is assigned to a
server based on hashing irrespective of whether the server
is currently saturated.
to set the weight of a server. Setting it with the "weight:" prefix is
preferred.
- - The string "weight:" following by an positive interger or a positive
- interger percentage, with no space. If the value ends with the '%' sign,
+ - The string "weight:" following by an positive integer or a positive
+ integer percentage, with no space. If the value ends with the '%' sign,
then the new weight will be proportional to the initially weight of the
server. Otherwise, the value is considered as an absolute weight and must
be between 0 and 256. Servers which are part of a farm running a static
some rarely needed data that should only be emitted under certain conditions,
such as debugging information when an error is met.
- The condition is made of a keyword among the list below, optionally preceeded
+ The condition is made of a keyword among the list below, optionally preceded
by an exclamation mark ('!') to negate it, and optionally suffixed by some
arguments specific to that condition:
is considered the best CPUs. So the preference really looks like
a different setting.
-More precisely, the final stategy involves multiple criteria. For example,
+More precisely, the final strategy involves multiple criteria. For example,
let's say that the number of threads is set to 4 and we've restricted ourselves
to using the first thread of each CPU core. We're on an EPYC74F3, there are 3
cores per CCX. One algorithm (resource) would create one group with 3 threads
above). However the info about the capacity still allows to figure that and
should probably be used for that. At this point it would seem logical to say
that the cluster number is re-adjusted based on the claimed capacity, at
-least to avoid accidentally mixing workloads on heterogenous cores. But
+least to avoid accidentally mixing workloads on heterogeneous cores. But
sorting by cluster number might not necessarily work if allocated randomly.
So we might need a distinct metric that doesn't require to override the
system's numbering, like a "set", "group", "team", "bond", "bunch", "club",
in case of duplicated entries, only the first matching entry is returned.
.. Warning::
- Not meant to be shared bewteen multiple contexts. If multiple contexts
+ Not meant to be shared between multiple contexts. If multiple contexts
need to work on the same pattern reference, each context should have
its own patref object.
.. js:function:: Patref.commit(ref)
Tries to commit pending Patref object updates, that is updates made to the
- local object will be committed to the underlying patter reference storage
+ local object will be committed to the underlying pattern reference storage
in an atomic manner upon success. Upon failure, local pending updates are
lost. Upon success, all other pending updates on the pattern reference
(e.g.: "prepare" from the cli or from other Patref Lua objects) started
output reports less entries than really exist because it will dump all
existing streams up to the last one that was created before the command was
entered; those which die in the mean time will not appear.
- For supported opitons, see below.
+ For supported options, see below.
show sess [<id> | all | help] [<options>*]
Display a lot of internal information about the matching streams. The command
The 'SNI' column shows the SNI, it can be either a CN, a SAN or a filter from a crt-list.
The default certificates of a bind line, (which are either declared
- explicitely by 'default-crt' or is implicitely the first certificate of a bind
+ explicitly by 'default-crt' or is implicitly the first certificate of a bind
line when no 'strict-sni' is used) shows the '*' character in the SNI column.
The 'Negative Filter' column is the list of negative filters associated to a
/* ctl command used by mux->ctl() */
enum mux_ctl_type {
- MUX_CTL_STATUS, /* Expects an int as output, sets it to a combinaison of MUX_CTL_STATUS flags */
+ MUX_CTL_STATUS, /* Expects an int as output, sets it to a combination of MUX_CTL_STATUS flags */
MUX_CTL_EXIT_STATUS, /* Expects an int as output, sets the mux exist/error/http status, if known or 0 */
MUX_CTL_REVERSE_CONN, /* Notify about an active reverse connection accepted. */
MUX_CTL_SUBS_RECV, /* Notify the mux it must wait for read events again */
if (!evt)
continue;
- /* Backend location are displayed in captial letter */
+ /* Backend location are displayed in capital letter */
is_back = !!((evt >> 4) & 0x8);
switch ((enum term_event_loc)((evt >> 4) & ~0x8)) {
case tevt_loc_fd: tevt_evts_str[idx++] = (is_back ? 'F' : 'f'); break;
unsigned char cluster_secret[16]; /* 128 bits of an SHA1 digest of a secret defined as ASCII string */
struct {
int maxpollevents; /* max number of poll events at once */
- int max_rules_at_once; /* max number of rules excecuted in a single evaluation loop */
+ int max_rules_at_once; /* max number of rules executed in a single evaluation loop */
int maxaccept; /* max number of consecutive accept() */
int options; /* various tuning options */
uint debug; /* various debugging options (GDBG_*) */
struct buffer *srcbuf, size_t ofs, size_t max);
/* Returns the URI of an HTX message in the most common format for a H1 peer. It
- * is the path part of an absolute URI when the URI was normalized, ortherwise
+ * is the path part of an absolute URI when the URI was normalized, otherwise
* it is the whole URI, as received. Concretely, it is only a special case for
* URIs received from H2 clients, to be able to send a relative path the H1
* servers.
REDIRECT_FLAG_FROM_REQ = 4, /* redirect rule on the request path */
REDIRECT_FLAG_IGNORE_EMPTY = 8, /* silently ignore empty location expressions */
REDIRECT_FLAG_KEEP_QS = 16, /* append the query string to location, if any */
- REDIRECT_FLAG_COOKIE_FMT = 32, /* The cookie value is a log-format stirng*/
+ REDIRECT_FLAG_COOKIE_FMT = 32, /* The cookie value is a log-format string */
};
/* Redirect types (location, prefix, extended ) */
#define SSL_OP_CIPHER_SERVER_PREFERENCE 0
#endif
-/* needs OpenSSL >= 0.9.7 and renegotation options on WolfSSL */
+/* needs OpenSSL >= 0.9.7 and renegotiation options on WolfSSL */
#if !defined(SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION) || \
(defined(USE_OPENSSL_WOLFSSL) && !defined(HAVE_SECURE_RENEGOTIATION) && !defined(HAVE_SERVER_RENEGOTIATION_INFO))
#undef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
char buf[VAR_ARRAY]; /* copy of the beginning of the message for bufsize bytes */
};
-/* Each proxy will have one occurence of this structure per thread group */
+/* Each proxy will have one occurrence of this structure per thread group */
struct proxy_per_tgroup {
struct queue queue;
} THREAD_ALIGNED(64);
uint32_t recovery_start_ts;
};
-/* pacing can be optionnaly activated on top of the algorithm */
+/* pacing can be optionally activated on top of the algorithm */
#define QUIC_CC_ALGO_FL_OPT_PACING 0x01
struct quic_cc_algo {
#include <haproxy/quic_cc-t.h>
struct quic_pacer {
- const struct quic_cc *cc; /* Congestion controler algo used for this connection */
+ const struct quic_cc *cc; /* Congestion controller algo used for this connection */
ullong cur; /* Nanosecond timestamp of the last credit reloading */
uint credit; /* Number of packets which can be emitted in a single burst */
else if (sc_ep_test(sc, SE_FL_T_APPLET)) {
sc_applet_sync_send(sc);
if (sc_oc(sc)->flags & CF_WRITE_EVENT) {
- /* Data was send, wake the applet up. It is safe to do so becasuse sc_applet_sync_send()
+ /* Data was send, wake the applet up. It is safe to do so because sc_applet_sync_send()
* removes CF_WRITE_EVENT flag from the channel before trying to send data to the applet.
*/
task_wakeup(__sc_appctx(sc)->t, TASK_WOKEN_OTHER);
/* All supported SPOP actions */
enum spoe_action_type {
- SPOP_ACT_T_NOOP = 0, /* internal action for ampty ACK */
+ SPOP_ACT_T_NOOP = 0, /* internal action for an empty ACK */
SPOP_ACT_T_SET_VAR = 1,
SPOP_ACT_T_UNSET_VAR,
SPOP_ACT_TYPES,
* the same split bit as its parent node, it is necessary its associated leaf
*
* When descending along the tree, it is possible to know that a search key is
- * not present, because its XOR with both of the branches is stricly higher
+ * not present, because its XOR with both of the branches is strictly higher
* than the inter-branch XOR. The reason is simple : the inter-branch XOR will
* have its highest bit set indicating the split bit. Since it's the bit that
* differs between the two branches, the key cannot have it both set and
expect resp.http.transfer-encoding == "<undef>"
expect resp.bodylen == 100
- # 7. Response alerady compressed by the server (with "Accept-Encoding")
+ # 7. Response already compressed by the server (with "Accept-Encoding")
txreq -url "/c1.7" \
-hdr "Accept-Encoding: gzip"
rxresp
static char *memprof_strdup_initial_handler(const char *s);
static void memprof_free_initial_handler(void *ptr);
-/* these ones are optional but may be used by some dependecies */
+/* these ones are optional but may be used by some dependencies */
static char *memprof_strndup_initial_handler(const char *s, size_t n);
static void *memprof_valloc_initial_handler(size_t sz);
static void *memprof_pvalloc_initial_handler(size_t sz);
static char *(*memprof_strdup_handler)(const char *s) = memprof_strdup_initial_handler;
static void (*memprof_free_handler)(void *ptr) = memprof_free_initial_handler;
-/* these ones are optional but may be used by some dependecies */
+/* these ones are optional but may be used by some dependencies */
static char *(*memprof_strndup_handler)(const char *s, size_t n) = memprof_strndup_initial_handler;
static void *(*memprof_valloc_handler)(size_t sz) = memprof_valloc_initial_handler;
static void *(*memprof_pvalloc_handler)(size_t sz) = memprof_pvalloc_initial_handler;
break;
}
else if (*p == '.') {
- /* The pointer is rewinded to the dot before the
+ /* The pointer is rewound to the dot before the
* tld, we memorize the end of the domain and
* can enter the domain processing. */
end = p;
continue;
if (strcmp(kwl->kw[index].kw, args[0]) == 0) {
- /* in MODE_DISCOVERY we read only the keywords, which contains the appropiate flag */
+ /* in MODE_DISCOVERY we read only the keywords, which contains the appropriate flag */
if ((global.mode & MODE_DISCOVERY) && ((kwl->kw[index].flags & KWF_DISCOVERY) == 0 ))
goto out;
file, line, args[0], args[1], strerror(errno));
else if (errno == EACCES)
ha_diag_warning("parsing [%s:%d]: '%s': '%s': %s "
- "(process is need to be started with root priviledges to be able to chroot).\n",
+ "(process is need to be started with root privileges to be able to chroot).\n",
file, line, args[0], args[1], strerror(errno));
else
ha_diag_warning("parsing [%s:%d]: '%s': '%s': stat() is failed: %s.\n",
if (strcmp(suffix, "cc.cubic.min-losses") == 0)
global.tune.quic_cubic_loss_tol = arg - 1;
else if (strcmp(suffix, "frontend.conn-tx-buffers.limit") == 0) {
- memprintf(err, "'%s' keyword is now obsolote and has no effect. "
+ memprintf(err, "'%s' keyword is now obsolete and has no effect. "
"Use 'tune.quic.frontend.default-max-window-size' to limit Tx buffer allocation per connection.", args[0]);
return 1;
}
global.tune.quic_frontend_glitches_threshold = arg;
else if (strcmp(suffix, "frontend.max-data-size") == 0) {
if ((errptr = parse_size_err(args[1], &arg))) {
- memprintf(err, "'%s': unexpected charater '%c' in size argument '%s'.",
+ memprintf(err, "'%s': unexpected character '%c' in size argument '%s'.",
args[0], *errptr, args[1]);
return -1;
}
if (l->idx > r->idx && r->idx >= 0)
return 1;
- /* exactly the same (e.g. absent, should not happend) */
+ /* exactly the same (e.g. absent, should not happen) */
return 0;
}
/* First, let's check the cache hierarchy. On systems exposing
* it, index0 generally is the L1D cache, index1 the L1I, index2
* the L2 and index3 the L3. But sometimes L1I/D are reversed,
- * and some CPUs also have L0 or L4. Maybe some heterogenous
+ * and some CPUs also have L0 or L4. Maybe some heterogeneous
* SoCs even have inconsistent levels between clusters... Thus
* we'll scan all entries that we can find for each CPU and
* assign levels based on what is reported. The types generally
mworker_run_master();
}
-/* parse conf in disovery mode and set modes from config */
+/* parse conf in discovery mode and set modes from config */
static void read_cfg_in_discovery_mode(int argc, char **argv)
{
struct cfgfile *cfg, *cfg_tmp;
exit(EXIT_FAILURE);
}
- /* "progam" sections, if there are any, were alredy parsed only by master
+ /* "program" sections, if there are any, were already parsed only by master
* and programs are forked before calling postparser functions from
* postparser list. So, all checks related to "program" section integrity
* and sections vs MODE_MWORKER combinations should be done here.
if (backup_env() != 0)
exit(EXIT_FAILURE);
- /* parse conf in disovery mode and set modes from config */
+ /* parse conf in discovery mode and set modes from config */
read_cfg_in_discovery_mode(argc, argv);
/* From this stage all runtime modes are known. So let's do below some
* forked. Thus the current worker inherits ipc_fd[0]s from the previous
* ones by it's parent, master, because we have to keep shared sockpair
* ipc_fd[0] always opened in master (master CLI server is listening on
- * this fd). It's safe to call close() at this point on these inhereted
- * ipc_fd[0]s, as they are inhereted after master re-exec unbound, we
+ * this fd). It's safe to call close() at this point on these inherited
+ * ipc_fd[0]s, as they are inherited after master re-exec unbound, we
* keep them like this during bind_listeners() call. So, these fds were
* never referenced in the current worker's fdtab.
*/
}
/* applies the renice value in the worker or standalone after configuration parsing
- * but before chaning identity */
+ * but before changing identity */
if (!master && global.tune.renice_runtime) {
if (setpriority(PRIO_PROCESS, 0, global.tune.renice_runtime - 100) == -1) {
ha_warning("[%s.main()] couldn't set the runtime nice value to %d: %s\n",
*
* configured | Number of
* instructions | loops executed
- * between two | in milions
+ * between two | in millions
* forced yields |
* ---------------+---------------
* 10 | 160
#include <haproxy/version.h>
-/* Release memory allocated by most of HTTP actions. Concretly, it releases
+/* Release memory allocated by most of HTTP actions. Concretely, it releases
* <arg.http>.
*/
static void release_http_action(struct act_rule *rule)
lf_expr_deinit(&rule->arg.http.fmt);
}
-/* Release memory allocated by HTTP actions relying on an http reply. Concretly,
+/* Release memory allocated by HTTP actions relying on an http reply. Concretely,
* it releases <.arg.http_reply>
*/
static void release_act_http_reply(struct act_rule *rule)
/*
* input: ipv4 address, ipv6 address or str (empty string will result in
- * "unknown" indentifier, else string will be translated to _obfs
- * indentifier, prefixed by '_'. Must comply with RFC7239 charset)
+ * "unknown" identifier, else string will be translated to _obfs
+ * identifier, prefixed by '_'. Must comply with RFC7239 charset)
*
* output: rfc7239-compliant forwarded header nodename
*/
/*
* input: unsigned integer or str (string will be translated to _obfs
- * indentifier, prefixed by '_'. Must comply with RFC7239 charset)
+ * identifier, prefixed by '_'. Must comply with RFC7239 charset)
*
* output: rfc7239-compliant forwarded header nodeport
*/
const BIGNUM *r = NULL, *s = NULL;
int bignum_len;
- /* need to pad to byte size, essentialy for P-521 */
+ /* need to pad to byte size, essentially for P-521 */
bignum_len = (EVP_PKEY_bits(pkey) + 7) / 8;
if ((sig = d2i_ECDSA_SIG(NULL, (const unsigned char **)&sign->area, sign->data)) == NULL)
}
/* Returns 1 if the H1 connection is alive (IDLE, EMBRYONIC, RUNNING or
- * DRAINING). Ortherwise 0 is returned.
+ * DRAINING). Otherwise 0 is returned.
*/
static inline int h1_is_alive(const struct h1c *h1c)
{
if ((unsigned)hdr.len > (unsigned)global.tune.bufsize) {
/* RFC7540#4.2: invalid frame length */
h2c_report_glitch(h2c, 1, "too large CONTINUATION frame");
- TRACE_STATE("too large CONTIUATION frame", H2_EV_RX_FRAME|H2_EV_RX_FHDR|H2_EV_RX_HDR|H2_EV_RX_CONT|H2_EV_H2C_ERR|H2_EV_PROTO_ERR, h2c->conn);
+ TRACE_STATE("too large CONTINUATION frame", H2_EV_RX_FRAME|H2_EV_RX_FHDR|H2_EV_RX_HDR|H2_EV_RX_CONT|H2_EV_H2C_ERR|H2_EV_PROTO_ERR, h2c->conn);
h2c_error(h2c, H2_ERR_FRAME_SIZE_ERROR);
goto fail;
}
qcc_clear_frms(qcc);
if (urg) {
- /* qcc_emit_rs_ss() relies on resetted/aborted streams in send_list front. */
+ /* qcc_emit_rs_ss() relies on reset/aborted streams in send_list front. */
BUG_ON(!(qcs->flags & (QC_SF_TO_RESET|QC_SF_TO_STOP_SENDING|QC_SF_TXBUB_OOB)));
LIST_DEL_INIT(&qcs->el_send);
*
* This functions also serves to emit RESET_STREAM and STOP_SENDING frames. In
* this case, frame is emitted immediately without using <qcc> tx frms. If an
- * error occured during this step, this is considered as fatal. Tx frms is
+ * error occurred during this step, this is considered as fatal. Tx frms is
* cleared and 0 is returned.
*
* Returns the sum of encoded payload STREAM frames length. Note that 0 can be
* mechanism. A message is notified in this case when running in diagnostic
* mode.
*
- * Returns ERR_NONE if every checks performed, wether or not some features are
+ * Returns ERR_NONE if every checks performed, whether or not some features are
* not available. ERR_FATAL is reported if checks cannot be executed.
*/
static int quic_test_socketopts(void)
/* defproxy is const pointer, so we need to typecast log_steps to
* drop the const in order to use EB tree API, please note however
- * that the operations performed below should theorically be read-only
+ * that the operations performed below should theoretically be read-only
*/
node = eb32_first((struct eb_root *)&defproxy->conf.log_steps);
while (node) {
*
* We'll dequeue MAX_SELF_USE_QUEUE items from the queue corresponding
* to our thread group, then we'll get one from a different one, to
- * be sure those actually get processsed too.
+ * be sure those actually get processed too.
*/
while (non_empty_tgids != 0
&& (done < global.tune.maxpollevents || !s->served) &&
* The camelcase naming convention is used by the BBR RFC for the function names
* and constants. To helps in matching the code below with the RFC one, note
* that all the function names have been translated this way. The uppercase
- * letters have been replaced by lowercase letters. The words have been seperated
+ * letters have been replaced by lowercase letters. The words have been separated
* by underscores as follows:
*
* ex: BBRMinPipeCwnd() -> bbr_min_pipe_cwnd()
/* Note: if no token for address validation was received
* for a 0RTT connection, some 0RTT packet could still be
* waiting for HP removal AFTER the successful handshake completion.
- * Indeed a successful handshake completion implicitely valids
+ * Indeed a successful handshake completion implicitly valids
* the peer address. In this case, one wants to process
- * these ORTT packets AFTER the succesful handshake completion.
+ * these ORTT packets AFTER the successful handshake completion.
*
* On the contrary, when a token for address validation was received,
* release 0RTT packets still waiting for HP removal. These
/* Handle <frm> frame whose packet it is attached to has just been acknowledged. The memory allocated
* for this frame will be at least released in every cases.
*
- * Returns 1 on sucess else 0.
+ * Returns 1 on success else 0.
*/
static int qc_handle_newly_acked_frm(struct quic_conn *qc, struct quic_frame *frm)
{
/* Handle <newly_acked_pkts> list of newly acknowledged TX packets.
*
- * Returns 1 on sucess else 0.
+ * Returns 1 on success else 0.
*/
static int qc_handle_newly_acked_pkts(struct quic_conn *qc,
unsigned int *pkt_flags, struct list *newly_acked_pkts)
if (final_size < tail_offset)
b_sub(buf, tail_offset - final_size);
- /* Release active buffer, or delete it immediatly if there is
+ /* Release active buffer, or delete it immediately if there is
* no data to acknowledge. Both functions will reset active
* buf pointer and invoke <notify_room> if necessary.
*/
}
/* Acknowledges data for buffer <buf> attached to <stream> instance. This covers
- * the range strating at <offset> and of length <len>, with <fin> sets for the
+ * the range starting at <offset> and of length <len>, with <fin> sets for the
* last stream frame.
*
* Returns <buf> if there is still data to acknowledge or buffered ACK to
/* This function is reserved to convert a big buffer to a smaller one. */
BUG_ON(!stream->buf || !stream->buf->sbuf);
- /* This function can only be used if targetted buffer is empty. */
+ /* This function can only be used if targeted buffer is empty. */
BUG_ON(b_data(&stream->buf->buf));
/* Release buffer */
/* Commit a datagram payload written into <buf> of length <length>. <first_pkt>
* must contains the address of the first packet stored in the payload. When
- * GSO is used, several datagrams can be commited at once. In this case,
+ * GSO is used, several datagrams can be committed at once. In this case,
* <length> must be the total length of all consecutive datagrams.
*
* Caller is responsible that there is enough space in the buffer.
* its frames which were already acknowledeged.
* See qc_stream_frm_is_acked()) called by qc_build_frms().
* Note that qc_stream_frm_is_acked() logs a trace in this
- * case mentionning some frames were already acknowledged.
+ * case mentioning some frames were already acknowledged.
*
* That said, the consequence must be the same: cancelling
* the packet build as if there was not enough room in the
}
/* Append delimiter (only to a non empty input) followed by the optional
- * variable contents concatenated with the optional sufix.
+ * variable contents concatenated with the optional suffix.
*/
static int sample_conv_add_item(const struct arg *arg_p, struct sample *smp, void *private)
{
while (sft) {
HA_SPIN_LOCK(SFT_LOCK, &sft->lock);
/* If appctx is NULL, start a new session and perform the appctx
- * assigment right away since the applet is not supposed to change
+ * assignment right away since the applet is not supposed to change
* during the session lifetime. By doing the assignment now we
* make sure to start the session exactly once.
*
*
* We have no explanation for now. Why epoll report the
* connection is closed while the connect() it able to validate
- * it ? no idea. But, it seems reasonnable in this case, and if
+ * it ? no idea. But, it seems reasonable in this case, and if
* no error was reported, to remove the the HUP flag. At worst, if
* the connection is really closed, this will be reported later.
*
/* IO handler of "show ssl sni [<frontend>]".
* It makes use of a show_sni_ctx context
*
- * The fonction does loop over the frontend, the bind_conf and the sni_ctx.
+ * The function does loop over the frontend, the bind_conf and the sni_ctx.
*/
static int cli_io_handler_show_sni(struct appctx *appctx)
{
else
n = ebmb_first(&bind->sni_w_ctx);
}
- /* emty SNI tree, skip */
+ /* empty SNI tree, skip */
if (!n)
continue;
[ST_I_PX_HANAFAIL] = ME_NEW_BE("hanafail", NULL, FN_COUNTER, FF_U64, failed_hana, STATS_PX_CAP____S, "Total number of failed checks caused by an 'on-error' directive after an 'observe' condition matched"),
[ST_I_PX_REQ_RATE] = ME_NEW_FE("req_rate", NULL, FN_RATE, FF_U32, req_per_sec, STATS_PX_CAP__F__, "Number of HTTP requests processed over the last second on this object"),
[ST_I_PX_REQ_RATE_MAX] = { .name = "req_rate_max", .alt_name = "http_requests_rate_max", .desc = "Highest value of http requests observed since the worker process started", .cap = STATS_PX_CAP__F__ },
- /* Note: ST_I_PX_REQ_TOT is also diplayed on frontend but does not uses a raw counter value, see me_generate_field() for details. */
+ /* Note: ST_I_PX_REQ_TOT is also displayed on frontend but does not uses a raw counter value, see me_generate_field() for details. */
[ST_I_PX_REQ_TOT] = ME_NEW_BE("req_tot", "http_requests_total", FN_COUNTER, FF_U64, p.http.cum_req, STATS_PX_CAP__FBS, "Total number of HTTP requests processed by this object since the worker process started"),
[ST_I_PX_CLI_ABRT] = ME_NEW_BE("cli_abrt", "client_aborts_total", FN_COUNTER, FF_U64, cli_aborts, STATS_PX_CAP___BS, "Total number of requests or connections aborted by the client since the worker process started"),
[ST_I_PX_SRV_ABRT] = ME_NEW_BE("srv_abrt", "server_aborts_total", FN_COUNTER, FF_U64, srv_aborts, STATS_PX_CAP___BS, "Total number of requests or connections aborted by the server since the worker process started"),
}
/* TODO Special case needed for ST_I_PX_REQ_TOT. It is defined as a
- * generic column for backend side. Extra code required to diplay it on
+ * generic column for backend side. Extra code required to display it on
* frontend side as an aggregate of values split by HTTP version.
*/
if (idx == ST_I_PX_REQ_TOT && cap == STATS_PX_CAP_FE && !stat_file) {
}
/*
- * Decrease the refcount of a stksess and relase it if the refcount falls to 0.
+ * Decrease the refcount of a stksess and release it if the refcount falls to 0.
* Returns non-zero if deleted, zero otherwise.
*
* This function locks the corresponding table shard to proceed. When this
}
}
- /* if that's an exact match, no need to call dl_addr. This happends
+ /* if that's an exact match, no need to call dl_addr. This happens
* when showing callback pointers for example, but not in backtraces.
*/
if (!best_dist)
projects / thirdparty / haproxy.git / commitdiff
