One Level Up Top Level

src/http/modules/ngx_http_upstream_keepalive_module.c - nginx-1.7.10

Global variables defined

Data types defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Maxim Dounin
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_http.h>


  13. typedef struct {
  14.     ngx_uint_t                         max_cached;

  16.     ngx_queue_t                        cache;
  17.     ngx_queue_t                        free;

  19.     ngx_http_upstream_init_pt          original_init_upstream;
  20.     ngx_http_upstream_init_peer_pt     original_init_peer;

  22. ‌} ngx_http_upstream_keepalive_srv_conf_t;


  25. typedef struct {
  26.     ngx_http_upstream_keepalive_srv_conf_t  *conf;

  28.     ngx_http_upstream_t               *upstream;

  30.     void                              *data;

  32.     ngx_event_get_peer_pt              original_get_peer;
  33.     ngx_event_free_peer_pt             original_free_peer;

  35. #if (NGX_HTTP_SSL)
  36.     ngx_event_set_peer_session_pt      original_set_session;
  37.     ngx_event_save_peer_session_pt     original_save_session;
  38. #endif

  40. ‌} ngx_http_upstream_keepalive_peer_data_t;


  43. typedef struct {
  44.     ngx_http_upstream_keepalive_srv_conf_t  *conf;

  46.     ngx_queue_t                        queue;
  47.     ngx_connection_t                  *connection;

  49.     socklen_t                          socklen;
  50.     u_char                             sockaddr[NGX_SOCKADDRLEN];

  52. ‌} ngx_http_upstream_keepalive_cache_t;


  55. static ngx_int_t ngx_http_upstream_init_keepalive_peer(ngx_http_request_t *r,
  56.     ngx_http_upstream_srv_conf_t *us);
  57. static ngx_int_t ngx_http_upstream_get_keepalive_peer(ngx_peer_connection_t *pc,
  58.     void *data);
  59. static void ngx_http_upstream_free_keepalive_peer(ngx_peer_connection_t *pc,
  60.     void *data, ngx_uint_t state);

  62. static void ngx_http_upstream_keepalive_dummy_handler(ngx_event_t *ev);
  63. static void ngx_http_upstream_keepalive_close_handler(ngx_event_t *ev);
  64. static void ngx_http_upstream_keepalive_close(ngx_connection_t *c);


  67. #if (NGX_HTTP_SSL)
  68. static ngx_int_t ngx_http_upstream_keepalive_set_session(
  69.     ngx_peer_connection_t *pc, void *data);
  70. static void ngx_http_upstream_keepalive_save_session(ngx_peer_connection_t *pc,
  71.     void *data);
  72. #endif

  74. static void *ngx_http_upstream_keepalive_create_conf(ngx_conf_t *cf);
  75. static char *ngx_http_upstream_keepalive(ngx_conf_t *cf, ngx_command_t *cmd,
  76.     void *conf);


  79. ‌static ngx_command_t  ngx_http_upstream_keepalive_commands[] = {

  81.     { ngx_string("keepalive"),
  82.       NGX_HTTP_UPS_CONF|NGX_CONF_TAKE1,
  83.       ngx_http_upstream_keepalive,
  84.       NGX_HTTP_SRV_CONF_OFFSET,
  85.       0,
  86.       NULL },

  88.       ngx_null_command
  89. };


  92. ‌static ngx_http_module_t  ngx_http_upstream_keepalive_module_ctx = {
  93.     NULL,                                  /* preconfiguration */
  94.     NULL,                                  /* postconfiguration */

  96.     NULL,                                  /* create main configuration */
  97.     NULL,                                  /* init main configuration */

  99.     ngx_http_upstream_keepalive_create_conf, /* create server configuration */
  100.     NULL,                                  /* merge server configuration */

  102.     NULL,                                  /* create location configuration */
  103.     NULL                                   /* merge location configuration */
  104. };


  107. ‌ngx_module_t  ngx_http_upstream_keepalive_module = {
  108.     NGX_MODULE_V1,
  109.     &ngx_http_upstream_keepalive_module_ctx, /* module context */
  110.     ngx_http_upstream_keepalive_commands,    /* module directives */
  111.     NGX_HTTP_MODULE,                       /* module type */
  112.     NULL,                                  /* init master */
  113.     NULL,                                  /* init module */
  114.     NULL,                                  /* init process */
  115.     NULL,                                  /* init thread */
  116.     NULL,                                  /* exit thread */
  117.     NULL,                                  /* exit process */
  118.     NULL,                                  /* exit master */
  119.     NGX_MODULE_V1_PADDING
  120. };


  123. static ngx_int_t
  124. ‌ngx_http_upstream_init_keepalive(ngx_conf_t *cf,
  125.     ngx_http_upstream_srv_conf_t *us)
  126. {
  127.     ngx_uint_t                               i;
  128.     ngx_http_upstream_keepalive_srv_conf_t  *kcf;
  129.     ngx_http_upstream_keepalive_cache_t     *cached;

  131.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0,
  132.                    "init keepalive");

  134.     kcf = ngx_http_conf_upstream_srv_conf(us,
  135.                                           ngx_http_upstream_keepalive_module);

  137.     if (kcf->original_init_upstream(cf, us) != NGX_OK) {
  138.         return NGX_ERROR;
  139.     }

  141.     kcf->original_init_peer = us->peer.init;

  143.     us->peer.init = ngx_http_upstream_init_keepalive_peer;

  145.     /* allocate cache items and add to free queue */

  147.     cached = ngx_pcalloc(cf->pool,
  148.                 sizeof(ngx_http_upstream_keepalive_cache_t) * kcf->max_cached);
  149.     if (cached == NULL) {
  150.         return NGX_ERROR;
  151.     }

  153.     ngx_queue_init(&kcf->cache);
  154.     ngx_queue_init(&kcf->free);

  156.     for (i = 0; i < kcf->max_cached; i++) {
  157.         ngx_queue_insert_head(&kcf->free, &cached[i].queue);
  158.         cached[i].conf = kcf;
  159.     }

  161.     return NGX_OK;
  162. }


  165. static ngx_int_t
  166. ‌ngx_http_upstream_init_keepalive_peer(ngx_http_request_t *r,
  167.     ngx_http_upstream_srv_conf_t *us)
  168. {
  169.     ngx_http_upstream_keepalive_peer_data_t  *kp;
  170.     ngx_http_upstream_keepalive_srv_conf_t   *kcf;

  172.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  173.                    "init keepalive peer");

  175.     kcf = ngx_http_conf_upstream_srv_conf(us,
  176.                                           ngx_http_upstream_keepalive_module);

  178.     kp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_keepalive_peer_data_t));
  179.     if (kp == NULL) {
  180.         return NGX_ERROR;
  181.     }

  183.     if (kcf->original_init_peer(r, us) != NGX_OK) {
  184.         return NGX_ERROR;
  185.     }

  187.     kp->conf = kcf;
  188.     kp->upstream = r->upstream;
  189.     kp->data = r->upstream->peer.data;
  190.     kp->original_get_peer = r->upstream->peer.get;
  191.     kp->original_free_peer = r->upstream->peer.free;

  193.     r->upstream->peer.data = kp;
  194.     r->upstream->peer.get = ngx_http_upstream_get_keepalive_peer;
  195.     r->upstream->peer.free = ngx_http_upstream_free_keepalive_peer;

  197. #if (NGX_HTTP_SSL)
  198.     kp->original_set_session = r->upstream->peer.set_session;
  199.     kp->original_save_session = r->upstream->peer.save_session;
  200.     r->upstream->peer.set_session = ngx_http_upstream_keepalive_set_session;
  201.     r->upstream->peer.save_session = ngx_http_upstream_keepalive_save_session;
  202. #endif

  204.     return NGX_OK;
  205. }


  208. static ngx_int_t
  209. ‌ngx_http_upstream_get_keepalive_peer(ngx_peer_connection_t *pc, void *data)
  210. {
  211.     ngx_http_upstream_keepalive_peer_data_t  *kp = data;
  212.     ngx_http_upstream_keepalive_cache_t      *item;

  214.     ngx_int_t          rc;
  215.     ngx_queue_t       *q, *cache;
  216.     ngx_connection_t  *c;

  218.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  219.                    "get keepalive peer");

  221.     /* ask balancer */

  223.     rc = kp->original_get_peer(pc, kp->data);

  225.     if (rc != NGX_OK) {
  226.         return rc;
  227.     }

  229.     /* search cache for suitable connection */

  231.     cache = &kp->conf->cache;

  233.     for (q = ngx_queue_head(cache);
  234.          q != ngx_queue_sentinel(cache);
  235.          q = ngx_queue_next(q))
  236.     {
  237.         item = ngx_queue_data(q, ngx_http_upstream_keepalive_cache_t, queue);
  238.         c = item->connection;

  240.         if (ngx_memn2cmp((u_char *) &item->sockaddr, (u_char *) pc->sockaddr,
  241.                          item->socklen, pc->socklen)
  242.             == 0)
  243.         {
  244.             ngx_queue_remove(q);
  245.             ngx_queue_insert_head(&kp->conf->free, q);

  247.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  248.                            "get keepalive peer: using connection %p", c);

  250.             c->idle = 0;
  251.             c->sent = 0;
  252.             c->log = pc->log;
  253.             c->read->log = pc->log;
  254.             c->write->log = pc->log;
  255.             c->pool->log = pc->log;

  257.             pc->connection = c;
  258.             pc->cached = 1;

  260.             return NGX_DONE;
  261.         }
  262.     }

  264.     return NGX_OK;
  265. }


  268. static void
  269. ‌ngx_http_upstream_free_keepalive_peer(ngx_peer_connection_t *pc, void *data,
  270.     ngx_uint_t state)
  271. {
  272.     ngx_http_upstream_keepalive_peer_data_t  *kp = data;
  273.     ngx_http_upstream_keepalive_cache_t      *item;

  275.     ngx_queue_t          *q;
  276.     ngx_connection_t     *c;
  277.     ngx_http_upstream_t  *u;

  279.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  280.                    "free keepalive peer");

  282.     /* cache valid connections */

  284.     u = kp->upstream;
  285.     c = pc->connection;

  287.     if (state & NGX_PEER_FAILED
  288.         || c == NULL
  289.         || c->read->eof
  290.         || c->read->error
  291.         || c->read->timedout
  292.         || c->write->error
  293.         || c->write->timedout)
  294.     {
  295.         goto invalid;
  296.     }

  298.     if (!u->keepalive) {
  299.         goto invalid;
  300.     }

  302.     if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  303.         goto invalid;
  304.     }

  306.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  307.                    "free keepalive peer: saving connection %p", c);

  309.     if (ngx_queue_empty(&kp->conf->free)) {

  311.         q = ngx_queue_last(&kp->conf->cache);
  312.         ngx_queue_remove(q);

  314.         item = ngx_queue_data(q, ngx_http_upstream_keepalive_cache_t, queue);

  316.         ngx_http_upstream_keepalive_close(item->connection);

  318.     } else {
  319.         q = ngx_queue_head(&kp->conf->free);
  320.         ngx_queue_remove(q);

  322.         item = ngx_queue_data(q, ngx_http_upstream_keepalive_cache_t, queue);
  323.     }

  325.     item->connection = c;
  326.     ngx_queue_insert_head(&kp->conf->cache, q);

  328.     pc->connection = NULL;

  330.     if (c->read->timer_set) {
  331.         ngx_del_timer(c->read);
  332.     }
  333.     if (c->write->timer_set) {
  334.         ngx_del_timer(c->write);
  335.     }

  337.     c->write->handler = ngx_http_upstream_keepalive_dummy_handler;
  338.     c->read->handler = ngx_http_upstream_keepalive_close_handler;

  340.     c->data = item;
  341.     c->idle = 1;
  342.     c->log = ngx_cycle->log;
  343.     c->read->log = ngx_cycle->log;
  344.     c->write->log = ngx_cycle->log;
  345.     c->pool->log = ngx_cycle->log;

  347.     item->socklen = pc->socklen;
  348.     ngx_memcpy(&item->sockaddr, pc->sockaddr, pc->socklen);

  350.     if (c->read->ready) {
  351.         ngx_http_upstream_keepalive_close_handler(c->read);
  352.     }

  354. invalid:

  356.     kp->original_free_peer(pc, kp->data, state);
  357. }


  360. static void
  361. ‌ngx_http_upstream_keepalive_dummy_handler(ngx_event_t *ev)
  362. {
  363.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ev->log, 0,
  364.                    "keepalive dummy handler");
  365. }


  368. static void
  369. ‌ngx_http_upstream_keepalive_close_handler(ngx_event_t *ev)
  370. {
  371.     ngx_http_upstream_keepalive_srv_conf_t  *conf;
  372.     ngx_http_upstream_keepalive_cache_t     *item;

  374.     int                n;
  375.     char               buf[1];
  376.     ngx_connection_t  *c;

  378.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ev->log, 0,
  379.                    "keepalive close handler");

  381.     c = ev->data;

  383.     if (c->close) {
  384.         goto close;
  385.     }

  387.     n = recv(c->fd, buf, 1, MSG_PEEK);

  389.     if (n == -1 && ngx_socket_errno == NGX_EAGAIN) {
  390.         /* stale event */

  392.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  393.             goto close;
  394.         }

  396.         return;
  397.     }

  399. close:

  401.     item = c->data;
  402.     conf = item->conf;

  404.     ngx_http_upstream_keepalive_close(c);

  406.     ngx_queue_remove(&item->queue);
  407.     ngx_queue_insert_head(&conf->free, &item->queue);
  408. }


  411. static void
  412. ‌ngx_http_upstream_keepalive_close(ngx_connection_t *c)
  413. {

  415. #if (NGX_HTTP_SSL)

  417.     if (c->ssl) {
  418.         c->ssl->no_wait_shutdown = 1;
  419.         c->ssl->no_send_shutdown = 1;

  421.         if (ngx_ssl_shutdown(c) == NGX_AGAIN) {
  422.             c->ssl->handler = ngx_http_upstream_keepalive_close;
  423.             return;
  424.         }
  425.     }

  427. #endif

  429.     ngx_destroy_pool(c->pool);
  430.     ngx_close_connection(c);
  431. }


  434. #if (NGX_HTTP_SSL)

  436. static ngx_int_t
  437. ‌ngx_http_upstream_keepalive_set_session(ngx_peer_connection_t *pc, void *data)
  438. {
  439.     ngx_http_upstream_keepalive_peer_data_t  *kp = data;

  441.     return kp->original_set_session(pc, kp->data);
  442. }


  445. static void
  446. ‌ngx_http_upstream_keepalive_save_session(ngx_peer_connection_t *pc, void *data)
  447. {
  448.     ngx_http_upstream_keepalive_peer_data_t  *kp = data;

  450.     kp->original_save_session(pc, kp->data);
  451.     return;
  452. }

  454. #endif


  457. static void *
  458. ‌ngx_http_upstream_keepalive_create_conf(ngx_conf_t *cf)
  459. {
  460.     ngx_http_upstream_keepalive_srv_conf_t  *conf;

  462.     conf = ngx_pcalloc(cf->pool,
  463.                        sizeof(ngx_http_upstream_keepalive_srv_conf_t));
  464.     if (conf == NULL) {
  465.         return NULL;
  466.     }

  468.     /*
  469.      * set by ngx_pcalloc():
  470.      *
  471.      *     conf->original_init_upstream = NULL;
  472.      *     conf->original_init_peer = NULL;
  473.      */

  475.     conf->max_cached = 1;

  477.     return conf;
  478. }


  481. static char *
  482. ‌ngx_http_upstream_keepalive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  483. {
  484.     ngx_http_upstream_srv_conf_t            *uscf;
  485.     ngx_http_upstream_keepalive_srv_conf_t  *kcf = conf;

  487.     ngx_int_t    n;
  488.     ngx_str_t   *value;

  490.     uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);

  492.     if (kcf->original_init_upstream) {
  493.         return "is duplicate";
  494.     }

  496.     kcf->original_init_upstream = uscf->peer.init_upstream
  497.                                   ? uscf->peer.init_upstream
  498.                                   : ngx_http_upstream_init_round_robin;

  500.     uscf->peer.init_upstream = ngx_http_upstream_init_keepalive;

  502.     /* read options */

  504.     value = cf->args->elts;

  506.     n = ngx_atoi(value[1].data, value[1].len);

  508.     if (n == NGX_ERROR || n == 0) {
  509.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  510.                            "invalid value \"%V\" in \"%V\" directive",
  511.                            &value[1], &cmd->name);
  512.         return NGX_CONF_ERROR;
  513.     }

  515.     kcf->max_cached = n;

  517.     return NGX_CONF_OK;
  518. }

One Level Up Top Level