MT#55283 redis: use FakeRedis.pm in the older Redis tests

Ref #2211

redis, redis-json and redis-subscribe compared raw bytes on their own
sockets, and redis-srtp-index and rollback-redis each carried the same
forked server. They now use NGCP::Rtpengine::FakeRedis, and the forked
server moves into it as redis_serve(). The checks, their names and
their counts are unchanged.

Change-Id: Ieb281e1fe2a772b31a2f928104c741e9c5607297
pull/2221/head
Kevin Binetruy 4 weeks ago committed by Richard Fuchs
parent 5a0b6d6aca
commit 8eb93450c3

@ -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', { });

@ -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");
};

@ -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 });

@ -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', {});

@ -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");
};

@ -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,

Loading…
Cancel
Save