blob: 79da91bb86b3238a675094c9f48f1eb343c1c817 [file] [log] [blame]
#!/usr/bin/perl
# (C) Nginx, Inc.
# (C) Sergey Kandaurov
# Tests for stream upstream module with max_conns feature.
###############################################################################
use warnings;
use strict;
use Test::More;
use IO::Select;
BEGIN { use FindBin; chdir($FindBin::Bin); }
use lib 'lib';
use Test::Nginx qw/ :DEFAULT http_end /;
###############################################################################
select STDERR; $| = 1;
select STDOUT; $| = 1;
my $t = Test::Nginx->new()->has(qw/stream stream_upstream_least_conn/)
->has(qw/stream_upstream_hash/)->plan(14);
$t->write_file_expand('nginx.conf', <<'EOF');
%%TEST_GLOBALS%%
daemon off;
events {
}
stream {
%%TEST_GLOBALS_STREAM%%
upstream u_unlim {
server 127.0.0.1:8081 max_conns=0;
server 127.0.0.1:8082;
}
upstream u_lim {
server 127.0.0.1:8081 max_conns=3;
}
upstream u_backup {
server 127.0.0.1:8081 max_conns=2;
server 127.0.0.1:8082 backup;
}
upstream u_backup_lim {
server 127.0.0.1:8081 max_conns=2;
server 127.0.0.1:8082 backup max_conns=3;
}
upstream u_two {
server 127.0.0.1:8081 max_conns=1;
server 127.0.0.1:8082 max_conns=1;
}
upstream u_some {
server 127.0.0.1:8081 max_conns=1;
server 127.0.0.1:8082;
}
upstream u_many {
server 127.0.0.1:8081 max_conns=1;
server 127.0.0.1:8081 max_conns=1;
server 127.0.0.1:8082;
}
upstream u_weight {
server 127.0.0.1:8081 weight=2 max_conns=1;
server 127.0.0.1:8082;
}
upstream u_lc {
least_conn;
server 127.0.0.1:8081 max_conns=1;
server 127.0.0.1:8082;
}
upstream u_lc_backup {
least_conn;
server 127.0.0.1:8081 max_conns=2;
server 127.0.0.1:8082 backup;
}
upstream u_lc_backup_lim {
least_conn;
server 127.0.0.1:8081 max_conns=2;
server 127.0.0.1:8082 backup max_conns=3;
}
upstream u_hash {
hash $remote_addr;
server 127.0.0.1:8081 max_conns=1;
server 127.0.0.1:8082 max_conns=2;
}
upstream u_chash {
hash $remote_addr consistent;
server 127.0.0.1:8081 max_conns=1;
server 127.0.0.1:8082 max_conns=2;
}
server {
listen 127.0.0.1:8086;
proxy_pass u_unlim;
}
server {
listen 127.0.0.1:8087;
proxy_pass u_lim;
}
server {
listen 127.0.0.1:8088;
proxy_pass u_backup;
}
server {
listen 127.0.0.1:8089;
proxy_pass u_backup_lim;
}
server {
listen 127.0.0.1:8090;
proxy_pass u_two;
}
server {
listen 127.0.0.1:8091;
proxy_pass u_some;
}
server {
listen 127.0.0.1:8092;
proxy_pass u_many;
}
server {
listen 127.0.0.1:8093;
proxy_pass u_weight;
}
server {
listen 127.0.0.1:8094;
proxy_pass u_lc;
}
server {
listen 127.0.0.1:8095;
proxy_pass u_lc_backup;
}
server {
listen 127.0.0.1:8096;
proxy_pass u_lc_backup_lim;
}
server {
listen 127.0.0.1:8097;
proxy_pass u_hash;
}
server {
listen 127.0.0.1:8098;
proxy_pass u_chash;
}
}
EOF
$t->run_daemon(\&http_daemon, port(8081), port(8082), port(8085));
$t->run();
$t->waitforsocket('127.0.0.1:' . port(8081));
$t->waitforsocket('127.0.0.1:' . port(8082));
$t->waitforsocket('127.0.0.1:' . port(8085));
###############################################################################
my @ports = my ($p1, $p2) = (port(8081), port(8082));
# two peers without max_conns
is(parallel(8086, '/u_unlim?delay=0', 4), "$p1: 2, $p2: 2", 'unlimited');
# reopen connection to test connection subtraction
my @s = http_get_multi(8087, '/u_lim', 2, 1.1);
get(8087, '/close');
push @s, http_get_multi(8087, '/u_lim', 1, 1.1);
get(8085, '/closeall');
is(http_end_multi(\@s), "$p1: 3", 'conn subtraction');
# simple test with limited peer
is(parallel(8087, '/u_lim', 4), "$p1: 3", 'single');
# limited peer with backup peer
is(peers(8088, '/u_backup', 6), "$p1 $p1 $p2 $p2 $p2 $p2", 'backup');
# peer and backup peer, both limited
is(peers(8089, '/u_backup_lim', 6), "$p1 $p1 $p2 $p2 $p2 ", 'backup limited');
# all peers limited
is(parallel(8090, '/u_two', 4), "$p1: 1, $p2: 1", 'all peers');
# subset of peers limited
is(parallel(8091, '/u_some', 4), "$p1: 1, $p2: 3", 'some peers');
# ensure that peer "weight" does not affect its max_conns limit
is(parallel(8093, '/u_weight', 4), "$p1: 1, $p2: 3", 'weight');
# peers with equal server value aggregate max_conns limit
is(parallel(8092, '/u_many', 6), "$p1: 2, $p2: 4", 'equal peer');
# least_conn balancer tests
is(parallel(8094, '/u_lc', 4), "$p1: 1, $p2: 3", 'least_conn');
is(peers(8095, '/u_lc_backup', 6), "$p1 $p1 $p2 $p2 $p2 $p2",
'least_conn backup');
is(peers(8096, '/u_lc_backup_lim', 6), "$p1 $p1 $p2 $p2 $p2 ",
'least_conn backup limited');
# hash balancer tests
is(parallel(8097, '/u_hash', 4), "$p1: 1, $p2: 2", 'hash');
is(parallel(8098, '/u_chash', 4), "$p1: 1, $p2: 2", 'hash consistent');
###############################################################################
sub peers {
my ($port, $uri, $count) = @_;
my @sockets = http_get_multi($port, $uri, $count, 1.1);
get(8085, '/closeall');
join ' ', map { defined $_ && /X-Port: (\d+)/ && $1 }
map { http_end $_ } (@sockets);
}
sub parallel {
my ($port, $uri, $count) = @_;
my @sockets = http_get_multi($port, $uri, $count);
for (1 .. 20) {
last if IO::Select->new(@sockets)->can_read(3) == $count;
select undef, undef, undef, 0.01;
}
get(8085, '/closeall');
return http_end_multi(\@sockets);
}
sub get {
my ($port, $uri, %opts) = @_;
my $s = IO::Socket::INET->new(
Proto => 'tcp',
PeerAddr => '127.0.0.1',
PeerPort => port($port),
)
or die "Can't connect to nginx: $!\n";
http_get($uri, socket => $s, %opts);
}
sub http_get_multi {
my ($port, $uri, $count, $wait) = @_;
my @sockets;
for (0 .. $count - 1) {
$sockets[$_] = get($port, $uri, start => 1);
IO::Select->new($sockets[$_])->can_read($wait) if $wait;
}
return @sockets;
}
sub http_end_multi {
my ($sockets) = @_;
my %ports;
for my $sock (@$sockets) {
my $r = http_end($sock);
if ($r && $r =~ /X-Port: (\d+)/) {
$ports{$1} = 0 unless defined $ports{$1};
$ports{$1}++;
}
close $sock;
}
my @keys = map { my $p = $_; grep { $p == $_ } keys %ports } @ports;
return join ', ', map { $_ . ": " . $ports{$_} } @keys;
}
###############################################################################
sub http_daemon {
my (@ports) = @_;
my (@socks, @clients);
for my $port (@ports) {
my $server = IO::Socket::INET->new(
Proto => 'tcp',
LocalHost => "127.0.0.1:$port",
Listen => 42,
Reuse => 1
)
or die "Can't create listening socket: $!\n";
push @socks, $server;
}
my $sel = IO::Select->new(@socks);
my $skip = 4;
my $count = 0;
local $SIG{PIPE} = 'IGNORE';
OUTER:
while (my @ready = $sel->can_read) {
foreach my $fh (@ready) {
if (grep $_ == $fh, @socks) {
my $new = $fh->accept;
$new->autoflush(1);
$sel->add($new);
$count++;
} else {
my @busy = grep { $_->sockport() } @ready;
# finish other handles
if ($fh->sockport() == port(8085) && @busy > 1
&& grep $_->sockport() != port(8085),
@busy)
{
next;
}
# late events in other handles
if ($fh->sockport() == port(8085) && @busy == 1
&& $count > 1 && $skip-- > 0)
{
select undef, undef, undef, 0.1;
next OUTER;
}
my $rv = process_socket($fh, \@clients);
if ($rv == 1) {
$sel->remove($fh);
$fh->close;
}
if ($rv == 2) {
for (@clients) {
$sel->remove($_);
$_->close;
}
$sel->remove($fh);
$fh->close;
$skip = 4;
}
$count--;
}
}
}
}
# Returns true to close connection
sub process_socket {
my ($client, $saved) = @_;
my $port = $client->sockport();
my $headers = '';
my $uri = '';
while (<$client>) {
$headers .= $_;
last if (/^\x0d?\x0a?$/);
}
return 1 if $headers eq '';
$uri = $1 if $headers =~ /^\S+\s+([^ ]+)\s+HTTP/i;
return 1 if $uri eq '';
Test::Nginx::log_core('||', "$port: response, 200");
print $client <<EOF;
HTTP/1.1 200 OK
X-Port: $port
OK
EOF
return 2 if $uri =~ /closeall/;
return 1 if $uri =~ /close/;
push @$saved, $client;
return 0;
}
###############################################################################