Changeset cd26d0

Timestamp:

01/19/09 13:06:02 (3 years ago)

Author:

George Potapov <nephrite@…>

Branches:

master-v0.7, upstream_count_limit

Children:

f8bbb6

Parents:

ca37e8 (diff), b3765f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

git-author:

George Potapov <nephrite@…> (01/19/09 13:06:02)

git-committer:

George Potapov <nephrite@…> (01/19/09 13:06:02)

Message:

Merge branch 'master-v0.7' of  git://openhack.ru/nginx-patched into master-v0.7

Files:

• memcached_hash/Changes (modified) (1 diff)
• memcached_hash/README (modified) (1 diff)
• memcached_hash/dist.sh (modified) (1 diff)
• memcached_hash/ngx_http_upstream_memcached_hash_module.c (modified) (8 diffs)
• upstream_keepalive/ngx_http_upstream_keepalive_module.c (modified) (4 diffs)
• upstream_keepalive/t/memcached-keepalive.t (modified) (4 diffs)

memcached_hash/Changes

@@ -1 +1 @@
 Revision history of ngx_http_upstream_memcached_hash_module.
+
+0.04  ???
+        - ???
+
+        Do not change callback and data pointers passed by nginx after
+        module initialization.  This makes the module compatible with
+        other intermediate "balancers" up the chain.  Such balancers
+        do not perform actual balancing, but may process host address
+        that we return, for instance map it to cached open connection.
+
 
 0.03  2008-05-01

memcached_hash/README

@@ -1 @@
-ngx_http_upstream_memcached_hash_module 0.03
+ngx_http_upstream_memcached_hash_module 0.04
 ============================================
 

memcached_hash/dist.sh

@@ -1 +1 @@
 #! /bin/sh
+
+BRANCH=$1
+if [ "x$BRANCH" = "x" ]; then
+    echo "Usage: $0 NGINX-BRANCH"
+    exit 1
+fi
 
 PWD=`pwd`

memcached_hash/ngx_http_upstream_memcached_hash_module.c

@@ -1 +1 @@
 /*
-  Copyright (C) 2007-2008 Tomash Brechko.  All rights reserved.
+  Copyright (C) 2007-2009 Tomash Brechko.  All rights reserved.
 
   Development of this module was sponsored by Monashev Co. Ltd.
@@ -7 +7 @@
   source code.
 
-  Version 0.03.
+  Version 0.04.
 */
 
@@ -55 +55 @@
   ngx_http_upstream_server_t *server;
   ngx_http_request_t *request;
+  struct memcached_hash_peer *peer;
 };
 
@@ -97 +98 @@
 
 static
