include/proto/server.h - haproxy - Gitiles

 /*
  * include/proto/server.h
  * This file defines everything related to servers.
  *
  * Copyright (C) 2000-2009 Willy Tarreau - w@1wt.eu
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation, version 2.1
  * exclusively.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */

 #ifndef _PROTO_SERVER_H
 #define _PROTO_SERVER_H

 #include <unistd.h>

 #include <common/config.h>
 #include <common/time.h>
 #include <types/applet.h>
 #include <types/dns.h>
 #include <types/proxy.h>
 #include <types/queue.h>
 #include <types/server.h>

 #include <proto/queue.h>
 #include <proto/log.h>
 #include <proto/freq_ctr.h>

 int srv_downtime(const struct server *s);
 int srv_lastsession(const struct server *s);
 int srv_getinter(const struct check *check);
 int parse_server(const char *file, int linenum, char **args, struct proxy *curproxy, struct proxy *defproxy);
 int update_server_addr(struct server *s, void *ip, int ip_sin_family, const char *updater);
 const char *update_server_addr_port(struct server *s, const char *addr, const char *port, char *updater);
 struct server *server_find_by_id(struct proxy *bk, int id);
 struct server *server_find_by_name(struct proxy *bk, const char *name);
 struct server *server_find_best_match(struct proxy *bk, char *name, int id, int *diff);
 void apply_server_state(void);
 void srv_compute_all_admin_states(struct proxy *px);
 int srv_set_addr_via_libc(struct server *srv, int *err_code);
 int srv_init_addr(void);
 struct server *cli_find_server(struct appctx *appctx, char *arg);

 /* functions related to server name resolution */
 int snr_update_srv_status(struct server *s, int has_no_ip);
 const char *update_server_fqdn(struct server *server, const char *fqdn, const char *updater);
 int snr_resolution_cb(struct dns_requester *requester, struct dns_nameserver *nameserver);
 int snr_resolution_error_cb(struct dns_requester *requester, int error_code);
 struct server *snr_check_ip_callback(struct server *srv, void *ip, unsigned char *ip_family);
 void srv_free_from_resolution(struct server *srv);

 /* increase the number of cumulated connections on the designated server */
 static void inline srv_inc_sess_ctr(struct server *s)
 {
 	s->counters.cum_sess++;
 	update_freq_ctr(&s->sess_per_sec, 1);
 	if (s->sess_per_sec.curr_ctr > s->counters.sps_max)
 		s->counters.sps_max = s->sess_per_sec.curr_ctr;
 }

 /* set the time of last session on the designated server */
 static void inline srv_set_sess_last(struct server *s)
 {
 	s->counters.last_sess = now.tv_sec;
 }

 /*
  * Registers the server keyword list <kwl> as a list of valid keywords for next
  * parsing sessions.
  */
 void srv_register_keywords(struct srv_kw_list *kwl);

 /* Return a pointer to the server keyword <kw>, or NULL if not found. */
 struct srv_kw *srv_find_kw(const char *kw);

 /* Dumps all registered "server" keywords to the <out> string pointer. */
 void srv_dump_kws(char **out);

 /* Recomputes the server's eweight based on its state, uweight, the current time,
  * and the proxy's algorihtm. To be used after updating sv->uweight. The warmup
  * state is automatically disabled if the time is elapsed.
  */
 void server_recalc_eweight(struct server *sv);

 /* returns the current server throttle rate between 0 and 100% */
 static inline unsigned int server_throttle_rate(struct server *sv)
 {
 	struct proxy *px = sv->proxy;

 	/* when uweight is 0, we're in soft-stop so that cannot be a slowstart,
 	 * thus the throttle is 100%.
 	 */
 	if (!sv->uweight)
 		return 100;

 	return (100U * px->lbprm.wmult * sv->eweight + px->lbprm.wdiv - 1) / (px->lbprm.wdiv * sv->uweight);
 }

 /*
  * Parses weight_str and configures sv accordingly.
  * Returns NULL on success, error message string otherwise.
  */
 const char *server_parse_weight_change_request(struct server *sv,
 					       const char *weight_str);

 /*
  * Parses addr_str and configures sv accordingly. updater precise
  * the source of the change in the associated message log.
  * Returns NULL on success, error message string otherwise.
  */
 const char *server_parse_addr_change_request(struct server *sv,
                                              const char *addr_str, const char *updater);

 /*
  * Parses maxconn_str and configures sv accordingly.
  * Returns NULL on success, error message string otherwise.
  */
 const char *server_parse_maxconn_change_request(struct server *sv,
 					       const char *maxconn_str);

 /*
  * Return true if the server has a zero user-weight, meaning it's in draining
  * mode (ie: not taking new non-persistent connections).
  */
 static inline int server_is_draining(const struct server *s)
 {
 	return !s->uweight || (s->admin & SRV_ADMF_DRAIN);
 }

 /* Shutdown all connections of a server. The caller must pass a termination
  * code in <why>, which must be one of SF_ERR_* indicating the reason for the
  * shutdown.
  */
 void srv_shutdown_streams(struct server *srv, int why);

 /* Shutdown all connections of all backup servers of a proxy. The caller must
  * pass a termination code in <why>, which must be one of SF_ERR_* indicating
  * the reason for the shutdown.
  */
 void srv_shutdown_backup_streams(struct proxy *px, int why);

 /* Appends some information to a message string related to a server going UP or
  * DOWN.  If both <forced> and <reason> are null and the server tracks another
  * one, a "via" information will be provided to know where the status came from.
  * If <reason> is non-null, the entire string will be appended after a comma and
  * a space (eg: to report some information from the check that changed the state).
  * If <xferred> is non-negative, some information about requeued sessions are
  * provided.
  */
 void srv_append_status(struct chunk *msg, struct server *s, const char *reason, int xferred, int forced);

 /* Marks server <s> down, regardless of its checks' statuses, notifies by all
  * available means, recounts the remaining servers on the proxy and transfers
  * queued sessions whenever possible to other servers. It automatically
  * recomputes the number of servers, but not the map. Maintenance servers are
  * ignored. It reports <reason> if non-null as the reason for going down. Note
  * that it makes use of the trash to build the log strings, so <reason> must
  * not be placed there.
  */
 void srv_set_stopped(struct server *s, const char *reason);

 /* Marks server <s> up regardless of its checks' statuses and provided it isn't
  * in maintenance. Notifies by all available means, recounts the remaining
  * servers on the proxy and tries to grab requests from the proxy. It
  * automatically recomputes the number of servers, but not the map. Maintenance
  * servers are ignored. It reports <reason> if non-null as the reason for going
  * up. Note that it makes use of the trash to build the log strings, so <reason>
  * must not be placed there.
  */
 void srv_set_running(struct server *s, const char *reason);

 /* Marks server <s> stopping regardless of its checks' statuses and provided it
  * isn't in maintenance. Notifies by all available means, recounts the remaining
  * servers on the proxy and tries to grab requests from the proxy. It
  * automatically recomputes the number of servers, but not the map. Maintenance
  * servers are ignored. It reports <reason> if non-null as the reason for going
  * up. Note that it makes use of the trash to build the log strings, so <reason>
  * must not be placed there.
  */
 void srv_set_stopping(struct server *s, const char *reason);

 /* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
  * enforce either maint mode or drain mode. It is not allowed to set more than
  * one flag at once. The equivalent "inherited" flag is propagated to all
  * tracking servers. Maintenance mode disables health checks (but not agent
  * checks). When either the flag is already set or no flag is passed, nothing
  * is done. If <cause> is non-null, it will be displayed at the end of the log
  * lines to justify the state change.
  */
 void srv_set_admin_flag(struct server *s, enum srv_admin mode, const char *cause);

 /* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
  * stop enforcing either maint mode or drain mode. It is not allowed to set more
  * than one flag at once. The equivalent "inherited" flag is propagated to all
  * tracking servers. Leaving maintenance mode re-enables health checks. When
  * either the flag is already cleared or no flag is passed, nothing is done.
  */
 void srv_clr_admin_flag(struct server *s, enum srv_admin mode);

 /* Calculates the dynamic persitent cookie for a server, if a secret key has
  * been provided.
  */
 void srv_set_dyncookie(struct server *s);

 /* Puts server <s> into maintenance mode, and propagate that status down to all
  * tracking servers.
  */
 static inline void srv_adm_set_maint(struct server *s)
 {
 	srv_set_admin_flag(s, SRV_ADMF_FMAINT, NULL);
 	srv_clr_admin_flag(s, SRV_ADMF_FDRAIN);
 }

 /* Puts server <s> into drain mode, and propagate that status down to all
  * tracking servers.
  */
 static inline void srv_adm_set_drain(struct server *s)
 {
 	srv_set_admin_flag(s, SRV_ADMF_FDRAIN, NULL);
 	srv_clr_admin_flag(s, SRV_ADMF_FMAINT);
 }

 /* Puts server <s> into ready mode, and propagate that status down to all
  * tracking servers.
  */
 static inline void srv_adm_set_ready(struct server *s)
 {
 	srv_clr_admin_flag(s, SRV_ADMF_FDRAIN);
 	srv_clr_admin_flag(s, SRV_ADMF_FMAINT);
 }

 /* appends an initaddr method to the existing list. Returns 0 on failure. */
 static inline int srv_append_initaddr(unsigned int *list, enum srv_initaddr addr)
 {
 	int shift = 0;

 	while (shift + 3 < 32 && (*list >> shift))
 		shift += 3;

 	if (shift + 3 > 32)
 		return 0;

 	*list |= addr << shift;
 	return 1;
 }

 /* returns the next initaddr method and removes it from <list> by shifting
  * it right (implying that it MUST NOT be the server's. Returns SRV_IADDR_END
  * at the end.
  */
 static inline enum srv_initaddr srv_get_next_initaddr(unsigned int *list)
 {
 	enum srv_initaddr ret;

 	ret = *list & 7;
 	*list >>= 3;
 	return ret;
 }

 #endif /* _PROTO_SERVER_H */

 /*
  * Local variables:
  *  c-indent-level: 8
  *  c-basic-offset: 8
  * End:
  */
	/*
	* include/proto/server.h
	* This file defines everything related to servers.
	*
	* Copyright (C) 2000-2009 Willy Tarreau - w@1wt.eu
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation, version 2.1
	* exclusively.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#ifndef _PROTO_SERVER_H
	#define _PROTO_SERVER_H

	#include <unistd.h>

	#include <common/config.h>
	#include <common/time.h>
	#include <types/applet.h>
	#include <types/dns.h>
	#include <types/proxy.h>
	#include <types/queue.h>
	#include <types/server.h>

	#include <proto/queue.h>
	#include <proto/log.h>
	#include <proto/freq_ctr.h>

	int srv_downtime(const struct server *s);
	int srv_lastsession(const struct server *s);
	int srv_getinter(const struct check *check);
	int parse_server(const char file, int linenum, char args, struct proxy curproxy, struct proxy *defproxy);
	int update_server_addr(struct server s, void ip, int ip_sin_family, const char *updater);
	const char update_server_addr_port(struct server s, const char addr, const char port, char *updater);
	struct server server_find_by_id(struct proxy bk, int id);
	struct server server_find_by_name(struct proxy bk, const char *name);
	struct server server_find_best_match(struct proxy bk, char name, int id, int diff);
	void apply_server_state(void);
	void srv_compute_all_admin_states(struct proxy *px);
	int srv_set_addr_via_libc(struct server srv, int err_code);
	int srv_init_addr(void);
	struct server cli_find_server(struct appctx appctx, char *arg);

	/* functions related to server name resolution */
	int snr_update_srv_status(struct server *s, int has_no_ip);
	const char update_server_fqdn(struct server server, const char fqdn, const char updater);
	int snr_resolution_cb(struct dns_requester requester, struct dns_nameserver nameserver);
	int snr_resolution_error_cb(struct dns_requester *requester, int error_code);
	struct server snr_check_ip_callback(struct server srv, void ip, unsigned char ip_family);
	void srv_free_from_resolution(struct server *srv);

	/* increase the number of cumulated connections on the designated server */
	static void inline srv_inc_sess_ctr(struct server *s)
	{
	s->counters.cum_sess++;
	update_freq_ctr(&s->sess_per_sec, 1);
	if (s->sess_per_sec.curr_ctr > s->counters.sps_max)
	s->counters.sps_max = s->sess_per_sec.curr_ctr;
	}

	/* set the time of last session on the designated server */
	static void inline srv_set_sess_last(struct server *s)
	{
	s->counters.last_sess = now.tv_sec;
	}

	/*
	* Registers the server keyword list <kwl> as a list of valid keywords for next
	* parsing sessions.
	*/
	void srv_register_keywords(struct srv_kw_list *kwl);

	/* Return a pointer to the server keyword <kw>, or NULL if not found. */
	struct srv_kw srv_find_kw(const char kw);

	/* Dumps all registered "server" keywords to the <out> string pointer. */
	void srv_dump_kws(char **out);

	/* Recomputes the server's eweight based on its state, uweight, the current time,
	* and the proxy's algorihtm. To be used after updating sv->uweight. The warmup
	* state is automatically disabled if the time is elapsed.
	*/
	void server_recalc_eweight(struct server *sv);

	/* returns the current server throttle rate between 0 and 100% */
	static inline unsigned int server_throttle_rate(struct server *sv)
	{
	struct proxy *px = sv->proxy;

	/* when uweight is 0, we're in soft-stop so that cannot be a slowstart,
	* thus the throttle is 100%.
	*/
	if (!sv->uweight)
	return 100;

	return (100U * px->lbprm.wmult * sv->eweight + px->lbprm.wdiv - 1) / (px->lbprm.wdiv * sv->uweight);
	}

	/*
	* Parses weight_str and configures sv accordingly.
	* Returns NULL on success, error message string otherwise.
	*/
	const char server_parse_weight_change_request(struct server sv,
	const char *weight_str);

	/*
	* Parses addr_str and configures sv accordingly. updater precise
	* the source of the change in the associated message log.
	* Returns NULL on success, error message string otherwise.
	*/
	const char server_parse_addr_change_request(struct server sv,
	const char addr_str, const char updater);

	/*
	* Parses maxconn_str and configures sv accordingly.
	* Returns NULL on success, error message string otherwise.
	*/
	const char server_parse_maxconn_change_request(struct server sv,
	const char *maxconn_str);

	/*
	* Return true if the server has a zero user-weight, meaning it's in draining
	* mode (ie: not taking new non-persistent connections).
	*/
	static inline int server_is_draining(const struct server *s)
	{
	return !s->uweight \|\| (s->admin & SRV_ADMF_DRAIN);
	}

	/* Shutdown all connections of a server. The caller must pass a termination
	* code in <why>, which must be one of SF_ERR_* indicating the reason for the
	* shutdown.
	*/
	void srv_shutdown_streams(struct server *srv, int why);

	/* Shutdown all connections of all backup servers of a proxy. The caller must
	* pass a termination code in <why>, which must be one of SF_ERR_* indicating
	* the reason for the shutdown.
	*/
	void srv_shutdown_backup_streams(struct proxy *px, int why);

	/* Appends some information to a message string related to a server going UP or
	* DOWN. If both <forced> and <reason> are null and the server tracks another
	* one, a "via" information will be provided to know where the status came from.
	* If <reason> is non-null, the entire string will be appended after a comma and
	* a space (eg: to report some information from the check that changed the state).
	* If <xferred> is non-negative, some information about requeued sessions are
	* provided.
	*/
	void srv_append_status(struct chunk msg, struct server s, const char *reason, int xferred, int forced);

	/* Marks server <s> down, regardless of its checks' statuses, notifies by all
	* available means, recounts the remaining servers on the proxy and transfers
	* queued sessions whenever possible to other servers. It automatically
	* recomputes the number of servers, but not the map. Maintenance servers are
	* ignored. It reports <reason> if non-null as the reason for going down. Note
	* that it makes use of the trash to build the log strings, so <reason> must
	* not be placed there.
	*/
	void srv_set_stopped(struct server s, const char reason);

	/* Marks server <s> up regardless of its checks' statuses and provided it isn't
	* in maintenance. Notifies by all available means, recounts the remaining
	* servers on the proxy and tries to grab requests from the proxy. It
	* automatically recomputes the number of servers, but not the map. Maintenance
	* servers are ignored. It reports <reason> if non-null as the reason for going
	* up. Note that it makes use of the trash to build the log strings, so <reason>
	* must not be placed there.
	*/
	void srv_set_running(struct server s, const char reason);

	/* Marks server <s> stopping regardless of its checks' statuses and provided it
	* isn't in maintenance. Notifies by all available means, recounts the remaining
	* servers on the proxy and tries to grab requests from the proxy. It
	* automatically recomputes the number of servers, but not the map. Maintenance
	* servers are ignored. It reports <reason> if non-null as the reason for going
	* up. Note that it makes use of the trash to build the log strings, so <reason>
	* must not be placed there.
	*/
	void srv_set_stopping(struct server s, const char reason);

	/* Enables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
	* enforce either maint mode or drain mode. It is not allowed to set more than
	* one flag at once. The equivalent "inherited" flag is propagated to all
	* tracking servers. Maintenance mode disables health checks (but not agent
	* checks). When either the flag is already set or no flag is passed, nothing
	* is done. If <cause> is non-null, it will be displayed at the end of the log
	* lines to justify the state change.
	*/
	void srv_set_admin_flag(struct server s, enum srv_admin mode, const char cause);

	/* Disables admin flag <mode> (among SRV_ADMF_*) on server <s>. This is used to
	* stop enforcing either maint mode or drain mode. It is not allowed to set more
	* than one flag at once. The equivalent "inherited" flag is propagated to all
	* tracking servers. Leaving maintenance mode re-enables health checks. When
	* either the flag is already cleared or no flag is passed, nothing is done.
	*/
	void srv_clr_admin_flag(struct server *s, enum srv_admin mode);

	/* Calculates the dynamic persitent cookie for a server, if a secret key has
	* been provided.
	*/
	void srv_set_dyncookie(struct server *s);

	/* Puts server <s> into maintenance mode, and propagate that status down to all
	* tracking servers.
	*/
	static inline void srv_adm_set_maint(struct server *s)
	{
	srv_set_admin_flag(s, SRV_ADMF_FMAINT, NULL);
	srv_clr_admin_flag(s, SRV_ADMF_FDRAIN);
	}

	/* Puts server <s> into drain mode, and propagate that status down to all
	* tracking servers.
	*/
	static inline void srv_adm_set_drain(struct server *s)
	{
	srv_set_admin_flag(s, SRV_ADMF_FDRAIN, NULL);
	srv_clr_admin_flag(s, SRV_ADMF_FMAINT);
	}

	/* Puts server <s> into ready mode, and propagate that status down to all
	* tracking servers.
	*/
	static inline void srv_adm_set_ready(struct server *s)
	{
	srv_clr_admin_flag(s, SRV_ADMF_FDRAIN);
	srv_clr_admin_flag(s, SRV_ADMF_FMAINT);
	}

	/* appends an initaddr method to the existing list. Returns 0 on failure. */
	static inline int srv_append_initaddr(unsigned int *list, enum srv_initaddr addr)
	{
	int shift = 0;

	while (shift + 3 < 32 && (*list >> shift))
	shift += 3;

	if (shift + 3 > 32)
	return 0;

	*list \|= addr << shift;
	return 1;
	}

	/* returns the next initaddr method and removes it from <list> by shifting
	* it right (implying that it MUST NOT be the server's. Returns SRV_IADDR_END
	* at the end.
	*/
	static inline enum srv_initaddr srv_get_next_initaddr(unsigned int *list)
	{
	enum srv_initaddr ret;

	ret = *list & 7;
	*list >>= 3;
	return ret;
	}

	#endif /* _PROTO_SERVER_H */

	/*
	* Local variables:
	* c-indent-level: 8
	* c-basic-offset: 8
	* End:
	*/