← Back to branch summary

~ubuntu-branches/ubuntu/vivid/haproxy/vivid

« back to all changes in this revision

Viewing changes to src/lb_fwrr.c

  • Committer: Package Import Robot
  • Author(s): Apollon Oikonomopoulos
  • Date: 2014-06-20 11:05:17 UTC
  • mfrom: (1.1.15) (15.1.12 experimental)
  • Revision ID: package-import@ubuntu.com-20140620110517-u6q5p9kyy2f3ozw9
Tags: 1.5.0-1
* New upstream stable series. Notable changes since the 1.4 series:
  + Native SSL support on both sides with SNI/NPN/ALPN and OCSP stapling.
  + IPv6 and UNIX sockets are supported everywhere
  + End-to-end HTTP keep-alive for better support of NTLM and improved
    efficiency in static farms
  + HTTP/1.1 response compression (deflate, gzip) to save bandwidth
  + PROXY protocol versions 1 and 2 on both sides
  + Data sampling on everything in request or response, including payload
  + ACLs can use any matching method with any input sample
  + Maps and dynamic ACLs updatable from the CLI
  + Stick-tables support counters to track activity on any input sample
  + Custom format for logs, unique-id, header rewriting, and redirects
  + Improved health checks (SSL, scripted TCP, check agent, ...)
  + Much more scalable configuration supports hundreds of thousands of
    backends and certificates without sweating

* Upload to unstable, merge all 1.5 work from experimental. Most important
  packaging changes since 1.4.25-1 include:
  + systemd support.
  + A more sane default config file.
  + Zero-downtime upgrades between 1.5 releases by gracefully reloading
    HAProxy during upgrades.
  + HTML documentation shipped in the haproxy-doc package.
  + kqueue support for kfreebsd.

* Packaging changes since 1.5~dev26-2:
  + Drop patches merged upstream:
    o Fix-reference-location-in-manpage.patch
    o 0001-BUILD-stats-workaround-stupid-and-bogus-Werror-forma.patch
  + d/watch: look for stable 1.5 releases
  + systemd: respect CONFIG and EXTRAOPTS when specified in
    /etc/default/haproxy.
  + initscript: test the configuration before start or reload.
  + initscript: remove the ENABLED flag and logic.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lb_fwrr.c
39
39
        struct proxy *p = srv->proxy;
40
40
        struct fwrr_group *grp;
41
41
 
42
 
        if (srv->state == srv->prev_state &&
43
 
            srv->eweight == srv->prev_eweight)
 
42
        if (!srv_lb_status_changed(srv))
44
43
                return;
45
44
 
46
 
        if (srv_is_usable(srv->state, srv->eweight))
 
45
        if (srv_is_usable(srv))
47
46
                goto out_update_state;
48
47
 
49
 
        if (!srv_is_usable(srv->prev_state, srv->prev_eweight))
 
48
        if (!srv_was_usable(srv))
50
49
                /* server was already down */
51
50
                goto out_update_backend;
52
51
 
53
 
        grp = (srv->state & SRV_BACKUP) ? &p->lbprm.fwrr.bck : &p->lbprm.fwrr.act;
 
52
        grp = (srv->flags & SRV_F_BACKUP) ? &p->lbprm.fwrr.bck : &p->lbprm.fwrr.act;
54
53
        grp->next_weight -= srv->prev_eweight;
55
54
 
56
 
        if (srv->state & SRV_BACKUP) {
 
55
        if (srv->flags & SRV_F_BACKUP) {
57
56
                p->lbprm.tot_wbck = p->lbprm.fwrr.bck.next_weight;
58
57
                p->srv_bck--;
59
58
 
65
64
                        do {
66
65
                                srv2 = srv2->next;
67
66
                        } while (srv2 &&
68
 
                                 !((srv2->state & SRV_BACKUP) &&
69
 
                                   srv_is_usable(srv2->state, srv2->eweight)));
 
67
                                 !((srv2->flags & SRV_F_BACKUP) &&
 
68
                                   srv_is_usable(srv2)));
70
69
                        p->lbprm.fbck = srv2;
71
70
                }
72
71
        } else {
81
80
        /* check/update tot_used, tot_weight */
82
81
        update_backend_weight(p);
83
82
 out_update_state:
84
 
        srv->prev_state = srv->state;
85
 
        srv->prev_eweight = srv->eweight;
 
83
        srv_lb_commit_status(srv);
86
84
}
87
85
 
88
86
/* This function updates the server trees according to server <srv>'s new
97
95
        struct proxy *p = srv->proxy;
98
96
        struct fwrr_group *grp;
99
97
 
100
 
        if (srv->state == srv->prev_state &&
101
 
            srv->eweight == srv->prev_eweight)
 
98
        if (!srv_lb_status_changed(srv))
102
99
                return;
103
100
 
104
 
        if (!srv_is_usable(srv->state, srv->eweight))
 
101
        if (!srv_is_usable(srv))
105
102
                goto out_update_state;
106
103
 
107
 
        if (srv_is_usable(srv->prev_state, srv->prev_eweight))
 
104
        if (srv_was_usable(srv))
108
105
                /* server was already up */
109
106
                goto out_update_backend;
110
107
 
111
 
        grp = (srv->state & SRV_BACKUP) ? &p->lbprm.fwrr.bck : &p->lbprm.fwrr.act;
 
108
        grp = (srv->flags & SRV_F_BACKUP) ? &p->lbprm.fwrr.bck : &p->lbprm.fwrr.act;
112
109
        grp->next_weight += srv->eweight;
113
110
 
