/* * First Available Server load balancing algorithm. * * This file implements an algorithm which emerged during a discussion with * Steen Larsen, initially inspired from Anshul Gandhi et.al.'s work now * described as "packing" in section 3.5: * * http://reports-archive.adm.cs.cmu.edu/anon/2012/CMU-CS-12-109.pdf * * Copyright 2000-2012 Willy Tarreau * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. * */ #include #include #include #include #include #include #include #include /* Remove a server from a tree. It must have previously been dequeued. This * function is meant to be called when a server is going down or has its * weight disabled. */ static inline void fas_remove_from_tree(struct server *s) { s->lb_tree = NULL; } /* simply removes a server from a tree */ static inline void fas_dequeue_srv(struct server *s) { eb32_delete(&s->lb_node); } /* Queue a server in its associated tree, assuming the weight is >0. * Servers are sorted by unique ID so that we send all connections to the first * available server in declaration order (or ID order) until its maxconn is * reached. It is important to understand that the server weight is not used * here. */ static inline void fas_queue_srv(struct server *s) { s->lb_node.key = s->puid; eb32_insert(s->lb_tree, &s->lb_node); } /* Re-position the server in the FS tree after it has been assigned one * connection or after it has released one. Note that it is possible that * the server has been moved out of the tree due to failed health-checks. */ static void fas_srv_reposition(struct server *s) { if (!s->lb_tree) return; fas_dequeue_srv(s); fas_queue_srv(s); } /* This function updates the server trees according to server 's new * state. It should be called when server 's status changes to down. * It is not important whether the server was already down or not. It is not * important either that the new state is completely down (the caller may not * know all the variables of a server's state). */ static void fas_set_server_status_down(struct server *srv) { struct proxy *p = srv->proxy; if (!srv_lb_status_changed(srv)) return; if (srv_is_usable(srv)) goto out_update_state; if (!srv_was_usable(srv)) /* server was already down */ goto out_update_backend; if (srv->flags & SRV_F_BACKUP) { p->lbprm.tot_wbck -= srv->prev_eweight; p->srv_bck--; if (srv == p->lbprm.fbck) { /* we lost the first backup server in a single-backup * configuration, we must search another one. */ struct server *srv2 = p->lbprm.fbck; do { srv2 = srv2->next; } while (srv2 && !((srv2->flags & SRV_F_BACKUP) && srv_is_usable(srv2))); p->lbprm.fbck = srv2; } } else { p->lbprm.tot_wact -= srv->prev_eweight; p->srv_act--; } fas_dequeue_srv(srv); fas_remove_from_tree(srv); out_update_backend: /* check/update tot_used, tot_weight */ update_backend_weight(p); out_update_state: srv_lb_commit_status(srv); } /* This function updates the server trees according to server 's new * state. It should be called when server 's status changes to up. * It is not important whether the server was already down or not. It is not * important either that the new state is completely UP (the caller may not * know all the variables of a server's state). This function will not change * the weight of a server which was already up. */ static void fas_set_server_status_up(struct server *srv) { struct proxy *p = srv->proxy; if (!srv_lb_status_changed(srv)) return; if (!srv_is_usable(srv)) goto out_update_state; if (srv_was_usable(srv)) /* server was already up */ goto out_update_backend; if (srv->flags & SRV_F_BACKUP) { srv->lb_tree = &p->lbprm.fas.bck; p->lbprm.tot_wbck += srv->eweight; p->srv_bck++; if (!(p->options & PR_O_USE_ALL_BK)) { if (!p->lbprm.fbck) { /* there was no backup server anymore */ p->lbprm.fbck = srv; } else { /* we may have restored a backup server prior to fbck, * in which case it should replace it. */ struct server *srv2 = srv; do { srv2 = srv2->next; } while (srv2 && (srv2 != p->lbprm.fbck)); if (srv2) p->lbprm.fbck = srv; } } } else { srv->lb_tree = &p->lbprm.fas.act; p->lbprm.tot_wact += srv->eweight; p->srv_act++; } /* note that eweight cannot be 0 here */ fas_queue_srv(srv); out_update_backend: /* check/update tot_used, tot_weight */ update_backend_weight(p); out_update_state: srv_lb_commit_status(srv); } /* This function must be called after an update to server 's effective * weight. It may be called after a state change too. */ static void fas_update_server_weight(struct server *srv) { int old_state, new_state; struct proxy *p = srv->proxy; if (!srv_lb_status_changed(srv)) return; /* If changing the server's weight changes its state, we simply apply * the procedures we already have for status change. If the state * remains down, the server is not in any tree, so it's as easy as * updating its values. If the state remains up with different weights, * there are some computations to perform to find a new place and * possibly a new tree for this server. */ old_state = srv_was_usable(srv); new_state = srv_is_usable(srv); if (!old_state && !new_state) { srv_lb_commit_status(srv); return; } else if (!old_state && new_state) { fas_set_server_status_up(srv); return; } else if (old_state && !new_state) { fas_set_server_status_down(srv); return; } if (srv->lb_tree) fas_dequeue_srv(srv); if (srv->flags & SRV_F_BACKUP) { p->lbprm.tot_wbck += srv->eweight - srv->prev_eweight; srv->lb_tree = &p->lbprm.fas.bck; } else { p->lbprm.tot_wact += srv->eweight - srv->prev_eweight; srv->lb_tree = &p->lbprm.fas.act; } fas_queue_srv(srv); update_backend_weight(p); srv_lb_commit_status(srv); } /* This function is responsible for building the trees in case of fast * weighted least-conns. It also sets p->lbprm.wdiv to the eweight to * uweight ratio. Both active and backup groups are initialized. */ void fas_init_server_tree(struct proxy *p) { struct server *srv; struct eb_root init_head = EB_ROOT; p->lbprm.set_server_status_up = fas_set_server_status_up; p->lbprm.set_server_status_down = fas_set_server_status_down; p->lbprm.update_server_eweight = fas_update_server_weight; p->lbprm.server_take_conn = fas_srv_reposition; p->lbprm.server_drop_conn = fas_srv_reposition; p->lbprm.wdiv = BE_WEIGHT_SCALE; for (srv = p->srv; srv; srv = srv->next) { srv->eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult; srv_lb_commit_status(srv); } recount_servers(p); update_backend_weight(p); p->lbprm.fas.act = init_head; p->lbprm.fas.bck = init_head; /* queue active and backup servers in two distinct groups */ for (srv = p->srv; srv; srv = srv->next) { if (!srv_is_usable(srv)) continue; srv->lb_tree = (srv->flags & SRV_F_BACKUP) ? &p->lbprm.fas.bck : &p->lbprm.fas.act; fas_queue_srv(srv); } } /* Return next server from the FS tree in backend

. If the tree is empty, * return NULL. Saturated servers are skipped. */ struct server *fas_get_next_server(struct proxy *p, struct server *srvtoavoid) { struct server *srv, *avoided; struct eb32_node *node; srv = avoided = NULL; if (p->srv_act) node = eb32_first(&p->lbprm.fas.act); else if (p->lbprm.fbck) return p->lbprm.fbck; else if (p->srv_bck) node = eb32_first(&p->lbprm.fas.bck); else return NULL; while (node) { /* OK, we have a server. However, it may be saturated, in which * case we don't want to reconsider it for now, so we'll simply * skip it. Same if it's the server we try to avoid, in which * case we simply remember it for later use if needed. */ struct server *s; s = eb32_entry(node, struct server, lb_node); if (!s->maxconn || (!s->nbpend && s->served < srv_dynamic_maxconn(s))) { if (s != srvtoavoid) { srv = s; break; } avoided = s; } node = eb32_next(node); } if (!srv) srv = avoided; return srv; } /* * Local variables: * c-indent-level: 8 * c-basic-offset: 8 * End: */