summaryrefslogtreecommitdiffstats
path: root/src/server.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-06-03 05:11:10 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-06-03 05:11:10 +0000
commitcff6d757e3ba609c08ef2aaa00f07e53551e5bf6 (patch)
tree08c4fc3255483ad397d712edb4214ded49149fd9 /src/server.c
parentAdding upstream version 2.9.7. (diff)
downloadhaproxy-cff6d757e3ba609c08ef2aaa00f07e53551e5bf6.tar.xz
haproxy-cff6d757e3ba609c08ef2aaa00f07e53551e5bf6.zip
Adding upstream version 3.0.0.upstream/3.0.0
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--src/server.c1295
1 files changed, 854 insertions, 441 deletions
diff --git a/src/server.c b/src/server.c
index 9196fac..caf2f40 100644
--- a/src/server.c
+++ b/src/server.c
@@ -28,6 +28,7 @@
#include <haproxy/dict-t.h>
#include <haproxy/errors.h>
#include <haproxy/global.h>
+#include <haproxy/guid.h>
#include <haproxy/log.h>
#include <haproxy/mailers.h>
#include <haproxy/namespace.h>
@@ -140,18 +141,10 @@ const char *srv_op_st_chg_cause(enum srv_op_st_chg_cause cause)
int srv_downtime(const struct server *s)
{
- if ((s->cur_state != SRV_ST_STOPPED) || s->last_change >= ns_to_sec(now_ns)) // ignore negative time
+ if ((s->cur_state != SRV_ST_STOPPED) || s->counters.last_change >= ns_to_sec(now_ns)) // ignore negative time
return s->down_time;
- return ns_to_sec(now_ns) - s->last_change + s->down_time;
-}
-
-int srv_lastsession(const struct server *s)
-{
- if (s->counters.last_sess)
- return ns_to_sec(now_ns) - s->counters.last_sess;
-
- return -1;
+ return ns_to_sec(now_ns) - s->counters.last_change + s->down_time;
}
int srv_getinter(const struct check *check)
@@ -170,7 +163,7 @@ int srv_getinter(const struct check *check)
/* Update server's addr:svc_port tuple in INET context
*
- * Must be called under thread isolation to ensure consistent readings accross
+ * Must be called under thread isolation to ensure consistent readings across
* all threads (addr:svc_port might be read without srv lock being held).
*/
static void _srv_set_inetaddr_port(struct server *srv,
@@ -184,6 +177,11 @@ static void _srv_set_inetaddr_port(struct server *srv,
else
srv->flags &= ~SRV_F_MAPPORTS;
+ if (srv->proxy->lbprm.update_server_eweight) {
+ /* some balancers (chash in particular) may use the addr in their routing decisions */
+ srv->proxy->lbprm.update_server_eweight(srv);
+ }
+
if (srv->log_target && srv->log_target->type == LOG_TARGET_DGRAM) {
/* server is used as a log target, manually update log target addr for DGRAM */
ipcpy(addr, srv->log_target->addr);
@@ -268,7 +266,7 @@ static struct task *server_atomic_sync(struct task *task, void *context, unsigne
px = proxy_find_by_id(data->server.safe.proxy_uuid, PR_CAP_BE, 0);
if (!px)
continue;
- srv = findserver_unique_id(px, data->server.safe.puid, data->server.safe.rid);
+ srv = server_find_by_id_unique(px, data->server.safe.puid, data->server.safe.rid);
if (!srv)
continue;
@@ -295,7 +293,7 @@ static struct task *server_atomic_sync(struct task *task, void *context, unsigne
/*
* this requires thread isolation, which is safe since we're the only
* task working for the current subscription and we don't hold locks
- * or ressources that other threads may depend on to complete a running
+ * or resources that other threads may depend on to complete a running
* cycle. Note that we do this way because we assume that this event is
* rather rare.
*/
@@ -306,9 +304,24 @@ static struct task *server_atomic_sync(struct task *task, void *context, unsigne
_srv_set_inetaddr_port(srv, &new_addr,
data->safe.next.port.svc, data->safe.next.port.map);
- /* propagate the changes */
- if (data->safe.purge_conn) /* force connection cleanup on the given server? */
- srv_cleanup_connections(srv);
+ /* propagate the changes, force connection cleanup */
+ if (new_addr.ss_family != AF_UNSPEC &&
+ (srv->next_admin & SRV_ADMF_RMAINT)) {
+ /* server was previously put under DNS maintenance due
+ * to DNS error, but addr resolves again, so we must
+ * put it out of maintenance
+ */
+ srv_clr_admin_flag(srv, SRV_ADMF_RMAINT);
+
+ /* thanks to valid DNS resolution? */
+ if (data->safe.updater.dns) {
+ chunk_reset(&trash);
+ chunk_printf(&trash, "Server %s/%s administratively READY thanks to valid DNS answer", srv->proxy->id, srv->id);
+ ha_warning("%s.\n", trash.area);
+ send_log(srv->proxy, LOG_NOTICE, "%s.\n", trash.area);
+ }
+ }
+ srv_cleanup_connections(srv);
srv_set_dyncookie(srv);
srv_set_addr_desc(srv, 1);
}
@@ -437,47 +450,25 @@ void _srv_event_hdl_prepare_state(struct event_hdl_cb_data_server_state *cb_data
*/
static void _srv_event_hdl_prepare_inetaddr(struct event_hdl_cb_data_server_inetaddr *cb_data,
struct server *srv,
- const struct sockaddr_storage *next_addr,
- unsigned int next_port, uint8_t next_mapports,
- uint8_t purge_conn)
+ const struct server_inetaddr *next_inetaddr,
+ struct server_inetaddr_updater updater)
{
- struct sockaddr_storage *prev_addr = &srv->addr;
- unsigned int prev_port = srv->svc_port;
- uint8_t prev_mapports = !!(srv->flags & SRV_F_MAPPORTS);
+ struct server_inetaddr prev_inetaddr;
+
+ server_get_inetaddr(srv, &prev_inetaddr);
/* only INET families are supported */
- BUG_ON((prev_addr->ss_family != AF_UNSPEC &&
- prev_addr->ss_family != AF_INET && prev_addr->ss_family != AF_INET6) ||
- (next_addr->ss_family != AF_UNSPEC &&
- next_addr->ss_family != AF_INET && next_addr->ss_family != AF_INET6));
+ BUG_ON((next_inetaddr->family != AF_UNSPEC &&
+ next_inetaddr->family != AF_INET && next_inetaddr->family != AF_INET6));
/* prev */
- cb_data->safe.prev.family = prev_addr->ss_family;
- memset(&cb_data->safe.prev.addr, 0, sizeof(cb_data->safe.prev.addr));
- if (prev_addr->ss_family == AF_INET)
- cb_data->safe.prev.addr.v4.s_addr =
- ((struct sockaddr_in *)prev_addr)->sin_addr.s_addr;
- else if (prev_addr->ss_family == AF_INET6)
- memcpy(&cb_data->safe.prev.addr.v6,
- &((struct sockaddr_in6 *)prev_addr)->sin6_addr,
- sizeof(struct in6_addr));
- cb_data->safe.prev.port.svc = prev_port;
- cb_data->safe.prev.port.map = prev_mapports;
+ cb_data->safe.prev = prev_inetaddr;
/* next */
- cb_data->safe.next.family = next_addr->ss_family;
- memset(&cb_data->safe.next.addr, 0, sizeof(cb_data->safe.next.addr));
- if (next_addr->ss_family == AF_INET)
- cb_data->safe.next.addr.v4.s_addr =
- ((struct sockaddr_in *)next_addr)->sin_addr.s_addr;
- else if (next_addr->ss_family == AF_INET6)
- memcpy(&cb_data->safe.next.addr.v6,
- &((struct sockaddr_in6 *)next_addr)->sin6_addr,
- sizeof(struct in6_addr));
- cb_data->safe.next.port.svc = next_port;
- cb_data->safe.next.port.map = next_mapports;
+ cb_data->safe.next = *next_inetaddr;
- cb_data->safe.purge_conn = purge_conn;
+ /* updater */
+ cb_data->safe.updater = updater;
}
/* server event publishing helper: publish in both global and
@@ -900,11 +891,6 @@ static int srv_parse_disabled(char **args, int *cur_arg,
static int srv_parse_enabled(char **args, int *cur_arg,
struct proxy *curproxy, struct server *newsrv, char **err)
{
- if (newsrv->flags & SRV_F_DYNAMIC) {
- ha_warning("Keyword 'enabled' is ignored for dynamic servers. It will be rejected from 3.0 onward.");
- return 0;
- }
-
newsrv->next_admin &= ~SRV_ADMF_CMAINT & ~SRV_ADMF_FMAINT;
newsrv->next_state = SRV_ST_RUNNING;
newsrv->check.state &= ~CHK_ST_PAUSED;
@@ -933,6 +919,28 @@ static int srv_parse_error_limit(char **args, int *cur_arg,
return 0;
}
+/* Parse the "guid" keyword */
+static int srv_parse_guid(char **args, int *cur_arg,
+ struct proxy *curproxy, struct server *newsrv, char **err)
+{
+ const char *guid;
+ char *guid_err = NULL;
+
+ if (!*args[*cur_arg + 1]) {
+ memprintf(err, "'%s' : expects an argument", args[*cur_arg]);
+ return ERR_ALERT | ERR_FATAL;
+ }
+
+ guid = args[*cur_arg + 1];
+ if (guid_insert(&newsrv->obj_type, guid, &guid_err)) {
+ memprintf(err, "'%s': %s", args[*cur_arg], guid_err);
+ ha_free(&guid_err);
+ return ERR_ALERT | ERR_FATAL;
+ }
+
+ return 0;
+}
+
/* Parse the "ws" keyword */
static int srv_parse_ws(char **args, int *cur_arg,
struct proxy *curproxy, struct server *newsrv, char **err)
@@ -960,6 +968,32 @@ static int srv_parse_ws(char **args, int *cur_arg,
return 0;
}
+/* Parse the "hash-key" server keyword */
+static int srv_parse_hash_key(char **args, int *cur_arg,
+ struct proxy *curproxy, struct server *newsrv, char **err)
+{
+ if (!args[*cur_arg + 1]) {
+ memprintf(err, "'%s expects 'id', 'addr', or 'addr-port' value", args[*cur_arg]);
+ return ERR_ALERT | ERR_FATAL;
+ }
+
+ if (strcmp(args[*cur_arg + 1], "id") == 0) {
+ newsrv->hash_key = SRV_HASH_KEY_ID;
+ }
+ else if (strcmp(args[*cur_arg + 1], "addr") == 0) {
+ newsrv->hash_key = SRV_HASH_KEY_ADDR;
+ }
+ else if (strcmp(args[*cur_arg + 1], "addr-port") == 0) {
+ newsrv->hash_key = SRV_HASH_KEY_ADDR_PORT;
+ }
+ else {
+ memprintf(err, "'%s' has to be 'id', 'addr', or 'addr-port'", args[*cur_arg]);
+ return ERR_ALERT | ERR_FATAL;
+ }
+
+ return 0;
+}
+
/* Parse the "init-addr" server keyword */
static int srv_parse_init_addr(char **args, int *cur_arg,
struct proxy *curproxy, struct server *newsrv, char **err)
@@ -1119,6 +1153,26 @@ static int srv_parse_pool_purge_delay(char **args, int *cur_arg, struct proxy *c
return 0;
}
+static int srv_parse_pool_conn_name(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
+{
+ char *arg;
+
+ arg = args[*cur_arg + 1];
+ if (!*arg) {
+ memprintf(err, "'%s' expects <value> as argument", args[*cur_arg]);
+ return ERR_ALERT | ERR_FATAL;
+ }
+
+ ha_free(&newsrv->pool_conn_name);
+ newsrv->pool_conn_name = strdup(arg);
+ if (!newsrv->pool_conn_name) {
+ memprintf(err, "'%s' : out of memory", args[*cur_arg]);
+ return ERR_ALERT | ERR_FATAL;
+ }
+
+ return 0;
+}
+
static int srv_parse_pool_low_conn(char **args, int *cur_arg, struct proxy *curproxy, struct server *newsrv, char **err)
{
char *arg;
@@ -1199,6 +1253,7 @@ static int srv_parse_namespace(char **args, int *cur_arg,
if (strcmp(arg, "*") == 0) {
/* Use the namespace associated with the connection (if present). */
newsrv->flags |= SRV_F_USE_NS_FROM_PP;
+ global.last_checks |= LSTCHK_SYSADM;
return 0;
}
@@ -1217,6 +1272,7 @@ static int srv_parse_namespace(char **args, int *cur_arg,
memprintf(err, "Cannot open namespace '%s'", arg);
return ERR_ALERT | ERR_FATAL;
}
+ global.last_checks |= LSTCHK_SYSADM;
return 0;
#else
@@ -2230,9 +2286,11 @@ static struct srv_kw_list srv_kws = { "ALL", { }, {
{ "backup", srv_parse_backup, 0, 1, 1 }, /* Flag as backup server */
{ "cookie", srv_parse_cookie, 1, 1, 1 }, /* Assign a cookie to the server */
{ "disabled", srv_parse_disabled, 0, 1, 1 }, /* Start the server in 'disabled' state */
- { "enabled", srv_parse_enabled, 0, 1, 1 }, /* Start the server in 'enabled' state */
+ { "enabled", srv_parse_enabled, 0, 1, 0 }, /* Start the server in 'enabled' state */
{ "error-limit", srv_parse_error_limit, 1, 1, 1 }, /* Configure the consecutive count of check failures to consider a server on error */
+ { "guid", srv_parse_guid, 1, 0, 1 }, /* Set global unique ID of the server */
{ "ws", srv_parse_ws, 1, 1, 1 }, /* websocket protocol */
+ { "hash-key", srv_parse_hash_key, 1, 1, 1 }, /* Configure how chash keys are computed */
{ "id", srv_parse_id, 1, 0, 1 }, /* set id# of server */
{ "init-addr", srv_parse_init_addr, 1, 1, 0 }, /* */
{ "log-bufsize", srv_parse_log_bufsize, 1, 1, 0 }, /* Set the ring bufsize for log server (only for log backends) */
@@ -2251,6 +2309,7 @@ static struct srv_kw_list srv_kws = { "ALL", { }, {
{ "on-error", srv_parse_on_error, 1, 1, 1 }, /* Configure the action on check failure */
{ "on-marked-down", srv_parse_on_marked_down, 1, 1, 1 }, /* Configure the action when a server is marked down */
{ "on-marked-up", srv_parse_on_marked_up, 1, 1, 1 }, /* Configure the action when a server is marked up */
+ { "pool-conn-name", srv_parse_pool_conn_name, 1, 1, 1 }, /* Define expression to identify connections in idle pool */
{ "pool-low-conn", srv_parse_pool_low_conn, 1, 1, 1 }, /* Set the min number of orphan idle connecbefore being allowed to pick from other threads */
{ "pool-max-conn", srv_parse_pool_max_conn, 1, 1, 1 }, /* Set the max number of orphan idle connections, -1 means unlimited */
{ "pool-purge-delay", srv_parse_pool_purge_delay, 1, 1, 1 }, /* Set the time before we destroy orphan idle connections, defaults to 1s */
@@ -2290,17 +2349,19 @@ void server_recalc_eweight(struct server *sv, int must_update)
struct proxy *px = sv->proxy;
unsigned w;
- if (ns_to_sec(now_ns) < sv->last_change || ns_to_sec(now_ns) >= sv->last_change + sv->slowstart) {
- /* go to full throttle if the slowstart interval is reached */
- if (sv->next_state == SRV_ST_STARTING)
+ if (ns_to_sec(now_ns) < sv->counters.last_change || ns_to_sec(now_ns) >= sv->counters.last_change + sv->slowstart) {
+ /* go to full throttle if the slowstart interval is reached unless server is currently down */
+ if ((sv->cur_state != SRV_ST_STOPPED) && (sv->next_state == SRV_ST_STARTING))
sv->next_state = SRV_ST_RUNNING;
}
/* We must take care of not pushing the server to full throttle during slow starts.
* It must also start immediately, at least at the minimal step when leaving maintenance.
*/
- if ((sv->next_state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
- w = (px->lbprm.wdiv * (ns_to_sec(now_ns) - sv->last_change) + sv->slowstart) / sv->slowstart;
+ if ((sv->cur_state == SRV_ST_STOPPED) && (sv->next_state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
+ w = 1;
+ else if ((sv->next_state == SRV_ST_STARTING) && (px->lbprm.algo & BE_LB_PROP_DYN))
+ w = (px->lbprm.wdiv * (ns_to_sec(now_ns) - sv->counters.last_change) + sv->slowstart) / sv->slowstart;
else
w = px->lbprm.wdiv;
@@ -2334,7 +2395,7 @@ const char *server_parse_weight_change_request(struct server *sv,
w = strtol(weight_str, &end, 10);
if (end == weight_str)
- return "Empty weight string empty or preceded by garbage";
+ return "Empty weight string empty or preceded by garbage\n";
else if (end[0] == '%' && end[1] == '\0') {
if (w < 0)
return "Relative weight must be positive.\n";
@@ -2348,7 +2409,7 @@ const char *server_parse_weight_change_request(struct server *sv,
else if (w < 0 || w > 256)
return "Absolute weight can only be between 0 and 256 inclusive.\n";
else if (end[0] != '\0')
- return "Trailing garbage in weight string";
+ return "Trailing garbage in weight string\n";
if (w && w != sv->iweight && !(px->lbprm.algo & BE_LB_PROP_DYN))
return "Backend is using a static LB algorithm and only accepts weights '0%' and '100%'.\n";
@@ -2360,32 +2421,6 @@ const char *server_parse_weight_change_request(struct server *sv,
}
/*
- * Parses <addr_str> and configures <sv> accordingly. <from> precise
- * the source of the change in the associated message log.
- * Returns:
- * - error string on error
- * - NULL on success
- *
- * Must be called with the server lock held.
- */
-const char *server_parse_addr_change_request(struct server *sv,
- const char *addr_str, const char *updater)
-{
- unsigned char ip[INET6_ADDRSTRLEN];
-
- if (inet_pton(AF_INET6, addr_str, ip)) {
- srv_update_addr(sv, ip, AF_INET6, updater);
- return NULL;
- }
- if (inet_pton(AF_INET, addr_str, ip)) {
- srv_update_addr(sv, ip, AF_INET, updater);
- return NULL;
- }
-
- return "Could not understand IP address format.\n";
-}
-
-/*
* Must be called with the server lock held.
*/
const char *server_parse_maxconn_change_request(struct server *sv,
@@ -2399,9 +2434,9 @@ const char *server_parse_maxconn_change_request(struct server *sv,
v = strtol(maxconn_str, &end, 10);
if (end == maxconn_str)
- return "maxconn string empty or preceded by garbage";
+ return "maxconn string empty or preceded by garbage\n";
else if (end[0] != '\0')
- return "Trailing garbage in maxconn string";
+ return "Trailing garbage in maxconn string\n";
if (sv->maxconn == sv->minconn) { // static maxconn
sv->maxconn = sv->minconn = v;
@@ -2415,42 +2450,56 @@ const char *server_parse_maxconn_change_request(struct server *sv,
return NULL;
}
-static struct sample_expr *srv_sni_sample_parse_expr(struct server *srv, struct proxy *px,
- const char *file, int linenum, char **err)
+/* Interpret <expr> as sample expression. This function is reserved for
+ * internal server allocation. On parsing use parse_srv_expr() for extra sample
+ * check validity.
+ *
+ * Returns the allocated sample on success or NULL on error.
+ */
+struct sample_expr *_parse_srv_expr(char *expr, struct arg_list *args_px,
+ const char *file, int linenum, char **err)
{
int idx;
const char *args[] = {
- srv->sni_expr,
+ expr,
NULL,
};
idx = 0;
- px->conf.args.ctx = ARGC_SRV;
+ args_px->ctx = ARGC_SRV;
- return sample_parse_expr((char **)args, &idx, file, linenum, err, &px->conf.args, NULL);
+ return sample_parse_expr((char **)args, &idx, file, linenum, err, args_px, NULL);
}
-int server_parse_sni_expr(struct server *newsrv, struct proxy *px, char **err)
+/* Interpret <str> if not empty as a sample expression and store it into <out>.
+ * Contrary to _parse_srv_expr(), fetch scope validity is checked to ensure it
+ * is valid on a server line context. It also updates <px> HTTP mode
+ * requirement depending on fetch method used.
+ *
+ * Returns 0 on success else non zero.
+ */
+static int parse_srv_expr(char *str, struct sample_expr **out, struct proxy *px,
+ char **err)
{
struct sample_expr *expr;
- expr = srv_sni_sample_parse_expr(newsrv, px, px->conf.file, px->conf.line, err);
- if (!expr) {
- memprintf(err, "error detected while parsing sni expression : %s", *err);
+ if (!str)
+ return 0;
+
+ expr = _parse_srv_expr(str, &px->conf.args, px->conf.file, px->conf.line, err);
+ if (!expr)
return ERR_ALERT | ERR_FATAL;
- }
if (!(expr->fetch->val & SMP_VAL_BE_SRV_CON)) {
- memprintf(err, "error detected while parsing sni expression : "
- " fetch method '%s' extracts information from '%s', "
+ memprintf(err, "fetch method '%s' extracts information from '%s', "
"none of which is available here.",
- newsrv->sni_expr, sample_src_names(expr->fetch->use));
+ str, sample_src_names(expr->fetch->use));
return ERR_ALERT | ERR_FATAL;
}
px->http_needed |= !!(expr->fetch->use & SMP_USE_HTTP_ANY);
- release_sample_expr(newsrv->ssl_ctx.sni);
- newsrv->ssl_ctx.sni = expr;
+ release_sample_expr(*out);
+ *out = expr;
return 0;
}
@@ -2634,6 +2683,45 @@ int srv_prepare_for_resolution(struct server *srv, const char *hostname)
return -1;
}
+/* Initialize default values for <srv>. Used both for dynamic servers and
+ * default servers. The latter are not initialized via new_server(), hence this
+ * function purpose. For static servers, srv_settings_cpy() is used instead
+ * reusing their default server instance.
+ */
+void srv_settings_init(struct server *srv)
+{
+ srv->check.inter = DEF_CHKINTR;
+ srv->check.fastinter = 0;
+ srv->check.downinter = 0;
+ srv->check.rise = DEF_RISETIME;
+ srv->check.fall = DEF_FALLTIME;
+ srv->check.port = 0;
+
+ srv->agent.inter = DEF_CHKINTR;
+ srv->agent.fastinter = 0;
+ srv->agent.downinter = 0;
+ srv->agent.rise = DEF_AGENT_RISETIME;
+ srv->agent.fall = DEF_AGENT_FALLTIME;
+ srv->agent.port = 0;
+
+ srv->maxqueue = 0;
+ srv->minconn = 0;
+ srv->maxconn = 0;
+
+ srv->max_reuse = -1;
+ srv->max_idle_conns = -1;
+ srv->pool_purge_delay = 5000;
+
+ srv->slowstart = 0;
+
+ srv->onerror = DEF_HANA_ONERR;
+ srv->consecutive_errors_limit = DEF_HANA_ERRLIMIT;
+
+ srv->uweight = srv->iweight = 1;
+
+ LIST_INIT(&srv->pp_tlvs);
+}
+
/*
* Copy <src> server settings to <srv> server allocating
* everything needed.
@@ -2704,6 +2792,7 @@ void srv_settings_cpy(struct server *srv, const struct server *src, int srv_tmpl
srv->minconn = src->minconn;
srv->maxconn = src->maxconn;
srv->slowstart = src->slowstart;
+ srv->hash_key = src->hash_key;
srv->observe = src->observe;
srv->onerror = src->onerror;
srv->onmarkeddown = src->onmarkeddown;
@@ -2751,6 +2840,8 @@ void srv_settings_cpy(struct server *srv, const struct server *src, int srv_tmpl
srv->tcp_ut = src->tcp_ut;
#endif
srv->mux_proto = src->mux_proto;
+ if (srv->pool_conn_name)
+ srv->pool_conn_name = strdup(srv->pool_conn_name);
srv->pool_purge_delay = src->pool_purge_delay;
srv->low_idle_conns = src->low_idle_conns;
srv->max_idle_conns = src->max_idle_conns;
@@ -2806,7 +2897,7 @@ struct server *new_server(struct proxy *proxy)
srv->rid = 0; /* rid defaults to 0 */
srv->next_state = SRV_ST_RUNNING; /* early server setup */
- srv->last_change = ns_to_sec(now_ns);
+ srv->counters.last_change = ns_to_sec(now_ns);
srv->check.obj_type = OBJ_TYPE_CHECK;
srv->check.status = HCHK_STATUS_INI;
@@ -2820,6 +2911,10 @@ struct server *new_server(struct proxy *proxy)
srv->agent.proxy = proxy;
srv->xprt = srv->check.xprt = srv->agent.xprt = xprt_get(XPRT_RAW);
+ MT_LIST_INIT(&srv->sess_conns);
+
+ guid_init(&srv->guid);
+
srv->extra_counters = NULL;
#ifdef USE_OPENSSL
HA_RWLOCK_INIT(&srv->ssl_ctx.lock);
@@ -2840,6 +2935,8 @@ void srv_take(struct server *srv)
/* deallocate common server parameters (may be used by default-servers) */
void srv_free_params(struct server *srv)
{
+ struct srv_pp_tlv_list *srv_tlv = NULL;
+
free(srv->cookie);
free(srv->rdr_pfx);
free(srv->hostname);
@@ -2848,6 +2945,8 @@ void srv_free_params(struct server *srv)
free(srv->per_thr);
free(srv->per_tgrp);
free(srv->curr_idle_thr);
+ free(srv->pool_conn_name);
+ release_sample_expr(srv->pool_conn_name_expr);
free(srv->resolvers_id);
free(srv->addr_node.key);
free(srv->lb_nodes);
@@ -2858,6 +2957,14 @@ void srv_free_params(struct server *srv)
if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->destroy_srv)
xprt_get(XPRT_SSL)->destroy_srv(srv);
+
+ while (!LIST_ISEMPTY(&srv->pp_tlvs)) {
+ srv_tlv = LIST_ELEM(srv->pp_tlvs.n, struct srv_pp_tlv_list *, list);
+ LIST_DEL_INIT(&srv_tlv->list);
+ lf_expr_deinit(&srv_tlv->fmt);
+ ha_free(&srv_tlv->fmt_string);
+ ha_free(&srv_tlv);
+ }
}
/* Deallocate a server <srv> and its member. <srv> must be allocated. For
@@ -2882,6 +2989,8 @@ struct server *srv_drop(struct server *srv)
if (HA_ATOMIC_SUB_FETCH(&srv->refcount, 1))
goto end;
+ guid_remove(&srv->guid);
+
/* make sure we are removed from our 'next->prev_deleted' list
* This doesn't require full thread isolation as we're using mt lists
* However this could easily be turned into regular list if required
@@ -3018,6 +3127,12 @@ static int _srv_parse_tmpl_init(struct server *srv, struct proxy *px)
int i;
struct server *newsrv;
+ /* Set the first server's ID. */
+ _srv_parse_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
+ srv->conf.name.key = srv->id;
+ ebis_insert(&curproxy->conf.used_server_name, &srv->conf.name);
+
+ /* then create other servers from this one */
for (i = srv->tmpl_info.nb_low + 1; i <= srv->tmpl_info.nb_high; i++) {
newsrv = new_server(px);
if (!newsrv)
@@ -3029,8 +3144,21 @@ static int _srv_parse_tmpl_init(struct server *srv, struct proxy *px)
srv_settings_cpy(newsrv, srv, 1);
srv_prepare_for_resolution(newsrv, srv->hostname);
+ /* Use sni as fallback if pool_conn_name isn't set */
+ if (!newsrv->pool_conn_name && newsrv->sni_expr) {
+ newsrv->pool_conn_name = strdup(newsrv->sni_expr);
+ if (!newsrv->pool_conn_name)
+ goto err;
+ }
+
+ if (newsrv->pool_conn_name) {
+ newsrv->pool_conn_name_expr = _parse_srv_expr(srv->pool_conn_name, &px->conf.args, NULL, 0, NULL);
+ if (!newsrv->pool_conn_name_expr)
+ goto err;
+ }
+
if (newsrv->sni_expr) {
- newsrv->ssl_ctx.sni = srv_sni_sample_parse_expr(newsrv, px, NULL, 0, NULL);
+ newsrv->ssl_ctx.sni = _parse_srv_expr(srv->sni_expr, &px->conf.args, NULL, 0, NULL);
if (!newsrv->ssl_ctx.sni)
goto err;
}
@@ -3045,6 +3173,9 @@ static int _srv_parse_tmpl_init(struct server *srv, struct proxy *px)
/* Linked backwards first. This will be restablished after parsing. */
newsrv->next = px->srv;
px->srv = newsrv;
+
+ newsrv->conf.name.key = newsrv->id;
+ ebis_insert(&curproxy->conf.used_server_name, &newsrv->conf.name);
}
_srv_parse_set_id_from_prefix(srv, srv->tmpl_info.prefix, srv->tmpl_info.nb_low);
@@ -3316,30 +3447,18 @@ static int _srv_parse_init(struct server **srv, char **args, int *cur_arg,
/* Copy default server settings to new server */
srv_settings_cpy(newsrv, &curproxy->defsrv, 0);
} else {
- /* Initialize dynamic server weight to 1 */
- newsrv->uweight = newsrv->iweight = 1;
+ srv_settings_init(newsrv);
/* A dynamic server is disabled on startup */
newsrv->next_admin = SRV_ADMF_FMAINT;
newsrv->next_state = SRV_ST_STOPPED;
server_recalc_eweight(newsrv, 0);
-
- /* Set default values for checks */
- newsrv->check.inter = DEF_CHKINTR;
- newsrv->check.rise = DEF_RISETIME;
- newsrv->check.fall = DEF_FALLTIME;
-
- newsrv->agent.inter = DEF_CHKINTR;
- newsrv->agent.rise = DEF_AGENT_RISETIME;
- newsrv->agent.fall = DEF_AGENT_FALLTIME;
}
HA_SPIN_INIT(&newsrv->lock);
}
else {
*srv = newsrv = &curproxy->defsrv;
*cur_arg = 1;
- newsrv->resolv_opts.family_prio = AF_INET6;
- newsrv->resolv_opts.accept_duplicate_ip = 0;
}
free(fqdn);
@@ -3426,25 +3545,6 @@ out:
return err_code;
}
-/* This function is first intended to be used through parse_server to
- * initialize a new server on startup.
- */
-static int _srv_parse_sni_expr_init(char **args, int cur_arg,
- struct server *srv, struct proxy *proxy,
- char **errmsg)
-{
- int ret;
-
- if (!srv->sni_expr)
- return 0;
-
- ret = server_parse_sni_expr(srv, proxy, errmsg);
- if (!ret)
- return 0;
-
- return ret;
-}
-
/* Server initializations finalization.
* Initialize health check, agent check, SNI expression and outgoing TLVs if enabled.
* Must not be called for a default server instance.
@@ -3471,9 +3571,27 @@ static int _srv_parse_finalize(char **args, int cur_arg,
return ERR_ALERT | ERR_FATAL;
}
- if ((ret = _srv_parse_sni_expr_init(args, cur_arg, srv, px, &errmsg)) != 0) {
+ if ((ret = parse_srv_expr(srv->sni_expr, &srv->ssl_ctx.sni, px, &errmsg))) {
if (errmsg) {
- ha_alert("%s\n", errmsg);
+ ha_alert("error detected while parsing sni expression : %s.\n", errmsg);
+ free(errmsg);
+ }
+ return ret;
+ }
+
+ /* Use sni as fallback if pool_conn_name isn't set */
+ if (!srv->pool_conn_name && srv->sni_expr) {
+ srv->pool_conn_name = strdup(srv->sni_expr);
+ if (!srv->pool_conn_name) {
+ ha_alert("out of memory\n");
+ return ERR_ALERT | ERR_FATAL;
+ }
+ }
+
+ if ((ret = parse_srv_expr(srv->pool_conn_name, &srv->pool_conn_name_expr,
+ px, &errmsg))) {
+ if (errmsg) {
+ ha_alert("error detected while parsing pool-conn-name expression : %s.\n", errmsg);
free(errmsg);
}
return ret;
@@ -3490,7 +3608,7 @@ static int _srv_parse_finalize(char **args, int cur_arg,
}
list_for_each_entry(srv_tlv, &srv->pp_tlvs, list) {
- LIST_INIT(&srv_tlv->fmt);
+ lf_expr_init(&srv_tlv->fmt);
if (srv_tlv->fmt_string && unlikely(!parse_logformat_string(srv_tlv->fmt_string,
srv->proxy, &srv_tlv->fmt, 0, SMP_VAL_BE_SRV_CON, &errmsg))) {
if (errmsg) {
@@ -3562,8 +3680,13 @@ int parse_server(const char *file, int linenum, char **args,
goto out;
}
- if (parse_flags & SRV_PARSE_TEMPLATE)
+ if (parse_flags & SRV_PARSE_TEMPLATE) {
_srv_parse_tmpl_init(newsrv, curproxy);
+ }
+ else if (!(parse_flags & SRV_PARSE_DEFAULT_SERVER)) {
+ newsrv->conf.name.key = newsrv->id;
+ ebis_insert(&curproxy->conf.used_server_name, &newsrv->conf.name);
+ }
/* If the server id is fixed, insert it in the proxy used_id tree.
* This is needed to detect a later duplicate id via srv_parse_id.
@@ -3610,6 +3733,25 @@ struct server *server_find_by_id(struct proxy *bk, int id)
return curserver;
}
+/*
+ * This function finds a server with matching "<puid> x <rid>" within
+ * selected backend <bk>.
+ * Using the combination of proxy-uid + revision id ensures that the function
+ * will either return the server we're expecting or NULL if it has been removed
+ * from the proxy (<id> is unique within the list, but it is not true over the
+ * process lifetime as new servers may reuse the id of a previously deleted
+ * server).
+ */
+struct server *server_find_by_id_unique(struct proxy *bk, int id, uint32_t rid)
+{
+ struct server *curserver;
+
+ curserver = server_find_by_id(bk, id);
+ if (!curserver || curserver->rid != rid)
+ return NULL;
+ return curserver;
+}
+
/* Returns a pointer to the first server matching either name <name>, or id
* if <name> starts with a '#'. NULL is returned if no match is found.
* the lookup is performed in the backend <bk>
@@ -3628,20 +3770,43 @@ struct server *server_find_by_name(struct proxy *bk, const char *name)
curserver = NULL;
if (*name == '#') {
curserver = server_find_by_id(bk, atoi(name + 1));
- if (curserver)
- return curserver;
}
else {
- curserver = bk->srv;
-
- while (curserver && (strcmp(curserver->id, name) != 0))
- curserver = curserver->next;
+ struct ebpt_node *node;
- if (curserver)
- return curserver;
+ node = ebis_lookup(&bk->conf.used_server_name, name);
+ if (node)
+ curserver = container_of(node, struct server, conf.name);
}
- return NULL;
+ return curserver;
+}
+
+/*
+ * This function finds a server with matching "<name> x <rid>" within
+ * selected backend <bk>.
+ * Using the combination of name + revision id ensures that the function
+ * will either return the server we're expecting or NULL if it has been removed
+ * from the proxy. For this we assume that <name> is unique within the list,
+ * which is the case in most setups, but in rare cases the user may have
+ * enforced duplicate server names in the initial config (ie: if he intends to
+ * use numerical IDs for identification instead). In this particular case, the
+ * function will not work as expected so server_find_by_id_unique() should be
+ * used to match a unique server instead.
+ *
+ * Just like server_find_by_id_unique(), if a server is deleted and a new server
+ * reuses the same name, the rid check will prevent the function from returning
+ * a different server from the one we were expecting to match against at a given
+ * time.
+ */
+struct server *server_find_by_name_unique(struct proxy *bk, const char *name, uint32_t rid)
+{
+ struct server *curserver;
+
+ curserver = server_find_by_name(bk, name);
+ if (!curserver || curserver->rid != rid)
+ return NULL;
+ return curserver;
}
struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff)
@@ -3705,101 +3870,332 @@ struct server *server_find_best_match(struct proxy *bk, char *name, int id, int
return NULL;
}
-/*
- * update a server's current IP address.
- * ip is a pointer to the new IP address, whose address family is ip_sin_family.
- * ip is in network format.
- * updater is a string which contains an information about the requester of the update.
- * updater is used if not NULL.
+/* This functions retrieves server's addr and port to fill
+ * <inetaddr> struct passed as argument.
*
- * A log line and a stderr warning message is generated based on server's backend options.
- *
- * Must be called with the server lock held.
+ * This may only be used under inet context.
*/
-int srv_update_addr(struct server *s, void *ip, int ip_sin_family, const char *updater)
+void server_get_inetaddr(struct server *s, struct server_inetaddr *inetaddr)
{
- union {
- struct event_hdl_cb_data_server_inetaddr addr;
- struct event_hdl_cb_data_server common;
- } cb_data;
- struct sockaddr_storage new_addr = { }; // shut up gcc warning
+ struct sockaddr_storage *addr = &s->addr;
+ unsigned int port = s->svc_port;
+ uint8_t mapports = !!(s->flags & SRV_F_MAPPORTS);
- /* save the new IP family & address if necessary */
- switch (ip_sin_family) {
- case AF_INET:
- if (s->addr.ss_family == ip_sin_family &&
- !memcmp(ip, &((struct sockaddr_in *)&s->addr)->sin_addr.s_addr, 4))
- return 0;
- break;
- case AF_INET6:
- if (s->addr.ss_family == ip_sin_family &&
- !memcmp(ip, &((struct sockaddr_in6 *)&s->addr)->sin6_addr.s6_addr, 16))
- return 0;
- break;
- };
+ /* only INET families are supported */
+ BUG_ON((addr->ss_family != AF_UNSPEC &&
+ addr->ss_family != AF_INET && addr->ss_family != AF_INET6));
- /* generates a log line and a warning on stderr */
- if (1) {
- /* book enough space for both IPv4 and IPv6 */
- char oldip[INET6_ADDRSTRLEN];
- char newip[INET6_ADDRSTRLEN];
+ inetaddr->family = addr->ss_family;
+ memset(&inetaddr->addr, 0, sizeof(inetaddr->addr));
- memset(oldip, '\0', INET6_ADDRSTRLEN);
- memset(newip, '\0', INET6_ADDRSTRLEN);
+ if (addr->ss_family == AF_INET)
+ inetaddr->addr.v4 =
+ ((struct sockaddr_in *)addr)->sin_addr;
+ else if (addr->ss_family == AF_INET6)
+ inetaddr->addr.v6 =
+ ((struct sockaddr_in6 *)addr)->sin6_addr;
- /* copy old IP address in a string */
- switch (s->addr.ss_family) {
- case AF_INET:
- inet_ntop(s->addr.ss_family, &((struct sockaddr_in *)&s->addr)->sin_addr, oldip, INET_ADDRSTRLEN);
+ inetaddr->port.svc = port;
+ inetaddr->port.map = mapports;
+}
+
+/* get human readable name for server_inetaddr_updater .by struct member
+ */
+const char *server_inetaddr_updater_by_to_str(enum server_inetaddr_updater_by by)
+{
+ switch (by) {
+ case SERVER_INETADDR_UPDATER_BY_CLI:
+ return "stats socket command";
+ case SERVER_INETADDR_UPDATER_BY_LUA:
+ return "Lua script";
+ case SERVER_INETADDR_UPDATER_BY_DNS_AR:
+ return "DNS additional record";
+ case SERVER_INETADDR_UPDATER_BY_DNS_CACHE:
+ return "DNS cache";
+ case SERVER_INETADDR_UPDATER_BY_DNS_RESOLVER:
+ return "DNS resolver";
+ default:
+ /* unknown, don't mention updater */
break;
- case AF_INET6:
- inet_ntop(s->addr.ss_family, &((struct sockaddr_in6 *)&s->addr)->sin6_addr, oldip, INET6_ADDRSTRLEN);
+ }
+ return NULL;
+}
+
+/* append inetaddr updater info to chunk <out>
+ */
+static void _srv_append_inetaddr_updater_info(struct buffer *out,
+ struct server *s,
+ struct server_inetaddr_updater updater)
+{
+ switch (updater.by) {
+ case SERVER_INETADDR_UPDATER_BY_DNS_RESOLVER:
+ /* we need to report the resolver/nameserver id which is
+ * responsible for the update
+ */
+ {
+ struct resolvers *r = s->resolvers;
+ struct dns_nameserver *ns;
+
+ /* we already know that the update comes from the
+ * resolver section linked to the server, but we
+ * need to find out which nameserver handled the dns
+ * query
+ */
+ BUG_ON(!r);
+ ns = find_nameserver_by_resolvers_and_id(r, updater.u.dns_resolver.ns_id);
+ BUG_ON(!ns);
+ chunk_appendf(out, " by '%s/%s'", r->id, ns->id);
+ }
break;
default:
- strlcpy2(oldip, "(none)", sizeof(oldip));
+ {
+ const char *by_name;
+
+ by_name = server_inetaddr_updater_by_to_str(updater.by);
+ if (by_name)
+ chunk_appendf(out, " by '%s'", by_name);
+ }
break;
- };
+ }
+}
- /* copy new IP address in a string */
- switch (ip_sin_family) {
+/* server_set_inetaddr() helper */
+static void _addr_to_str(int family, const void *addr, char *addr_str, size_t len)
+{
+ memset(addr_str, 0, len);
+ switch (family) {
case AF_INET:
- inet_ntop(ip_sin_family, ip, newip, INET_ADDRSTRLEN);
- break;
case AF_INET6:
- inet_ntop(ip_sin_family, ip, newip, INET6_ADDRSTRLEN);
+ inet_ntop(family, addr, addr_str, len);
break;
- };
+ default:
+ strlcpy2(addr_str, "(none)", len);
+ break;
+ }
+}
+/* server_set_inetaddr() helper */
+static int _inetaddr_addr_cmp(const struct server_inetaddr *inetaddr, const struct sockaddr_storage *addr)
+{
+ struct in_addr *v4;
+ struct in6_addr *v6;
+
+ if (inetaddr->family != addr->ss_family)
+ return 1;
+
+ if (inetaddr->family == AF_INET) {
+ v4 = &((struct sockaddr_in *)addr)->sin_addr;
+ if (memcmp(&inetaddr->addr.v4, v4, sizeof(struct in_addr)))
+ return 1;
+ }
+ else if (inetaddr->family == AF_INET6) {
+ v6 = &((struct sockaddr_in6 *)addr)->sin6_addr;
+ if (memcmp(&inetaddr->addr.v6, v6, sizeof(struct in6_addr)))
+ return 1;
+ }
+
+ return 0; // both inetaddr storage are equivalent
+}
+
+/* This function sets a server's addr and port in inet context based on new
+ * inetaddr input
+ *
+ * The function first does the following, in that order:
+ * - checks if an update is required (new IP or port is different than current
+ * one)
+ * - check the update is allowed:
+ * - allow all changes if no CHECKS are configured
+ * - if CHECK is configured:
+ * - if switch to port map (SRV_F_MAPPORTS), ensure health check have their
+ * own ports
+ * - applies required changes to both ADDR and PORT if both 'required' and
+ * 'allowed' conditions are met.
+ *
+ * Caller can pass <msg> buffer so that it gets some information about the
+ * operation. It may as well provide <updater> so that messages mention that
+ * the update was performed on the behalf of it.
+ *
+ * <inetaddr> family may be set to UNSPEC to reset server's addr
+ *
+ * Caller must set <inetaddr>->port.map to 1 if <inetaddr>->port.svc must be
+ * handled as an offset
+ *
+ * The function returns 1 if an update was performed and 0 if nothing was
+ * changed.
+ */
+int server_set_inetaddr(struct server *s,
+ const struct server_inetaddr *inetaddr,
+ struct server_inetaddr_updater updater, struct buffer *msg)
+{
+ union {
+ struct event_hdl_cb_data_server_inetaddr addr;
+ struct event_hdl_cb_data_server common;
+ } cb_data;
+ char addr_str[INET6_ADDRSTRLEN];
+ uint16_t current_port;
+ uint8_t ip_change = 0;
+ uint8_t port_change = 0;
+ int ret = 0;
+
+ /* only INET families are supported */
+ BUG_ON((inetaddr->family != AF_UNSPEC &&
+ inetaddr->family != AF_INET && inetaddr->family != AF_INET6) ||
+ (s->addr.ss_family != AF_UNSPEC &&
+ s->addr.ss_family != AF_INET && s->addr.ss_family != AF_INET6));
+
+ /* ignore if no change */
+ if (!_inetaddr_addr_cmp(inetaddr, &s->addr))
+ goto port;
+
+ ip_change = 1;
+
+ /* update report for caller */
+ if (msg) {
+ void *from_ptr = NULL;
+
+ if (s->addr.ss_family == AF_INET)
+ from_ptr = &((struct sockaddr_in *)&s->addr)->sin_addr;
+ else if (s->addr.ss_family == AF_INET6)
+ from_ptr = &((struct sockaddr_in6 *)&s->addr)->sin6_addr;
- /* save log line into a buffer */
- chunk_printf(&trash, "%s/%s changed its IP from %s to %s by %s",
- s->proxy->id, s->id, oldip, newip, updater);
+ _addr_to_str(s->addr.ss_family, from_ptr, addr_str, sizeof(addr_str));
+ chunk_printf(msg, "IP changed from '%s'", addr_str);
+ _addr_to_str(inetaddr->family, &inetaddr->addr, addr_str, sizeof(addr_str));
+ chunk_appendf(msg, " to '%s'", addr_str);
+ }
+
+ if (inetaddr->family == AF_UNSPEC)
+ goto out; // ignore port information when unsetting addr
+
+ port:
+ /* collection data currently setup */
+ current_port = s->svc_port;
+
+ /* check if caller triggers a port mapped or offset */
+ if (inetaddr->port.map) {
+ /* check if server currently uses port map */
+ if (!(s->flags & SRV_F_MAPPORTS)) {
+ /* we're switching from a fixed port to a SRV_F_MAPPORTS
+ * (mapped) port, prevent PORT change if check is enabled
+ * and it doesn't have it's dedicated port while switching
+ * to port mapping
+ */
+ if ((s->check.state & CHK_ST_ENABLED) && !s->check.port) {
+ if (msg) {
+ if (ip_change)
+ chunk_appendf(msg, ", ");
+ chunk_appendf(msg, "can't change <port> to port map because it is incompatible with current health check port configuration (use 'port' statement from the 'server' directive).");
+ }
+ goto out;
+ }
+ /* switch from fixed port to port map mandatorily triggers
+ * a port change
+ */
+ port_change = 1;
+ }
+ /* else we're already using port maps */
+ else {
+ port_change = current_port != inetaddr->port.svc;
+ }
+ }
+ /* fixed port */
+ else {
+ if ((s->flags & SRV_F_MAPPORTS))
+ port_change = 1; // changing from mapped to fixed
+ else
+ port_change = current_port != inetaddr->port.svc;
+ }
+
+ /* update response message about PORT change */
+ if (port_change && msg) {
+ if (ip_change)
+ chunk_appendf(msg, ", ");
+
+ chunk_appendf(msg, "port changed from '");
+ if (s->flags & SRV_F_MAPPORTS)
+ chunk_appendf(msg, "+");
+
+ chunk_appendf(msg, "%d' to '", s->svc_port);
+ if (inetaddr->port.map)
+ chunk_appendf(msg, "+");
+ chunk_appendf(msg, "%d'", inetaddr->port.svc);
+ }
+
+ out:
+ if (ip_change || port_change) {
+ _srv_event_hdl_prepare(&cb_data.common, s, 0);
+ _srv_event_hdl_prepare_inetaddr(&cb_data.addr, s,
+ inetaddr,
+ updater);
+
+ /* server_atomic_sync_task will apply the changes for us */
+ _srv_event_hdl_publish(EVENT_HDL_SUB_SERVER_INETADDR, cb_data, s);
+
+ ret = 1;
+ }
+
+ if (ret && msg && updater.by != SERVER_INETADDR_UPDATER_BY_NONE)
+ _srv_append_inetaddr_updater_info(msg, s, updater);
+ return ret;
+}
+
+/* Sets new server's addr and/or svc_port, then send a log and report a
+ * warning on stderr if something has changed.
+ *
+ * Returns 1 if something has changed, 0 otherwise.
+ * see server_set_inetaddr() for more information.
+ */
+int server_set_inetaddr_warn(struct server *s,
+ const struct server_inetaddr *inetaddr,
+ struct server_inetaddr_updater updater)
+{
+ struct buffer *msg = get_trash_chunk();
+ int ret;
+
+ chunk_reset(msg);
+
+ ret = server_set_inetaddr(s, inetaddr, updater, msg);
+ if (msg->data) {
/* write the buffer on stderr */
- ha_warning("%s.\n", trash.area);
+ ha_warning("%s/%s: %s.\n", s->proxy->id, s->id, msg->area);
/* send a log */
- send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
+ send_log(s->proxy, LOG_NOTICE, "%s/%s: %s.\n", s->proxy->id, s->id, msg->area);
}
+ return ret;
+}
+
+/*
+ * update a server's current IP address.
+ * ip is a pointer to the new IP address, whose address family is ip_sin_family.
+ * ip is in network format.
+ * updater is a string which contains an information about the requester of the update.
+ * updater is used if not NULL.
+ *
+ * A log line and a stderr warning message is generated based on server's backend options.
+ *
+ * Must be called with the server lock held.
+ */
+int srv_update_addr(struct server *s, void *ip, int ip_sin_family, struct server_inetaddr_updater updater)
+{
+ struct server_inetaddr inetaddr;
+
+ server_get_inetaddr(s, &inetaddr);
+ BUG_ON(ip_sin_family != AF_INET && ip_sin_family != AF_INET6);
/* save the new IP family */
- new_addr.ss_family = ip_sin_family;
+ inetaddr.family = ip_sin_family;
/* save the new IP address */
switch (ip_sin_family) {
case AF_INET:
- memcpy(&((struct sockaddr_in *)&new_addr)->sin_addr.s_addr, ip, 4);
+ memcpy(&inetaddr.addr.v4, ip, 4);
break;
case AF_INET6:
- memcpy(((struct sockaddr_in6 *)&new_addr)->sin6_addr.s6_addr, ip, 16);
+ memcpy(&inetaddr.addr.v6, ip, 16);
break;
};
- _srv_event_hdl_prepare(&cb_data.common, s, 0);
- _srv_event_hdl_prepare_inetaddr(&cb_data.addr, s,
- &new_addr, s->svc_port, !!(s->flags & SRV_F_MAPPORTS),
- 0);
-
- /* server_atomic_sync_task will apply the changes for us */
- _srv_event_hdl_publish(EVENT_HDL_SUB_SERVER_INETADDR, cb_data, s);
+ server_set_inetaddr_warn(s, &inetaddr, updater);
return 0;
}
@@ -3906,40 +4302,37 @@ out:
/*
* This function update a server's addr and port only for AF_INET and AF_INET6 families.
*
- * Caller can pass its name through <updater> to get it integrated in the response message
- * returned by the function.
+ * Caller can pass its info through <updater> to get it integrated in the response
+ * message returned by the function.
*
* The function first does the following, in that order:
+ * - checks that don't switch from/to a family other than AF_INET and AF_INET6
* - validates the new addr and/or port
- * - checks if an update is required (new IP or port is different than current ones)
- * - checks the update is allowed:
- * - don't switch from/to a family other than AF_INET4 and AF_INET6
- * - allow all changes if no CHECKS are configured
- * - if CHECK is configured:
- * - if switch to port map (SRV_F_MAPPORTS), ensure health check have their own ports
- * - applies required changes to both ADDR and PORT if both 'required' and 'allowed'
- * conditions are met
+ * - calls server_set_inetaddr() to check and apply the change
*
* Must be called with the server lock held.
*/
-const char *srv_update_addr_port(struct server *s, const char *addr, const char *port, char *updater)
+const char *srv_update_addr_port(struct server *s, const char *addr, const char *port,
+ struct server_inetaddr_updater updater)
{
- union {
- struct event_hdl_cb_data_server_inetaddr addr;
- struct event_hdl_cb_data_server common;
- } cb_data;
struct sockaddr_storage sa;
- int ret;
- char current_addr[INET6_ADDRSTRLEN];
- uint16_t current_port, new_port = 0;
+ struct server_inetaddr inetaddr;
struct buffer *msg;
- int ip_change = 0;
- int port_change = 0;
- uint8_t mapports = !!(s->flags & SRV_F_MAPPORTS);
+ int ret;
msg = get_trash_chunk();
chunk_reset(msg);
+ /* even a simple port change is not supported outside of inet context, because
+ * s->svc_port is only relevant under inet context
+ */
+ if ((s->addr.ss_family != AF_INET) && (s->addr.ss_family != AF_INET6)) {
+ chunk_printf(msg, "Update for the current server address family is only supported through configuration file.");
+ goto out;
+ }
+
+ server_get_inetaddr(s, &inetaddr);
+
if (addr) {
memset(&sa, 0, sizeof(struct sockaddr_storage));
if (str2ip2(addr, &sa, 0) == NULL) {
@@ -3953,40 +4346,24 @@ const char *srv_update_addr_port(struct server *s, const char *addr, const char
goto out;
}
- /* collecting data currently setup */
- memset(current_addr, '\0', sizeof(current_addr));
- ret = addr_to_str(&s->addr, current_addr, sizeof(current_addr));
- /* changes are allowed on AF_INET* families only */
- if ((ret != AF_INET) && (ret != AF_INET6)) {
- chunk_printf(msg, "Update for the current server address family is only supported through configuration file");
- goto out;
- }
-
- /* applying ADDR changes if required and allowed
- * ipcmp returns 0 when both ADDR are the same
- */
- if (ipcmp(&s->addr, &sa, 0) == 0) {
- chunk_appendf(msg, "no need to change the addr");
- goto port;
+ inetaddr.family = sa.ss_family;
+ switch (inetaddr.family) {
+ case AF_INET:
+ inetaddr.addr.v4 = ((struct sockaddr_in *)&sa)->sin_addr;
+ break;
+ case AF_INET6:
+ inetaddr.addr.v6 = ((struct sockaddr_in6 *)&sa)->sin6_addr;
+ break;
}
- ip_change = 1;
-
- /* update report for caller */
- chunk_printf(msg, "IP changed from '%s' to '%s'", current_addr, addr);
}
- port:
if (port) {
+ uint16_t new_port;
char sign = '\0';
char *endptr;
- if (addr)
- chunk_appendf(msg, ", ");
-
- /* collecting data currently setup */
- current_port = s->svc_port;
-
sign = *port;
+
errno = 0;
new_port = strtol(port, &endptr, 10);
if ((errno != 0) || (port == endptr)) {
@@ -3995,98 +4372,46 @@ const char *srv_update_addr_port(struct server *s, const char *addr, const char
}
/* check if caller triggers a port mapped or offset */
- if (sign == '-' || (sign == '+')) {
- /* check if server currently uses port map */
- if (!(s->flags & SRV_F_MAPPORTS)) {
- /* check is configured
- * we're switching from a fixed port to a SRV_F_MAPPORTS (mapped) port
- * prevent PORT change if check doesn't have it's dedicated port while switching
- * to port mapping */
- if (!s->check.port) {
- chunk_appendf(msg, "can't change <port> to port map because it is incompatible with current health check port configuration (use 'port' statement from the 'server' directive.");
- goto out;
- }
- /* switch from fixed port to port map mandatorily triggers
- * a port change */
- port_change = 1;
- }
- /* we're already using port maps */
- else {
- port_change = current_port != new_port;
- }
- }
- /* fixed port */
- else {
- port_change = current_port != new_port;
- }
-
- /* applying PORT changes if required and update response message */
- if (port_change) {
- uint16_t new_port_print = new_port;
-
- /* prepare message */
- chunk_appendf(msg, "port changed from '");
- if (s->flags & SRV_F_MAPPORTS)
- chunk_appendf(msg, "+");
- chunk_appendf(msg, "%d' to '", current_port);
-
- if (sign == '-') {
- mapports = 1;
- chunk_appendf(msg, "%c", sign);
- /* just use for result output */
- new_port_print = -new_port_print;
- }
- else if (sign == '+') {
- mapports = 1;
- chunk_appendf(msg, "%c", sign);
- }
- else {
- mapports = 0;
- }
-
- chunk_appendf(msg, "%d'", new_port_print);
- }
- else {
- chunk_appendf(msg, "no need to change the port");
- }
+ if (sign == '-' || sign == '+')
+ inetaddr.port.map = 1;
+ else
+ inetaddr.port.map = 0;
+
+ inetaddr.port.svc = new_port;
+
+ /* note: negative offset was converted to positive offset
+ * (new_port is unsigned) to prevent later conversions errors
+ * since svc_port is handled as an unsigned int all along the
+ * chain. Unfortunately this is a one-way operation so the user
+ * could be surprised to see a negative offset reported using
+ * its equivalent positive offset in the generated message
+ * (-X = +(65535 - (X-1))), but thanks to proper wraparound it
+ * will be interpreted as a negative offset during port
+ * remapping so it will work as expected.
+ */
}
-out:
- if (ip_change || port_change) {
- _srv_event_hdl_prepare(&cb_data.common, s, 0);
- _srv_event_hdl_prepare_inetaddr(&cb_data.addr, s,
- ((ip_change) ? &sa : &s->addr),
- ((port_change) ? new_port : s->svc_port), mapports,
- 1);
+ ret = server_set_inetaddr(s, &inetaddr, updater, msg);
+ if (!ret)
+ chunk_printf(msg, "nothing changed");
- /* server_atomic_sync_task will apply the changes for us */
- _srv_event_hdl_publish(EVENT_HDL_SUB_SERVER_INETADDR, cb_data, s);
- }
- if (updater)
- chunk_appendf(msg, " by '%s'", updater);
- chunk_appendf(msg, "\n");
+ out:
return msg->area;
}
/*
- * update server status based on result of SRV resolution
+ * put the server in maintenance because of failing SRV resolution
* returns:
- * 0 if server status is updated
+ * 0 if server was put under maintenance
* 1 if server status has not changed
*
* Must be called with the server lock held.
*/
-int srvrq_update_srv_status(struct server *s, int has_no_ip)
+int srvrq_set_srv_down(struct server *s)
{
if (!s->srvrq)
return 1;
- /* since this server has an IP, it can go back in production */
- if (has_no_ip == 0) {
- srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
- return 1;
- }
-
if (s->next_admin & SRV_ADMF_RMAINT)
return 1;
@@ -4095,59 +4420,46 @@ int srvrq_update_srv_status(struct server *s, int has_no_ip)
}
/*
- * update server status based on result of name resolution
+ * put server under maintenance as a result of name resolution
* returns:
- * 0 if server status is updated
+ * 0 if server was put under maintenance
* 1 if server status has not changed
*
* Must be called with the server lock held.
*/
-int snr_update_srv_status(struct server *s, int has_no_ip)
+int snr_set_srv_down(struct server *s)
{
struct resolvers *resolvers = s->resolvers;
struct resolv_resolution *resolution = (s->resolv_requester ? s->resolv_requester->resolution : NULL);
int exp;
+ /* server already under maintenance */
+ if (s->next_admin & SRV_ADMF_RMAINT)
+ goto out;
+
/* If resolution is NULL we're dealing with SRV records Additional records */
if (resolution == NULL)
- return srvrq_update_srv_status(s, has_no_ip);
+ return srvrq_set_srv_down(s);
switch (resolution->status) {
case RSLV_STATUS_NONE:
/* status when HAProxy has just (re)started.
* Nothing to do, since the task is already automatically started */
- break;
+ goto out;
case RSLV_STATUS_VALID:
/*
- * resume health checks
- * server will be turned back on if health check is safe
+ * valid resolution but no usable server address
*/
- if (has_no_ip) {
- if (s->next_admin & SRV_ADMF_RMAINT)
- return 1;
- srv_set_admin_flag(s, SRV_ADMF_RMAINT, SRV_ADM_STCHGC_DNS_NOIP);
- return 0;
- }
-
- if (!(s->next_admin & SRV_ADMF_RMAINT))
- return 1;
- srv_clr_admin_flag(s, SRV_ADMF_RMAINT);
- chunk_printf(&trash, "Server %s/%s administratively READY thanks to valid DNS answer",
- s->proxy->id, s->id);
-
- ha_warning("%s.\n", trash.area);
- send_log(s->proxy, LOG_NOTICE, "%s.\n", trash.area);
+ srv_set_admin_flag(s, SRV_ADMF_RMAINT, SRV_ADM_STCHGC_DNS_NOIP);
return 0;
case RSLV_STATUS_NX:
/* stop server if resolution is NX for a long enough period */
exp = tick_add(resolution->last_valid, resolvers->hold.nx);
if (!tick_is_expired(exp, now_ms))
- break;
+ goto out; // not yet expired
- if (s->next_admin & SRV_ADMF_RMAINT)
- return 1;
srv_set_admin_flag(s, SRV_ADMF_RMAINT, SRV_ADM_STCHGC_DNS_NX);
return 0;
@@ -4155,10 +4467,8 @@ int snr_update_srv_status(struct server *s, int has_no_ip)
/* stop server if resolution is TIMEOUT for a long enough period */
exp = tick_add(resolution->last_valid, resolvers->hold.timeout);
if (!tick_is_expired(exp, now_ms))
- break;
+ goto out; // not yet expired
- if (s->next_admin & SRV_ADMF_RMAINT)
- return 1;
srv_set_admin_flag(s, SRV_ADMF_RMAINT, SRV_ADM_STCHGC_DNS_TIMEOUT);
return 0;
@@ -4166,10 +4476,8 @@ int snr_update_srv_status(struct server *s, int has_no_ip)
/* stop server if resolution is REFUSED for a long enough period */
exp = tick_add(resolution->last_valid, resolvers->hold.refused);
if (!tick_is_expired(exp, now_ms))
- break;
+ goto out; // not yet expired
- if (s->next_admin & SRV_ADMF_RMAINT)
- return 1;
srv_set_admin_flag(s, SRV_ADMF_RMAINT, SRV_ADM_STCHGC_DNS_REFUSED);
return 0;
@@ -4177,14 +4485,13 @@ int snr_update_srv_status(struct server *s, int has_no_ip)
/* stop server if resolution failed for a long enough period */
exp = tick_add(resolution->last_valid, resolvers->hold.other);
if (!tick_is_expired(exp, now_ms))
- break;
+ goto out; // not yet expired
- if (s->next_admin & SRV_ADMF_RMAINT)
- return 1;
srv_set_admin_flag(s, SRV_ADMF_RMAINT, SRV_ADM_STCHGC_DNS_UNSPEC);
return 0;
}
+ out:
return 1;
}
@@ -4210,7 +4517,6 @@ int snr_resolution_cb(struct resolv_requester *requester, struct dns_counters *c
void *serverip, *firstip;
short server_sin_family, firstip_sin_family;
int ret;
- struct buffer *chk = get_trash_chunk();
int has_no_ip = 0;
s = objt_server(requester->owner);
@@ -4269,12 +4575,6 @@ int snr_resolution_cb(struct resolv_requester *requester, struct dns_counters *c
has_no_ip = 1;
goto update_status;
- case RSLV_UPD_NAME_ERROR:
- /* update resolution status to OTHER error type */
- resolution->status = RSLV_STATUS_OTHER;
- has_no_ip = 1;
- goto update_status;
-
default:
has_no_ip = 1;
goto invalid;
@@ -4285,15 +4585,21 @@ int snr_resolution_cb(struct resolv_requester *requester, struct dns_counters *c
if (counters) {
counters->app.resolver.update++;
/* save the first ip we found */
- chunk_printf(chk, "%s/%s", counters->pid, counters->id);
+ srv_update_addr(s, firstip, firstip_sin_family,
+ SERVER_INETADDR_UPDATER_DNS_RESOLVER(counters->ns_puid));
}
else
- chunk_printf(chk, "DNS cache");
- srv_update_addr(s, firstip, firstip_sin_family, (char *) chk->area);
+ srv_update_addr(s, firstip, firstip_sin_family, SERVER_INETADDR_UPDATER_DNS_CACHE);
update_status:
- if (!snr_update_srv_status(s, has_no_ip) && has_no_ip)
- memset(&s->addr, 0, sizeof(s->addr));
+ if (has_no_ip && !snr_set_srv_down(s)) {
+ struct server_inetaddr srv_addr;
+
+ /* unset server's addr, keep port */
+ server_get_inetaddr(s, &srv_addr);
+ memset(&srv_addr.addr, 0, sizeof(srv_addr.addr));
+ server_set_inetaddr(s, &srv_addr, SERVER_INETADDR_UPDATER_NONE, NULL);
+ }
return 1;
invalid:
@@ -4301,8 +4607,14 @@ int snr_resolution_cb(struct resolv_requester *requester, struct dns_counters *c
counters->app.resolver.invalid++;
goto update_status;
}
- if (!snr_update_srv_status(s, has_no_ip) && has_no_ip)
- memset(&s->addr, 0, sizeof(s->addr));
+ if (has_no_ip && !snr_set_srv_down(s)) {
+ struct server_inetaddr srv_addr;
+
+ /* unset server's addr, keep port */
+ server_get_inetaddr(s, &srv_addr);
+ memset(&srv_addr.addr, 0, sizeof(srv_addr.addr));
+ server_set_inetaddr(s, &srv_addr, SERVER_INETADDR_UPDATER_NONE, NULL);
+ }
return 0;
}
@@ -4382,8 +4694,13 @@ int snr_resolution_error_cb(struct resolv_requester *requester, int error_code)
return 0;
HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
- if (!snr_update_srv_status(s, 1)) {
- memset(&s->addr, 0, sizeof(s->addr));
+ if (!snr_set_srv_down(s)) {
+ struct server_inetaddr srv_addr;
+
+ /* unset server's addr, keep port */
+ server_get_inetaddr(s, &srv_addr);
+ memset(&srv_addr.addr, 0, sizeof(srv_addr.addr));
+ server_set_inetaddr(s, &srv_addr, SERVER_INETADDR_UPDATER_NONE, NULL);
HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
resolv_detach_from_resolution_answer_items(requester->resolution, requester);
return 0;
@@ -4739,16 +5056,16 @@ struct server *cli_find_server(struct appctx *appctx, char *arg)
be_name = istsplit(&sv_name, '/');
if (!istlen(sv_name)) {
- cli_err(appctx, "Require 'backend/server'.");
+ cli_err(appctx, "Require 'backend/server'.\n");
return NULL;
}
if (!(px = proxy_be_by_name(ist0(be_name)))) {
- cli_err(appctx, "No such backend.");
+ cli_err(appctx, "No such backend.\n");
return NULL;
}
if (!(sv = server_find_by_name(px, ist0(sv_name)))) {
- cli_err(appctx, "No such server.");
+ cli_err(appctx, "No such server.\n");
return NULL;
}
@@ -4915,10 +5232,9 @@ static int cli_parse_set_server(char **args, char *payload, struct appctx *appct
port = args[6];
}
HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
- warning = srv_update_addr_port(sv, addr, port, "stats socket command");
+ warning = srv_update_addr_port(sv, addr, port, SERVER_INETADDR_UPDATER_CLI);
if (warning)
cli_msg(appctx, LOG_WARNING, warning);
- srv_clr_admin_flag(sv, SRV_ADMF_RMAINT);
HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
}
else if (strcmp(args[3], "fqdn") == 0) {
@@ -4994,12 +5310,12 @@ static int cli_parse_get_weight(char **args, char *payload, struct appctx *appct
be_name = istsplit(&sv_name, '/');
if (!istlen(sv_name))
- return cli_err(appctx, "Require 'backend/server'.");
+ return cli_err(appctx, "Require 'backend/server'.\n");
if (!(be = proxy_be_by_name(ist0(be_name))))
- return cli_err(appctx, "No such backend.");
+ return cli_err(appctx, "No such backend.\n");
if (!(sv = server_find_by_name(be, ist0(sv_name))))
- return cli_err(appctx, "No such server.");
+ return cli_err(appctx, "No such server.\n");
/* return server's effective weight at the moment */
snprintf(trash.area, trash.size, "%d (initial %d)\n", sv->uweight,
@@ -5234,7 +5550,7 @@ static int srv_alloc_lb(struct server *sv, struct proxy *be)
/* updates the server's weight during a warmup stage. Once the final weight is
* reached, the task automatically stops. Note that any server status change
- * must have updated s->last_change accordingly.
+ * must have updated s->counters.last_change accordingly.
*/
static struct task *server_warmup(struct task *t, void *context, unsigned int state)
{
@@ -5290,7 +5606,7 @@ static int init_srv_slowstart(struct server *srv)
if (srv->next_state == SRV_ST_STARTING) {
task_schedule(srv->warmup,
tick_add(now_ms,
- MS_TO_TICKS(MAX(1000, (ns_to_sec(now_ns) - srv->last_change)) / 20)));
+ MS_TO_TICKS(MAX(1000, (ns_to_sec(now_ns) - srv->counters.last_change)) / 20)));
}
}
@@ -5352,19 +5668,19 @@ static int cli_parse_add_server(char **args, char *payload, struct appctx *appct
}
if (!*sv_name)
- return cli_err(appctx, "Require 'backend/server'.");
+ return cli_err(appctx, "Require 'backend/server'.\n");
be = proxy_be_by_name(be_name);
if (!be)
- return cli_err(appctx, "No such backend.");
+ return cli_err(appctx, "No such backend.\n");
if (!(be->lbprm.algo & BE_LB_PROP_DYN)) {
- cli_err(appctx, "Backend must use a dynamic load balancing to support dynamic servers.");
+ cli_err(appctx, "Backend must use a dynamic load balancing to support dynamic servers.\n");
return 1;
}
if (be->mode == PR_MODE_SYSLOG) {
- cli_err(appctx," Dynamic servers cannot be used with log backends.");
+ cli_err(appctx," Dynamic servers cannot be used with log backends.\n");
return 1;
}
@@ -5554,11 +5870,11 @@ static int cli_parse_add_server(char **args, char *payload, struct appctx *appct
*/
if (srv->check.state & CHK_ST_CONFIGURED) {
if (!start_check_task(&srv->check, 0, 1, 1))
- ha_alert("System might be unstable, consider to execute a reload");
+ ha_alert("System might be unstable, consider to execute a reload\n");
}
if (srv->agent.state & CHK_ST_CONFIGURED) {
if (!start_check_task(&srv->agent, 0, 1, 1))
- ha_alert("System might be unstable, consider to execute a reload");
+ ha_alert("System might be unstable, consider to execute a reload\n");
}
if (srv->cklen && be->mode != PR_MODE_HTTP)
@@ -5594,6 +5910,72 @@ out:
return 1;
}
+/* Check if the server <bename>/<svname> exists and is ready for being deleted.
+ * Both <bename> and <svname> must be valid strings. This must be called under
+ * thread isolation. If pb/ps are not null, upon success, the pointer to
+ * the backend and server respectively will be put there. If pm is not null,
+ * a pointer to an error/success message is returned there (possibly NULL if
+ * nothing to say). Returned values:
+ * >0 if OK
+ * 0 if not yet (should wait if it can)
+ * <0 if not possible
+ */
+int srv_check_for_deletion(const char *bename, const char *svname, struct proxy **pb, struct server **ps, const char **pm)
+{
+ struct server *srv = NULL;
+ struct proxy *be = NULL;
+ const char *msg = NULL;
+ int ret;
+
+ /* First, unrecoverable errors */
+ ret = -1;
+
+ if (!(be = proxy_be_by_name(bename))) {
+ msg = "No such backend.";
+ goto leave;
+ }
+
+ if (!(srv = server_find_by_name(be, svname))) {
+ msg = "No such server.";
+ goto leave;
+ }
+
+ if (srv->flags & SRV_F_NON_PURGEABLE) {
+ msg = "This server cannot be removed at runtime due to other configuration elements pointing to it.";
+ goto leave;
+ }
+
+ /* Only servers in maintenance can be deleted. This ensures that the
+ * server is not present anymore in the lb structures (through
+ * lbprm.set_server_status_down).
+ */
+ if (!(srv->cur_admin & SRV_ADMF_MAINT)) {
+ msg = "Only servers in maintenance mode can be deleted.";
+ goto leave;
+ }
+
+ /* Second, conditions that may change over time */
+ ret = 0;
+
+ /* Ensure that there is no active/pending connection on the server. */
+ if (srv->curr_used_conns ||
+ !eb_is_empty(&srv->queue.head) || srv_has_streams(srv)) {
+ msg = "Server still has connections attached to it, cannot remove it.";
+ goto leave;
+ }
+
+ /* OK, let's go */
+ ret = 1;
+leave:
+ if (pb)
+ *pb = be;
+ if (ps)
+ *ps = srv;
+ if (pm)
+ *pm = msg;
+ return ret;
+}
+
/* Parse a "del server" command
* Returns 0 if the server has been successfully initialized, 1 on failure.
*/
@@ -5603,6 +5985,10 @@ static int cli_parse_delete_server(char **args, char *payload, struct appctx *ap
struct server *srv;
struct server *prev_del;
struct ist be_name, sv_name;
+ struct mt_list *elt1, elt2;
+ struct sess_priv_conns *sess_conns = NULL;
+ const char *msg;
+ int ret, i;
if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
return 1;
@@ -5620,42 +6006,71 @@ static int cli_parse_delete_server(char **args, char *payload, struct appctx *ap
sv_name = ist(args[1]);
be_name = istsplit(&sv_name, '/');
if (!istlen(sv_name)) {
- cli_err(appctx, "Require 'backend/server'.");
+ cli_err(appctx, "Require 'backend/server'.\n");
goto out;
}
- if (!(be = proxy_be_by_name(ist0(be_name)))) {
- cli_err(appctx, "No such backend.");
- goto out;
- }
- if (!(srv = server_find_by_name(be, ist0(sv_name)))) {
- cli_err(appctx, "No such server.");
+ ret = srv_check_for_deletion(ist0(be_name), ist0(sv_name), &be, &srv, &msg);
+ if (ret <= 0) {
+ /* failure (recoverable or not) */
+ cli_err(appctx, msg);
goto out;
}
- if (srv->flags & SRV_F_NON_PURGEABLE) {
- cli_err(appctx, "This server cannot be removed at runtime due to other configuration elements pointing to it.");
- goto out;
- }
+ /* Close idle connections attached to this server. */
+ for (i = tid;;) {
+ struct list *list = &srv->per_thr[i].idle_conn_list;
+ struct connection *conn;
+
+ while (!LIST_ISEMPTY(list)) {
+ conn = LIST_ELEM(list->n, struct connection *, idle_list);
+ if (i != tid) {
+ if (conn->mux && conn->mux->takeover)
+ conn->mux->takeover(conn, i, 1);
+ else if (conn->xprt && conn->xprt->takeover)
+ conn->xprt->takeover(conn, conn->ctx, i, 1);
+ }
+ conn_release(conn);
+ }
- /* Only servers in maintenance can be deleted. This ensures that the
- * server is not present anymore in the lb structures (through
- * lbprm.set_server_status_down).
- */
- if (!(srv->cur_admin & SRV_ADMF_MAINT)) {
- cli_err(appctx, "Only servers in maintenance mode can be deleted.");
- goto out;
+ /* Also remove all purgeable conns as some of them may still
+ * reference the currently deleted server.
+ */
+ while ((conn = MT_LIST_POP(&idle_conns[i].toremove_conns,
+ struct connection *, toremove_list))) {
+ conn_release(conn);
+ }
+
+ if ((i = ((i + 1 == global.nbthread) ? 0 : i + 1)) == tid)
+ break;
}
- /* Ensure that there is no active/idle/pending connection on the server.
- *
- * TODO idle connections should not prevent server deletion. A proper
- * cleanup function should be implemented to be used here.
- */
- if (srv->curr_used_conns || srv->curr_idle_conns ||
- !eb_is_empty(&srv->queue.head) || srv_has_streams(srv)) {
- cli_err(appctx, "Server still has connections attached to it, cannot remove it.");
- goto out;
+ /* All idle connections should be removed now. */
+ BUG_ON(srv->curr_idle_conns);
+
+ /* Close idle private connections attached to this server. */
+ mt_list_for_each_entry_safe(sess_conns, &srv->sess_conns, srv_el, elt1, elt2) {
+ struct connection *conn, *conn_back;
+ list_for_each_entry_safe(conn, conn_back, &sess_conns->conn_list, sess_el) {
+
+ /* Only idle connections should be present if srv_check_for_deletion() is true. */
+ BUG_ON(!(conn->flags & CO_FL_SESS_IDLE));
+
+ LIST_DEL_INIT(&conn->sess_el);
+ conn->owner = NULL;
+ conn->flags &= ~CO_FL_SESS_IDLE;
+ if (sess_conns->tid != tid) {
+ if (conn->mux && conn->mux->takeover)
+ conn->mux->takeover(conn, sess_conns->tid, 1);
+ else if (conn->xprt && conn->xprt->takeover)
+ conn->xprt->takeover(conn, conn->ctx, sess_conns->tid, 1);
+ }
+ conn_release(conn);
+ }
+
+ LIST_DELETE(&sess_conns->sess_el);
+ MT_LIST_DELETE_SAFE(elt1);
+ pool_free(pool_head_sess_priv_conns, sess_conns);
}
/* removing cannot fail anymore when we reach this:
@@ -5724,13 +6139,11 @@ static int cli_parse_delete_server(char **args, char *payload, struct appctx *ap
ha_notice("Server deleted.\n");
srv_drop(srv);
- cli_msg(appctx, LOG_INFO, "Server deleted.");
-
+ cli_msg(appctx, LOG_INFO, "Server deleted.\n");
return 0;
out:
thread_release();
-
return 1;
}
@@ -6334,8 +6747,8 @@ static void srv_update_status(struct server *s, int type, int cause)
if (srv_prev_state != s->cur_state) {
if (srv_prev_state == SRV_ST_STOPPED) {
/* server was down and no longer is */
- if (s->last_change < ns_to_sec(now_ns)) // ignore negative times
- s->down_time += ns_to_sec(now_ns) - s->last_change;
+ if (s->counters.last_change < ns_to_sec(now_ns)) // ignore negative times
+ s->down_time += ns_to_sec(now_ns) - s->counters.last_change;
_srv_event_hdl_publish(EVENT_HDL_SUB_SERVER_UP, cb_data.common, s);
}
else if (s->cur_state == SRV_ST_STOPPED) {
@@ -6343,7 +6756,7 @@ static void srv_update_status(struct server *s, int type, int cause)
s->counters.down_trans++;
_srv_event_hdl_publish(EVENT_HDL_SUB_SERVER_DOWN, cb_data.common, s);
}
- s->last_change = ns_to_sec(now_ns);
+ s->counters.last_change = ns_to_sec(now_ns);
/* publish the state change */
_srv_event_hdl_prepare_state(&cb_data.state,
@@ -6358,9 +6771,9 @@ static void srv_update_status(struct server *s, int type, int cause)
/* backend was down and is back up again:
* no helper function, updating last_change and backend downtime stats
*/
- if (s->proxy->last_change < ns_to_sec(now_ns)) // ignore negative times
- s->proxy->down_time += ns_to_sec(now_ns) - s->proxy->last_change;
- s->proxy->last_change = ns_to_sec(now_ns);
+ if (s->proxy->be_counters.last_change < ns_to_sec(now_ns)) // ignore negative times
+ s->proxy->down_time += ns_to_sec(now_ns) - s->proxy->be_counters.last_change;
+ s->proxy->be_counters.last_change = ns_to_sec(now_ns);
}
}