114
 
        if (srv->state & SRV_BACKUP) {
 
111
        if (srv->flags & SRV_F_BACKUP) {
115
112
                p->lbprm.tot_wbck = p->lbprm.fwrr.bck.next_weight;
116
113
                p->srv_bck++;
117
114
 
145
142
        /* check/update tot_used, tot_weight */
146
143
        update_backend_weight(p);
147
144
 out_update_state:
148
 
        srv->prev_state = srv->state;
149
 
        srv->prev_eweight = srv->eweight;
 
145
        srv_lb_commit_status(srv);
150
146
}
151
147
 
152
148
/* This function must be called after an update to server <srv>'s effective
158
154
        struct proxy *p = srv->proxy;
159
155
        struct fwrr_group *grp;
160
156
 
161
 
        if (srv->state == srv->prev_state &&
162
 
            srv->eweight == srv->prev_eweight)
 
157
        if (!srv_lb_status_changed(srv))
163
158
                return;
164
159
 
165
160
        /* If changing the server's weight changes its state, we simply apply
170
165
         * possibly a new tree for this server.
171
166
         */
172
167
         
173
 
        old_state = srv_is_usable(srv->prev_state, srv->prev_eweight);
174
 
        new_state = srv_is_usable(srv->state, srv->eweight);
 
168
        old_state = srv_was_usable(srv);
 
169
        new_state = srv_is_usable(srv);
175
170
 
176
171
        if (!old_state && !new_state) {
177
 
                srv->prev_state = srv->state;
178
 
                srv->prev_eweight = srv->eweight;
 
172
                srv_lb_commit_status(srv);
179
173
                return;
180
174
        }
181
175
        else if (!old_state && new_state) {
187
181
                return;
188
182
        }
189
183
 
190
 
        grp = (srv->state & SRV_BACKUP) ? &p->lbprm.fwrr.bck : &p->lbprm.fwrr.act;
 
184
        grp = (srv->flags & SRV_F_BACKUP) ? &p->lbprm.fwrr.bck : &p->lbprm.fwrr.act;
191
185
        grp->next_weight = grp->next_weight - srv->prev_eweight + srv->eweight;
192
186
 
193
187
        p->lbprm.tot_wact = p->lbprm.fwrr.act.next_weight;
233
227
        }
234
228
 
235
229
        update_backend_weight(p);
236
 
        srv->prev_state = srv->state;
237
 
        srv->prev_eweight = srv->eweight;
 
230
        srv_lb_commit_status(srv);
238
231
}
239
232
 
240
233
/* Remove a server from a tree. It must have previously been dequeued. This
273
266
        p->lbprm.wdiv = BE_WEIGHT_SCALE;
274
267
        for (srv = p->srv; srv; srv = srv->next) {
275
268
                srv->eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult;
276
 
                srv->prev_eweight = srv->eweight;
277
 
                srv->prev_state = srv->state;
 
269
                srv_lb_commit_status(srv);
278
270
        }
279
271
 
280
272
        recount_servers(p);
298
290
 
299
291
        /* queue active and backup servers in two distinct groups */
300
292
        for (srv = p->srv; srv; srv = srv->next) {
301
 
                if (!srv_is_usable(srv->state, srv->eweight))
 
293
                if (!srv_is_usable(srv))
302
294
                        continue;
303
 
                fwrr_queue_by_weight((srv->state & SRV_BACKUP) ?
 
295
                fwrr_queue_by_weight((srv->flags & SRV_F_BACKUP) ?
304
296
                                p->lbprm.fwrr.bck.init :
305
297
                                p->lbprm.fwrr.act.init,
306
298
                                srv);
322
314
        struct proxy *p = s->proxy;
323
315
        struct fwrr_group *grp;
324
316
 
325
 
        grp = (s->state & SRV_BACKUP) ? &p->lbprm.fwrr.bck : &p->lbprm.fwrr.act;
 
317
        grp = (s->flags & SRV_F_BACKUP) ? &p->lbprm.fwrr.bck : &p->lbprm.fwrr.act;
326
318
        
327
319
        /* Delay everything which does not fit into the window and everything
328
320
         * which does not fit into the theorical new window.
329
321
         */
330
 
        if (!srv_is_usable(s->state, s->eweight)) {
 
322
        if (!srv_is_usable(s)) {
331
323
                fwrr_remove_from_tree(s);
332
324
        }
333
325
        else if (s->eweight <= 0 ||
363
355
/* prepares a server when extracting it from the "next" tree */
364
356
static inline void fwrr_get_srv_next(struct server *s)
365
357
{
366
 
        struct fwrr_group *grp = (s->state & SRV_BACKUP) ?
 
358
        struct fwrr_group *grp = (s->flags & SRV_F_BACKUP) ?
367
359
                &s->proxy->lbprm.fwrr.bck :
368
360
                &s->proxy->lbprm.fwrr.act;
369
361
 
373
365
/* prepares a server when it was marked down */
374
366
static inline void fwrr_get_srv_down(struct server *s)
375
367
{
376
 
        struct fwrr_group *grp = (s->state & SRV_BACKUP) ?
 
368
        struct fwrr_group *grp = (s->flags & SRV_F_BACKUP) ?
377
369
                &s->proxy->lbprm.fwrr.bck :
378
370
                &s->proxy->lbprm.fwrr.act;
379
371
 
384
376
static void fwrr_get_srv(struct server *s)
385
377
{
386
378
        struct proxy *p = s->proxy;
387
 
        struct fwrr_group *grp = (s->state & SRV_BACKUP) ?
 
379
        struct fwrr_group *grp = (s->flags & SRV_F_BACKUP) ?
388
380
                &p->lbprm.fwrr.bck :
389
381
                &p->lbprm.fwrr.act;
390
382