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