-ngx_int_t
-memcached_hash_get_peer(ngx_peer_connection_t *pc, void *data)
-{
-  struct memcached_hash_peer *peer = data;
-  ngx_peer_addr_t *addr;
-
-  if (peer->server->down)
-    goto fail;
-
-  if (peer->server->max_fails > 0 && peer->fails >= peer->server->max_fails)
-    {
-      time_t now = ngx_time();
-      if (now - peer->accessed <= peer->server->fail_timeout)
-        goto fail;
-      else
-        peer->fails = 0;
-    }
-
-  addr = &peer->server->addrs[peer->addr_index];
-
-  pc->sockaddr = addr->sockaddr;
-  pc->socklen = addr->socklen;
-  pc->name = &addr->name;
-
-  return NGX_OK;
-
-fail:
-  /* This is the last try.  */
-  pc->tries = 1;
-
-  return NGX_BUSY;
-}
-
-
-static
-ngx_int_t
-memcached_hash_find_peer(ngx_peer_connection_t *pc, void *data)
-{
-  struct memcached_hash_find_ctx *find_ctx = data;
+unsigned int
+memcached_hash_find_peer(struct memcached_hash_find_ctx *find_ctx)
+{
   struct memcached_hash *memd = find_ctx->memd;
   u_char *key;
@@ -185 +150 @@
     }
 
-  pc->data = &memd->peers[index];
-  pc->get = memcached_hash_get_peer;
-  pc->tries = find_ctx->server[index].naddrs;
-
-  return memcached_hash_get_peer(pc, pc->data);
+  find_ctx->peer = &memd->peers[index];
+
+  return index;
+}
+
+
+static
+ngx_int_t
+memcached_hash_get_peer(ngx_peer_connection_t *pc, void *data)
+{
+  struct memcached_hash_find_ctx *find_ctx = data;
+  struct memcached_hash_peer *peer = find_ctx->peer;
+  ngx_peer_addr_t *addr;
+
+  if (! peer)
+    {
+      unsigned int index;
+
+      index = memcached_hash_find_peer(find_ctx);
+
+      peer = find_ctx->peer;
+      pc->tries = find_ctx->server[index].naddrs;
+    }
+
+  if (peer->server->down)
+    goto fail;
+
+  if (peer->server->max_fails > 0 && peer->fails >= peer->server->max_fails)
+    {
+      time_t now = ngx_time();
+      if (now - peer->accessed <= peer->server->fail_timeout)
+        goto fail;
+      else
+        peer->fails = 0;
+    }
+
+  addr = &peer->server->addrs[peer->addr_index];
+
+  pc->sockaddr = addr->sockaddr;
+  pc->socklen = addr->socklen;
+  pc->name = &addr->name;
+
+  return NGX_OK;
+
+fail:
+  /* This is the last try.  */
+  pc->tries = 1;
+
+  return NGX_BUSY;
 }
 
@@ -198 +207 @@
                          ngx_uint_t state)
 {
-  struct memcached_hash_peer *peer = data;
+  struct memcached_hash_find_ctx *find_ctx = data;
+  struct memcached_hash_peer *peer = find_ctx->peer;
 
   if (state & NGX_PEER_FAILED)
@@ -243 +253 @@
   find_ctx->request = r;
   find_ctx->server = us->servers->elts;
+  find_ctx->peer = NULL;
 
   r->upstream->peer.free = memcached_hash_free_peer;
@@ -250 +261 @@
     memcached_hash_find_peer().
   */
-  r->upstream->peer.get = memcached_hash_find_peer;
+  r->upstream->peer.get = memcached_hash_get_peer;
   r->upstream->peer.data = find_ctx;
   r->upstream->peer.tries = 1;

upstream_keepalive/ngx_http_upstream_keepalive_module.c

@@ -26 +26 @@
     ngx_http_upstream_keepalive_srv_conf_t  *conf;
 
+    ngx_http_upstream_t               *upstream;
+
     void                              *data;
 
     ngx_event_get_peer_pt              original_get_peer;
     ngx_event_free_peer_pt             original_free_peer;
+
+    ngx_uint_t                         failed;       /* unsigned:1 */
 
 } ngx_http_upstream_keepalive_peer_data_t;
@@ -170 +174 @@
 
     kp->conf = kcf;
+    kp->upstream = r->upstream;
     kp->data = r->upstream->peer.data;
     kp->original_get_peer = r->upstream->peer.get;
@@ -194 +199 @@
     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
                    "get keepalive peer");
+
+    kp->failed = 0;
 
     /* single pool of cached connections */
@@ -265 +272 @@
     ngx_http_upstream_keepalive_cache_t      *item;
 
-    ngx_queue_t       *q;
-    ngx_connection_t  *c;
+    ngx_uint_t            status;
+    ngx_queue_t          *q;
+    ngx_connection_t     *c;
+    ngx_http_upstream_t  *u;
 
     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
                    "free keepalive peer");
 
