Changeset 56389f

Timestamp:

04/13/08 13:19:54 (4 years ago)

Author:

Tomash Brechko <tomash.brechko@…>

Branches:

master-v0.7, master-v0.6, memcached_gzip, upstream_count_limit

Children:

f54237

Parents:

b3076c (diff), 21b759 (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:

Tomash Brechko <tomash.brechko@…> (04/13/08 13:19:54)

git-committer:

Tomash Brechko <tomash.brechko@…> (04/13/08 13:19:54)

Message:

Merge branch 'gunzip' into memcached_gzip

Location:

server/src/http/modules

Files:

• ngx_http_gzip_filter_module.c (modified) (1 diff)
• ngx_http_memcached_module.c (modified) (7 diffs)

server/src/http/modules/ngx_http_gzip_filter_module.c

@@ -629 +629 @@
                  * On decompression we could already output everything
                  * under (ctx->flush == Z_SYNC_FLUSH), so we test here
-                 * that the buffer is not empty.
+                 * that the buffer is not empty, or Transfer-Encoding:
+                 * is chunked.  In the latter case we output empty
+                 * buffer to get last zero length chunk.
                  */
-                if (!r->gunzip || ctx->out_buf->last > ctx->out_buf->pos) {
+                if (!r->gunzip || ctx->out_buf->last > ctx->out_buf->pos
+                    || r->chunked) {
                     cl->buf = ctx->out_buf;
                     cl->next = NULL;

server/src/http/modules/ngx_http_memcached_module.c

@@ -14 +14 @@
     ngx_http_upstream_conf_t   upstream;
     ngx_int_t                  index;
+    ngx_uint_t                 gzip_flag;
 } ngx_http_memcached_loc_conf_t;
 
@@ -99 +100 @@
       offsetof(ngx_http_memcached_loc_conf_t, upstream.next_upstream),
       &ngx_http_memcached_next_upstream_masks },
+
+    { ngx_string("memcached_gzip_flag"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
+                        |NGX_CONF_TAKE1,
+      ngx_conf_set_num_slot,
+      NGX_HTTP_LOC_CONF_OFFSET,
+      offsetof(ngx_http_memcached_loc_conf_t, gzip_flag),
+      NULL },
 
     { ngx_string("memcached_upstream_max_fails"),
@@ -298 +307 @@
 ngx_http_memcached_process_header(ngx_http_request_t *r)
 {
-    u_char                    *p, *len;
+    u_char                    *p, *beg;
     ngx_str_t                  line;
     ngx_http_upstream_t       *u;
     ngx_http_memcached_ctx_t  *ctx;
+    ngx_http_memcached_loc_conf_t  *mlcf;
+    uint32_t                   flags;
+    ngx_table_elt_t           *h;
+    ngx_http_core_loc_conf_t  *clcf;
 
     u = r->upstream;
@@ -346 +359 @@
         }
 
-        /* skip flags */
-
-        while (*p) {
-            if (*p++ == ' ') {
-                goto length;
-            }
+        beg = p;
+
+        while (*p && *p++ != ' ') { /* void */ }
+
+        if (! *p) {
+            goto no_valid;
         }
 
-        goto no_valid;
-
-    length:
-
-        len = p;
+        flags = ngx_atoof(beg, p - beg - 1);
+
+        beg = p;
 
         while (*p && *p++ != CR) { /* void */ }
 
-        r->headers_out.content_length_n = ngx_atoof(len, p - len - 1);
+        r->headers_out.content_length_n = ngx_atoof(beg, p - beg - 1);
         if (r->headers_out.content_length_n == -1) {
             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
@@ -369 +380 @@
                           &line, &ctx->key);
             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
+        }
+
+        mlcf = ngx_http_get_module_loc_conf(r, ngx_http_memcached_module);
+
+        if (flags & mlcf->gzip_flag) {
+#if (NGX_HTTP_GZIP)
+            clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
+
+            if (ngx_http_gzip_ok(r) == NGX_OK) {
+                h = ngx_list_push(&r->headers_out.headers);
+                if (h == NULL) {
+                    return NGX_ERROR;
+                }
+
+                h->hash = 1;
+                h->key.len = sizeof("Content-Encoding") - 1;
+                h->key.data = (u_char *) "Content-Encoding";
+                h->value.len = sizeof("gzip") - 1;
+                h->value.data = (u_char *) "gzip";
+
+                r->headers_out.content_encoding = h;
+
+                if (clcf->gzip_vary) {
+                    h = ngx_list_push(&r->headers_out.headers);
+                    if (h == NULL) {
+                        return NGX_ERROR;
+                    }
+
+                    h->hash = 1;
+                    h->key.len = sizeof("Vary") - 1;
+                    h->key.data = (u_char *) "Vary";
+                    h->value.len = sizeof("Accept-Encoding") - 1;
+                    h->value.data = (u_char *) "Accept-Encoding";
+                }
+            } else {
+                if (clcf->gunzip) {
+                    r->gunzip = 1;
+                } else {
+#endif
+                    /*
+                     * If the client can't accept compressed data, and
+                     * automatic decompression is not enabled, we
+                     * return 404 in the hope that the next upstream
+                     * will return uncompressed data.
+                     */
+                    u->headers_in.status_n = 404;
+                    u->state->status = 404;
+
+                    return NGX_OK;
+#if (NGX_HTTP_GZIP)
+                }
+            }
+#endif
         }
 
@@ -532 +596 @@
 
     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;
+
+    conf->gzip_flag = NGX_CONF_UNSET_UINT;
 
     /* the hardcoded values */
@@ -576 +642 @@
                                |NGX_HTTP_UPSTREAM_FT_TIMEOUT));
 
+    ngx_conf_merge_uint_value(conf->gzip_flag,
+                              prev->gzip_flag, 0);
+
     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET