blob: ae1297ea11f84845c3e05e4481ea42d7c0358927 [file] [log] [blame]
Willy Tarreauf09c6602012-02-13 17:12:08 +01001/*
2 * First Available Server load balancing algorithm.
3 *
Willy Tarreau64559c52012-04-07 09:08:45 +02004 * This file implements an algorithm which emerged during a discussion with
5 * Steen Larsen, initially inspired from Anshul Gandhi et.al.'s work now
6 * described as "packing" in section 3.5:
7 *
8 * http://reports-archive.adm.cs.cmu.edu/anon/2012/CMU-CS-12-109.pdf
9 *
Willy Tarreauf09c6602012-02-13 17:12:08 +010010 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
16 *
17 */
18
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020019#include <haproxy/api.h>
Willy Tarreau8d2b7772020-05-27 10:58:19 +020020#include <import/eb32tree.h>
Willy Tarreauf09c6602012-02-13 17:12:08 +010021
Willy Tarreauf09c6602012-02-13 17:12:08 +010022#include <types/server.h>
23
24#include <proto/backend.h>
25#include <proto/queue.h>
26
27
28/* Remove a server from a tree. It must have previously been dequeued. This
29 * function is meant to be called when a server is going down or has its
30 * weight disabled.
Willy Tarreau1b877482018-08-21 19:44:53 +020031 *
32 * The server's lock and the lbprm's lock must be held.
Willy Tarreauf09c6602012-02-13 17:12:08 +010033 */
34static inline void fas_remove_from_tree(struct server *s)
35{
36 s->lb_tree = NULL;
37}
38
Willy Tarreau1b877482018-08-21 19:44:53 +020039/* simply removes a server from a tree.
40 *
41 * The server's lock and the lbprm's lock must be held.
42 */
Willy Tarreauf09c6602012-02-13 17:12:08 +010043static inline void fas_dequeue_srv(struct server *s)
44{
45 eb32_delete(&s->lb_node);
46}
47
48/* Queue a server in its associated tree, assuming the weight is >0.
49 * Servers are sorted by unique ID so that we send all connections to the first
50 * available server in declaration order (or ID order) until its maxconn is
51 * reached. It is important to understand that the server weight is not used
52 * here.
Willy Tarreau1b877482018-08-21 19:44:53 +020053 *
54 * The server's lock and the lbprm's lock must be held.
Willy Tarreauf09c6602012-02-13 17:12:08 +010055 */
56static inline void fas_queue_srv(struct server *s)
57{
58 s->lb_node.key = s->puid;
59 eb32_insert(s->lb_tree, &s->lb_node);
60}
61
62/* Re-position the server in the FS tree after it has been assigned one
63 * connection or after it has released one. Note that it is possible that
64 * the server has been moved out of the tree due to failed health-checks.
Willy Tarreau1b877482018-08-21 19:44:53 +020065 *
66 * The server's lock must be held. The lbprm's lock will be used.
Willy Tarreauf09c6602012-02-13 17:12:08 +010067 */
68static void fas_srv_reposition(struct server *s)
69{
Christopher Faulet2a944ee2017-11-07 10:42:54 +010070 HA_SPIN_LOCK(LBPRM_LOCK, &s->proxy->lbprm.lock);
Christopher Faulet16b2be92019-07-04 11:59:42 +020071 if (s->lb_tree) {
72 fas_dequeue_srv(s);
73 fas_queue_srv(s);
74 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +010075 HA_SPIN_UNLOCK(LBPRM_LOCK, &s->proxy->lbprm.lock);
Willy Tarreauf09c6602012-02-13 17:12:08 +010076}
77
78/* This function updates the server trees according to server <srv>'s new
79 * state. It should be called when server <srv>'s status changes to down.
80 * It is not important whether the server was already down or not. It is not
81 * important either that the new state is completely down (the caller may not
82 * know all the variables of a server's state).
Willy Tarreau1b877482018-08-21 19:44:53 +020083 *
84 * The server's lock must be held. The lbprm's lock will be used.
Willy Tarreauf09c6602012-02-13 17:12:08 +010085 */
86static void fas_set_server_status_down(struct server *srv)
87{
88 struct proxy *p = srv->proxy;
89
Willy Tarreauc5150da2014-05-13 19:27:31 +020090 if (!srv_lb_status_changed(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +010091 return;
92
Emeric Brun52a91d32017-08-31 14:41:55 +020093 if (srv_willbe_usable(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +010094 goto out_update_state;
95
Willy Tarreau1b877482018-08-21 19:44:53 +020096 HA_SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
97
Emeric Brun52a91d32017-08-31 14:41:55 +020098 if (!srv_currently_usable(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +010099 /* server was already down */
100 goto out_update_backend;
101
Willy Tarreauc93cd162014-05-13 15:54:22 +0200102 if (srv->flags & SRV_F_BACKUP) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200103 p->lbprm.tot_wbck -= srv->cur_eweight;
Willy Tarreauf09c6602012-02-13 17:12:08 +0100104 p->srv_bck--;
105
106 if (srv == p->lbprm.fbck) {
107 /* we lost the first backup server in a single-backup
108 * configuration, we must search another one.
109 */
110 struct server *srv2 = p->lbprm.fbck;
111 do {
112 srv2 = srv2->next;
113 } while (srv2 &&
Willy Tarreauc93cd162014-05-13 15:54:22 +0200114 !((srv2->flags & SRV_F_BACKUP) &&
Emeric Brun52a91d32017-08-31 14:41:55 +0200115 srv_willbe_usable(srv2)));
Willy Tarreauf09c6602012-02-13 17:12:08 +0100116 p->lbprm.fbck = srv2;
117 }
118 } else {
Emeric Brun52a91d32017-08-31 14:41:55 +0200119 p->lbprm.tot_wact -= srv->cur_eweight;
Willy Tarreauf09c6602012-02-13 17:12:08 +0100120 p->srv_act--;
121 }
122
123 fas_dequeue_srv(srv);
124 fas_remove_from_tree(srv);
125
Christopher Faulet5b517552017-06-09 14:17:53 +0200126 out_update_backend:
Willy Tarreauf09c6602012-02-13 17:12:08 +0100127 /* check/update tot_used, tot_weight */
128 update_backend_weight(p);
Willy Tarreau1b877482018-08-21 19:44:53 +0200129 HA_SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
130
Willy Tarreauf09c6602012-02-13 17:12:08 +0100131 out_update_state:
Willy Tarreauc5150da2014-05-13 19:27:31 +0200132 srv_lb_commit_status(srv);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100133}
134
135/* This function updates the server trees according to server <srv>'s new
136 * state. It should be called when server <srv>'s status changes to up.
137 * It is not important whether the server was already down or not. It is not
138 * important either that the new state is completely UP (the caller may not
139 * know all the variables of a server's state). This function will not change
140 * the weight of a server which was already up.
Willy Tarreau1b877482018-08-21 19:44:53 +0200141 *
142 * The server's lock must be held. The lbprm's lock will be used.
Willy Tarreauf09c6602012-02-13 17:12:08 +0100143 */
144static void fas_set_server_status_up(struct server *srv)
145{
146 struct proxy *p = srv->proxy;
147
Willy Tarreauc5150da2014-05-13 19:27:31 +0200148 if (!srv_lb_status_changed(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +0100149 return;
150
Emeric Brun52a91d32017-08-31 14:41:55 +0200151 if (!srv_willbe_usable(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +0100152 goto out_update_state;
153
Willy Tarreau1b877482018-08-21 19:44:53 +0200154 HA_SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
155
Emeric Brun52a91d32017-08-31 14:41:55 +0200156 if (srv_currently_usable(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +0100157 /* server was already up */
158 goto out_update_backend;
159
Willy Tarreauc93cd162014-05-13 15:54:22 +0200160 if (srv->flags & SRV_F_BACKUP) {
Willy Tarreauf09c6602012-02-13 17:12:08 +0100161 srv->lb_tree = &p->lbprm.fas.bck;
Emeric Brun52a91d32017-08-31 14:41:55 +0200162 p->lbprm.tot_wbck += srv->next_eweight;
Willy Tarreauf09c6602012-02-13 17:12:08 +0100163 p->srv_bck++;
164
165 if (!(p->options & PR_O_USE_ALL_BK)) {
166 if (!p->lbprm.fbck) {
167 /* there was no backup server anymore */
168 p->lbprm.fbck = srv;
169 } else {
170 /* we may have restored a backup server prior to fbck,
171 * in which case it should replace it.
172 */
173 struct server *srv2 = srv;
174 do {
175 srv2 = srv2->next;
176 } while (srv2 && (srv2 != p->lbprm.fbck));
177 if (srv2)
178 p->lbprm.fbck = srv;
179 }
180 }
181 } else {
182 srv->lb_tree = &p->lbprm.fas.act;
Emeric Brun52a91d32017-08-31 14:41:55 +0200183 p->lbprm.tot_wact += srv->next_eweight;
Willy Tarreauf09c6602012-02-13 17:12:08 +0100184 p->srv_act++;
185 }
186
187 /* note that eweight cannot be 0 here */
188 fas_queue_srv(srv);
189
190 out_update_backend:
191 /* check/update tot_used, tot_weight */
192 update_backend_weight(p);
Willy Tarreau1b877482018-08-21 19:44:53 +0200193 HA_SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
194
Willy Tarreauf09c6602012-02-13 17:12:08 +0100195 out_update_state:
Willy Tarreauc5150da2014-05-13 19:27:31 +0200196 srv_lb_commit_status(srv);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100197}
198
199/* This function must be called after an update to server <srv>'s effective
200 * weight. It may be called after a state change too.
Willy Tarreau1b877482018-08-21 19:44:53 +0200201 *
202 * The server's lock must be held. The lbprm's lock will be used.
Willy Tarreauf09c6602012-02-13 17:12:08 +0100203 */
204static void fas_update_server_weight(struct server *srv)
205{
206 int old_state, new_state;
207 struct proxy *p = srv->proxy;
208
Willy Tarreauc5150da2014-05-13 19:27:31 +0200209 if (!srv_lb_status_changed(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +0100210 return;
211
212 /* If changing the server's weight changes its state, we simply apply
213 * the procedures we already have for status change. If the state
214 * remains down, the server is not in any tree, so it's as easy as
215 * updating its values. If the state remains up with different weights,
216 * there are some computations to perform to find a new place and
217 * possibly a new tree for this server.
218 */
219
Emeric Brun52a91d32017-08-31 14:41:55 +0200220 old_state = srv_currently_usable(srv);
221 new_state = srv_willbe_usable(srv);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100222
223 if (!old_state && !new_state) {
Willy Tarreauc5150da2014-05-13 19:27:31 +0200224 srv_lb_commit_status(srv);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100225 return;
226 }
227 else if (!old_state && new_state) {
228 fas_set_server_status_up(srv);
229 return;
230 }
231 else if (old_state && !new_state) {
232 fas_set_server_status_down(srv);
233 return;
234 }
235
Willy Tarreau1b877482018-08-21 19:44:53 +0200236 HA_SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
237
Willy Tarreauf09c6602012-02-13 17:12:08 +0100238 if (srv->lb_tree)
239 fas_dequeue_srv(srv);
240
Willy Tarreauc93cd162014-05-13 15:54:22 +0200241 if (srv->flags & SRV_F_BACKUP) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200242 p->lbprm.tot_wbck += srv->next_eweight - srv->cur_eweight;
Willy Tarreauf09c6602012-02-13 17:12:08 +0100243 srv->lb_tree = &p->lbprm.fas.bck;
244 } else {
Emeric Brun52a91d32017-08-31 14:41:55 +0200245 p->lbprm.tot_wact += srv->next_eweight - srv->cur_eweight;
Willy Tarreauf09c6602012-02-13 17:12:08 +0100246 srv->lb_tree = &p->lbprm.fas.act;
247 }
248
249 fas_queue_srv(srv);
250
251 update_backend_weight(p);
Willy Tarreau1b877482018-08-21 19:44:53 +0200252 HA_SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
253
Willy Tarreauc5150da2014-05-13 19:27:31 +0200254 srv_lb_commit_status(srv);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100255}
256
257/* This function is responsible for building the trees in case of fast
258 * weighted least-conns. It also sets p->lbprm.wdiv to the eweight to
259 * uweight ratio. Both active and backup groups are initialized.
260 */
261void fas_init_server_tree(struct proxy *p)
262{
263 struct server *srv;
264 struct eb_root init_head = EB_ROOT;
265
266 p->lbprm.set_server_status_up = fas_set_server_status_up;
267 p->lbprm.set_server_status_down = fas_set_server_status_down;
268 p->lbprm.update_server_eweight = fas_update_server_weight;
269 p->lbprm.server_take_conn = fas_srv_reposition;
270 p->lbprm.server_drop_conn = fas_srv_reposition;
271
272 p->lbprm.wdiv = BE_WEIGHT_SCALE;
273 for (srv = p->srv; srv; srv = srv->next) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200274 srv->next_eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult;
Willy Tarreauc5150da2014-05-13 19:27:31 +0200275 srv_lb_commit_status(srv);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100276 }
277
278 recount_servers(p);
279 update_backend_weight(p);
280
281 p->lbprm.fas.act = init_head;
282 p->lbprm.fas.bck = init_head;
283
284 /* queue active and backup servers in two distinct groups */
285 for (srv = p->srv; srv; srv = srv->next) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200286 if (!srv_currently_usable(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +0100287 continue;
Willy Tarreauc93cd162014-05-13 15:54:22 +0200288 srv->lb_tree = (srv->flags & SRV_F_BACKUP) ? &p->lbprm.fas.bck : &p->lbprm.fas.act;
Willy Tarreauf09c6602012-02-13 17:12:08 +0100289 fas_queue_srv(srv);
290 }
291}
292
293/* Return next server from the FS tree in backend <p>. If the tree is empty,
294 * return NULL. Saturated servers are skipped.
Willy Tarreau1b877482018-08-21 19:44:53 +0200295 *
296 * The server's lock must be held. The lbprm's lock will be used.
Willy Tarreauf09c6602012-02-13 17:12:08 +0100297 */
298struct server *fas_get_next_server(struct proxy *p, struct server *srvtoavoid)
299{
300 struct server *srv, *avoided;
301 struct eb32_node *node;
302
303 srv = avoided = NULL;
304
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100305 HA_SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100306 if (p->srv_act)
307 node = eb32_first(&p->lbprm.fas.act);
Christopher Faulet5b517552017-06-09 14:17:53 +0200308 else if (p->lbprm.fbck) {
309 srv = p->lbprm.fbck;
310 goto out;
311 }
Willy Tarreauf09c6602012-02-13 17:12:08 +0100312 else if (p->srv_bck)
313 node = eb32_first(&p->lbprm.fas.bck);
Christopher Faulet5b517552017-06-09 14:17:53 +0200314 else {
315 srv = NULL;
316 goto out;
317 }
Willy Tarreauf09c6602012-02-13 17:12:08 +0100318
319 while (node) {
320 /* OK, we have a server. However, it may be saturated, in which
321 * case we don't want to reconsider it for now, so we'll simply
322 * skip it. Same if it's the server we try to avoid, in which
323 * case we simply remember it for later use if needed.
324 */
325 struct server *s;
326
327 s = eb32_entry(node, struct server, lb_node);
328 if (!s->maxconn || (!s->nbpend && s->served < srv_dynamic_maxconn(s))) {
329 if (s != srvtoavoid) {
330 srv = s;
331 break;
332 }
333 avoided = s;
334 }
335 node = eb32_next(node);
336 }
337
338 if (!srv)
339 srv = avoided;
Christopher Faulet5b517552017-06-09 14:17:53 +0200340 out:
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100341 HA_SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100342 return srv;
343}
344
345
346/*
347 * Local variables:
348 * c-indent-level: 8
349 * c-basic-offset: 8
350 * End:
351 */