One Level Up Top Level

src/http/modules/ngx_http_upstream_keepalive_module.c - nginx

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;
  15.     ngx_uint_t                         requests;
  16.     ngx_msec_t                         time;
  17.     ngx_msec_t                         timeout;

  19.     ngx_queue_t                        cache;
  20.     ngx_queue_t                        free;

  22.     ngx_http_upstream_init_peer_pt     original_init_peer;

  24.     ngx_uint_t                         local; /* unsigned  local:1; */

  26. ‌} ngx_http_upstream_keepalive_srv_conf_t;


  29. ‌typedef struct {
  30.     ngx_http_upstream_keepalive_srv_conf_t  *conf;

  32.     ngx_queue_t                        queue;
  33.     ngx_connection_t                  *connection;

  35.     socklen_t                          socklen;
  36.     ngx_sockaddr_t                     sockaddr;

  38.     ngx_http_upstream_conf_t          *tag;

  40. ‌} ngx_http_upstream_keepalive_cache_t;


  43. ‌typedef struct {
  44.     ngx_http_upstream_keepalive_srv_conf_t  *conf;

  46.     ngx_http_upstream_t               *upstream;

  48.     void                              *data;

  50.     ngx_event_get_peer_pt              original_get_peer;
  51.     ngx_event_free_peer_pt             original_free_peer;

  53. #if (NGX_HTTP_SSL)
  54.     ngx_event_set_peer_session_pt      original_set_session;
  55.     ngx_event_save_peer_session_pt     original_save_session;
  56. #endif

  58.     ngx_event_notify_peer_pt           original_notify;

  60. ‌} ngx_http_upstream_keepalive_peer_data_t;


  63. static ngx_int_t ngx_http_upstream_init_keepalive_peer(ngx_http_request_t *r,
  64.     ngx_http_upstream_srv_conf_t *us);
  65. static ngx_int_t ngx_http_upstream_get_keepalive_peer(ngx_peer_connection_t *pc,
  66.     void *data);
  67. static void ngx_http_upstream_free_keepalive_peer(ngx_peer_connection_t *pc,
  68.     void *data, ngx_uint_t state);

  70. static void ngx_http_upstream_keepalive_dummy_handler(ngx_event_t *ev);
  71. static void ngx_http_upstream_keepalive_close_handler(ngx_event_t *ev);
  72. static void ngx_http_upstream_keepalive_close(ngx_connection_t *c);

  74. #if (NGX_HTTP_SSL)
  75. static ngx_int_t ngx_http_upstream_keepalive_set_session(
  76.     ngx_peer_connection_t *pc, void *data);
  77. static void ngx_http_upstream_keepalive_save_session(ngx_peer_connection_t *pc,
  78.     void *data);
  79. #endif

  81. static void ngx_http_upstream_notify_keepalive_peer(ngx_peer_connection_t *pc,
  82.     void *data, ngx_uint_t type);

  84. static void *ngx_http_upstream_keepalive_create_conf(ngx_conf_t *cf);
  85. static char *ngx_http_upstream_keepalive_init_main_conf(ngx_conf_t *cf,
  86.     void *conf);
  87. static char *ngx_http_upstream_keepalive(ngx_conf_t *cf, ngx_command_t *cmd,
  88.     void *conf);


  91. ‌static ngx_command_t  ngx_http_upstream_keepalive_commands[] = {

  93.     { ngx_string("keepalive"),
  94.       NGX_HTTP_UPS_CONF|NGX_CONF_TAKE12,
  95.       ngx_http_upstream_keepalive,
  96.       NGX_HTTP_SRV_CONF_OFFSET,
  97.       0,
  98.       NULL },

  100.     { ngx_string("keepalive_time"),
  101.       NGX_HTTP_UPS_CONF|NGX_CONF_TAKE1,
  102.       ngx_conf_set_msec_slot,
  103.       NGX_HTTP_SRV_CONF_OFFSET,
  104.       offsetof(ngx_http_upstream_keepalive_srv_conf_t, time),
  105.       NULL },

  107.     { ngx_string("keepalive_timeout"),
  108.       NGX_HTTP_UPS_CONF|NGX_CONF_TAKE1,
  109.       ngx_conf_set_msec_slot,
  110.       NGX_HTTP_SRV_CONF_OFFSET,
  111.       offsetof(ngx_http_upstream_keepalive_srv_conf_t, timeout),
  112.       NULL },

  114.     { ngx_string("keepalive_requests"),
  115.       NGX_HTTP_UPS_CONF|NGX_CONF_TAKE1,
  116.       ngx_conf_set_num_slot,
  117.       NGX_HTTP_SRV_CONF_OFFSET,
  118.       offsetof(ngx_http_upstream_keepalive_srv_conf_t, requests),
  119.       NULL },

  121.       ngx_null_command
  122. };


  125. ‌static ngx_http_module_t  ngx_http_upstream_keepalive_module_ctx = {
  126.     NULL,                                  /* preconfiguration */
  127.     NULL,                                  /* postconfiguration */

  129.     NULL,                                  /* create main configuration */
  130.     ngx_http_upstream_keepalive_init_main_conf, /* init main configuration */

  132.     ngx_http_upstream_keepalive_create_conf, /* create server configuration */
  133.     NULL,                                  /* merge server configuration */

  135.     NULL,                                  /* create location configuration */
  136.     NULL                                   /* merge location configuration */
  137. };


  140. ‌ngx_module_t  ngx_http_upstream_keepalive_module = {
  141.     NGX_MODULE_V1,
  142.     &ngx_http_upstream_keepalive_module_ctx, /* module context */
  143.     ngx_http_upstream_keepalive_commands,    /* module directives */
  144.     NGX_HTTP_MODULE,                       /* module type */
  145.     NULL,                                  /* init master */
  146.     NULL,                                  /* init module */
  147.     NULL,                                  /* init process */
  148.     NULL,                                  /* init thread */
  149.     NULL,                                  /* exit thread */
  150.     NULL,                                  /* exit process */
  151.     NULL,                                  /* exit master */
  152.     NGX_MODULE_V1_PADDING
  153. };


  156. static ngx_int_t
  157. ‌ngx_http_upstream_init_keepalive_peer(ngx_http_request_t *r,
  158.     ngx_http_upstream_srv_conf_t *us)
  159. {
  160.     ngx_http_upstream_keepalive_peer_data_t  *kp;
  161.     ngx_http_upstream_keepalive_srv_conf_t   *kcf;

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

  166.     kcf = ngx_http_conf_upstream_srv_conf(us,
  167.                                           ngx_http_upstream_keepalive_module);

  169.     kp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_keepalive_peer_data_t));
  170.     if (kp == NULL) {
  171.         return NGX_ERROR;
  172.     }

  174.     if (kcf->original_init_peer(r, us) != NGX_OK) {
  175.         return NGX_ERROR;
  176.     }

  178.     kp->conf = kcf;
  179.     kp->upstream = r->upstream;
  180.     kp->data = r->upstream->peer.data;
  181.     kp->original_get_peer = r->upstream->peer.get;
  182.     kp->original_free_peer = r->upstream->peer.free;

  184.     r->upstream->peer.data = kp;
  185.     r->upstream->peer.get = ngx_http_upstream_get_keepalive_peer;
  186.     r->upstream->peer.free = ngx_http_upstream_free_keepalive_peer;

  188. #if (NGX_HTTP_SSL)
  189.     kp->original_set_session = r->upstream->peer.set_session;
  190.     kp->original_save_session = r->upstream->peer.save_session;
  191.     r->upstream->peer.set_session = ngx_http_upstream_keepalive_set_session;
  192.     r->upstream->peer.save_session = ngx_http_upstream_keepalive_save_session;
  193. #endif

  195.     if (r->upstream->peer.notify) {
  196.         kp->original_notify = r->upstream->peer.notify;
  197.         r->upstream->peer.notify = ngx_http_upstream_notify_keepalive_peer;
  198.     }

  200.     return NGX_OK;
  201. }


  204. static ngx_int_t
  205. ‌ngx_http_upstream_get_keepalive_peer(ngx_peer_connection_t *pc, void *data)
  206. {
  207.     ngx_http_upstream_keepalive_peer_data_t  *kp = data;
  208.     ngx_http_upstream_keepalive_cache_t      *item;

  210.     ngx_int_t          rc;
  211.     ngx_queue_t       *q, *cache;
  212.     ngx_connection_t  *c;

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

  217.     /* ask balancer */

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

  221.     if (rc != NGX_OK) {
  222.         return rc;
  223.     }

  225.     /* search cache for suitable connection */

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

  229.     for (q = ngx_queue_head(cache);
  230.          q != ngx_queue_sentinel(cache);
  231.          q = ngx_queue_next(q))
  232.     {
  233.         item = ngx_queue_data(q, ngx_http_upstream_keepalive_cache_t, queue);
  234.         c = item->connection;

  236.         if (kp->conf->local && item->tag != kp->upstream->conf) {
  237.             continue;
  238.         }

  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.             goto found;
  248.         }
  249.     }

  251.     return NGX_OK;

  253. found:

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

  258.     c->idle = 0;
  259.     c->sent = 0;
  260.     c->data = NULL;
  261.     c->log = pc->log;
  262.     c->read->log = pc->log;
  263.     c->write->log = pc->log;
  264.     c->pool->log = pc->log;

  266.     if (c->read->timer_set) {
  267.         ngx_del_timer(c->read);
  268.     }

  270.     pc->connection = c;
  271.     pc->cached = 1;

  273.     return NGX_DONE;
  274. }


  277. static void
  278. ‌ngx_http_upstream_free_keepalive_peer(ngx_peer_connection_t *pc, void *data,
  279.     ngx_uint_t state)
  280. {
  281.     ngx_http_upstream_keepalive_peer_data_t  *kp = data;
  282.     ngx_http_upstream_keepalive_cache_t      *item;

  284.     ngx_queue_t          *q;
  285.     ngx_connection_t     *c;
  286.     ngx_http_upstream_t  *u;

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

  291.     /* cache valid connections */

  293.     u = kp->upstream;
  294.     c = pc->connection;

  296.     if (state & NGX_PEER_FAILED
  297.         || c == NULL
  298.         || c->read->eof
  299.         || c->read->error
  300.         || c->read->timedout
  301.         || c->write->error
  302.         || c->write->timedout)
  303.     {
  304.         goto invalid;
  305.     }

  307.     if (c->requests >= kp->conf->requests) {
  308.         goto invalid;
  309.     }

  311.     if (ngx_current_msec - c->start_time > kp->conf->time) {
  312.         goto invalid;
  313.     }

  315.     if (!u->keepalive) {
  316.         goto invalid;
  317.     }

  319.     if (!u->request_body_sent) {
  320.         goto invalid;
  321.     }

  323.     if (ngx_terminate || ngx_exiting) {
  324.         goto invalid;
  325.     }

  327.     if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  328.         goto invalid;
  329.     }

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

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

  336.         q = ngx_queue_last(&kp->conf->cache);
  337.         ngx_queue_remove(q);

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

  341.         ngx_http_upstream_keepalive_close(item->connection);

  343.     } else {
  344.         q = ngx_queue_head(&kp->conf->free);
  345.         ngx_queue_remove(q);

  347.         item = ngx_queue_data(q, ngx_http_upstream_keepalive_cache_t, queue);
  348.     }

  350.     ngx_queue_insert_head(&kp->conf->cache, q);

  352.     item->connection = c;
  353.     item->tag = u->conf;

  355.     pc->connection = NULL;

  357.     c->read->delayed = 0;
  358.     ngx_add_timer(c->read, kp->conf->timeout);

  360.     if (c->write->timer_set) {
  361.         ngx_del_timer(c->write);
  362.     }

  364.     c->write->handler = ngx_http_upstream_keepalive_dummy_handler;
  365.     c->read->handler = ngx_http_upstream_keepalive_close_handler;

  367.     c->data = item;
  368.     c->idle = 1;
  369.     c->log = ngx_cycle->log;
  370.     c->read->log = ngx_cycle->log;
  371.     c->write->log = ngx_cycle->log;
  372.     c->pool->log = ngx_cycle->log;

  374.     item->socklen = pc->socklen;
  375.     ngx_memcpy(&item->sockaddr, pc->sockaddr, pc->socklen);

  377.     if (c->read->ready) {
  378.         ngx_http_upstream_keepalive_close_handler(c->read);
  379.     }

  381. invalid:

  383.     kp->original_free_peer(pc, kp->data, state);
  384. }


  387. static void
  388. ‌ngx_http_upstream_keepalive_dummy_handler(ngx_event_t *ev)
  389. {
  390.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ev->log, 0,
  391.                    "keepalive dummy handler");
  392. }


  395. static void
  396. ‌ngx_http_upstream_keepalive_close_handler(ngx_event_t *ev)
  397. {
  398.     ngx_http_upstream_keepalive_srv_conf_t  *conf;
  399.     ngx_http_upstream_keepalive_cache_t     *item;

  401.     int                n;
  402.     char               buf[1];
  403.     ngx_connection_t  *c;

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

  408.     c = ev->data;

  410.     if (c->close || c->read->timedout) {
  411.         goto close;
  412.     }

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

  416.     if (n == -1 && ngx_socket_errno == NGX_EAGAIN) {
  417.         ev->ready = 0;

  419.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  420.             goto close;
  421.         }

  423.         return;
  424.     }

  426. close:

  428.     item = c->data;
  429.     conf = item->conf;

  431.     ngx_http_upstream_keepalive_close(c);

  433.     ngx_queue_remove(&item->queue);
  434.     ngx_queue_insert_head(&conf->free, &item->queue);
  435. }


  438. static void
  439. ‌ngx_http_upstream_keepalive_close(ngx_connection_t *c)
  440. {

  442. #if (NGX_HTTP_SSL)

  444.     if (c->ssl) {
  445.         c->ssl->no_wait_shutdown = 1;
  446.         c->ssl->no_send_shutdown = 1;

  448.         if (ngx_ssl_shutdown(c) == NGX_AGAIN) {
  449.             c->ssl->handler = ngx_http_upstream_keepalive_close;
  450.             return;
  451.         }
  452.     }

  454. #endif

  456.     ngx_destroy_pool(c->pool);
  457.     ngx_close_connection(c);
  458. }


  461. #if (NGX_HTTP_SSL)

  463. static ngx_int_t
  464. ‌ngx_http_upstream_keepalive_set_session(ngx_peer_connection_t *pc, void *data)
  465. {
  466.     ngx_http_upstream_keepalive_peer_data_t  *kp = data;

  468.     return kp->original_set_session(pc, kp->data);
  469. }


  472. static void
  473. ‌ngx_http_upstream_keepalive_save_session(ngx_peer_connection_t *pc, void *data)
  474. {
  475.     ngx_http_upstream_keepalive_peer_data_t  *kp = data;

  477.     kp->original_save_session(pc, kp->data);
  478.     return;
  479. }

  481. #endif


  484. static void
  485. ‌ngx_http_upstream_notify_keepalive_peer(ngx_peer_connection_t *pc, void *data,
  486.     ngx_uint_t type)
  487. {
  488.     ngx_http_upstream_keepalive_peer_data_t  *kp = data;

  490.     kp->original_notify(pc, kp->data, type);
  491. }


  494. static void *
  495. ‌ngx_http_upstream_keepalive_create_conf(ngx_conf_t *cf)
  496. {
  497.     ngx_http_upstream_keepalive_srv_conf_t  *conf;

  499.     conf = ngx_pcalloc(cf->pool,
  500.                        sizeof(ngx_http_upstream_keepalive_srv_conf_t));
  501.     if (conf == NULL) {
  502.         return NULL;
  503.     }

  505.     /*
  506.      * set by ngx_pcalloc():
  507.      *
  508.      *     conf->original_init_peer = NULL;
  509.      *     conf->local = 0;
  510.      */

  512.     conf->time = NGX_CONF_UNSET_MSEC;
  513.     conf->timeout = NGX_CONF_UNSET_MSEC;
  514.     conf->requests = NGX_CONF_UNSET_UINT;
  515.     conf->max_cached = NGX_CONF_UNSET_UINT;

  517.     return conf;
  518. }


  521. static char *
  522. ‌ngx_http_upstream_keepalive_init_main_conf(ngx_conf_t *cf, void *conf)
  523. {
  524.     ngx_uint_t                                i, j;
  525.     ngx_http_upstream_srv_conf_t            **uscfp;
  526.     ngx_http_upstream_main_conf_t            *umcf;
  527.     ngx_http_upstream_keepalive_cache_t      *cached;
  528.     ngx_http_upstream_keepalive_srv_conf_t   *kcf;

  530.     umcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_upstream_module);

  532.     uscfp = umcf->upstreams.elts;

  534.     for (i = 0; i < umcf->upstreams.nelts; i++) {

  536.         /* skip implicit upstreams */
  537.         if (uscfp[i]->srv_conf == NULL) {
  538.             continue;
  539.         }

  541.         kcf = ngx_http_conf_upstream_srv_conf(uscfp[i],
  542.                                             ngx_http_upstream_keepalive_module);

  544.         if (kcf->max_cached == 0) {
  545.             continue;
  546.         }

  548.         ngx_conf_init_msec_value(kcf->time, 3600000);
  549.         ngx_conf_init_msec_value(kcf->timeout, 60000);
  550.         ngx_conf_init_uint_value(kcf->requests, 1000);

  552.         if (kcf->max_cached == NGX_CONF_UNSET_UINT) {
  553.             kcf->local = 1;
  554.             kcf->max_cached = 32;
  555.         }

  557.         kcf->original_init_peer = uscfp[i]->peer.init;

  559.         uscfp[i]->peer.init = ngx_http_upstream_init_keepalive_peer;

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

  563.         cached = ngx_pcalloc(cf->pool,
  564.                  sizeof(ngx_http_upstream_keepalive_cache_t) * kcf->max_cached);
  565.         if (cached == NULL) {
  566.             return NGX_CONF_ERROR;
  567.         }

  569.         ngx_queue_init(&kcf->cache);
  570.         ngx_queue_init(&kcf->free);

  572.         for (j = 0; j < kcf->max_cached; j++) {
  573.             ngx_queue_insert_head(&kcf->free, &cached[j].queue);
  574.             cached[j].conf = kcf;
  575.         }
  576.     }

  578.     return NGX_CONF_OK;
  579. }


  582. static char *
  583. ‌ngx_http_upstream_keepalive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  584. {
  585.     ngx_http_upstream_keepalive_srv_conf_t  *kcf = conf;

  587.     ngx_int_t    n;
  588.     ngx_str_t   *value;

  590.     if (kcf->max_cached != NGX_CONF_UNSET_UINT) {
  591.         return "is duplicate";
  592.     }

  594.     /* read options */

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

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

  600.     if (n == NGX_ERROR) {
  601.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  602.                            "invalid value \"%V\" in \"%V\" directive",
  603.                            &value[1], &cmd->name);
  604.         return NGX_CONF_ERROR;
  605.     }

  607.     kcf->max_cached = n;

  609.     if (cf->args->nelts == 3) {
  610.         if (ngx_strcmp(value[2].data, "local") == 0) {
  611.             kcf->local = 1;

  613.         } else {
  614.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  615.                                "invalid parameter \"%V\"", &value[2]);
  616.             return NGX_CONF_ERROR;
  617.         }
  618.     }

  620.     return NGX_CONF_OK;
  621. }

One Level Up Top Level