-    if (!(state & NGX_PEER_FAILED)
-        && pc->connection != NULL)
+    /* remember failed state - peer.free() may be called more than once */
+
+    if (state & NGX_PEER_FAILED) {
+        kp->failed = 1;
+    }
+
+    /*
+     * cache valid connections
+     *
+     * For memcached this means status either 404 or 200.  For status 200 we
+     * should also check if all response body was read (u->length == 0) and
+     * make sure that u->length is valid (we use u->header_sent flag to test
+     * this).  Memcached is the only supported protocol for now.
+     *
+     * Some notes on other possibilities (incomplete):
+     *
+     * fastcgi: u->pipe->upstream_done should be sufficient
+     *
+     * proxy buffered: u->pipe->upstream_done, 304 replies, replies to head
+     * requests (see RFC 2616, 4.4 Message Length)
+     *
+     * proxy unbuffered: 200 as for memcached (with u->length == 0 and
+     * header_sent), 304, replies to head requests
+     *
+     * subrequest_in_memory: won't work as of now
+     *
+     * TODO: move this logic to protocol modules (NGX_PEER_KEEPALIVE?)
+     */
+
+    u = kp->upstream;
+    status = u->headers_in.status_n;
+
+    if (!kp->failed
+        && pc->connection != NULL
+        && (status == NGX_HTTP_NOT_FOUND
+            || (status == NGX_HTTP_OK && u->header_sent && u->length == 0)))
     {
         c = pc->connection;
+
+        ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
+                       "free keepalive peer: saving connection %p", c);
 
         if (ngx_queue_empty(&kp->conf->free)) {

upstream_keepalive/t/memcached-keepalive.t

@@ -21 +21 @@
 plain(skip_all => 'Cache::Memcached not installed') if $@;
 
-my $t = Test::Nginx->new()->has('rewrite')->has_daemon('memcached')->plan(10)
+my $t = Test::Nginx->new()->has('rewrite')->has_daemon('memcached')->plan(16)
     ->write_file_expand('nginx.conf', <<'EOF');
 
@@ -95 +95 @@
 EOF
 
-$t->run_daemon('memcached', '-l', '127.0.0.1', '-p', '8081');
-$t->run_daemon('memcached', '-l', '127.0.0.1', '-p', '8082');
+if (`memcached -h` =~ /repcached/) {
+    # repcached patches adds additional listen socket memcached
+    # that should be different too
+
+    $t->run_daemon('memcached', '-l', '127.0.0.1', '-p', '8081',
+        '-X', '8091');
+    $t->run_daemon('memcached', '-l', '127.0.0.1', '-p', '8082',
+        '-X', '8092');
+
+} else {
+    $t->run_daemon('memcached', '-l', '127.0.0.1', '-p', '8081');
+    $t->run_daemon('memcached', '-l', '127.0.0.1', '-p', '8082');
+}
+
 $t->run();
+
+$t->waitforsocket('127.0.0.1:8081')
+    or die "Unable to start memcached";
+$t->waitforsocket('127.0.0.1:8082')
+    or die "Unable to start second memcached";
 
 ###############################################################################
@@ -106 +123 @@
 $memd1->set('/', 'SEE-THIS');
 $memd2->set('/', 'SEE-THIS');
+$memd1->set('/big', 'X' x 1000000);
 
 my $total = $memd1->stats()->{total}->{total_connections};
@@ -120 +138 @@
     'only one connection used');
 
+# Since nginx doesn't read all data from connection in some situations (head
+# requests, post_action, errors writing to client) we have to close such
+# connections.  Check if we really do close them.
+
+$total = $memd1->stats()->{total}->{total_connections};
+
+unlike(http_head('/'), qr/SEE-THIS/, 'head request');
+like(http_get('/'), qr/SEE-THIS/, 'get after head');
+
+is($memd1->stats()->{total}->{total_connections}, $total + 1,
+    'head request closes connection');
+
+$total = $memd1->stats()->{total}->{total_connections};
+
+unlike(http_head('/big'), qr/XXX/, 'big head');
+like(http_get('/'), qr/SEE-THIS/, 'get after big head');
+
+is($memd1->stats()->{total}->{total_connections}, $total + 1,
+    'big head request closes connection');
+
 # two backends with 'single' option - should establish only one connection