diff --git a/perl/NGCP/Rtpengine/FakeRedis.pm b/perl/NGCP/Rtpengine/FakeRedis.pm index 00c6e2bde..bc15b3f8e 100644 --- a/perl/NGCP/Rtpengine/FakeRedis.pm +++ b/perl/NGCP/Rtpengine/FakeRedis.pm @@ -7,14 +7,18 @@ package NGCP::Rtpengine::FakeRedis; use strict; use warnings; use Socket qw(AF_INET SOCK_STREAM sockaddr_in inet_aton); +use File::Temp; use Test::More; use Time::HiRes qw(time sleep); +use IO::Select; +use POSIX (); use NGCP::Rtpengine::AutoTest; use Exporter 'import'; our @EXPORT = qw(redis_listen redis_accept redis_conn redis_read redis_send redis_expect redis_expect_set redis_expect_del redis_close redis_closed readable info_reply - redis_write_errors wait_log); + redis_write_errors wait_log + redis_serve redis_sets_seen redis_record_after redis_serve_next_get); my %rbuf; # what was read from each socket and not parsed yet @@ -158,6 +162,145 @@ sub redis_expect_del { redis_expect($fd, ['DEL', $id], $reply, "$n DEL"); } +# A fake Redis that answers every command, run in a forked child, for tests +# that cannot answer rtpengine's writes in step: the daemon also writes from +# the poller thread, and a write left unanswered blocks it. It keeps the SETs +# in a hash, answers GET and KEYS from it, and leaves files for the parent in +# a temporary directory: +# seq number of SETs answered +# last value of the most recent SET +# override if present, served in place of the next GET, then removed +# The listener stays open in the parent: under the preload's fake network, +# closing it there removes the socket the child accepts on. + +my ($serve_dir, $serve_pid); + +sub serve_write { + my ($path, $content) = @_; + open(my $fh, '>', "$path.tmp") or die "$path: $!"; + binmode($fh); + print $fh $content; + close($fh) or die; + rename("$path.tmp", $path) or die "$path: $!"; +} + +sub serve_read { + my ($path) = @_; + open(my $fh, '<', $path) or return; + binmode($fh); + local $/ = undef; + my $content = <$fh>; + close($fh); + return $content; +} + +sub serve_cmd { + my ($fh, $store, $sets, $c) = @_; + my $verb = uc($c->[0]); + if ($verb eq 'PING') { + redis_send($fh, "+PONG\r\n"); + } + elsif ($verb eq 'INFO') { + redis_send($fh, info_reply('master', short => 1)); + } + elsif ($verb eq 'TYPE') { + redis_send($fh, "+none\r\n"); + } + elsif ($verb eq 'KEYS') { + my @keys = keys %$store; + redis_send($fh, '*' . scalar(@keys) . "\r\n" . join('', map { bulk($_) } @keys)); + } + elsif ($verb eq 'GET') { + my $value = serve_read("$serve_dir/override"); + if (defined $value) { + unlink("$serve_dir/override"); + } + else { + $value = $store->{$c->[1]}; + } + redis_send($fh, defined($value) ? bulk($value) : "\$-1\r\n"); + } + elsif ($verb eq 'SET') { + $store->{$c->[1]} = $c->[2]; + serve_write("$serve_dir/last", $c->[2]); + serve_write("$serve_dir/seq", ++$$sets); + redis_send($fh, "+OK\r\n"); + } + elsif ($verb eq 'DEL') { + delete $store->{$c->[1]}; + redis_send($fh, ":1\r\n"); + } + else { + redis_send($fh, "+OK\r\n"); + } +} + +sub redis_serve { + my ($l) = @_; + $serve_dir = File::Temp::tempdir("fake-redis-XXXXXX", TMPDIR => 1, CLEANUP => 1); + serve_write("$serve_dir/seq", "0"); + $serve_pid = fork(); + defined($serve_pid) or die "cannot fork the fake Redis"; + return if $serve_pid; + + # the child leaves only through _exit(): a normal exit would run + # File::Temp's cleanup and remove the directory under the parent + $SIG{TERM} = sub { POSIX::_exit(0) }; ## no critic (Variables::RequireLocalizedPunctuationVars) + eval { serve_loop($l) }; + print STDERR "fake Redis: $@" if $@; + POSIX::_exit($@ ? 1 : 0); +} + +sub serve_loop { + my ($l) = @_; + my %store; + my $sets = 0; + my $select = IO::Select->new($l); + while (1) { + for my $fh ($select->can_read(1)) { + if ($fh == $l) { + my $client; + accept($client, $l) or next; + $rbuf{fileno($client)} = ''; + $select->add($client); + next; + } + # every complete command read, then wait for more + while (1) { + my $c = redis_read($fh, 60); + if (!$c) { + $select->remove($fh); + redis_close($fh); + last; + } + serve_cmd($fh, \%store, \$sets, $c); + last unless length($rbuf{fileno($fh)}); + } + } + } +} +END { kill('TERM', $serve_pid) if $serve_pid } + +sub redis_sets_seen { + return int(serve_read("$serve_dir/seq") // 0); +} + +# The daemon writes to Redis before it answers, so the record is normally there +# already; poll briefly to cover the child not having flushed it yet. +sub redis_record_after { + my ($before) = @_; + for (1 .. 500) { + return serve_read("$serve_dir/last") if redis_sets_seen() > $before; + sleep(0.01); + } + die 'no Redis update seen after the daemon answered'; +} + +sub redis_serve_next_get { + my ($record) = @_; + serve_write("$serve_dir/override", $record); +} + sub redis_write_errors { local $NGCP::Rtpengine::req_cb; my $resp = rtpe_req('statistics', 'statistics', { }); diff --git a/t/auto-daemon-tests-redis-json.pl b/t/auto-daemon-tests-redis-json.pl index bedc6aaa2..582fe94ba 100755 --- a/t/auto-daemon-tests-redis-json.pl +++ b/t/auto-daemon-tests-redis-json.pl @@ -5,9 +5,9 @@ use warnings; use NGCP::Rtpengine::Test; use NGCP::Rtpclient::SRTP; use NGCP::Rtpengine::AutoTest; +use NGCP::Rtpengine::FakeRedis; use Test::More; use Test2::Tools::Compare qw(); -use Socket qw(AF_INET SOCK_STREAM sockaddr_in pack_sockaddr_in inet_aton); use JSON; use Data::Dumper; @@ -15,41 +15,22 @@ $Data::Dumper::Sortkeys = 1; # fake Redis listener -my $redis_listener; -socket($redis_listener, AF_INET, SOCK_STREAM, 0) or die; -bind($redis_listener, sockaddr_in(6379, inet_aton('203.0.113.42'))) or die; -listen($redis_listener, 10) or die; - +my $redis_listener = redis_listen('203.0.113.42'); my $redis_fd; -sub redis_i { - my ($i, $n) = @_; - my $buf; - alarm(1); - recv($redis_fd, $buf, length($i), 0) or die; - alarm(0); - is($buf, $i, $n); -} -sub redis_io { - my ($i, $o, $n) = @_; - redis_i($i, $n); - send($redis_fd, $o, 0) or die; -}; - - $NGCP::Rtpengine::AutoTest::launch_cb = sub { # accept Redis connection and read preamble - accept($redis_fd, $redis_listener) or die; + $redis_fd = redis_accept($redis_listener); - redis_io("*2\r\n\$4\r\nAUTH\r\n\$4\r\nauth\r\n", "+OK\r\n", "AUTH"); - redis_io("*2\r\n\$6\r\nSELECT\r\n\$1\r\n2\r\n", "+OK\r\n", "SELECT 1"); - redis_io("*1\r\n\$4\r\nINFO\r\n", "\$13\r\nrole:master\r\n\r\n", "INFO"); - redis_io("*2\r\n\$4\r\nTYPE\r\n\$5\r\ncalls\r\n", "+none\r\n", "TYPE"); + redis_expect($redis_fd, ['AUTH', 'auth'], "+OK\r\n", "AUTH"); + redis_expect($redis_fd, ['SELECT', 2], "+OK\r\n", "SELECT 1"); + redis_expect($redis_fd, ['INFO'], info_reply('master', short => 1), "INFO"); + redis_expect($redis_fd, ['TYPE', 'calls'], "+none\r\n", "TYPE"); - redis_io("*1\r\n\$4\r\nPING\r\n", "+PONG\r\n", "PING"); - redis_io("*2\r\n\$4\r\nKEYS\r\n\$1\r\n*\r\n", "*0\r\n", "KEYS"); + redis_expect($redis_fd, ['PING'], "+PONG\r\n", "PING"); + redis_expect($redis_fd, ['KEYS', '*'], "*0\r\n", "KEYS"); }; @@ -63,36 +44,16 @@ autotest_start(qw(--config-file=none -t -1 -i foo/203.0.113.1 -i foo/2001:db8:43 my $json_exp; $NGCP::Rtpengine::req_cb = sub { - redis_io("*1\r\n\$4\r\nPING\r\n", "+PONG\r\n", "req PING"); - redis_i("*5\r\n\$3\r\nSET\r\n\$" . length(cid()) . "\r\n" . cid() . "\r\n\$", "req intro"); - # the length is however many digits it takes, and a record large enough to - # need more than one read is normal - my $buf = ''; - alarm(1); - while ($buf !~ /\r\n\z/) { - my $c; - defined(recv($redis_fd, $c, 1, 0)) or die; - $buf .= $c; - } - alarm(0); - ok($buf =~ /^\d+\r\n\z/, "record length"); - my $len = int($buf); - my $rec = ''; - alarm(5); - while (length($rec) < $len) { - my $chunk; - defined(recv($redis_fd, $chunk, $len - length($rec), 0)) or die; - length($chunk) or die "short read from redis socket"; - $rec .= $chunk; - } - alarm(0); - $buf = $rec; - my $json = decode_json($buf); + redis_expect($redis_fd, ['PING'], "+PONG\r\n", "req PING"); + # a record large enough to need more than one read is normal + my $c = redis_read($redis_fd); + is(join(' ', @$c[0, 1]), 'SET ' . cid(), "req intro"); + ok(@$c == 5 && length($c->[2]), "record length"); + my $json = decode_json($c->[2]); #print Dumper($json); Test2::Tools::Compare::like($json, $json_exp, "JSON"); - redis_io("\r\n\$2\r\nEX\r\n\$5\r\n86400\r\n", - "+OK\r\n", - "req EXPIRE"); + is(join(' ', @$c[3, 4]), 'EX 86400', "req EXPIRE"); + redis_send($redis_fd, "+OK\r\n"); }; diff --git a/t/auto-daemon-tests-redis-srtp-index.pl b/t/auto-daemon-tests-redis-srtp-index.pl index d76621834..7002e008f 100755 --- a/t/auto-daemon-tests-redis-srtp-index.pl +++ b/t/auto-daemon-tests-redis-srtp-index.pl @@ -13,193 +13,16 @@ use warnings; use Bencode; use JSON; use NGCP::Rtpengine::AutoTest; +use NGCP::Rtpengine::FakeRedis; use NGCP::Rtpclient::SRTP; -use File::Temp (); -use IO::Select; -use POSIX (); -use Socket qw(AF_INET SOCK_STREAM sockaddr_in inet_aton); use Test::More; -use Time::HiRes; my $redis_format = $ENV{RTPE_REDIS_FORMAT} // 'json'; -# Fake Redis server, run in a forked child. -# -# The daemon writes to Redis from the poller thread as well as after a signalling -# request, so a test servicing it only between requests eventually leaves a write -# unanswered, which blocks the daemon in redis_consume(). A separate process -# always answers; the parent reads what was stored through the files below. -# -# $state/seq number of SETs the child has serviced -# $state/last value of the most recent SET -# $state/override if present, served in place of the next GET, then removed - -my $redis_listener; -socket($redis_listener, AF_INET, SOCK_STREAM, 0) or die; -bind($redis_listener, sockaddr_in(6379, inet_aton('203.0.113.42'))) or die; -listen($redis_listener, 10) or die; - -my $state = File::Temp::tempdir("redis-srtp-index-XXXXXX", TMPDIR => 1, CLEANUP => 1); -write_file("$state/seq", "0"); - -sub write_file { - my ($path, $content) = @_; - open(my $fh, '>', "$path.tmp") or die "$path: $!"; - binmode($fh); - print $fh $content; - close($fh) or die; - rename("$path.tmp", $path) or die "$path: $!"; -} - -sub read_file { - my ($path) = @_; - open(my $fh, '<', $path) or return; - binmode($fh); - local $/ = undef; - my $content = <$fh>; - close($fh); - return $content; -} - -sub server_read_exact { - my ($fd, $len) = @_; - my $buf = ''; - while (length($buf) < $len) { - my $part; - defined(recv($fd, $part, $len - length($buf), 0)) or return; - length($part) or return; - $buf .= $part; - } - return $buf; -} - -sub server_read_line { - my ($fd) = @_; - my $buf = ''; - while ($buf !~ /\r\n\z/) { - my $byte = server_read_exact($fd, 1); - defined($byte) or return; - $buf .= $byte; - } - $buf =~ s/\r\n\z//; - return $buf; -} - -sub server_read_command { - my ($fd) = @_; - my $intro = server_read_line($fd); - (defined($intro) && $intro =~ /^\*(\d+)\z/) or return; - my @args; - for (1 .. $1) { - my $bulk = server_read_line($fd); - (defined($bulk) && $bulk =~ /^\$(\d+)\z/) or return; - my $arg = server_read_exact($fd, $1); - defined($arg) or return; - server_read_exact($fd, 2); - push @args, $arg; - } - return \@args; -} - -# Answer every command the daemon can send, so it is never left waiting. -sub redis_server { - my %store; - my $sets = 0; - my $select = IO::Select->new($redis_listener); - - while (1) { - for my $fh ($select->can_read(1)) { - if ($fh == $redis_listener) { - my $client; - accept($client, $redis_listener) or next; - $select->add($client); - next; - } - my $command = server_read_command($fh); - if (!$command) { - $select->remove($fh); - close($fh); - next; - } - my $verb = uc($command->[0]); - if ($verb eq 'PING') { - send($fh, "+PONG\r\n", 0); - } - elsif ($verb eq 'INFO') { - my $info = "role:master\r\n"; - send($fh, '$' . length($info) . "\r\n$info\r\n", 0); - } - elsif ($verb eq 'TYPE') { - send($fh, "+none\r\n", 0); - } - elsif ($verb eq 'KEYS') { - my @keys = keys %store; - my $reply = '*' . scalar(@keys) . "\r\n"; - $reply .= '$' . length($_) . "\r\n$_\r\n" for @keys; - send($fh, $reply, 0); - } - elsif ($verb eq 'GET') { - my $value = read_file("$state/override"); - if (defined $value) { - unlink("$state/override"); - } - else { - $value = $store{$command->[1]}; - } - if (defined $value) { - send($fh, '$' . length($value) . "\r\n$value\r\n", 0); - } - else { - send($fh, "\$-1\r\n", 0); - } - } - elsif ($verb eq 'SET') { - $store{$command->[1]} = $command->[2]; - write_file("$state/last", $command->[2]); - write_file("$state/seq", ++$sets); - send($fh, "+OK\r\n", 0); - } - elsif ($verb eq 'DEL') { - delete $store{$command->[1]}; - send($fh, ":1\r\n", 0); - } - else { - send($fh, "+OK\r\n", 0); - } - } - } -} - -my $redis_pid = fork(); -defined($redis_pid) or die "cannot fork Redis server"; -if (!$redis_pid) { - $SIG{TERM} = sub { POSIX::_exit(0) }; ## no critic (Variables::RequireLocalizedPunctuationVars) - redis_server(); - POSIX::_exit(0); -} -# The listener stays open here: under the preload's fake network, closing it in -# the parent removes the socket the child is accepting on. -END { kill('TERM', $redis_pid) if $redis_pid } - -sub redis_sets_seen { - return int(read_file("$state/seq") // 0); -} - -# The daemon writes to Redis before it answers, so the record is normally there -# already; poll briefly to cover the child not having flushed it yet. -sub redis_record_after { - my ($before) = @_; - for (1 .. 500) { - return read_file("$state/last") if redis_sets_seen() > $before; - Time::HiRes::sleep(0.01); - } - die 'no Redis update seen after the daemon answered'; -} - -sub serve_next_get { - my ($record) = @_; - write_file("$state/override", $record); -} +# Fake Redis server that answers every command, in a forked child: the +# daemon writes from the poller thread as well as after a signalling request. +my $redis_listener = redis_listen('203.0.113.42'); +redis_serve($redis_listener); sub decode_record { my ($record) = @_; @@ -338,7 +161,7 @@ is($srtp_ctx_a->{roc}, 1, 'receiver still at ROC 1'); my %legacy = %$decoded; delete @legacy{grep { /^ssrc_out_table-/ } keys %legacy}; NGCP::Rtpengine::AutoTest::shut_rtpe(); -serve_next_get(encode_record(\%legacy)); +redis_serve_next_get(encode_record(\%legacy)); autotest_start(@daemon_args) or die; $query = rtpe_req('query', 'query call restored from legacy record', { 'call-id' => $call_id }); @@ -359,7 +182,7 @@ $combined{$table_a} = [ { ssrc => $ssrc, in_srtp_index => 0, in_srtcp_index => 0 in_payload_type => 8, out_srtp_index => 0x10002, out_srtcp_index => 0, out_payload_type => 8 } ]; NGCP::Rtpengine::AutoTest::shut_rtpe(); -serve_next_get(encode_record(\%combined)); +redis_serve_next_get(encode_record(\%combined)); autotest_start(@daemon_args) or die; $query = rtpe_req('query', 'query call restored from combined record', { 'call-id' => $call_id }); diff --git a/t/auto-daemon-tests-redis-subscribe.pl b/t/auto-daemon-tests-redis-subscribe.pl index 18a57ecfc..3cda89c79 100755 --- a/t/auto-daemon-tests-redis-subscribe.pl +++ b/t/auto-daemon-tests-redis-subscribe.pl @@ -5,9 +5,9 @@ use warnings; use NGCP::Rtpengine::Test; use NGCP::Rtpclient::SRTP; use NGCP::Rtpengine::AutoTest; +use NGCP::Rtpengine::FakeRedis; use Test::More; use Test2::Tools::Compare qw(); -use Socket qw(AF_INET SOCK_STREAM sockaddr_in pack_sockaddr_in inet_aton); use Bencode; use Data::Dumper; @@ -15,174 +15,99 @@ $Data::Dumper::Sortkeys = 1; # fake Redis listener -my $redis_listener; -socket($redis_listener, AF_INET, SOCK_STREAM, 0) or die; -bind($redis_listener, sockaddr_in(6379, inet_aton('203.0.113.42'))) or die; -listen($redis_listener, 10) or die; +my $redis_listener = redis_listen('203.0.113.42'); my ($redis_fd, $redis_notify, $redis_subscribe); - -sub redis_rd { - my ($fd, $len) = @_; - my $buf; - alarm(1); - recv($fd, $buf, $len, 0) or die; - alarm(0); - return $buf; -} -sub redis_i { - my ($fd, $i, $n) = @_; - my $buf = redis_rd($fd, length($i)); - is($buf, $i, $n); -} -sub redis_io { - my ($fd, $i, $o, $n) = @_; - redis_i($fd, $i, $n); - send($fd, $o, 0) or die; -}; +my $info = info_reply('master', short => 1); $NGCP::Rtpengine::AutoTest::launch_cb = sub { # accept Redis connection and read preamble - accept($redis_fd, $redis_listener) or die; - - redis_io($redis_fd, "*1\r\n\$4\r\nPING\r\n", - "+PONG\r\n", - "PING 1"); - redis_io($redis_fd, "*2\r\n\$6\r\nSELECT\r\n\$1\r\n2\r\n", - "+OK\r\n", - "SELECT 1"); - redis_io($redis_fd, "*1\r\n\$4\r\nINFO\r\n", - "\$13\r\nrole:master\r\n\r\n", - "INFO 1"); - redis_io($redis_fd, "*2\r\n\$4\r\nTYPE\r\n\$5\r\ncalls\r\n", - "+none\r\n", - "TYPE 1"); + $redis_fd = redis_accept($redis_listener); + + redis_expect($redis_fd, ['PING'], "+PONG\r\n", "PING 1"); + redis_expect($redis_fd, ['SELECT', 2], "+OK\r\n", "SELECT 1"); + redis_expect($redis_fd, ['INFO'], $info, "INFO 1"); + redis_expect($redis_fd, ['TYPE', 'calls'], "+none\r\n", "TYPE 1"); # second FD, notification socket - accept($redis_notify, $redis_listener) or die; - - redis_io($redis_notify, "*1\r\n\$4\r\nPING\r\n", - "+PONG\r\n", - "PING 2"); - redis_io($redis_notify, "*2\r\n\$6\r\nSELECT\r\n\$1\r\n2\r\n", - "+OK\r\n", - "SELECT 2"); - redis_io($redis_notify, "*1\r\n\$4\r\nINFO\r\n", - "\$13\r\nrole:master\r\n\r\n", - "INFO 2"); - redis_io($redis_notify, "*2\r\n\$4\r\nTYPE\r\n\$5\r\ncalls\r\n", - "+none\r\n", - "TYPE 2"); + $redis_notify = redis_accept($redis_listener); + + redis_expect($redis_notify, ['PING'], "+PONG\r\n", "PING 2"); + redis_expect($redis_notify, ['SELECT', 2], "+OK\r\n", "SELECT 2"); + redis_expect($redis_notify, ['INFO'], $info, "INFO 2"); + redis_expect($redis_notify, ['TYPE', 'calls'], "+none\r\n", "TYPE 2"); # two more sockets from different threads - my @fds; - accept($fds[0], $redis_listener) or die; - accept($fds[1], $redis_listener) or die; + my @fds = (redis_accept($redis_listener), redis_accept($redis_listener)); # notification socket re-init - redis_io($redis_notify, "*1\r\n\$4\r\nPING\r\n", - "+PONG\r\n", - "PING 2+1"); - - for my $i (0, 1) { - my $fd = $fds[$i]; + redis_expect($redis_notify, ['PING'], "+PONG\r\n", "PING 2+1"); - my $s = redis_rd($fd, 10); + for my $fd (@fds) { + my $c = redis_read($fd); - if ($s eq "*2\r\n\$10\r\np") { + if ($c && $c->[0] eq 'psubscribe') { $redis_subscribe = $fd; - redis_io($fd, "subscribe\r\n\$16\r\n__keyspace\@3__:*\r\n", - "*3\r\n\$10\r\npsubscribe\r\n\$16\r\n__keyspace\@3__:*\r\n:1\r\n", - "psubscribe"); + is(join(' ', @$c), "psubscribe __keyspace\@3__:*", "psubscribe"); + redis_send($fd, "*3\r\n\$10\r\npsubscribe\r\n\$16\r\n__keyspace\@3__:*\r\n:1\r\n"); } - elsif ($s eq "*1\r\n\$4\r\nPI") { + elsif ($c && $c->[0] eq 'PING') { # dup restore socket - redis_io($fd, "NG\r\n", - "+PONG\r\n", - "PING 3"); - redis_io($fd, "*2\r\n\$6\r\nSELECT\r\n\$1\r\n2\r\n", - "+OK\r\n", - "SELECT 3"); - redis_io($fd, "*1\r\n\$4\r\nINFO\r\n", - "\$13\r\nrole:master\r\n\r\n", - "INFO 3"); - redis_io($fd, "*2\r\n\$4\r\nTYPE\r\n\$5\r\ncalls\r\n", - "+none\r\n", - "TYPE 3"); + is(join(' ', @$c), 'PING', "PING 3"); + redis_send($fd, "+PONG\r\n"); + redis_expect($fd, ['SELECT', 2], "+OK\r\n", "SELECT 3"); + redis_expect($fd, ['INFO'], $info, "INFO 3"); + redis_expect($fd, ['TYPE', 'calls'], "+none\r\n", "TYPE 3"); # check conn, select DB, get keys, reset DB - redis_io($fd, "*1\r\n\$4\r\nPING\r\n", - "+PONG\r\n", - "PING 4"); - redis_io($fd, "*2\r\n\$6\r\nSELECT\r\n\$1\r\n3\r\n", - "+OK\r\n", - "SELECT 4"); - redis_io($fd, "*2\r\n\$4\r\nKEYS\r\n\$1\r\n*\r\n", - "*0\r\n", - "KEYS 4"); - redis_io($fd, "*2\r\n\$6\r\nSELECT\r\n\$1\r\n2\r\n", - "+OK\r\n", - "SELECT 4+1"); + redis_expect($fd, ['PING'], "+PONG\r\n", "PING 4"); + redis_expect($fd, ['SELECT', 3], "+OK\r\n", "SELECT 4"); + redis_expect($fd, ['KEYS', '*'], "*0\r\n", "KEYS 4"); + redis_expect($fd, ['SELECT', 2], "+OK\r\n", "SELECT 4+1"); } } # restore from main socket - redis_io($redis_fd, "*1\r\n\$4\r\nPING\r\n", - "+PONG\r\n", - "PING 5"); - redis_io($redis_fd, "*2\r\n\$4\r\nKEYS\r\n\$1\r\n*\r\n", - "*1\r\n\$6\r\nbadown\r\n", - "KEYS 5"); + redis_expect($redis_fd, ['PING'], "+PONG\r\n", "PING 5"); + redis_expect($redis_fd, ['KEYS', '*'], "*1\r\n\$6\r\nbadown\r\n", "KEYS 5"); # one own record, which cannot be restored: the restore thread's own # connection reads it ... - my $restore_fd; - accept($restore_fd, $redis_listener) or die; - redis_io($restore_fd, "*1\r\n\$4\r\nPING\r\n", - "+PONG\r\n", - "PING 6"); - redis_io($restore_fd, "*2\r\n\$6\r\nSELECT\r\n\$1\r\n2\r\n", - "+OK\r\n", - "SELECT 6"); - redis_io($restore_fd, "*1\r\n\$4\r\nINFO\r\n", - "\$13\r\nrole:master\r\n\r\n", - "INFO 6"); - redis_io($restore_fd, "*2\r\n\$4\r\nTYPE\r\n\$5\r\ncalls\r\n", - "+none\r\n", - "TYPE 6"); - redis_io($restore_fd, "*2\r\n\$3\r\nGET\r\n\$6\r\nbadown\r\n", - "\$9\r\nnot-a-rec\r\n", - "GET 6"); + my $restore_fd = redis_accept($redis_listener); + redis_expect($restore_fd, ['PING'], "+PONG\r\n", "PING 6"); + redis_expect($restore_fd, ['SELECT', 2], "+OK\r\n", "SELECT 6"); + redis_expect($restore_fd, ['INFO'], $info, "INFO 6"); + redis_expect($restore_fd, ['TYPE', 'calls'], "+none\r\n", "TYPE 6"); + redis_expect($restore_fd, ['GET', 'badown'], "\$9\r\nnot-a-rec\r\n", "GET 6"); # ... and the record is deleted from our own DB on the write connection, # and on no other connection - redis_io($redis_fd, "*2\r\n\$3\r\nDEL\r\n\$6\r\nbadown\r\n", - ":1\r\n", - "DEL of an unrestorable own record"); - my $rin = ''; - vec($rin, fileno($redis_notify), 1) = 1; - my $buf = ''; - if (select(my $rout = $rin, undef, undef, 0.5) > 0) { - alarm(1); - recv($redis_notify, $buf, 1000, 0); - alarm(0); - send($redis_notify, ":1\r\n", 0); - } - is($buf, '', 'no DEL of an own record on the notification connection'); + redis_expect($redis_fd, ['DEL', 'badown'], ":1\r\n", "DEL of an unrestorable own record"); + is(no_command($redis_notify), '', 'no DEL of an own record on the notification connection'); }; +# whatever command comes within 0.5 s, answered so that the daemon does not +# wait; '' if none +sub no_command { + my ($fd) = @_; + return '' unless readable($fd, 0.5); + my $c = redis_read($fd, 1) or return ''; + redis_send($fd, ":1\r\n"); + return join(' ', @$c); +} + autotest_start(qw(--config-file=none -t -1 -i 203.0.113.1 -n 2223 -f -L 7 -E @@ -196,36 +121,16 @@ autotest_start(qw(--config-file=none -t -1 -i 203.0.113.1 my $json_exp; $NGCP::Rtpengine::req_cb = sub { - redis_io($redis_fd, "*1\r\n\$4\r\nPING\r\n", "+PONG\r\n", "req PING"); - redis_i($redis_fd, "*5\r\n\$3\r\nSET\r\n\$" . length(cid()) . "\r\n" . cid() . "\r\n\$", "req intro"); - # the length is however many digits it takes, and a record large enough to - # need more than one read is normal - my $buf = ''; - alarm(1); - while ($buf !~ /\r\n\z/) { - my $c; - defined(recv($redis_fd, $c, 1, 0)) or die; - $buf .= $c; - } - alarm(0); - ok($buf =~ /^\d+\r\n\z/, "record length"); - my $len = int($buf); - my $rec = ''; - alarm(5); - while (length($rec) < $len) { - my $chunk; - defined(recv($redis_fd, $chunk, $len - length($rec), 0)) or die; - length($chunk) or die "short read from redis socket"; - $rec .= $chunk; - } - alarm(0); - $buf = $rec; - my $json = Bencode::bdecode($buf, 1); + redis_expect($redis_fd, ['PING'], "+PONG\r\n", "req PING"); + # a record large enough to need more than one read is normal + my $c = redis_read($redis_fd); + is(join(' ', @$c[0, 1]), 'SET ' . cid(), "req intro"); + ok(@$c == 5 && length($c->[2]), "record length"); + my $json = Bencode::bdecode($c->[2], 1); #print Dumper($json); Test2::Tools::Compare::like($json, $json_exp, "JSON"); - redis_io($redis_fd, "\r\n\$2\r\nEX\r\n\$5\r\n86400\r\n", - "+OK\r\n", - "req outro"); + is(join(' ', @$c[3, 4]), 'EX 86400', "req outro"); + redis_send($redis_fd, "+OK\r\n"); }; @@ -792,17 +697,11 @@ my $dict = { }; my $bdict = Bencode::bencode($dict), -send($redis_subscribe, "*4\r\n\$8\r\npmessage\r\n\$16\r\n__keyspace\@3__:*\r\n\$21\r\n__keyspace\@3__:foobar\r\n\$3\r\nset\r\n", 0); - -redis_io($redis_notify, "*1\r\n\$4\r\nPING\r\n", - "+PONG\r\n", - "PING"); -redis_io($redis_notify, "*2\r\n\$6\r\nSELECT\r\n\$1\r\n3\r\n", - "+OK\r\n", - "SELECT"); -redis_io($redis_notify, "*2\r\n\$3\r\nGET\r\n\$6\r\nfoobar\r\n", - "\$" . length($bdict) . "\r\n$bdict\r\n", - "GET"); +redis_send($redis_subscribe, "*4\r\n\$8\r\npmessage\r\n\$16\r\n__keyspace\@3__:*\r\n\$21\r\n__keyspace\@3__:foobar\r\n\$3\r\nset\r\n"); + +redis_expect($redis_notify, ['PING'], "+PONG\r\n", "PING"); +redis_expect($redis_notify, ['SELECT', 3], "+OK\r\n", "SELECT"); +redis_expect($redis_notify, ['GET', 'foobar'], "\$" . length($bdict) . "\r\n$bdict\r\n", "GET"); sleep(1); # wait for call to be created @@ -830,29 +729,14 @@ is($resp->{calls}[0], cid(), 'call ID'); # foreign call whose record cannot be restored: the key belongs to its owner, # so a failed restore must not delete it, on either connection -send($redis_subscribe, "*4\r\n\$8\r\npmessage\r\n\$16\r\n__keyspace\@3__:*\r\n\$22\r\n__keyspace\@3__:badcall\r\n\$3\r\nset\r\n", 0); +redis_send($redis_subscribe, "*4\r\n\$8\r\npmessage\r\n\$16\r\n__keyspace\@3__:*\r\n\$22\r\n__keyspace\@3__:badcall\r\n\$3\r\nset\r\n"); -redis_io($redis_notify, "*1\r\n\$4\r\nPING\r\n", - "+PONG\r\n", - "PING"); -redis_io($redis_notify, "*2\r\n\$3\r\nGET\r\n\$7\r\nbadcall\r\n", - "\$9\r\nnot-a-rec\r\n", - "GET unrestorable"); +redis_expect($redis_notify, ['PING'], "+PONG\r\n", "PING"); +redis_expect($redis_notify, ['GET', 'badcall'], "\$9\r\nnot-a-rec\r\n", "GET unrestorable"); # nothing may follow on the write or the notification connection for my $fd ([$redis_fd, 'write connection'], [$redis_notify, 'notification connection']) { - my $rin = ''; - vec($rin, fileno($fd->[0]), 1) = 1; - my $n = select(my $rout = $rin, undef, undef, 0.5); - my $buf = ''; - if ($n > 0) { - alarm(1); - recv($fd->[0], $buf, 1000, 0); - alarm(0); - # unblock the daemon, which waits for a reply - send($fd->[0], ":1\r\n", 0); - } - is($buf, '', "no DEL of a foreign key on the $fd->[1]"); + is(no_command($fd->[0]), '', "no DEL of a foreign key on the $fd->[1]"); } $resp = rtpe_req('list', 'list', {}); diff --git a/t/auto-daemon-tests-redis.pl b/t/auto-daemon-tests-redis.pl index dd3c99294..b63e6a6a4 100755 --- a/t/auto-daemon-tests-redis.pl +++ b/t/auto-daemon-tests-redis.pl @@ -5,9 +5,9 @@ use warnings; use NGCP::Rtpengine::Test; use NGCP::Rtpclient::SRTP; use NGCP::Rtpengine::AutoTest; +use NGCP::Rtpengine::FakeRedis; use Test::More; use Test2::Tools::Compare qw(); -use Socket qw(AF_INET SOCK_STREAM sockaddr_in pack_sockaddr_in inet_aton); use Bencode; use Data::Dumper; @@ -15,41 +15,22 @@ $Data::Dumper::Sortkeys = 1; # fake Redis listener -my $redis_listener; -socket($redis_listener, AF_INET, SOCK_STREAM, 0) or die; -bind($redis_listener, sockaddr_in(6379, inet_aton('203.0.113.42'))) or die; -listen($redis_listener, 10) or die; - +my $redis_listener = redis_listen('203.0.113.42'); my $redis_fd; -sub redis_i { - my ($i, $n) = @_; - my $buf; - alarm(1); - recv($redis_fd, $buf, length($i), 0) or die; - alarm(0); - is($buf, $i, $n); -} -sub redis_io { - my ($i, $o, $n) = @_; - redis_i($i, $n); - send($redis_fd, $o, 0) or die; -}; - - $NGCP::Rtpengine::AutoTest::launch_cb = sub { # accept Redis connection and read preamble - accept($redis_fd, $redis_listener) or die; + $redis_fd = redis_accept($redis_listener); - redis_io("*2\r\n\$4\r\nAUTH\r\n\$4\r\nauth\r\n", "+OK\r\n", "AUTH"); - redis_io("*2\r\n\$6\r\nSELECT\r\n\$1\r\n2\r\n", "+OK\r\n", "SELECT 1"); - redis_io("*1\r\n\$4\r\nINFO\r\n", "\$13\r\nrole:master\r\n\r\n", "INFO"); - redis_io("*2\r\n\$4\r\nTYPE\r\n\$5\r\ncalls\r\n", "+none\r\n", "TYPE"); + redis_expect($redis_fd, ['AUTH', 'auth'], "+OK\r\n", "AUTH"); + redis_expect($redis_fd, ['SELECT', 2], "+OK\r\n", "SELECT 1"); + redis_expect($redis_fd, ['INFO'], info_reply('master', short => 1), "INFO"); + redis_expect($redis_fd, ['TYPE', 'calls'], "+none\r\n", "TYPE"); - redis_io("*1\r\n\$4\r\nPING\r\n", "+PONG\r\n", "PING"); - redis_io("*2\r\n\$4\r\nKEYS\r\n\$1\r\n*\r\n", "*0\r\n", "KEYS"); + redis_expect($redis_fd, ['PING'], "+PONG\r\n", "PING"); + redis_expect($redis_fd, ['KEYS', '*'], "*0\r\n", "KEYS"); }; @@ -62,36 +43,16 @@ autotest_start(qw(--config-file=none -t -1 -i foo/203.0.113.1 -i foo/2001:db8:43 my $json_exp; $NGCP::Rtpengine::req_cb = sub { - redis_io("*1\r\n\$4\r\nPING\r\n", "+PONG\r\n", "req PING"); - redis_i("*5\r\n\$3\r\nSET\r\n\$" . length(cid()) . "\r\n" . cid() . "\r\n\$", "req intro"); - # the length is however many digits it takes, and a record large enough to - # need more than one read is normal - my $buf = ''; - alarm(1); - while ($buf !~ /\r\n\z/) { - my $c; - defined(recv($redis_fd, $c, 1, 0)) or die; - $buf .= $c; - } - alarm(0); - ok($buf =~ /^\d+\r\n\z/, "record length"); - my $len = int($buf); - my $rec = ''; - alarm(5); - while (length($rec) < $len) { - my $chunk; - defined(recv($redis_fd, $chunk, $len - length($rec), 0)) or die; - length($chunk) or die "short read from redis socket"; - $rec .= $chunk; - } - alarm(0); - $buf = $rec; - my $json = Bencode::bdecode($buf, 1); + redis_expect($redis_fd, ['PING'], "+PONG\r\n", "req PING"); + # a record large enough to need more than one read is normal + my $c = redis_read($redis_fd); + is(join(' ', @$c[0, 1]), 'SET ' . cid(), "req intro"); + ok(@$c == 5 && length($c->[2]), "record length"); + my $json = Bencode::bdecode($c->[2], 1); #print Dumper($json); Test2::Tools::Compare::like($json, $json_exp, "JSON"); - redis_io("\r\n\$2\r\nEX\r\n\$5\r\n86400\r\n", - "+OK\r\n", - "req outro"); + is(join(' ', @$c[3, 4]), 'EX 86400', "req outro"); + redis_send($redis_fd, "+OK\r\n"); }; diff --git a/t/auto-daemon-tests-rollback-redis.pl b/t/auto-daemon-tests-rollback-redis.pl index 1fcf6a012..18f584c75 100644 --- a/t/auto-daemon-tests-rollback-redis.pl +++ b/t/auto-daemon-tests-rollback-redis.pl @@ -5,192 +5,15 @@ use warnings; use Bencode; use JSON; use NGCP::Rtpengine::AutoTest; -use File::Temp (); -use IO::Select; -use POSIX (); -use Socket qw(AF_INET SOCK_STREAM sockaddr_in inet_aton); +use NGCP::Rtpengine::FakeRedis; use Test::More; -use Time::HiRes; my $redis_format = $ENV{RTPE_REDIS_FORMAT} // 'json'; -# Fake Redis server, run in a forked child. -# -# The daemon writes to Redis from the poller thread as well as after a signalling -# request, so a test servicing it only between requests eventually leaves a write -# unanswered, which blocks the daemon in redis_consume(). A separate process -# always answers; the parent reads what was stored through the files below. -# -# $state/seq number of SETs the child has serviced -# $state/last value of the most recent SET -# $state/override if present, served in place of the next GET, then removed - -my $redis_listener; -socket($redis_listener, AF_INET, SOCK_STREAM, 0) or die; -bind($redis_listener, sockaddr_in(6379, inet_aton('203.0.113.42'))) or die; -listen($redis_listener, 10) or die; - -my $state = File::Temp::tempdir("rollback-redis-XXXXXX", TMPDIR => 1, CLEANUP => 1); -write_file("$state/seq", "0"); - -sub write_file { - my ($path, $content) = @_; - open(my $fh, '>', "$path.tmp") or die "$path: $!"; - binmode($fh); - print $fh $content; - close($fh) or die; - rename("$path.tmp", $path) or die "$path: $!"; -} - -sub read_file { - my ($path) = @_; - open(my $fh, '<', $path) or return; - binmode($fh); - local $/ = undef; - my $content = <$fh>; - close($fh); - return $content; -} - -sub server_read_exact { - my ($fd, $len) = @_; - my $buf = ''; - while (length($buf) < $len) { - my $part; - defined(recv($fd, $part, $len - length($buf), 0)) or return; - length($part) or return; - $buf .= $part; - } - return $buf; -} - -sub server_read_line { - my ($fd) = @_; - my $buf = ''; - while ($buf !~ /\r\n\z/) { - my $byte = server_read_exact($fd, 1); - defined($byte) or return; - $buf .= $byte; - } - $buf =~ s/\r\n\z//; - return $buf; -} - -sub server_read_command { - my ($fd) = @_; - my $intro = server_read_line($fd); - (defined($intro) && $intro =~ /^\*(\d+)\z/) or return; - my @args; - for (1 .. $1) { - my $bulk = server_read_line($fd); - (defined($bulk) && $bulk =~ /^\$(\d+)\z/) or return; - my $arg = server_read_exact($fd, $1); - defined($arg) or return; - server_read_exact($fd, 2); - push @args, $arg; - } - return \@args; -} - -# Answer every command the daemon can send, so it is never left waiting. -sub redis_server { - my %store; - my $sets = 0; - my $select = IO::Select->new($redis_listener); - - while (1) { - for my $fh ($select->can_read(1)) { - if ($fh == $redis_listener) { - my $client; - accept($client, $redis_listener) or next; - $select->add($client); - next; - } - my $command = server_read_command($fh); - if (!$command) { - $select->remove($fh); - close($fh); - next; - } - my $verb = uc($command->[0]); - if ($verb eq 'PING') { - send($fh, "+PONG\r\n", 0); - } - elsif ($verb eq 'INFO') { - my $info = "role:master\r\n"; - send($fh, '$' . length($info) . "\r\n$info\r\n", 0); - } - elsif ($verb eq 'TYPE') { - send($fh, "+none\r\n", 0); - } - elsif ($verb eq 'KEYS') { - my @keys = keys %store; - my $reply = '*' . scalar(@keys) . "\r\n"; - $reply .= '$' . length($_) . "\r\n$_\r\n" for @keys; - send($fh, $reply, 0); - } - elsif ($verb eq 'GET') { - my $value = read_file("$state/override"); - if (defined $value) { - unlink("$state/override"); - } - else { - $value = $store{$command->[1]}; - } - if (defined $value) { - send($fh, '$' . length($value) . "\r\n$value\r\n", 0); - } - else { - send($fh, "\$-1\r\n", 0); - } - } - elsif ($verb eq 'SET') { - $store{$command->[1]} = $command->[2]; - write_file("$state/last", $command->[2]); - write_file("$state/seq", ++$sets); - send($fh, "+OK\r\n", 0); - } - elsif ($verb eq 'DEL') { - delete $store{$command->[1]}; - send($fh, ":1\r\n", 0); - } - else { - send($fh, "+OK\r\n", 0); - } - } - } -} - -my $redis_pid = fork(); -defined($redis_pid) or die "cannot fork Redis server"; -if (!$redis_pid) { - $SIG{TERM} = sub { POSIX::_exit(0) }; ## no critic (Variables::RequireLocalizedPunctuationVars) - redis_server(); - POSIX::_exit(0); -} -# The listener stays open here: under the preload's fake network, closing it in -# the parent removes the socket the child is accepting on. -END { kill('TERM', $redis_pid) if $redis_pid } - -sub redis_sets_seen { - return int(read_file("$state/seq") // 0); -} - -# The daemon writes to Redis before it answers, so the record is normally there -# already; poll briefly to cover the child not having flushed it yet. -sub redis_record_after { - my ($before) = @_; - for (1 .. 500) { - return read_file("$state/last") if redis_sets_seen() > $before; - Time::HiRes::sleep(0.01); - } - die 'no Redis update seen after the daemon answered'; -} - -sub serve_next_get { - my ($record) = @_; - write_file("$state/override", $record); -} +# Fake Redis server that answers every command, in a forked child: the +# daemon writes from the poller thread as well as after a signalling request. +my $redis_listener = redis_listen('203.0.113.42'); +redis_serve($redis_listener); my ($expected_pending, $last_record); @@ -420,7 +243,7 @@ $response = redis_rtpe_req(0, 'rollback', 'rollback after committed state crosse is($response->{'rolled-back'}, 0, 'committed checkpoint remains consumed in Redis'); NGCP::Rtpengine::AutoTest::shut_rtpe(); -serve_next_get(checkpoint_with_invalid_field_type($pending_record)); +redis_serve_next_get(checkpoint_with_invalid_field_type($pending_record)); autotest_start(@daemon_args) or die; $query = rtpe_req('query', 'query call restored without invalid checkpoint', { 'call-id' => $call_id,