1 # Copyright (c) 2010-2012 Zmanda Inc. All Rights Reserved.
3 # This program is free software; you can redistribute it and/or modify it
4 # under the terms of the GNU General Public License version 2 as published
5 # by the Free Software Foundation.
7 # This program is distributed in the hope that it will be useful, but
8 # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
9 # or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 # You should have received a copy of the GNU General Public License along
13 # with this program; if not, write to the Free Software Foundation, Inc.,
14 # 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 # Contact information: Zmanda Inc, 465 S. Mathilda Ave., Suite 300
17 # Sunnyvale, CA 94086, USA, or: http://www.zmanda.com
19 use Test::More tests => 21;
25 use lib "@amperldir@";
26 use Installcheck::Config;
27 use Installcheck::Dumpcache;
28 use Amanda::Config qw( :init );
30 use Amanda::Device qw( :constants );
33 use Amanda::DB::Catalog;
34 use Amanda::Xfer qw( :constants );
35 use Amanda::Recovery::Clerk;
36 use Amanda::Recovery::Scan;
41 # and disable Debug's die() and warn() overrides
42 Amanda::Debug::disable_die_override();
44 # put the debug messages somewhere
45 Amanda::Debug::dbopen("installcheck");
46 Installcheck::log_test_output();
49 $testconf = Installcheck::Config->new();
50 $testconf->add_param('debug_recovery', '9');
53 my $cfg_result = config_init($CONFIG_INIT_EXPLICIT_NAME, 'TESTCONF');
54 if ($cfg_result != $CFGERR_OK) {
55 my ($level, @errors) = Amanda::Config::config_errors();
56 die(join "\n", @errors);
59 my $taperoot = "$Installcheck::TMP/Amanda_Recovery_Clerk";
60 my $datestamp = "20100101010203";
62 # set up a 2-tape disk changer with some spanned dumps in it, and add those
63 # dumps to the catalog, too. To avoid re-implementing Amanda::Taper::Scribe, this
64 # uses individual transfers for each part.
66 my ($finished_cb, $chg_name, $to_write, $part_len) = @_;
70 my ($slot, $xfer_info, $partnum);
72 my $steps = define_steps
73 cb_ref => \$finished_cb,
74 finalize => sub { $chg->quit() };
77 $chg = Amanda::Changer->new($chg_name);
78 die "$chg" if $chg->isa("Amanda::Changer::Error");
84 return $steps->{'done'}->() unless @$to_write;
86 ($slot, $xfer_info, $partnum) = @{shift @$to_write};
87 die "xfer len <= 0" if $xfer_info->[0] <= 0;
89 if (!$res || $res->{'this_slot'} != $slot) {
90 $steps->{'new_dev'}->();
92 $steps->{'run_xfer'}->();
98 $res->release(finished_cb => $steps->{'released'});
100 $steps->{'released'}->();
104 step released => sub {
108 $chg->load(slot => $slot, res_cb => $steps->{'loaded'});
112 (my $err, $res) = @_;
115 my $dev = $res->{'device'};
118 $label = "TESTCONF0" . $slot;
119 $dev->start($Amanda::Device::ACCESS_WRITE, $label, $datestamp)
120 or die("starting dev: " . $dev->error_or_status());
122 $res->set_label(label => $label, finished_cb => $steps->{'run_xfer'});
125 step run_xfer => sub {
126 my $dev = $res->{'device'};
127 my $name = $xfer_info->[2];
129 my $hdr = Amanda::Header->new();
130 # if the partnum is 0, write a DUMPFILE like Amanda < 3.1 did
131 $hdr->{'type'} = $partnum? $Amanda::Header::F_SPLIT_DUMPFILE : $Amanda::Header::F_DUMPFILE;
132 $hdr->{'datestamp'} = $datestamp;
133 $hdr->{'dumplevel'} = 0;
134 $hdr->{'name'} = $name;
135 $hdr->{'disk'} = "/$name";
136 $hdr->{'program'} = "INSTALLCHECK";
137 $hdr->{'partnum'} = $partnum;
138 $hdr->{'compressed'} = 0;
139 $hdr->{'comp_suffix'} = "N";
141 $dev->start_file($hdr)
142 or die("starting file: " . $dev->error_or_status());
144 my $len = $xfer_info->[0];
145 $len = $part_len if $len > $part_len;
146 my $key = $xfer_info->[1];
148 my $xsrc = Amanda::Xfer::Source::Random->new($len, $key);
149 my $xdst = Amanda::Xfer::Dest::Device->new($dev, 0);
150 my $xfer = Amanda::Xfer->new([$xsrc, $xdst]);
153 my ($src, $msg, $xfer) = @_;
155 if ($msg->{'type'} == $XMSG_ERROR) {
156 die $msg->{'elt'} . " failed: " . $msg->{'message'};
157 } elsif ($msg->{'type'} == $XMSG_DONE) {
159 $xfer_info->[0] -= $len;
160 $xfer_info->[1] = $xsrc->get_seed();
162 # add the dump to the catalog
163 Amanda::DB::Catalog::add_part({
165 filenum => $dev->file() - 1,
166 dump_timestamp => $datestamp,
167 write_timestamp => $datestamp,
169 diskname => "/$name",
172 # get the partnum right, even if this wasn't split
173 partnum => $partnum? $partnum : ($partnum+1),
179 # and do the next part
180 $steps->{'next'}->();
187 $res->release(finished_cb => $steps->{'done_released'});
189 $steps->{'done_released'}->();
193 step done_released => sub {
199 # clean out the vtape root
205 for my $slot (1 .. 2) {
206 mkdir("$taperoot/slot$slot")
207 or die("Could not mkdir: $!");
210 ## specification of the on-tape data
212 # length, random, name ]
213 [ 1024*288, 0xF000, "home" ],
214 [ 1024*1088, 0xF001, "usr" ],
215 [ 1024*768, 0xF002, "games" ],
219 [ 1, $xfer_info[0], 0 ], # partnum 0 => old non-split header
220 [ 1, $xfer_info[1], 1 ],
221 [ 1, $xfer_info[1], 2 ],
222 [ 2, $xfer_info[1], 3 ],
223 [ 2, $xfer_info[2], 1 ],
224 [ 2, $xfer_info[2], 2 ],
227 setup_changer(\&Amanda::MainLoop::quit, "chg-disk:$taperoot", \@to_write, 512*1024);
228 Amanda::MainLoop::run();
229 pass("successfully set up test vtapes");
232 # make a holding file
233 my $holding_file = "$Installcheck::TMP/holding_file";
234 my $holding_key = 0x797;
237 open(my $fh, ">", "$holding_file") or die("opening '$holding_file': $!");
239 my $hdr = Amanda::Header->new();
240 $hdr->{'type'} = $Amanda::Header::F_DUMPFILE;
241 $hdr->{'datestamp'} = '21001010101010';
242 $hdr->{'dumplevel'} = 1;
243 $hdr->{'name'} = 'heldhost';
244 $hdr->{'disk'} = '/to/holding';
245 $hdr->{'program'} = "INSTALLCHECK";
246 $hdr->{'is_partial'} = 0;
248 Amanda::Util::full_write(fileno($fh), $hdr->to_string(32768,32768), 32768);
250 # transfer some data to that file
251 my $xfer = Amanda::Xfer->new([
252 Amanda::Xfer::Source::Random->new(1024*$holding_kb, $holding_key),
253 Amanda::Xfer::Dest::Fd->new($fh),
257 my ($src, $msg, $xfer) = @_;
258 if ($msg->{type} == $XMSG_ERROR) {
259 die $msg->{elt} . " failed: " . $msg->{message};
260 } elsif ($msg->{'type'} == $XMSG_DONE) {
262 Amanda::MainLoop::quit();
265 Amanda::MainLoop::run();
269 # fill out a dump object like that returned from Amanda::DB::Catalog, with all
270 # of the keys that we don't really need based on a much simpler description
272 my ($hostname, $diskname, $dump_timestamp, $level, @parts) = @_;
275 dump_timestamp => $dump_timestamp,
276 write_timestamp => $dump_timestamp,
277 hostname => $hostname,
278 diskname => $diskname,
282 nparts => 0, # filled in later
283 kb => 128, # ignored by clerk anyway
284 secs => 10.0, # ditto
288 for my $part (@parts) {
289 push @{$pldump->{'parts'}}, {
293 partnum => scalar @{$pldump->{'parts'}},
295 sec => 1.0, # ignored
297 $pldump->{'nparts'}++;
303 package main::Feedback;
305 use base 'Amanda::Recovery::Clerk::Feedback';
311 return bless \%params, $class;
314 sub clerk_notif_part {
317 if (exists $self->{'clerk_notif_part'}) {
318 $self->{'clerk_notif_part'}->(@_);
320 $self->SUPER::clerk_notif_part(@_);
326 # run a recovery with the given plan on the given clerk, expecting a bytestream with
327 # the given random seed.
330 my $clerk = $params{'clerk'};
332 my $running_xfers = 0;
334 my $finished_cb = \&Amanda::MainLoop::quit;
335 my $steps = define_steps
336 cb_ref => \$finished_cb;
339 $clerk->get_xfer_src(
340 dump => $params{'dump'},
341 xfer_src_cb => $steps->{'xfer_src_cb'});
344 step xfer_src_cb => sub {
345 my ($errors, $header, $xfer_src, $dtcp_supp) = @_;
347 # simulate errors for xfail, below
349 $result = { result => "FAILED", errors => $errors };
350 return $steps->{'verify'}->();
353 # double-check the header; the Clerk should have checked this, so these
354 # are die's, for simplicity
356 $header->{'name'} eq $params{'dump'}->{'hostname'} &&
357 $header->{'disk'} eq $params{'dump'}->{'diskname'} &&
358 $header->{'datestamp'} eq $params{'dump'}->{'dump_timestamp'} &&
359 $header->{'dumplevel'} == $params{'dump'}->{'level'};
361 die if $params{'expect_directtcp_supported'} and !$dtcp_supp;
362 die if !$params{'expect_directtcp_supported'} and $dtcp_supp;
366 if ($params{'directtcp'}) {
367 $xfer_dest = Amanda::Xfer::Dest::DirectTCPListen->new();
369 $xfer_dest = Amanda::Xfer::Dest::Null->new($params{'seed'});
372 $xfer = Amanda::Xfer->new([ $xfer_src, $xfer_dest ]);
374 $xfer->start(sub { $clerk->handle_xmsg(@_); });
376 if ($params{'directtcp'}) {
377 # use another xfer to read from that directtcp connection and verify
379 my $dest_xfer = Amanda::Xfer->new([
380 Amanda::Xfer::Source::DirectTCPConnect->new($xfer_dest->get_addrs()),
381 Amanda::Xfer::Dest::Null->new($params{'seed'}),
384 $dest_xfer->start(sub {
385 my ($src, $msg, $xfer) = @_;
386 if ($msg->{type} == $XMSG_ERROR) {
387 die $msg->{elt} . " failed: " . $msg->{message};
389 if ($msg->{'type'} == $XMSG_DONE) {
390 $steps->{'maybe_done'}->();
395 $clerk->start_recovery(
397 recovery_cb => $steps->{'recovery_cb'});
400 step recovery_cb => sub {
402 $steps->{'maybe_done'}->();
405 step maybe_done => sub {
406 $steps->{'verify'}->() unless --$running_xfers;
411 my $msg = $params{'msg'};
412 if (@{$result->{'errors'}}) {
413 if ($params{'xfail'}) {
414 if ($result->{'result'} ne 'FAILED') {
415 diag("expected failure, but got $result->{result}");
418 is_deeply($result->{'errors'}, $params{'xfail'}, $msg);
421 for (@{$result->{'errors'}}) {
424 if ($result->{'result'} ne 'FAILED') {
425 diag("XXX and result is " . $result->{'result'});
430 if ($result->{'result'} ne 'DONE') {
431 diag("XXX no errors but result is " . $result->{'result'});
441 Amanda::MainLoop::run();
447 $clerk->quit(finished_cb => make_cb(finished_cb => sub {
451 Amanda::MainLoop::quit();
453 Amanda::MainLoop::run();
463 my @clerk_notif_parts;
464 my $chg = Amanda::Changer->new("chg-disk:$taperoot");
465 my $scan = Amanda::Recovery::Scan->new(chg => $chg);
467 $clerk = Amanda::Recovery::Clerk->new(scan => $scan, debug => 1);
472 dump => fake_dump("home", "/home", $datestamp, 0,
473 { label => 'TESTCONF01', filenum => 1 },
475 msg => "one-part recovery successful");
480 dump => fake_dump("usr", "/usr", $datestamp, 0,
481 { label => 'TESTCONF01', filenum => 2 },
482 { label => 'TESTCONF01', filenum => 3 },
483 { label => 'TESTCONF02', filenum => 1 },
485 msg => "multi-part recovery successful");
489 # recover from TESTCONF02, then 01, and then 02 again
491 @clerk_notif_parts = ();
492 $feedback = main::Feedback->new(
493 clerk_notif_part => sub {
494 push @clerk_notif_parts, [ $_[0], $_[1] ],
498 $chg = Amanda::Changer->new("chg-disk:$taperoot");
499 $scan = Amanda::Recovery::Scan->new(chg => $chg);
500 $clerk = Amanda::Recovery::Clerk->new(scan => $scan, debug => 1,
501 feedback => $feedback);
506 dump => fake_dump("games", "/games", $datestamp, 0,
507 { label => 'TESTCONF02', filenum => 2 },
508 { label => 'TESTCONF02', filenum => 3 },
510 msg => "two-part recovery from second tape successful");
512 is_deeply([ @clerk_notif_parts ], [
515 ], "..and clerk_notif_part calls are correct");
520 dump => fake_dump("usr", "/usr", $datestamp, 0,
521 { label => 'TESTCONF01', filenum => 2 },
522 { label => 'TESTCONF01', filenum => 3 },
523 { label => 'TESTCONF02', filenum => 1 },
525 msg => "multi-part recovery spanning tapes 1 and 2 successful");
530 dump => fake_dump("usr", "/usr", $datestamp, 0,
531 { label => 'TESTCONF01', filenum => 2 },
532 { label => 'TESTCONF01', filenum => 3 },
533 { label => 'TESTCONF02', filenum => 1 },
536 msg => "multi-part recovery spanning tapes 1 and 2 successful, with directtcp");
540 seed => $holding_key,
541 dump => fake_dump("heldhost", "/to/holding", '21001010101010', 1,
542 { holding_file => $holding_file },
544 msg => "holding-disk recovery");
548 seed => $holding_key,
549 dump => fake_dump("heldhost", "/to/holding", '21001010101010', 1,
550 { holding_file => $holding_file },
553 msg => "holding-disk recovery, with directtcp");
555 # try some expected failures
559 seed => $holding_key,
560 dump => fake_dump("weldtoast", "/to/holding", '21001010101010', 1,
561 { holding_file => $holding_file },
563 xfail => [ "header on '$holding_file' does not match expectations: " .
564 "got hostname 'heldhost'; expected 'weldtoast'" ],
565 msg => "holding-disk recovery expected failure on header disagreement");
570 dump => fake_dump("XXXgames", "/games", $datestamp, 0,
571 { label => 'TESTCONF02', filenum => 2 },
573 xfail => [ "header on 'TESTCONF02' file 2 does not match expectations: " .
574 "got hostname 'games'; expected 'XXXgames'" ],
575 msg => "mismatched hostname detected");
580 dump => fake_dump("games", "XXX/games", $datestamp, 0,
581 { label => 'TESTCONF02', filenum => 2 },
583 xfail => [ "header on 'TESTCONF02' file 2 does not match expectations: " .
584 "got disk '/games'; expected 'XXX/games'" ],
585 msg => "mismatched disk detected");
590 dump => fake_dump("games", "/games", "XXX", 0,
591 { label => 'TESTCONF02', filenum => 2 },
593 xfail => [ "header on 'TESTCONF02' file 2 does not match expectations: " .
594 "got datestamp '$datestamp'; expected 'XXX'" ],
595 msg => "mismatched datestamp detected");
600 dump => fake_dump("games", "/games", $datestamp, 13,
601 { label => 'TESTCONF02', filenum => 2 },
603 xfail => [ "header on 'TESTCONF02' file 2 does not match expectations: " .
604 "got dumplevel '0'; expected '13'" ],
605 msg => "mismatched level detected");
610 # try a recovery from a DirectTCP-capable device. Note that this is the only real
611 # test of Amanda::Xfer::Source::Recovery's directtcp mode
614 skip "not built with ndmp and full client/server", 5 unless
615 Amanda::Util::built_with_component("ndmp")
616 and Amanda::Util::built_with_component("client")
617 and Amanda::Util::built_with_component("server");
619 Installcheck::Dumpcache::load("ndmp");
621 my $ndmp = Installcheck::Mock::NdmpServer->new(no_reset => 1);
623 $ndmp->edit_config();
624 my $cfg_result = config_init($CONFIG_INIT_EXPLICIT_NAME, 'TESTCONF');
625 if ($cfg_result != $CFGERR_OK) {
626 my ($level, @errors) = Amanda::Config::config_errors();
627 die(join "\n", @errors);
630 my $tapelist = Amanda::Config::config_dir_relative("tapelist");
631 my $tl = Amanda::Tapelist->new($tapelist);
633 my $chg = Amanda::Changer->new();
634 my $scan = Amanda::Recovery::Scan->new(chg => $chg);
635 my $clerk = Amanda::Recovery::Clerk->new(scan => $scan, debug => 1);
639 seed => 0, # no verification
640 dump => fake_dump("localhost", $Installcheck::Run::diskname,
641 $Installcheck::Dumpcache::timestamps[0], 0,
642 { label => 'TESTCONF01', filenum => 1 },
645 expect_directtcp_supported => 1,
646 msg => "recovery of a real dump via NDMP and directtcp");
649 ## specification of the on-tape data
651 # length, random, name ]
652 [ 1024*160, 0xB000, "home" ],
655 # (note that slots 1 and 2 are i/e slots, and are initially empty)
657 [ 3, $xfer_info[0], 1 ],
658 [ 4, $xfer_info[0], 2 ],
659 [ 4, $xfer_info[0], 3 ],
662 setup_changer(\&Amanda::MainLoop::quit, "ndmp_server", \@to_write, 64*1024);
663 Amanda::MainLoop::run();
664 pass("successfully set up ndmp test data");
666 $chg = Amanda::Changer->new();
667 $scan = Amanda::Recovery::Scan->new(chg => $chg);
668 $clerk = Amanda::Recovery::Clerk->new(scan => $scan, debug => 1);
673 dump => fake_dump("home", "/home", $datestamp, 0,
674 { label => 'TESTCONF03', filenum => 1 },
675 { label => 'TESTCONF04', filenum => 1 },
676 { label => 'TESTCONF04', filenum => 2 },
678 msg => "multi-part ndmp recovery successful",
679 expect_directtcp_supported => 1);
685 unlink($holding_file);