← Back to branch summary

~ubuntu-branches/ubuntu/quantal/nginx/quantal-security

« back to all changes in this revision

Viewing changes to debian/modules/nginx-lua/t/068-socket-keepalive.t

  • Committer: Package Import Robot
  • Author(s): Kartik Mistry, Cyril Lavier, Michael Lustfield, Kartik Mistry
  • Date: 2012-05-14 11:15:00 UTC
  • mfrom: (4.2.49 sid)
  • Revision ID: package-import@ubuntu.com-20120514111500-1y9ij7zulu9xnmry
Tags: 1.2.0-1
http://bugs.debian.org/670306
http://bugs.debian.org/664878
http://bugs.debian.org/664271
http://bugs.debian.org/673580
http://bugs.debian.org/672632
[Cyril Lavier]
* New upstream release. (Closes: #670306)
  + 1.2.x is stable release now.
* debian/modules/chunkin-nginx-module:
  + Updated chunkin-nginx-module to v0.23rc2-3-g85eca98.
* debian/modules/headers-more-module:
  + Updated headers-more-module to v0.17rc1-4-g33a82ed.
* debian/modules/nginx-development-kit:
  + Updated nginx-development-kit to v0.2.17-7-g24202b4.
* debian/modules/nginx-echo:
  + Updated nginx-echo to v0.38rc2-7-g080c0a1.
* debian/modules/nginx-lua:
  + Updated nginx-lua to v0.5.0rc25-5-g8d28785.
* debian/modules/nginx-upstream-fair:
  + Updated nginx-upstream-fair to a18b409.
* debian/modules/nginx-upload-progress:
  + Updated nginx-upload-progress to v0.9.0-0-ga788dea.
* debian/modules/naxsi:
  + Updated naxsi to 0.46
* debian/modules/README.Modules-versions:
  + Updated versions and URLs for modules.
* debian/naxsi-ui-extract, debian/naxsi-ui-intercept,
  debian/nginx-naxsi-ui.*, debian/naxsi-ui-extract.1,
  debian/naxsi-ui-intercept.1, debian/rules:
  + Added nginx-naxsi-ui package containing the learning daemon
    and the WebUI.
* debian/nginx-common.nginx.default, debian/nginx-common.nginx.init:
  + Renamed files to be compliant with the nginx-naxsi-ui package.
* debian/po:
  + Added needed files for using po-debconf.
  + Added French translation.
* debian/control:
  + Applied the modifications given after the review by Justin Rye.

[Michael Lustfield]
* debian/conf/uwsgi_params:
  + Added UWSGI_SCHEME to uwsgi_params. (Closes: #664878)
* debian/conf/sites-available/default:
  + Added allow directive for ipv6 localhost. (Closes: #664271)

[Kartik Mistry]
* debian/control:
  + wrap-and-sort.
* debian/copyright:
  + Added missing copyrights, minor formatting fixes.
* debian/nginx-common.nginx.init:
  + Added ulimit for restarts, Thanks to Daniel Roschka
    <danielroschka@phoenitydawn.de> for patch. (Closes: #673580)
* debian/conf/sites-available/default:
  + Added patch to fix deprecated "listen" directive, Thanks to
    Guillaume Plessis <gui@dotdeb.org> for patch. (Closes: #672632)

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/nginx-lua/t/068-socket-keepalive.t
 
1
# vim:set ft= ts=4 sw=4 et fdm=marker:
 
2
 
 
3
use lib 'lib';
 
4
use Test::Nginx::Socket;
 
5
 
 
6
repeat_each(2);
 
7
 
 
8
plan tests => repeat_each() * (blocks() * 5 + 10);
 
9
 
 
10
our $HtmlDir = html_dir;
 
11
 
 
12
$ENV{TEST_NGINX_CLIENT_PORT} ||= server_port();
 
13
$ENV{TEST_NGINX_MEMCACHED_PORT} ||= 11211;
 
14
#$ENV{TEST_NGINX_REDIS_PORT} ||= 6379;
 
15
 
 
16
$ENV{LUA_PATH} ||=
 
17
    '/usr/local/openresty-debug/lualib/?.lua;/usr/local/openresty/lualib/?.lua;;';
 
18
 
 
19
no_long_string();
 
20
#no_diff();
 
21
#log_level 'warn';
 
22
 
 
23
run_tests();
 
24
 
 
25
__DATA__
 
26
 
 
27
=== TEST 1: sanity
 
28
--- http_config eval
 
29
    "lua_package_path '$::HtmlDir/?.lua;./?.lua';"
 
30
--- config
 
31
    location /t {
 
32
        set $port $TEST_NGINX_MEMCACHED_PORT;
 
33
        content_by_lua '
 
34
            local test = require "test"
 
35
            local port = ngx.var.port
 
36
            test.go(port)
 
37
            test.go(port)
 
38
        ';
 
39
    }
 
40
--- user_files
 
41
>>> test.lua
 
42
module("test", package.seeall)
 
43
 
 
44
function go(port)
 
45
    local sock = ngx.socket.tcp()
 
46
    local ok, err = sock:connect("127.0.0.1", port)
 
47
    if not ok then
 
48
        ngx.say("failed to connect: ", err)
 
49
        return
 
50
    end
 
51
 
 
52
    ngx.say("connected: ", ok, ", reused: ", sock:getreusedtimes())
 
53
 
 
54
    local req = "flush_all\r\n"
 
55
 
 
56
    local bytes, err = sock:send(req)
 
57
    if not bytes then
 
58
        ngx.say("failed to send request: ", err)
 
59
        return
 
60
    end
 
61
    ngx.say("request sent: ", bytes)
 
62
 
 
63
    local line, err, part = sock:receive()
 
64
    if line then
 
65
        ngx.say("received: ", line)
 
66
 
 
67
    else
 
68
        ngx.say("failed to receive a line: ", err, " [", part, "]")
 
69
    end
 
70
 
 
71
    local ok, err = sock:setkeepalive()
 
72
    if not ok then
 
73
        ngx.say("failed to set reusable: ", err)
 
74
    end
 
75
end
 
76
--- request
 
77
GET /t
 
78
--- response_body_like
 
79
^connected: 1, reused: \d+
 
80
request sent: 11
 
81
received: OK
 
82
connected: 1, reused: [1-9]\d*
 
83
request sent: 11
 
84
received: OK
 
85
--- no_error_log eval
 
86
["[error]",
 
87
"lua socket keepalive: free connection pool for "]
 
88
--- error_log eval
 
89
qq{lua socket get keepalive peer: using connection
 
90
lua socket keepalive create connection pool for key "127.0.0.1:$ENV{TEST_NGINX_MEMCACHED_PORT}"
 
91
}
 
92
 
 
93
 
 
94
 
 
95
=== TEST 2: free up the whole connection pool if no active connections
 
96
--- http_config eval
 
97
    "lua_package_path '$::HtmlDir/?.lua;./?.lua';"
 
98
--- config
 
99
    location /t {
 
100
        set $port $TEST_NGINX_MEMCACHED_PORT;
 
101
        content_by_lua '
 
102
            local test = require "test"
 
103
            local port = ngx.var.port
 
104
            test.go(port, true)
 
105
            test.go(port, false)
 
106
        ';
 
107
    }
 
108
--- request
 
109
GET /t
 
110
--- user_files
 
111
>>> test.lua
 
112
module("test", package.seeall)
 
113
 
 
114
function go(port, keepalive)
 
115
    local sock = ngx.socket.tcp()
 
116
    local ok, err = sock:connect("127.0.0.1", port)
 
117
    if not ok then
 
118
        ngx.say("failed to connect: ", err)
 
119
        return
 
120
    end
 
121
 
 
122
    ngx.say("connected: ", ok, ", reused: ", sock:getreusedtimes())
 
123
 
 
124
    local req = "flush_all\r\n"
 
125
 
 
126
    local bytes, err = sock:send(req)
 
127
    if not bytes then
 
128
        ngx.say("failed to send request: ", err)
 
129
        return
 
130
    end
 
131
    ngx.say("request sent: ", bytes)
 
132
 
 
133
    local line, err, part = sock:receive()
 
134
    if line then
 
135
        ngx.say("received: ", line)
 
136
 
 
137
    else
 
138
        ngx.say("failed to receive a line: ", err, " [", part, "]")
 
139
    end
 
140
 
 
141
    if keepalive then
 
142
        local ok, err = sock:setkeepalive()
 
143
        if not ok then
 
144
            ngx.say("failed to set reusable: ", err)
 
145
        end
 
146
 
 
147
    else
 
148
        sock:close()
 
149
    end
 
150
end
 
151
--- response_body_like
 
152
^connected: 1, reused: \d+
 
153
request sent: 11
 
154
received: OK
 
155
connected: 1, reused: [1-9]\d*
 
156
request sent: 11
 
157
received: OK
 
158
--- no_error_log
 
159
[error]
 
160
--- error_log eval
 
161
["lua socket get keepalive peer: using connection",
 
162
"lua socket keepalive: free connection pool for "]
 
163
 
 
164
 
 
165
 
 
166
=== TEST 3: upstream sockets close prematurely
 
167
--- http_config eval
 
168
    "lua_package_path '$::HtmlDir/?.lua;./?.lua';"
 
169
--- config
 
170
   server_tokens off;
 
171
   keepalive_timeout 100ms;
 
172
   location /t {
 
173
        set $port $TEST_NGINX_CLIENT_PORT;
 
174
        content_by_lua '
 
175
            local port = ngx.var.port
 
176
 
 
177
            local sock = ngx.socket.tcp()
 
178
 
 
179
            local ok, err = sock:connect("127.0.0.1", port)
 
180
            if not ok then
 
181
                ngx.say("failed to connect: ", err)
 
182
                return
 
183
            end
 
184
 
 
185
            ngx.say("connected: ", ok)
 
186
 
 
187
            local req = "GET /foo HTTP/1.1\\r\\nHost: localhost\\r\\nConnection: keepalive\\r\\n\\r\\n"
 
188
 
 
189
            local bytes, err = sock:send(req)
 
190
            if not bytes then
 
191
                ngx.say("failed to send request: ", err)
 
192
                return
 
193
            end
 
194
 
 
195
            ngx.say("request sent: ", bytes)
 
196
 
 
197
            local reader = sock:receiveuntil("\\r\\n0\\r\\n\\r\\n")
 
198
            local data, err = reader()
 
199
 
 
200
            if not data then
 
201
                ngx.say("failed to receive response body: ", err)
 
202
                return
 
203
            end
 
204
 
 
205
            ngx.say("received response of ", #data, " bytes")
 
206
 
 
207
            local ok, err = sock:setkeepalive()
 
208
            if not ok then
 
209
                ngx.say("failed to set reusable: ", err)
 
210
            end
 
211
 
 
212
            ngx.location.capture("/sleep")
 
213
 
 
214
            ngx.say("done")
 
215
        ';
 
216
    }
 
217
 
 
218
    location /foo {
 
219
        echo foo;
 
220
    }
 
221
 
 
222
    location /sleep {
 
223
        echo_sleep 1;
 
224
    }
 
225
--- request
 
226
GET /t
 
227
--- response_body
 
228
connected: 1
 
229
request sent: 61
 
230
received response of 156 bytes
 
231
done
 
232
--- no_error_log
 
233
[error]
 
234
--- error_log eval
 
235
["lua socket keepalive close handler",
 
236
"lua socket keepalive: free connection pool for "]
 
237
--- timeout: 3
 
238
 
 
239
 
 
240
 
 
241
=== TEST 4: http keepalive
 
242
--- http_config eval
 
243
    "lua_package_path '$::HtmlDir/?.lua;./?.lua';"
 
244
--- config
 
245
   server_tokens off;
 
246
   location /t {
 
247
        keepalive_timeout 60s;
 
248
 
 
249
        set $port $TEST_NGINX_CLIENT_PORT;
 
250
        content_by_lua '
 
251
            local port = ngx.var.port
 
252
 
 
253
            local sock = ngx.socket.tcp()
 
254
 
 
255
            local ok, err = sock:connect("127.0.0.1", port)
 
256
            if not ok then
 
257
                ngx.say("failed to connect: ", err)
 
258
                return
 
259
            end
 
260
 
 
261
            ngx.say("connected: ", ok)
 
262
 
 
263
            local req = "GET /foo HTTP/1.1\\r\\nHost: localhost\\r\\nConnection: keepalive\\r\\n\\r\\n"
 
264
 
 
265
            local bytes, err = sock:send(req)
 
266
            if not bytes then
 
267
                ngx.say("failed to send request: ", err)
 
268
                return
 
269
            end
 
270
 
 
271
            ngx.say("request sent: ", bytes)
 
272
 
 
273
            local reader = sock:receiveuntil("\\r\\n0\\r\\n\\r\\n")
 
274
            local data, err = reader()
 
275
 
 
276
            if not data then
 
277
                ngx.say("failed to receive response body: ", err)
 
278
                return
 
279
            end
 
280
 
 
281
            ngx.say("received response of ", #data, " bytes")
 
282
 
 
283
            local ok, err = sock:setkeepalive()
 
284
            if not ok then
 
285
                ngx.say("failed to set reusable: ", err)
 
286
            end
 
287
 
 
288
            ngx.location.capture("/sleep")
 
289
 
 
290
            ngx.say("done")
 
291
        ';
 
292
    }
 
293
 
 
294
    location /foo {
 
295
        echo foo;
 
296
    }
 
297
 
 
298
    location /sleep {
 
299
        echo_sleep 1;
 
300
    }
 
301
--- request
 
302
GET /t
 
303
--- response_body
 
304
connected: 1
 
305
request sent: 61
 
306
received response of 156 bytes
 
307
done
 
308
--- no_error_log eval
 
309
["[error]",
 
310
"lua socket keepalive close handler: fd:",
 
311
"lua socket keepalive: free connection pool for "]
 
312
--- timeout: 4
 
313
 
 
314
 
 
315
 
 
316
=== TEST 5: lua_socket_keepalive_timeout
 
317
--- config
 
318
   server_tokens off;
 
319
   location /t {
 
320
       keepalive_timeout 60s;
 
321
       lua_socket_keepalive_timeout 100ms;
 
322
 
 
323
        set $port $TEST_NGINX_CLIENT_PORT;
 
324
        content_by_lua '
 
325
            local port = ngx.var.port
 
326
 
 
327
            local sock = ngx.socket.tcp()
 
328
 
 
329
            local ok, err = sock:connect("127.0.0.1", port)
 
330
            if not ok then
 
331
                ngx.say("failed to connect: ", err)
 
332
                return
 
333
            end
 
334
 
 
335
            ngx.say("connected: ", ok)
 
336
 
 
337
            local req = "GET /foo HTTP/1.1\\r\\nHost: localhost\\r\\nConnection: keepalive\\r\\n\\r\\n"
 
338
 
 
339
            local bytes, err = sock:send(req)
 
340
            if not bytes then
 
341
                ngx.say("failed to send request: ", err)
 
342
                return
 
343
            end
 
344
 
 
345
            ngx.say("request sent: ", bytes)
 
346
 
 
347
            local reader = sock:receiveuntil("\\r\\n0\\r\\n\\r\\n")
 
348
            local data, res = reader()
 
349
 
 
350
            if not data then
 
351
                ngx.say("failed to receive response body: ", err)
 
352
                return
 
353
            end
 
354
 
 
355
            ngx.say("received response of ", #data, " bytes")
 
356
 
 
357
            local ok, err = sock:setkeepalive()
 
358
            if not ok then
 
359
                ngx.say("failed to set reusable: ", err)
 
360
            end
 
361
 
 
362
            ngx.location.capture("/sleep")
 
363
 
 
364
            ngx.say("done")
 
365
        ';
 
366
    }
 
367
 
 
368
    location /foo {
 
369
        echo foo;
 
370
    }
 
371
 
 
372
    location /sleep {
 
373
        echo_sleep 1;
 
374
    }
 
375
--- request
 
376
GET /t
 
377
--- response_body
 
378
connected: 1
 
379
request sent: 61
 
380
received response of 156 bytes
 
381
done
 
382
--- no_error_log
 
383
[error]
 
384
--- error_log eval
 
385
["lua socket keepalive close handler",
 
386
"lua socket keepalive: free connection pool for ",
 
387
"lua socket keepalive timeout: 100 ms",
 
388
qr/lua socket connection pool size: 30\b/]
 
389
--- timeout: 4
 
390
 
 
391
 
 
392
 
 
393
=== TEST 6: lua_socket_pool_size
 
394
--- config
 
395
   server_tokens off;
 
396
   location /t {
 
397
       keepalive_timeout 60s;
 
398
       lua_socket_keepalive_timeout 100ms;
 
399
       lua_socket_pool_size 1;
 
400
 
 
401
        set $port $TEST_NGINX_CLIENT_PORT;
 
402
        content_by_lua '
 
403
            local port = ngx.var.port
 
404
 
 
405
            local sock = ngx.socket.tcp()
 
406
 
 
407
            local ok, err = sock:connect("127.0.0.1", port)
 
408
            if not ok then
 
409
                ngx.say("failed to connect: ", err)
 
410
                return
 
411
            end
 
412
 
 
413
            ngx.say("connected: ", ok)
 
414
 
 
415
            local req = "GET /foo HTTP/1.1\\r\\nHost: localhost\\r\\nConnection: keepalive\\r\\n\\r\\n"
 
416
 
 
417
            local bytes, err = sock:send(req)
 
418
            if not bytes then
 
419
                ngx.say("failed to send request: ", err)
 
420
                return
 
421
            end
 
422
 
 
423
            ngx.say("request sent: ", bytes)
 
424
 
 
425
            local reader = sock:receiveuntil("\\r\\n0\\r\\n\\r\\n")
 
426
            local data, res = reader()
 
427
 
 
428
            if not data then
 
429
                ngx.say("failed to receive response body: ", err)
 
430
                return
 
431
            end
 
432
 
 
433
            ngx.say("received response of ", #data, " bytes")
 
434
 
 
435
            local ok, err = sock:setkeepalive()
 
436
            if not ok then
 
437
                ngx.say("failed to set reusable: ", err)
 
438
            end
 
439
 
 
440
            ngx.location.capture("/sleep")
 
441
 
 
442
            ngx.say("done")
 
443
        ';
 
444
    }
 
445
 
 
446
    location /foo {
 
447
        echo foo;
 
448
    }
 
449
 
 
450
    location /sleep {
 
451
        echo_sleep 1;
 
452
    }
 
453
--- request
 
454
GET /t
 
455
--- response_body
 
456
connected: 1
 
457
request sent: 61
 
458
received response of 156 bytes
 
459
done
 
460
--- no_error_log
 
461
[error]
 
462
--- error_log eval
 
463
["lua socket keepalive close handler",
 
464
"lua socket keepalive: free connection pool for ",
 
465
"lua socket keepalive timeout: 100 ms",
 
466
qr/lua socket connection pool size: 1\b/]
 
467
--- timeout: 4
 
468
 
 
469
 
 
470
 
 
471
=== TEST 7: "lua_socket_keepalive_timeout 0" means unlimited
 
472
--- config
 
473
   server_tokens off;
 
474
   location /t {
 
475
       keepalive_timeout 60s;
 
476
       lua_socket_keepalive_timeout 0;
 
477
 
 
478
        set $port $TEST_NGINX_CLIENT_PORT;
 
479
        content_by_lua '
 
480
            local port = ngx.var.port
 
481
 
 
482
            local sock = ngx.socket.tcp()
 
483
 
 
484
            local ok, err = sock:connect("127.0.0.1", port)
 
485
            if not ok then
 
486
                ngx.say("failed to connect: ", err)
 
487
                return
 
488
            end
 
489
 
 
490
            ngx.say("connected: ", ok)
 
491
 
 
492
            local req = "GET /foo HTTP/1.1\\r\\nHost: localhost\\r\\nConnection: keepalive\\r\\n\\r\\n"
 
493
 
 
494
            local bytes, err = sock:send(req)
 
495
            if not bytes then
 
496
                ngx.say("failed to send request: ", err)
 
497
                return
 
498
            end
 
499
 
 
500
            ngx.say("request sent: ", bytes)
 
501
 
 
502
            local reader = sock:receiveuntil("\\r\\n0\\r\\n\\r\\n")
 
503
            local data, res = reader()
 
504
 
 
505
            if not data then
 
506
                ngx.say("failed to receive response body: ", err)
 
507
                return
 
508
            end
 
509
 
 
510
            ngx.say("received response of ", #data, " bytes")
 
511
 
 
512
            local ok, err = sock:setkeepalive()
 
513
            if not ok then
 
514
                ngx.say("failed to set reusable: ", err)
 
515
            end
 
516
 
 
517
            ngx.location.capture("/sleep")
 
518
 
 
519
            ngx.say("done")
 
520
        ';
 
521
    }
 
522
 
 
523
    location /foo {
 
524
        echo foo;
 
525
    }
 
526
 
 
527
    location /sleep {
 
528
        echo_sleep 1;
 
529
    }
 
530
--- request
 
531
GET /t
 
532
--- response_body
 
533
connected: 1
 
534
request sent: 61
 
535
received response of 156 bytes
 
536
done
 
537
--- no_error_log
 
538
[error]
 
539
--- error_log eval
 
540
["lua socket keepalive timeout: unlimited",
 
541
qr/lua socket connection pool size: 30\b/]
 
542
--- timeout: 4
 
543
 
 
544
 
 
545
 
 
546
=== TEST 8: setkeepalive(timeout) overrides lua_socket_keepalive_timeout
 
547
--- config
 
548
   server_tokens off;
 
549
   location /t {
 
550
        keepalive_timeout 60s;
 
551
        lua_socket_keepalive_timeout 60s;
 
552
 
 
553
        set $port $TEST_NGINX_CLIENT_PORT;
 
554
        content_by_lua '
 
555
            local port = ngx.var.port
 
556
 
 
557
            local sock = ngx.socket.tcp()
 
558
 
 
559
            local ok, err = sock:connect("127.0.0.1", port)
 
560
            if not ok then
 
561
                ngx.say("failed to connect: ", err)
 
562
                return
 
563
            end
 
564
 
 
565
            ngx.say("connected: ", ok)
 
566
 
 
567
            local req = "GET /foo HTTP/1.1\\r\\nHost: localhost\\r\\nConnection: keepalive\\r\\n\\r\\n"
 
568
 
 
569
            local bytes, err = sock:send(req)
 
570
            if not bytes then
 
571
                ngx.say("failed to send request: ", err)
 
572
                return
 
573
            end
 
574
 
 
575
            ngx.say("request sent: ", bytes)
 
576
 
 
577
            local reader = sock:receiveuntil("\\r\\n0\\r\\n\\r\\n")
 
578
            local data, res = reader()
 
579
 
 
580
            if not data then
 
581
                ngx.say("failed to receive response body: ", err)
 
582
                return
 
583
            end
 
584
 
 
585
            ngx.say("received response of ", #data, " bytes")
 
586
 
 
587
            local ok, err = sock:setkeepalive(123)
 
588
            if not ok then
 
589
                ngx.say("failed to set reusable: ", err)
 
590
            end
 
591
 
 
592
            ngx.location.capture("/sleep")
 
593
 
 
594
            ngx.say("done")
 
595
        ';
 
596
    }
 
597
 
 
598
    location /foo {
 
599
        echo foo;
 
600
    }
 
601
 
 
602
    location /sleep {
 
603
        echo_sleep 1;
 
604
    }
 
605
--- request
 
606
GET /t
 
607
--- response_body
 
608
connected: 1
 
609
request sent: 61
 
610
received response of 156 bytes
 
611
done
 
612
--- no_error_log
 
613
[error]
 
614
--- error_log eval
 
615
["lua socket keepalive close handler",
 
616
"lua socket keepalive: free connection pool for ",
 
617
"lua socket keepalive timeout: 123 ms",
 
618
qr/lua socket connection pool size: 30\b/]
 
619
--- timeout: 4
 
620
 
 
621
 
 
622
 
 
623
=== TEST 9: sock:setkeepalive(timeout, size) overrides lua_socket_pool_size
 
624
--- config
 
625
   server_tokens off;
 
626
   location /t {
 
627
       keepalive_timeout 60s;
 
628
       lua_socket_keepalive_timeout 100ms;
 
629
       lua_socket_pool_size 100;
 
630
 
 
631
        set $port $TEST_NGINX_CLIENT_PORT;
 
632
        content_by_lua '
 
633
            local port = ngx.var.port
 
634
 
 
635
            local sock = ngx.socket.tcp()
 
636
 
 
637
            local ok, err = sock:connect("127.0.0.1", port)
 
638
            if not ok then
 
639
                ngx.say("failed to connect: ", err)
 
640
                return
 
641
            end
 
642
 
 
643
            ngx.say("connected: ", ok)
 
644
 
 
645
            local req = "GET /foo HTTP/1.1\\r\\nHost: localhost\\r\\nConnection: keepalive\\r\\n\\r\\n"
 
646
 
 
647
            local bytes, err = sock:send(req)
 
648
            if not bytes then
 
649
                ngx.say("failed to send request: ", err)
 
650
                return
 
651
            end
 
652
 
 
653
            ngx.say("request sent: ", bytes)
 
654
 
 
655
            local reader = sock:receiveuntil("\\r\\n0\\r\\n\\r\\n")
 
656
            local data, res = reader()
 
657
 
 
658
            if not data then
 
659
                ngx.say("failed to receive response body: ", err)
 
660
                return
 
661
            end
 
662
 
 
663
            ngx.say("received response of ", #data, " bytes")
 
664
 
 
665
            local ok, err = sock:setkeepalive(101, 25)
 
666
            if not ok then
 
667
                ngx.say("failed to set reusable: ", err)
 
668
            end
 
669
 
 
670
            ngx.location.capture("/sleep")
 
671
 
 
672
            ngx.say("done")
 
673
        ';
 
674
    }
 
675
 
 
676
    location /foo {
 
677
        echo foo;
 
678
    }
 
679
 
 
680
    location /sleep {
 
681
        echo_sleep 1;
 
682
    }
 
683
--- request
 
684
GET /t
 
685
--- response_body
 
686
connected: 1
 
687
request sent: 61
 
688
received response of 156 bytes
 
689
done
 
690
--- no_error_log
 
691
[error]
 
692
--- error_log eval
 
693
["lua socket keepalive close handler",
 
694
"lua socket keepalive: free connection pool for ",
 
695
"lua socket keepalive timeout: 101 ms",
 
696
qr/lua socket connection pool size: 25\b/]
 
697
--- timeout: 4
 
698
 
 
699
 
 
700
 
 
701
=== TEST 10: sock:keepalive_timeout(0) means unlimited
 
702
--- config
 
703
   server_tokens off;
 
704
   location /t {
 
705
       keepalive_timeout 60s;
 
706
       lua_socket_keepalive_timeout 1000ms;
 
707
 
 
708
        set $port $TEST_NGINX_CLIENT_PORT;
 
709
        content_by_lua '
 
710
            local port = ngx.var.port
 
711
 
 
712
            local sock = ngx.socket.tcp()
 
713
 
 
714
            local ok, err = sock:connect("127.0.0.1", port)
 
715
            if not ok then
 
716
                ngx.say("failed to connect: ", err)
 
717
                return
 
718
            end
 
719
 
 
720
            ngx.say("connected: ", ok)
 
721
 
 
722
            local req = "GET /foo HTTP/1.1\\r\\nHost: localhost\\r\\nConnection: keepalive\\r\\n\\r\\n"
 
723
 
 
724
            local bytes, err = sock:send(req)
 
725
            if not bytes then
 
726
                ngx.say("failed to send request: ", err)
 
727
                return
 
728
            end
 
729
 
 
730
            ngx.say("request sent: ", bytes)
 
731
 
 
732
            local reader = sock:receiveuntil("\\r\\n0\\r\\n\\r\\n")
 
733
            local data, res = reader()
 
734
 
 
735
            if not data then
 
736
                ngx.say("failed to receive response body: ", err)
 
737
                return
 
738
            end
 
739
 
 
740
            ngx.say("received response of ", #data, " bytes")
 
741
 
 
742
            local ok, err = sock:setkeepalive(0)
 
743
            if not ok then
 
744
                ngx.say("failed to set reusable: ", err)
 
745
            end
 
746
 
 
747
            ngx.location.capture("/sleep")
 
748
 
 
749
            ngx.say("done")
 
750
        ';
 
751
    }
 
752
 
 
753
    location /foo {
 
754
        echo foo;
 
755
    }
 
756
 
 
757
    location /sleep {
 
758
        echo_sleep 1;
 
759
    }
 
760
--- request
 
761
GET /t
 
762
--- response_body
 
763
connected: 1
 
764
request sent: 61
 
765
received response of 156 bytes
 
766
done
 
767
--- no_error_log
 
768
[error]
 
769
--- error_log eval
 
770
["lua socket keepalive timeout: unlimited",
 
771
qr/lua socket connection pool size: 30\b/]
 
772
--- timeout: 4
 
773
 
 
774
 
 
775
 
 
776
=== TEST 11: sanity (uds)
 
777
--- http_config eval
 
778
"
 
779
    lua_package_path '$::HtmlDir/?.lua;./?.lua';
 
780
    server {
 
781
        listen unix:/tmp/test-nginx.sock;
 
782
        default_type 'text/plain';
 
783
 
 
784
        server_tokens off;
 
785
        location /foo {
 
786
            echo foo;
 
787
            more_clear_headers Date;
 
788
        }
 
789
    }
 
790
"
 
791
--- config
 
792
    location /t {
 
793
        set $port $TEST_NGINX_MEMCACHED_PORT;
 
794
        content_by_lua '
 
795
            local test = require "test"
 
796
            local port = ngx.var.port
 
797
            test.go(port)
 
798
            test.go(port)
 
799
        ';
 
800
    }
 
801
--- request
 
802
GET /t
 
803
--- user_files
 
804
>>> test.lua
 
805
module("test", package.seeall)
 
806
 
 
807
function go(port)
 
808
    local sock = ngx.socket.tcp()
 
809
    local ok, err = sock:connect("unix:/tmp/test-nginx.sock")
 
810
    if not ok then
 
811
        ngx.say("failed to connect: ", err)
 
812
        return
 
813
    end
 
814
 
 
815
    ngx.say("connected: ", ok, ", reused: ", sock:getreusedtimes())
 
816
 
 
817
    local req = "GET /foo HTTP/1.1\r\nHost: localhost\r\nConnection: keepalive\r\n\r\n"
 
818
 
 
819
    local bytes, err = sock:send(req)
 
820
    if not bytes then
 
821
        ngx.say("failed to send request: ", err)
 
822
        return
 
823
    end
 
824
    ngx.say("request sent: ", bytes)
 
825
 
 
826
    local reader = sock:receiveuntil("\r\n0\r\n\r\n")
 
827
    local data, err = reader()
 
828
 
 
829
    if not data then
 
830
        ngx.say("failed to receive response body: ", err)
 
831
        return
 
832
    end
 
833
 
 
834
    ngx.say("received response of ", #data, " bytes")
 
835
 
 
836
    local ok, err = sock:setkeepalive()
 
837
    if not ok then
 
838
        ngx.say("failed to set reusable: ", err)
 
839
    end
 
840
end
 
841
--- response_body_like
 
842
^connected: 1, reused: \d+
 
843
request sent: 61
 
844
received response of 119 bytes
 
845
connected: 1, reused: [1-9]\d*
 
846
request sent: 61
 
847
received response of 119 bytes
 
848
--- no_error_log eval
 
849
["[error]",
 
850
"lua socket keepalive: free connection pool for "]
 
851
--- error_log eval
 
852
["lua socket get keepalive peer: using connection",
 
853
'lua socket keepalive create connection pool for key "unix:/tmp/test-nginx.sock"']
 
854
 
 
855
 
 
856
 
 
857
=== TEST 12: github issue #108: ngx.locaiton.capture + redis.set_keepalive
 
858
--- http_config eval
 
859
    qq{
 
860
        lua_package_path "$::HtmlDir/?.lua;;";
 
861
    }
 
862
--- config
 
863
    location /t {
 
864
        default_type text/html;
 
865
        set $port $TEST_NGINX_MEMCACHED_PORT;
 
866
        #lua_code_cache off;
 
867
        lua_need_request_body on;
 
868
        content_by_lua_file html/t.lua;
 
869
    }
 
870
 
 
871
    location /anyurl {
 
872
        internal;
 
873
        proxy_pass http://127.0.0.1:$server_port/dummy;
 
874
    }
 
875
 
 
876
    location = /dummy {
 
877
        echo dummy;
 
878
    }
 
879
--- user_files
 
880
>>> t.lua
 
881
local sock, err = ngx.socket.connect("127.0.0.1", ngx.var.port)
 
882
if not sock then ngx.say(err) return end
 
883
sock:send("flush_all\r\n")
 
884
sock:receive()
 
885
sock:setkeepalive()
 
886
 
 
887
sock, err = ngx.socket.connect("127.0.0.1", ngx.var.port)
 
888
if not sock then ngx.say(err) return end
 
889
local res = ngx.location.capture("/anyurl") --3
 
890
 
 
891
ngx.say("ok")
 
892
--- request
 
893
    GET /t
 
894
--- response_body
 
895
ok
 
896
--- error_log
 
897
lua socket get keepalive peer: using connection
 
898
--- no_error_log
 
899
[error]
 
900
[alert]
 
901