One Level Up Top Level

src/http/ngx_http_upstream_round_robin.h - nginx source code

Data types defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #ifndef _NGX_HTTP_UPSTREAM_ROUND_ROBIN_H_INCLUDED_
  9. ‌#define _NGX_HTTP_UPSTREAM_ROUND_ROBIN_H_INCLUDED_


  12. #include <ngx_config.h>
  13. #include <ngx_core.h>
  14. #include <ngx_http.h>


  17. ‌typedef struct ngx_http_upstream_rr_peers_s  ngx_http_upstream_rr_peers_t;
  18. ‌typedef struct ngx_http_upstream_rr_peer_s   ngx_http_upstream_rr_peer_t;


  21. #if (NGX_HTTP_UPSTREAM_ZONE)

  23. ‌typedef struct {
  24.     ngx_event_t                     event;         /* must be first */
  25.     ngx_uint_t                      worker;
  26.     ngx_str_t                       name;
  27.     ngx_str_t                       service;
  28.     time_t                          valid;
  29.     ngx_http_upstream_rr_peers_t   *peers;
  30.     ngx_http_upstream_rr_peer_t    *peer;
  31. ‌} ngx_http_upstream_host_t;

  33. #endif


  36. ‌struct ngx_http_upstream_rr_peer_s {
  37.     struct sockaddr                *sockaddr;
  38.     socklen_t                       socklen;
  39.     ngx_str_t                       name;
  40.     ngx_str_t                       server;

  42.     ngx_int_t                       current_weight;
  43.     ngx_int_t                       effective_weight;
  44.     ngx_int_t                       weight;

  46.     ngx_uint_t                      conns;
  47.     ngx_uint_t                      max_conns;

  49.     ngx_uint_t                      fails;
  50.     time_t                          accessed;
  51.     time_t                          checked;

  53.     ngx_uint_t                      max_fails;
  54.     time_t                          fail_timeout;
  55.     ngx_msec_t                      slow_start;
  56.     ngx_msec_t                      start_time;

  58.     ngx_uint_t                      down;

  60. #if (NGX_HTTP_SSL || NGX_COMPAT)
  61.     void                           *ssl_session;
  62.     int                             ssl_session_len;
  63. #endif

  65. #if (NGX_HTTP_UPSTREAM_ZONE)
  66.     unsigned                        zombie:1;

  68.     ngx_atomic_t                    lock;
  69.     ngx_uint_t                      refs;
  70.     ngx_http_upstream_host_t       *host;
  71. #endif

  73.     ngx_http_upstream_rr_peer_t    *next;

  75.     NGX_COMPAT_BEGIN(15)
  76.     NGX_COMPAT_END
  77. };


  80. ‌struct ngx_http_upstream_rr_peers_s {
  81.     ngx_uint_t                      number;

  83. #if (NGX_HTTP_UPSTREAM_ZONE)
  84.     ngx_slab_pool_t                *shpool;
  85.     ngx_atomic_t                    rwlock;
  86.     ngx_uint_t                     *config;
  87.     ngx_http_upstream_rr_peer_t    *resolve;
  88.     ngx_http_upstream_rr_peers_t   *zone_next;
  89. #endif

  91.     ngx_uint_t                      total_weight;
  92.     ngx_uint_t                      tries;

  94.     unsigned                        single:1;
  95.     unsigned                        weighted:1;

  97.     ngx_str_t                      *name;

  99.     ngx_http_upstream_rr_peers_t   *next;

  101.     ngx_http_upstream_rr_peer_t    *peer;
  102. };


  105. #if (NGX_HTTP_UPSTREAM_ZONE)

  107. ‌#define ngx_http_upstream_rr_peers_rlock(peers)                               \
  108.                                                                               \
  109.     if (peers->shpool) {                                                      \
  110.         ngx_rwlock_rlock(&peers->rwlock);                                     \
  111.     }

  113. ‌#define ngx_http_upstream_rr_peers_wlock(peers)                               \
  114.                                                                               \
  115.     if (peers->shpool) {                                                      \
  116.         ngx_rwlock_wlock(&peers->rwlock);                                     \
  117.     }

  119. ‌#define ngx_http_upstream_rr_peers_unlock(peers)                              \
  120.                                                                               \
  121.     if (peers->shpool) {                                                      \
  122.         ngx_rwlock_unlock(&peers->rwlock);                                    \
  123.     }


  126. ‌#define ngx_http_upstream_rr_peer_lock(peers, peer)                           \
  127.                                                                               \
  128.     if (peers->shpool) {                                                      \
  129.         ngx_rwlock_wlock(&peer->lock);                                        \
  130.     }

  132. ‌#define ngx_http_upstream_rr_peer_unlock(peers, peer)                         \
  133.                                                                               \
  134.     if (peers->shpool) {                                                      \
  135.         ngx_rwlock_unlock(&peer->lock);                                       \
  136.     }


  139. ‌#define ngx_http_upstream_rr_peer_ref(peers, peer)                            \
  140.     (peer)->refs++;


  143. static ngx_inline void
  144. ‌ngx_http_upstream_rr_peer_free_locked(ngx_http_upstream_rr_peers_t *peers,
  145.     ngx_http_upstream_rr_peer_t *peer)
  146. {
  147.     if (peer->refs) {
  148.         peer->zombie = 1;
  149.         return;
  150.     }

  152.     ngx_slab_free_locked(peers->shpool, peer->sockaddr);
  153.     ngx_slab_free_locked(peers->shpool, peer->name.data);

  155.     if (peer->server.data) {
  156.         ngx_slab_free_locked(peers->shpool, peer->server.data);
  157.     }

  159. #if (NGX_HTTP_SSL)
  160.     if (peer->ssl_session) {
  161.         ngx_slab_free_locked(peers->shpool, peer->ssl_session);
  162.     }
  163. #endif

  165.     ngx_slab_free_locked(peers->shpool, peer);
  166. }


  169. static ngx_inline void
  170. ‌ngx_http_upstream_rr_peer_free(ngx_http_upstream_rr_peers_t *peers,
  171.     ngx_http_upstream_rr_peer_t *peer)
  172. {
  173.     ngx_shmtx_lock(&peers->shpool->mutex);
  174.     ngx_http_upstream_rr_peer_free_locked(peers, peer);
  175.     ngx_shmtx_unlock(&peers->shpool->mutex);
  176. }


  179. static ngx_inline ngx_int_t
  180. ‌ngx_http_upstream_rr_peer_unref(ngx_http_upstream_rr_peers_t *peers,
  181.     ngx_http_upstream_rr_peer_t *peer)
  182. {
  183.     peer->refs--;

  185.     if (peers->shpool == NULL) {
  186.         return NGX_OK;
  187.     }

  189.     if (peer->refs == 0 && peer->zombie) {
  190.         ngx_http_upstream_rr_peer_free(peers, peer);
  191.         return NGX_DONE;
  192.     }

  194.     return NGX_OK;
  195. }

  197. #else

  199. ‌#define ngx_http_upstream_rr_peers_rlock(peers)
  200. ‌#define ngx_http_upstream_rr_peers_wlock(peers)
  201. ‌#define ngx_http_upstream_rr_peers_unlock(peers)
  202. ‌#define ngx_http_upstream_rr_peer_lock(peers, peer)
  203. ‌#define ngx_http_upstream_rr_peer_unlock(peers, peer)
  204. ‌#define ngx_http_upstream_rr_peer_ref(peers, peer)
  205. ‌#define ngx_http_upstream_rr_peer_unref(peers, peer)  NGX_OK

  207. #endif


  210. ‌typedef struct {
  211.     ngx_uint_t                      config;
  212.     ngx_http_upstream_rr_peers_t   *peers;
  213.     ngx_http_upstream_rr_peer_t    *current;
  214.     uintptr_t                      *tried;
  215.     uintptr_t                       data;
  216. ‌} ngx_http_upstream_rr_peer_data_t;


  219. ngx_int_t ngx_http_upstream_init_round_robin(ngx_conf_t *cf,
  220.     ngx_http_upstream_srv_conf_t *us);
  221. ngx_int_t ngx_http_upstream_init_round_robin_peer(ngx_http_request_t *r,
  222.     ngx_http_upstream_srv_conf_t *us);
  223. ngx_int_t ngx_http_upstream_create_round_robin_peer(ngx_http_request_t *r,
  224.     ngx_http_upstream_resolved_t *ur);
  225. ngx_int_t ngx_http_upstream_get_round_robin_peer(ngx_peer_connection_t *pc,
  226.     void *data);
  227. void ngx_http_upstream_free_round_robin_peer(ngx_peer_connection_t *pc,
  228.     void *data, ngx_uint_t state);

  230. #if (NGX_HTTP_SSL)
  231. ngx_int_t
  232.     ngx_http_upstream_set_round_robin_peer_session(ngx_peer_connection_t *pc,
  233.     void *data);
  234. void ngx_http_upstream_save_round_robin_peer_session(ngx_peer_connection_t *pc,
  235.     void *data);
  236. #endif


  239. #endif /* _NGX_HTTP_UPSTREAM_ROUND_ROBIN_H_INCLUDED_ */

One Level Up Top Level