260
|
1
|
|
2 /*
|
|
3 * Copyright (C) Igor Sysoev
|
660
|
4 * Copyright (C) Nginx, Inc.
|
260
|
5 */
|
|
6
|
|
7
|
|
8 #include <ngx_config.h>
|
|
9 #include <ngx_core.h>
|
|
10 #include <ngx_http.h>
|
|
11
|
|
12
|
372
|
13 static ngx_int_t ngx_http_upstream_cmp_servers(const void *one,
|
|
14 const void *two);
|
674
|
15 static ngx_http_upstream_rr_peer_t *ngx_http_upstream_get_peer(
|
|
16 ngx_http_upstream_rr_peer_data_t *rrp);
|
324
|
17
|
632
|
18 #if (NGX_HTTP_SSL)
|
|
19
|
|
20 static ngx_int_t ngx_http_upstream_empty_set_session(ngx_peer_connection_t *pc,
|
|
21 void *data);
|
|
22 static void ngx_http_upstream_empty_save_session(ngx_peer_connection_t *pc,
|
|
23 void *data);
|
|
24
|
|
25 #endif
|
|
26
|
324
|
27
|
260
|
28 ngx_int_t
|
|
29 ngx_http_upstream_init_round_robin(ngx_conf_t *cf,
|
|
30 ngx_http_upstream_srv_conf_t *us)
|
|
31 {
|
|
32 ngx_url_t u;
|
|
33 ngx_uint_t i, j, n;
|
|
34 ngx_http_upstream_server_t *server;
|
326
|
35 ngx_http_upstream_rr_peers_t *peers, *backup;
|
260
|
36
|
|
37 us->peer.init = ngx_http_upstream_init_round_robin_peer;
|
|
38
|
|
39 if (us->servers) {
|
|
40 server = us->servers->elts;
|
|
41
|
326
|
42 n = 0;
|
|
43
|
260
|
44 for (i = 0; i < us->servers->nelts; i++) {
|
326
|
45 if (server[i].backup) {
|
|
46 continue;
|
|
47 }
|
|
48
|
260
|
49 n += server[i].naddrs;
|
|
50 }
|
|
51
|
670
|
52 if (n == 0) {
|
|
53 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
|
|
54 "no servers in upstream \"%V\" in %s:%ui",
|
|
55 &us->host, us->file_name, us->line);
|
|
56 return NGX_ERROR;
|
|
57 }
|
|
58
|
260
|
59 peers = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t)
|
|
60 + sizeof(ngx_http_upstream_rr_peer_t) * (n - 1));
|
|
61 if (peers == NULL) {
|
|
62 return NGX_ERROR;
|
|
63 }
|
|
64
|
326
|
65 peers->single = (n == 1);
|
260
|
66 peers->number = n;
|
|
67 peers->name = &us->host;
|
|
68
|
|
69 n = 0;
|
|
70
|
|
71 for (i = 0; i < us->servers->nelts; i++) {
|
|
72 for (j = 0; j < server[i].naddrs; j++) {
|
326
|
73 if (server[i].backup) {
|
|
74 continue;
|
|
75 }
|
|
76
|
260
|
77 peers->peer[n].sockaddr = server[i].addrs[j].sockaddr;
|
|
78 peers->peer[n].socklen = server[i].addrs[j].socklen;
|
|
79 peers->peer[n].name = server[i].addrs[j].name;
|
|
80 peers->peer[n].max_fails = server[i].max_fails;
|
|
81 peers->peer[n].fail_timeout = server[i].fail_timeout;
|
|
82 peers->peer[n].down = server[i].down;
|
674
|
83 peers->peer[n].weight = server[i].weight;
|
|
84 peers->peer[n].effective_weight = server[i].weight;
|
|
85 peers->peer[n].current_weight = 0;
|
260
|
86 n++;
|
|
87 }
|
|
88 }
|
|
89
|
|
90 us->peer.data = peers;
|
|
91
|
326
|
92 ngx_sort(&peers->peer[0], (size_t) n,
|
|
93 sizeof(ngx_http_upstream_rr_peer_t),
|
|
94 ngx_http_upstream_cmp_servers);
|
|
95
|
|
96 /* backup servers */
|
|
97
|
|
98 n = 0;
|
|
99
|
|
100 for (i = 0; i < us->servers->nelts; i++) {
|
|
101 if (!server[i].backup) {
|
|
102 continue;
|
|
103 }
|
|
104
|
|
105 n += server[i].naddrs;
|
|
106 }
|
|
107
|
|
108 if (n == 0) {
|
|
109 return NGX_OK;
|
|
110 }
|
|
111
|
|
112 backup = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t)
|
|
113 + sizeof(ngx_http_upstream_rr_peer_t) * (n - 1));
|
|
114 if (backup == NULL) {
|
|
115 return NGX_ERROR;
|
|
116 }
|
|
117
|
|
118 peers->single = 0;
|
|
119 backup->single = 0;
|
|
120 backup->number = n;
|
|
121 backup->name = &us->host;
|
|
122
|
|
123 n = 0;
|
|
124
|
|
125 for (i = 0; i < us->servers->nelts; i++) {
|
|
126 for (j = 0; j < server[i].naddrs; j++) {
|
|
127 if (!server[i].backup) {
|
|
128 continue;
|
|
129 }
|
|
130
|
|
131 backup->peer[n].sockaddr = server[i].addrs[j].sockaddr;
|
|
132 backup->peer[n].socklen = server[i].addrs[j].socklen;
|
|
133 backup->peer[n].name = server[i].addrs[j].name;
|
|
134 backup->peer[n].weight = server[i].weight;
|
674
|
135 backup->peer[n].effective_weight = server[i].weight;
|
|
136 backup->peer[n].current_weight = 0;
|
326
|
137 backup->peer[n].max_fails = server[i].max_fails;
|
|
138 backup->peer[n].fail_timeout = server[i].fail_timeout;
|
|
139 backup->peer[n].down = server[i].down;
|
|
140 n++;
|
|
141 }
|
|
142 }
|
|
143
|
|
144 peers->next = backup;
|
|
145
|
|
146 ngx_sort(&backup->peer[0], (size_t) n,
|
|
147 sizeof(ngx_http_upstream_rr_peer_t),
|
|
148 ngx_http_upstream_cmp_servers);
|
|
149
|
260
|
150 return NGX_OK;
|
|
151 }
|
|
152
|
|
153
|
|
154 /* an upstream implicitly defined by proxy_pass, etc. */
|
|
155
|
266
|
156 if (us->port == 0 && us->default_port == 0) {
|
|
157 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
|
|
158 "no port in upstream \"%V\" in %s:%ui",
|
336
|
159 &us->host, us->file_name, us->line);
|
266
|
160 return NGX_ERROR;
|
|
161 }
|
|
162
|
260
|
163 ngx_memzero(&u, sizeof(ngx_url_t));
|
|
164
|
|
165 u.host = us->host;
|
266
|
166 u.port = (in_port_t) (us->port ? us->port : us->default_port);
|
260
|
167
|
340
|
168 if (ngx_inet_resolve_host(cf->pool, &u) != NGX_OK) {
|
260
|
169 if (u.err) {
|
|
170 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
|
262
|
171 "%s in upstream \"%V\" in %s:%ui",
|
336
|
172 u.err, &us->host, us->file_name, us->line);
|
260
|
173 }
|
|
174
|
|
175 return NGX_ERROR;
|
|
176 }
|
|
177
|
|
178 n = u.naddrs;
|
|
179
|
|
180 peers = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t)
|
|
181 + sizeof(ngx_http_upstream_rr_peer_t) * (n - 1));
|
|
182 if (peers == NULL) {
|
|
183 return NGX_ERROR;
|
|
184 }
|
|
185
|
326
|
186 peers->single = (n == 1);
|
260
|
187 peers->number = n;
|
|
188 peers->name = &us->host;
|
|
189
|
|
190 for (i = 0; i < u.naddrs; i++) {
|
340
|
191 peers->peer[i].sockaddr = u.addrs[i].sockaddr;
|
|
192 peers->peer[i].socklen = u.addrs[i].socklen;
|
|
193 peers->peer[i].name = u.addrs[i].name;
|
|
194 peers->peer[i].weight = 1;
|
674
|
195 peers->peer[i].effective_weight = 1;
|
|
196 peers->peer[i].current_weight = 0;
|
340
|
197 peers->peer[i].max_fails = 1;
|
|
198 peers->peer[i].fail_timeout = 10;
|
260
|
199 }
|
|
200
|
|
201 us->peer.data = peers;
|
|
202
|
326
|
203 /* implicitly defined upstream has no backup servers */
|
|
204
|
260
|
205 return NGX_OK;
|
|
206 }
|
|
207
|
|
208
|
372
|
209 static ngx_int_t
|
326
|
210 ngx_http_upstream_cmp_servers(const void *one, const void *two)
|
|
211 {
|
|
212 ngx_http_upstream_rr_peer_t *first, *second;
|
|
213
|
|
214 first = (ngx_http_upstream_rr_peer_t *) one;
|
|
215 second = (ngx_http_upstream_rr_peer_t *) two;
|
|
216
|
|
217 return (first->weight < second->weight);
|
|
218 }
|
|
219
|
|
220
|
260
|
221 ngx_int_t
|
|
222 ngx_http_upstream_init_round_robin_peer(ngx_http_request_t *r,
|
|
223 ngx_http_upstream_srv_conf_t *us)
|
|
224 {
|
|
225 ngx_uint_t n;
|
|
226 ngx_http_upstream_rr_peer_data_t *rrp;
|
|
227
|
|
228 rrp = r->upstream->peer.data;
|
|
229
|
|
230 if (rrp == NULL) {
|
|
231 rrp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_rr_peer_data_t));
|
|
232 if (rrp == NULL) {
|
|
233 return NGX_ERROR;
|
|
234 }
|
|
235
|
|
236 r->upstream->peer.data = rrp;
|
|
237 }
|
|
238
|
|
239 rrp->peers = us->peer.data;
|
|
240 rrp->current = 0;
|
|
241
|
634
|
242 n = rrp->peers->number;
|
|
243
|
|
244 if (rrp->peers->next && rrp->peers->next->number > n) {
|
|
245 n = rrp->peers->next->number;
|
|
246 }
|
|
247
|
|
248 if (n <= 8 * sizeof(uintptr_t)) {
|
260
|
249 rrp->tried = &rrp->data;
|
|
250 rrp->data = 0;
|
|
251
|
|
252 } else {
|
634
|
253 n = (n + (8 * sizeof(uintptr_t) - 1)) / (8 * sizeof(uintptr_t));
|
260
|
254
|
|
255 rrp->tried = ngx_pcalloc(r->pool, n * sizeof(uintptr_t));
|
|
256 if (rrp->tried == NULL) {
|
|
257 return NGX_ERROR;
|
|
258 }
|
|
259 }
|
|
260
|
|
261 r->upstream->peer.get = ngx_http_upstream_get_round_robin_peer;
|
|
262 r->upstream->peer.free = ngx_http_upstream_free_round_robin_peer;
|
|
263 r->upstream->peer.tries = rrp->peers->number;
|
|
264 #if (NGX_HTTP_SSL)
|
318
|
265 r->upstream->peer.set_session =
|
|
266 ngx_http_upstream_set_round_robin_peer_session;
|
|
267 r->upstream->peer.save_session =
|
|
268 ngx_http_upstream_save_round_robin_peer_session;
|
260
|
269 #endif
|
|
270
|
|
271 return NGX_OK;
|
|
272 }
|
|
273
|
|
274
|
|
275 ngx_int_t
|
348
|
276 ngx_http_upstream_create_round_robin_peer(ngx_http_request_t *r,
|
|
277 ngx_http_upstream_resolved_t *ur)
|
|
278 {
|
|
279 u_char *p;
|
|
280 size_t len;
|
|
281 ngx_uint_t i, n;
|
|
282 struct sockaddr_in *sin;
|
|
283 ngx_http_upstream_rr_peers_t *peers;
|
|
284 ngx_http_upstream_rr_peer_data_t *rrp;
|
|
285
|
|
286 rrp = r->upstream->peer.data;
|
|
287
|
|
288 if (rrp == NULL) {
|
|
289 rrp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_rr_peer_data_t));
|
|
290 if (rrp == NULL) {
|
|
291 return NGX_ERROR;
|
|
292 }
|
|
293
|
|
294 r->upstream->peer.data = rrp;
|
|
295 }
|
|
296
|
|
297 peers = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_rr_peers_t)
|
|
298 + sizeof(ngx_http_upstream_rr_peer_t) * (ur->naddrs - 1));
|
|
299 if (peers == NULL) {
|
|
300 return NGX_ERROR;
|
|
301 }
|
|
302
|
|
303 peers->single = (ur->naddrs == 1);
|
|
304 peers->number = ur->naddrs;
|
|
305 peers->name = &ur->host;
|
|
306
|
434
|
307 if (ur->sockaddr) {
|
|
308 peers->peer[0].sockaddr = ur->sockaddr;
|
|
309 peers->peer[0].socklen = ur->socklen;
|
|
310 peers->peer[0].name = ur->host;
|
|
311 peers->peer[0].weight = 1;
|
674
|
312 peers->peer[0].effective_weight = 1;
|
|
313 peers->peer[0].current_weight = 0;
|
434
|
314 peers->peer[0].max_fails = 1;
|
|
315 peers->peer[0].fail_timeout = 10;
|
348
|
316
|
434
|
317 } else {
|
|
318
|
|
319 for (i = 0; i < ur->naddrs; i++) {
|
348
|
320
|
434
|
321 len = NGX_INET_ADDRSTRLEN + sizeof(":65536") - 1;
|
|
322
|
|
323 p = ngx_pnalloc(r->pool, len);
|
|
324 if (p == NULL) {
|
|
325 return NGX_ERROR;
|
|
326 }
|
348
|
327
|
434
|
328 len = ngx_inet_ntop(AF_INET, &ur->addrs[i], p, NGX_INET_ADDRSTRLEN);
|
|
329 len = ngx_sprintf(&p[len], ":%d", ur->port) - p;
|
348
|
330
|
434
|
331 sin = ngx_pcalloc(r->pool, sizeof(struct sockaddr_in));
|
|
332 if (sin == NULL) {
|
|
333 return NGX_ERROR;
|
|
334 }
|
348
|
335
|
434
|
336 sin->sin_family = AF_INET;
|
|
337 sin->sin_port = htons(ur->port);
|
|
338 sin->sin_addr.s_addr = ur->addrs[i];
|
|
339
|
|
340 peers->peer[i].sockaddr = (struct sockaddr *) sin;
|
|
341 peers->peer[i].socklen = sizeof(struct sockaddr_in);
|
|
342 peers->peer[i].name.len = len;
|
|
343 peers->peer[i].name.data = p;
|
|
344 peers->peer[i].weight = 1;
|
674
|
345 peers->peer[i].effective_weight = 1;
|
|
346 peers->peer[i].current_weight = 0;
|
434
|
347 peers->peer[i].max_fails = 1;
|
|
348 peers->peer[i].fail_timeout = 10;
|
|
349 }
|
348
|
350 }
|
|
351
|
|
352 rrp->peers = peers;
|
|
353 rrp->current = 0;
|
|
354
|
|
355 if (rrp->peers->number <= 8 * sizeof(uintptr_t)) {
|
|
356 rrp->tried = &rrp->data;
|
|
357 rrp->data = 0;
|
|
358
|
|
359 } else {
|
|
360 n = (rrp->peers->number + (8 * sizeof(uintptr_t) - 1))
|
|
361 / (8 * sizeof(uintptr_t));
|
|
362
|
|
363 rrp->tried = ngx_pcalloc(r->pool, n * sizeof(uintptr_t));
|
|
364 if (rrp->tried == NULL) {
|
|
365 return NGX_ERROR;
|
|
366 }
|
|
367 }
|
|
368
|
|
369 r->upstream->peer.get = ngx_http_upstream_get_round_robin_peer;
|
|
370 r->upstream->peer.free = ngx_http_upstream_free_round_robin_peer;
|
|
371 r->upstream->peer.tries = rrp->peers->number;
|
|
372 #if (NGX_HTTP_SSL)
|
632
|
373 r->upstream->peer.set_session = ngx_http_upstream_empty_set_session;
|
|
374 r->upstream->peer.save_session = ngx_http_upstream_empty_save_session;
|
348
|
375 #endif
|
|
376
|
|
377 return NGX_OK;
|
|
378 }
|
|
379
|
|
380
|
|
381 ngx_int_t
|
260
|
382 ngx_http_upstream_get_round_robin_peer(ngx_peer_connection_t *pc, void *data)
|
|
383 {
|
|
384 ngx_http_upstream_rr_peer_data_t *rrp = data;
|
|
385
|
326
|
386 ngx_int_t rc;
|
|
387 ngx_uint_t i, n;
|
|
388 ngx_connection_t *c;
|
|
389 ngx_http_upstream_rr_peer_t *peer;
|
|
390 ngx_http_upstream_rr_peers_t *peers;
|
260
|
391
|
|
392 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
|
|
393 "get rr peer, try: %ui", pc->tries);
|
|
394
|
|
395 /* ngx_lock_mutex(rrp->peers->mutex); */
|
|
396
|
|
397 if (rrp->peers->last_cached) {
|
|
398
|
|
399 /* cached connection */
|
|
400
|
|
401 c = rrp->peers->cached[rrp->peers->last_cached];
|
|
402 rrp->peers->last_cached--;
|
|
403
|
|
404 /* ngx_unlock_mutex(ppr->peers->mutex); */
|
|
405
|
|
406 #if (NGX_THREADS)
|
|
407 c->read->lock = c->read->own_lock;
|
|
408 c->write->lock = c->write->own_lock;
|
|
409 #endif
|
|
410
|
|
411 pc->connection = c;
|
|
412 pc->cached = 1;
|
|
413
|
|
414 return NGX_OK;
|
|
415 }
|
|
416
|
|
417 pc->cached = 0;
|
|
418 pc->connection = NULL;
|
|
419
|
326
|
420 if (rrp->peers->single) {
|
260
|
421 peer = &rrp->peers->peer[0];
|
|
422
|
|
423 } else {
|
|
424
|
|
425 /* there are several peers */
|
|
426
|
674
|
427 peer = ngx_http_upstream_get_peer(rrp);
|
260
|
428
|
674
|
429 if (peer == NULL) {
|
|
430 goto failed;
|
260
|
431 }
|
|
432
|
674
|
433 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
|
|
434 "get rr peer, current: %ui %i",
|
|
435 rrp->current, peer->current_weight);
|
260
|
436 }
|
|
437
|
|
438 pc->sockaddr = peer->sockaddr;
|
|
439 pc->socklen = peer->socklen;
|
|
440 pc->name = &peer->name;
|
|
441
|
|
442 /* ngx_unlock_mutex(rrp->peers->mutex); */
|
|
443
|
326
|
444 if (pc->tries == 1 && rrp->peers->next) {
|
|
445 pc->tries += rrp->peers->next->number;
|
|
446 }
|
|
447
|
260
|
448 return NGX_OK;
|
|
449
|
|
450 failed:
|
|
451
|
326
|
452 peers = rrp->peers;
|
|
453
|
|
454 if (peers->next) {
|
|
455
|
|
456 /* ngx_unlock_mutex(peers->mutex); */
|
|
457
|
|
458 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0, "backup servers");
|
|
459
|
|
460 rrp->peers = peers->next;
|
|
461 pc->tries = rrp->peers->number;
|
|
462
|
|
463 n = rrp->peers->number / (8 * sizeof(uintptr_t)) + 1;
|
|
464 for (i = 0; i < n; i++) {
|
|
465 rrp->tried[i] = 0;
|
|
466 }
|
|
467
|
|
468 rc = ngx_http_upstream_get_round_robin_peer(pc, rrp);
|
|
469
|
|
470 if (rc != NGX_BUSY) {
|
|
471 return rc;
|
|
472 }
|
|
473
|
|
474 /* ngx_lock_mutex(peers->mutex); */
|
|
475 }
|
|
476
|
260
|
477 /* all peers failed, mark them as live for quick recovery */
|
|
478
|
326
|
479 for (i = 0; i < peers->number; i++) {
|
|
480 peers->peer[i].fails = 0;
|
260
|
481 }
|
|
482
|
326
|
483 /* ngx_unlock_mutex(peers->mutex); */
|
260
|
484
|
326
|
485 pc->name = peers->name;
|
260
|
486
|
|
487 return NGX_BUSY;
|
|
488 }
|
|
489
|
|
490
|
674
|
491 static ngx_http_upstream_rr_peer_t *
|
|
492 ngx_http_upstream_get_peer(ngx_http_upstream_rr_peer_data_t *rrp)
|
324
|
493 {
|
674
|
494 time_t now;
|
|
495 uintptr_t m;
|
|
496 ngx_int_t total;
|
|
497 ngx_uint_t i, n;
|
|
498 ngx_http_upstream_rr_peer_t *peer, *best;
|
324
|
499
|
674
|
500 now = ngx_time();
|
324
|
501
|
674
|
502 best = NULL;
|
|
503 total = 0;
|
324
|
504
|
674
|
505 for (i = 0; i < rrp->peers->number; i++) {
|
324
|
506
|
674
|
507 n = i / (8 * sizeof(uintptr_t));
|
|
508 m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));
|
324
|
509
|
674
|
510 if (rrp->tried[n] & m) {
|
|
511 continue;
|
|
512 }
|
324
|
513
|
674
|
514 peer = &rrp->peers->peer[i];
|
324
|
515
|
674
|
516 if (peer->down) {
|
|
517 continue;
|
324
|
518 }
|
|
519
|
674
|
520 if (peer->max_fails
|
|
521 && peer->fails >= peer->max_fails
|
|
522 && now - peer->checked <= peer->fail_timeout)
|
|
523 {
|
|
524 continue;
|
|
525 }
|
|
526
|
|
527 peer->current_weight += peer->effective_weight;
|
|
528 total += peer->effective_weight;
|
|
529
|
|
530 if (peer->effective_weight < peer->weight) {
|
|
531 peer->effective_weight++;
|
634
|
532 }
|
|
533
|
674
|
534 if (best == NULL || peer->current_weight > best->current_weight) {
|
|
535 best = peer;
|
324
|
536 }
|
|
537 }
|
674
|
538
|
|
539 if (best == NULL) {
|
|
540 return NULL;
|
|
541 }
|
|
542
|
|
543 i = best - &rrp->peers->peer[0];
|
|
544
|
|
545 rrp->current = i;
|
|
546
|
|
547 n = i / (8 * sizeof(uintptr_t));
|
|
548 m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));
|
|
549
|
|
550 rrp->tried[n] |= m;
|
|
551
|
|
552 best->current_weight -= total;
|
|
553 best->checked = now;
|
|
554
|
|
555 return best;
|
324
|
556 }
|
|
557
|
|
558
|
260
|
559 void
|
|
560 ngx_http_upstream_free_round_robin_peer(ngx_peer_connection_t *pc, void *data,
|
|
561 ngx_uint_t state)
|
|
562 {
|
|
563 ngx_http_upstream_rr_peer_data_t *rrp = data;
|
|
564
|
|
565 time_t now;
|
|
566 ngx_http_upstream_rr_peer_t *peer;
|
|
567
|
|
568 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
|
|
569 "free rr peer %ui %ui", pc->tries, state);
|
|
570
|
|
571 if (state == 0 && pc->tries == 0) {
|
|
572 return;
|
|
573 }
|
|
574
|
|
575 /* TODO: NGX_PEER_KEEPALIVE */
|
|
576
|
326
|
577 if (rrp->peers->single) {
|
260
|
578 pc->tries = 0;
|
|
579 return;
|
|
580 }
|
|
581
|
644
|
582 peer = &rrp->peers->peer[rrp->current];
|
|
583
|
260
|
584 if (state & NGX_PEER_FAILED) {
|
|
585 now = ngx_time();
|
|
586
|
|
587 /* ngx_lock_mutex(rrp->peers->mutex); */
|
|
588
|
|
589 peer->fails++;
|
|
590 peer->accessed = now;
|
644
|
591 peer->checked = now;
|
260
|
592
|
400
|
593 if (peer->max_fails) {
|
674
|
594 peer->effective_weight -= peer->weight / peer->max_fails;
|
400
|
595 }
|
324
|
596
|
|
597 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
|
|
598 "free rr peer failed: %ui %i",
|
674
|
599 rrp->current, peer->effective_weight);
|
324
|
600
|
674
|
601 if (peer->effective_weight < 0) {
|
|
602 peer->effective_weight = 0;
|
260
|
603 }
|
|
604
|
|
605 /* ngx_unlock_mutex(rrp->peers->mutex); */
|
644
|
606
|
|
607 } else {
|
|
608
|
|
609 /* mark peer live if check passed */
|
|
610
|
|
611 if (peer->accessed < peer->checked) {
|
|
612 peer->fails = 0;
|
|
613 }
|
260
|
614 }
|
|
615
|
|
616 if (pc->tries) {
|
|
617 pc->tries--;
|
|
618 }
|
|
619
|
|
620 /* ngx_unlock_mutex(rrp->peers->mutex); */
|
|
621 }
|
|
622
|
|
623
|
|
624 #if (NGX_HTTP_SSL)
|
|
625
|
318
|
626 ngx_int_t
|
|
627 ngx_http_upstream_set_round_robin_peer_session(ngx_peer_connection_t *pc,
|
|
628 void *data)
|
260
|
629 {
|
|
630 ngx_http_upstream_rr_peer_data_t *rrp = data;
|
|
631
|
318
|
632 ngx_int_t rc;
|
260
|
633 ngx_ssl_session_t *ssl_session;
|
|
634 ngx_http_upstream_rr_peer_t *peer;
|
|
635
|
318
|
636 peer = &rrp->peers->peer[rrp->current];
|
|
637
|
|
638 /* TODO: threads only mutex */
|
|
639 /* ngx_lock_mutex(rrp->peers->mutex); */
|
|
640
|
|
641 ssl_session = peer->ssl_session;
|
|
642
|
|
643 rc = ngx_ssl_set_session(pc->connection, ssl_session);
|
|
644
|
|
645 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
|
332
|
646 "set session: %p:%d",
|
|
647 ssl_session, ssl_session ? ssl_session->references : 0);
|
318
|
648
|
|
649 /* ngx_unlock_mutex(rrp->peers->mutex); */
|
|
650
|
|
651 return rc;
|
|
652 }
|
|
653
|
|
654
|
|
655 void
|
|
656 ngx_http_upstream_save_round_robin_peer_session(ngx_peer_connection_t *pc,
|
|
657 void *data)
|
|
658 {
|
|
659 ngx_http_upstream_rr_peer_data_t *rrp = data;
|
|
660
|
|
661 ngx_ssl_session_t *old_ssl_session, *ssl_session;
|
|
662 ngx_http_upstream_rr_peer_t *peer;
|
|
663
|
260
|
664 ssl_session = ngx_ssl_get_session(pc->connection);
|
|
665
|
|
666 if (ssl_session == NULL) {
|
|
667 return;
|
|
668 }
|
|
669
|
318
|
670 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
|
332
|
671 "save session: %p:%d", ssl_session, ssl_session->references);
|
318
|
672
|
260
|
673 peer = &rrp->peers->peer[rrp->current];
|
|
674
|
318
|
675 /* TODO: threads only mutex */
|
260
|
676 /* ngx_lock_mutex(rrp->peers->mutex); */
|
318
|
677
|
|
678 old_ssl_session = peer->ssl_session;
|
260
|
679 peer->ssl_session = ssl_session;
|
318
|
680
|
260
|
681 /* ngx_unlock_mutex(rrp->peers->mutex); */
|
|
682
|
318
|
683 if (old_ssl_session) {
|
|
684
|
|
685 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
|
332
|
686 "old session: %p:%d",
|
318
|
687 old_ssl_session, old_ssl_session->references);
|
|
688
|
260
|
689 /* TODO: may block */
|
318
|
690
|
|
691 ngx_ssl_free_session(old_ssl_session);
|
260
|
692 }
|
|
693 }
|
|
694
|
632
|
695
|
|
696 static ngx_int_t
|
|
697 ngx_http_upstream_empty_set_session(ngx_peer_connection_t *pc, void *data)
|
|
698 {
|
|
699 return NGX_OK;
|
|
700 }
|
|
701
|
|
702
|
|
703 static void
|
|
704 ngx_http_upstream_empty_save_session(ngx_peer_connection_t *pc, void *data)
|
|
705 {
|
|
706 return;
|
|
707 }
|
|
708
|
260
|
709 #endif
|