percona/percona-toolkit
1
0
Fork 0
mirror of https://github.com/percona/percona-toolkit.git synced 2025-09-27 07:54:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rewrite t/pt-archiver/pxc.t.

Browse Source
This commit is contained in:
Daniel Nichter
2012-11-30 18:13:25 +00:00
parent 72a129bce1
commit a9ccca199d
1 changed files with 255 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

457
t/pt-archiver/pxc.t
View File

@@ -12,256 +12,309 @@ use English qw(-no_match_vars);
use Test::More; use Test::More;
use Time::HiRes qw(time); use Time::HiRes qw(time);
# Hostnames make testing less accurate. Tests need to see
# that such-and-such happened on specific slave hosts, but
# the sandbox servers are all on one host so all slaves have
# the same hostname.
$ENV{PERCONA_TOOLKIT_TEST_USE_DSN_NAMES} = 1;
use PerconaTest; use PerconaTest;
use Sandbox; use Sandbox;
use Data::Dumper; use Data::Dumper;
require "$trunk/bin/pt-archiver"; require "$trunk/bin/pt-archiver";
my $dp = new DSNParser(opts=>$dsn_opts); my $dp = new DSNParser(opts=>$dsn_opts);
my $sb = new Sandbox(basedir => '/tmp', DSNParser => $dp); my $sb = new Sandbox(basedir => '/tmp', DSNParser => $dp);
my $node1_dbh = $sb->get_dbh_for('node1');
my $node2_dbh = $sb->get_dbh_for('node2');
my $node3_dbh = $sb->get_dbh_for('node3');
my $node1 = $sb->get_dbh_for('node1'); if ( !$node1_dbh ) {
my $db_flavor = VersionParser->new($node1)->flavor(); plan skip_all => 'Cannot connect to cluster node1';
}
if ( $db_flavor !~ /XtraDB Cluster/ ) { elsif ( !$node2_dbh ) {
plan skip_all => 'Cannot connect to cluster node2';
}
elsif ( !$node3_dbh ) {
plan skip_all => 'Cannot connect to cluster node3';
}
elsif ( !$sb->is_cluster_mode ) {
plan skip_all => "PXC tests"; plan skip_all => "PXC tests";
} }
my $c = $sb->start_cluster(
nodes => [qw(node4 node5)],
env => q/CLUSTER_NAME="pt_archiver_cluster"/,
);
my $node4_dbh = $c->{node4}->{dbh};
my $node5_dbh = $c->{node5}->{dbh};
# Set this up so ->wait_for_slaves works
$node4_dbh->do("CREATE DATABASE IF NOT EXISTS percona_test");
$node4_dbh->do("CREATE TABLE IF NOT EXISTS percona_test.sentinel(id int primary key, ping varchar(64) not null default '')");
my ($ping) = $node4_dbh->selectrow_array("SELECT MD5(RAND())");
$node4_dbh->do("INSERT INTO percona_test.sentinel(id, ping) values(1, '$ping') ON DUPLICATE KEY UPDATE ping='$ping'");
sleep 1 until eval { $node5_dbh->selectrow_array("SELECT * FROM percona_test.sentinel") };
my $output; my $output;
my $count; my $count;
my $sql; my $sql;
my $cnf = $sb->config_file_for("node4"); my $rows;
my $node1_cnf = $sb->config_file_for("node1");
my $node2_cnf = $sb->config_file_for("node2");
my @args = qw(--where 1=1); my @args = qw(--where 1=1);
$sb->create_dbs($node4_dbh, ['test']); $sb->create_dbs($node1_dbh, ['test']);
# ########################################################################### sub check_rows {
# These are roughly the same tests as basics.t, but we also check that the my (%args) = @_;
# other ndoes got the right data. my @required_args = qw(name sql expect);
# ########################################################################### foreach my $arg ( @required_args ) {
die "I need a $arg argument" unless $args{$arg};
}
my ($name, $sql, $expect) = @args{@required_args};
# Test --why-quit and --statistics output $sb->wait_for_slaves;
$sb->load_file('node4', 't/pt-archiver/samples/tables1-4.sql');
$sb->wait_for_slaves(master => 'node4', slave => 'node5');
$output = output(sub {pt_archiver::main(@args, '--source', "D=test,t=table_1,F=$cnf", qw(--purge --why-quit --statistics)) });
like($output, qr/Started at \d/, 'Start timestamp');
like($output, qr/Source:/, 'source');
like($output, qr/SELECT 4\nINSERT 0\nDELETE 4\n/, 'row counts');
like($output, qr/Exiting because there are no more rows/, 'Exit reason');
$sql = "SELECT * FROM test.table_1"; my $rows = $node1_dbh->selectall_arrayref($sql);
$sb->wait_for_slaves(master => 'node4', slave => 'node5');
my ($m, $n);
is_deeply(
$m = $node4_dbh->selectall_arrayref($sql),
$n = $node5_dbh->selectall_arrayref($sql),
"Node4 & Node5 remain the same after --purge"
);
# Test --no-delete.
$sb->load_file('node4', 't/pt-archiver/samples/tables1-4.sql');
output(sub {pt_archiver::main(@args, qw(--no-delete --purge --source), "D=test,t=table_1,F=$cnf") });
$sb->wait_for_slaves(master => 'node4', slave => 'node5');
is_deeply(
$node4_dbh->selectall_arrayref($sql),
$node5_dbh->selectall_arrayref($sql),
"Node4 & Node5 remain the same after --dest"
);
# --dest
$sb->load_file('node4', 't/pt-archiver/samples/tables1-4.sql');
output(sub {pt_archiver::main(@args, qw(--statistics --source), "D=test,t=table_1,F=$cnf", qw(--dest t=table_2)) });
$sb->wait_for_slaves(master => 'node4', slave => 'node5');
$sql = "SELECT * FROM test.table_1, test.table_2";
is_deeply(
$node4_dbh->selectall_arrayref($sql),
$node5_dbh->selectall_arrayref($sql),
"Node4 & Node5 remain the same after --dest"
);
# #############################################################################
# Bug 903387: pt-archiver doesn't honor b=1 flag to create SQL_LOG_BIN statement
# #############################################################################
SKIP: {
$sb->load_file('node4', "t/pt-archiver/samples/bulk_regular_insert.sql");
$sb->wait_for_slaves(master => 'node4', slave => 'node5');
my $original_rows = $node5_dbh->selectall_arrayref("SELECT * FROM bri.t ORDER BY id");
my $original_no_id = $node5_dbh->selectall_arrayref("SELECT c,t FROM bri.t ORDER BY id");
is_deeply(
$original_no_id,
[
['aa', '11:11:11'],
['bb', '11:11:12'],
['cc', '11:11:13'],
['dd', '11:11:14'],
['ee', '11:11:15'],
['ff', '11:11:16'],
['gg', '11:11:17'],
['hh', '11:11:18'],
['ii', '11:11:19'],
['jj', '11:11:10'],
],
"Bug 903387: node5 has rows"
);
$output = output(
sub { pt_archiver::main(
'--source', "D=bri,L=1,t=t,F=$cnf,b=1",
'--dest', "D=bri,t=t_arch",
qw(--where 1=1 --replace --commit-each --bulk-insert --bulk-delete),
qw(--limit 10)) },
);
$sb->wait_for_slaves(master => 'node4', slave => 'node5');
my $rows = $node4_dbh->selectall_arrayref("SELECT c,t FROM bri.t ORDER BY id");
is_deeply( is_deeply(
$rows, $rows,
[ $expect,
['jj', '11:11:10'], "$name on node1"
],
"Bug 903387: rows deleted on node4"
) or diag(Dumper($rows)); ) or diag(Dumper($rows));
$rows = $node5_dbh->selectall_arrayref("SELECT * FROM bri.t ORDER BY id"); $rows = $node2_dbh->selectall_arrayref($sql);
is_deeply( is_deeply(
$rows, $rows,
$original_rows, $expect,
"Bug 903387: node5 still has rows" "$name on node2"
) or diag(Dumper($rows)); ) or diag(Dumper($rows));
$sql = "SELECT * FROM bri.t_arch ORDER BY id"; $rows = $node3_dbh->selectall_arrayref($sql);
is_deeply( is_deeply(
$node5_dbh->selectall_arrayref($sql), $rows,
$node4_dbh->selectall_arrayref($sql), $expect,
"Bug 903387: node5 has t_arch" "$name on node3"
); ) or diag(Dumper($rows));
$sb->load_file('node4', "t/pt-archiver/samples/bulk_regular_insert.sql");
$sb->wait_for_slaves(master => 'node4', slave => 'node5');
output(
sub { pt_archiver::main(
'--source', "D=bri,L=1,t=t,F=$cnf,b=1",
'--dest', "D=bri,t=t_arch,b=1",
qw(--where 1=1 --replace --commit-each --bulk-insert --bulk-delete),
qw(--limit 10)) },
);
is_deeply(
$node5_dbh->selectall_arrayref("SELECT * FROM bri.t_arch ORDER BY id"),
[],
"Bug 903387: ...unless b=1 was also specified for --dest"
);
} }
# ###########################################################################
# Purge rows.
# ###########################################################################
$sb->load_file('node1', 't/pt-archiver/samples/tables1-4.sql');
$node1_dbh->do("INSERT INTO test.table_2 SELECT * FROM test.table_1");
# Since there's no auto-inc column, all rows should be purged on all nodes.
$output = output(
sub {
pt_archiver::main(@args, '--source', "D=test,t=table_1,F=$node1_cnf",
qw(--purge))
},
stderr => 1,
);
check_rows(
name => "Purged all rows",
sql => "SELECT * FROM test.table_1 ORDER BY a",
expect => [],
);
# table_2 has an auto-inc, so all rows less the max auto-inc row
# should be purged on all nodes. This is due to --[no]safe-auto-increment.
$output = output(
sub {
pt_archiver::main(@args, '--source', "D=test,t=table_2,F=$node1_cnf",
qw(--purge))
},
stderr => 1,
);
check_rows(
name => "Purged rows less max auto-inc",
sql => "SELECT * FROM test.table_2 ORDER BY a",
expect => [[qw(4 2 3), "\n"]],
);
# ###########################################################################
# Do not purge rows.
# ###########################################################################
$sb->load_file('node1', 't/pt-archiver/samples/tables1-4.sql');
my $expected_rows = $node1_dbh->selectall_arrayref(
"SELECT * FROM test.table_1 ORDER BY a");
$output = output(
sub {
pt_archiver::main(@args, '--source', "D=test,t=table_1,F=$node1_cnf",
qw(--no-delete --purge))
},
stderr => 1,
);
check_rows(
name => "--no-delete left all rows",
sql => "SELECT * FROM test.table_1 ORDER BY a",
expect => $expected_rows,
);
# ############################################################################# # #############################################################################
# Test --bulk-insert # Archive rows to another table
# ############################################################################# # #############################################################################
$sb->load_file('node4', "t/pt-archiver/samples/bulk_regular_insert.sql"); # Presume the previous test ^ left tables1-4.sql loaded and that $expect_rows
# is still the real, expected rows.
# Same node
$output = output(
sub {
pt_archiver::main(@args, '--source', "D=test,t=table_1,F=$node1_cnf",
qw(--dest t=table_2))
},
stderr => 1,
);
check_rows(
name => "Rows purged from table_1 (same node)",
sql => "SELECT * FROM test.table_1 ORDER BY a",
expect => [],
);
check_rows(
name => "Rows archived to table_2 (same node)",
sql => "SELECT * FROM test.table_2 ORDER BY a",
expect => $expected_rows,
);
# To another node
$sb->load_file('node1', 't/pt-archiver/samples/tables1-4.sql');
$expected_rows = $node1_dbh->selectall_arrayref(
"SELECT * FROM test.table_1 ORDER BY a");
$output = output(
sub {
pt_archiver::main(@args, '--source', "D=test,t=table_1,F=$node1_cnf",
'--dest', "F=$node2_cnf,D=test,t=table_2")
},
stderr => 1,
);
check_rows(
name => "Rows purged from table_1 (cross-node)",
sql => "SELECT * FROM test.table_1 ORDER BY a",
expect => [],
);
check_rows(
name => "Rows archived to table_2 (cross-node)",
sql => "SELECT * FROM test.table_2 ORDER BY a",
expect => $expected_rows,
);
# #############################################################################
# --bulk-insert
# #############################################################################
# Same node
$sb->load_file('node1', "t/pt-archiver/samples/bulk_regular_insert.sql");
$expected_rows = $node1_dbh->selectall_arrayref(
"SELECT * FROM bri.t ORDER BY id");
# The max auto-inc col won't be archived, so:
my $max_auto_inc_row = pop @$expected_rows;
output( output(
sub { pt_archiver::main("--source", "F=$cnf,D=bri,t=t,L=1", qw(--dest t=t_arch --where 1=1 --bulk-insert --limit 3)) }, sub {
); pt_archiver::main(@args, '--source', "F=$node1_cnf,D=bri,t=t,L=1",
$sb->wait_for_slaves(master => 'node4', slave => 'node5'); qw(--dest t=t_arch --bulk-insert --limit 3))
},
$sql = 'select * from bri.t order by id'; stderr => 1,
is_deeply(
$node5_dbh->selectall_arrayref($sql),
$node4_dbh->selectall_arrayref($sql),
"--bulk-insert works as expected on the source table"
); );
$sql = 'select * from bri.t_arch order by id'; check_rows(
is_deeply( name => "--bulk-insert source table (same node)",
$node5_dbh->selectall_arrayref($sql), sql => "select * from bri.t order by id",
$node4_dbh->selectall_arrayref($sql), expect => [ $max_auto_inc_row ],
"...and on the dest table"
); );
# ############################################################################# check_rows(
# Test --bulk-delete name => "--bulk-insert dest table (same node)",
# ############################################################################# sql => "select * from bri.t_arch order by id",
expect => $expected_rows,
$sb->load_file('node4', 't/pt-archiver/samples/table5.sql');
$output = output(
sub { pt_archiver::main(qw(--no-ascend --limit 50 --bulk-delete --where 1=1), "--source", "D=test,t=table_5,F=$cnf", qw(--statistics --dest t=table_5_dest)) },
);
$sb->wait_for_slaves(master => 'node4', slave => 'node5');
$sql = 'select * from test.table_5';
is_deeply(
$node5_dbh->selectall_arrayref($sql),
$node4_dbh->selectall_arrayref($sql),
"--bulk-delete works as expected on the source table"
); );
$sql = 'select * from test.table_5_dest'; # To another node
is_deeply(
$node5_dbh->selectall_arrayref($sql),
$node4_dbh->selectall_arrayref($sql),
"...and on the dest table"
);
# Same as above, but with a twist: --dest points to the second node. We should $sb->load_file('node1', "t/pt-archiver/samples/bulk_regular_insert.sql");
# get the archieved rows in the first node as well
my $node5_dsn = $sb->dsn_for('node5');
my $node5_cnf = $sb->config_file_for('node5');
$sb->load_file('node4', 't/pt-archiver/samples/table5.sql');
$sb->wait_for_slaves(master => 'node4', slave => 'node5');
$output = output(
sub { pt_archiver::main(qw(--no-ascend --limit 50 --bulk-delete --where 1=1),
"--source", "D=test,t=table_5,F=$cnf", qw(--statistics),
"--dest", "$node5_dsn,D=test,t=table_5_dest,F=$node5_cnf") },
);
# Wait for the --dest table to replicate back
$sb->wait_for_slaves(master => 'node5', slave => 'node4');
$sql = 'select * from test.table_5_dest';
is_deeply(
$node5_dbh->selectall_arrayref($sql),
$node4_dbh->selectall_arrayref($sql),
"--bulk-delete with --dest on the second node, archive ends up in node1 as well"
);
$sb->load_file('node4', "t/pt-archiver/samples/bulk_regular_insert.sql");
$sb->wait_for_slaves(master => 'node4', slave => 'node5');
output( output(
sub { pt_archiver::main("--source", "F=$cnf,D=bri,t=t,L=1", sub {
"--dest", "$node5_dsn,D=bri,t=t_arch,F=$node5_cnf", pt_archiver::main(@args, '--source', "F=$node1_cnf,D=bri,t=t,L=1",
qw(--where 1=1 --bulk-insert --limit 3)) }, '--dest', "F=$node2_cnf,t=t_arch", qw(--bulk-insert --limit 3))
},
stderr => 1,
); );
$sb->wait_for_slaves(master => 'node5', slave => 'node4');
$sql = 'select * from bri.t_arch'; check_rows(
is_deeply( name => "--bulk-insert source table (cross-node)",
$node5_dbh->selectall_arrayref($sql), sql => "select * from bri.t order by id",
$node4_dbh->selectall_arrayref($sql), expect => [ $max_auto_inc_row ],
"--bulk-insert with --dest on the second node, archive ends up in node1 as well" );
check_rows(
name => "--bulk-insert dest table (cross-node)",
sql => "select * from bri.t_arch order by id",
expect => $expected_rows,
);
# #############################################################################
# --bulk-delete
# #############################################################################
# Same node
$sb->load_file('node2', 't/pt-archiver/samples/table5.sql');
$expected_rows = $node1_dbh->selectall_arrayref(
"SELECT * FROM test.table_5 ORDER BY a,b,c,d");
$output = output(
sub {
pt_archiver::main(@args, '--source', "D=test,t=table_5,F=$node1_cnf",
qw(--no-ascend --limit 50 --bulk-delete),
qw(--statistics --dest t=table_5_dest))
},
stderr => 1,
);
check_rows(
name => "--bulk-delete source table (same node)",
sql => "select * from test.table_5",
expect => [],
);
check_rows(
name => "--bulk-delete dest table (same node)",
sql => "select * from test.table_5_dest order by a,b,c,d",
expect => $expected_rows,
);
# To another node
$sb->load_file('node2', 't/pt-archiver/samples/table5.sql');
$output = output(
sub {
pt_archiver::main(@args, '--source', "D=test,t=table_5,F=$node1_cnf",
qw(--no-ascend --limit 50 --bulk-delete),
qw(--statistics), '--dest', "F=$node2_cnf,t=table_5_dest")
},
stderr => 1,
);
check_rows(
name => "--bulk-delete source table (cross-node)",
sql => "select * from test.table_5",
expect => [],
);
check_rows(
name => "--bulk-delete dest table (cross-node)",
sql => "select * from test.table_5_dest order by a,b,c,d",
expect => $expected_rows,
); );
# ############################################################################# # #############################################################################
# Done. # Done.
# ############################################################################# # #############################################################################
$sb->stop_sandbox(qw(node4 node5)); $sb->wipe_clean($node1_dbh);
ok($sb->ok(), "Sandbox servers") or BAIL_OUT(__FILE__ . " broke the sandbox"); ok($sb->ok(), "Sandbox servers") or BAIL_OUT(__FILE__ . " broke the sandbox");
done_testing; done_testing;