1 # Copyright (c) 2010 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;
76 $chg = Amanda::Changer->new($chg_name);
77 die "$chg" if $chg->isa("Amanda::Changer::Error");
83 return $steps->{'done'}->() unless @$to_write;
85 ($slot, $xfer_info, $partnum) = @{shift @$to_write};
86 die "xfer len <= 0" if $xfer_info->[0] <= 0;
88 if (!$res || $res->{'this_slot'} != $slot) {
89 $steps->{'new_dev'}->();
91 $steps->{'run_xfer'}->();
97 $res->release(finished_cb => $steps->{'released'});
99 $steps->{'released'}->();
103 step released => sub {
107 $chg->load(slot => $slot, res_cb => $steps->{'loaded'});
111 (my $err, $res) = @_;
114 my $dev = $res->{'device'};
117 $label = "TESTCONF0" . $slot;
118 $dev->start($Amanda::Device::ACCESS_WRITE, $label, $datestamp)
119 or die("starting dev: " . $dev->error_or_status());
121 $res->set_label(label => $label, finished_cb => $steps->{'run_xfer'});
124 step run_xfer => sub {
125 my $dev = $res->{'device'};
126 my $name = $xfer_info->[2];
128 my $hdr = Amanda::Header->new();
129 # if the partnum is 0, write a DUMPFILE like Amanda < 3.1 did
130 $hdr->{'type'} = $partnum? $Amanda::Header::F_SPLIT_DUMPFILE : $Amanda::Header::F_DUMPFILE;
131 $hdr->{'datestamp'} = $datestamp;
132 $hdr->{'dumplevel'} = 0;
133 $hdr->{'name'} = $name;
134 $hdr->{'disk'} = "/$name";
135 $hdr->{'program'} = "INSTALLCHECK";
136 $hdr->{'partnum'} = $partnum;
137 $hdr->{'compressed'} = 0;
138 $hdr->{'comp_suffix'} = "N";
140 $dev->start_file($hdr)
141 or die("starting file: " . $dev->error_or_status());
143 my $len = $xfer_info->[0];
144 $len = $part_len if $len > $part_len;
145 my $key = $xfer_info->[1];
147 my $xsrc = Amanda::Xfer::Source::Random->new($len, $key);
148 my $xdst = Amanda::Xfer::Dest::Device->new($dev, 0);
149 my $xfer = Amanda::Xfer->new([$xsrc, $xdst]);
152 my ($src, $msg, $xfer) = @_;
154 if ($msg->{'type'} == $XMSG_ERROR) {
155 die $msg->{'elt'} . " failed: " . $msg->{'message'};
156 } elsif ($msg->{'type'} == $XMSG_DONE) {
158 $xfer_info->[0] -= $len;
159 $xfer_info->[1] = $xsrc->get_seed();
161 # add the dump to the catalog
162 Amanda::DB::Catalog::add_part({
164 filenum => $dev->file() - 1,
165 dump_timestamp => $datestamp,
166 write_timestamp => $datestamp,
168 diskname => "/$name",
171 # get the partnum right, even if this wasn't split
172 partnum => $partnum? $partnum : ($partnum+1),
178 # and do the next part
179 $steps->{'next'}->();
186 $res->release(finished_cb => $steps->{'done_released'});
188 $steps->{'done_released'}->();
192 step done_released => sub {
198 # clean out the vtape root
204 for my $slot (1 .. 2) {
205 mkdir("$taperoot/slot$slot")
206 or die("Could not mkdir: $!");
209 ## specification of the on-tape data
211 # length, random, name ]
212 [ 1024*288, 0xF000, "home" ],
213 [ 1024*1088, 0xF001, "usr" ],
214 [ 1024*768, 0xF002, "games" ],
218 [ 1, $xfer_info[0], 0 ], # partnum 0 => old non-split header
219 [ 1, $xfer_info[1], 1 ],
220 [ 1, $xfer_info[1], 2 ],
221 [ 2, $xfer_info[1], 3 ],
222 [ 2, $xfer_info[2], 1 ],
223 [ 2, $xfer_info[2], 2 ],
226 setup_changer(\&Amanda::MainLoop::quit, "chg-disk:$taperoot", \@to_write, 512*1024);
227 Amanda::MainLoop::run();
228 pass("successfully set up test vtapes");
231 # make a holding file
232 my $holding_file = "$Installcheck::TMP/holding_file";
233 my $holding_key = 0x797;
236 open(my $fh, ">", "$holding_file") or die("opening '$holding_file': $!");
238 my $hdr = Amanda::Header->new();
239 $hdr->{'type'} = $Amanda::Header::F_DUMPFILE;
240 $hdr->{'datestamp'} = '21001010101010';
241 $hdr->{'dumplevel'} = 1;
242 $hdr->{'name'} = 'heldhost';
243 $hdr->{'disk'} = '/to/holding';
244 $hdr->{'program'} = "INSTALLCHECK";
245 $hdr->{'is_partial'} = 0;
247 Amanda::Util::full_write(fileno($fh), $hdr->to_string(32768,32768), 32768);
249 # transfer some data to that file
250 my $xfer = Amanda::Xfer->new([
251 Amanda::Xfer::Source::Random->new(1024*$holding_kb, $holding_key),
252 Amanda::Xfer::Dest::Fd->new($fh),
256 my ($src, $msg, $xfer) = @_;
257 if ($msg->{type} == $XMSG_ERROR) {
258 die $msg->{elt} . " failed: " . $msg->{message};
259 } elsif ($msg->{'type'} == $XMSG_DONE) {
261 Amanda::MainLoop::quit();
264 Amanda::MainLoop::run();
268 # fill out a dump object like that returned from Amanda::DB::Catalog, with all
269 # of the keys that we don't really need based on a much simpler description
271 my ($hostname, $diskname, $dump_timestamp, $level, @parts) = @_;
274 dump_timestamp => $dump_timestamp,
275 write_timestamp => $dump_timestamp,
276 hostname => $hostname,
277 diskname => $diskname,
281 nparts => 0, # filled in later
282 kb => 128, # ignored by clerk anyway
283 secs => 10.0, # ditto
287 for my $part (@parts) {
288 push @{$pldump->{'parts'}}, {
292 partnum => scalar @{$pldump->{'parts'}},
294 sec => 1.0, # ignored
296 $pldump->{'nparts'}++;
302 package main::Feedback;
304 use base 'Amanda::Recovery::Clerk::Feedback';
310 return bless \%params, $class;
313 sub clerk_notif_part {
316 if (exists $self->{'clerk_notif_part'}) {
317 $self->{'clerk_notif_part'}->(@_);
319 $self->SUPER::clerk_notif_part(@_);
325 # run a recovery with the given plan on the given clerk, expecting a bytestream with
326 # the given random seed.
329 my $clerk = $params{'clerk'};
331 my $running_xfers = 0;
333 my $finished_cb = \&Amanda::MainLoop::quit;
334 my $steps = define_steps
335 cb_ref => \$finished_cb;
338 $clerk->get_xfer_src(
339 dump => $params{'dump'},
340 xfer_src_cb => $steps->{'xfer_src_cb'});
343 step xfer_src_cb => sub {
344 my ($errors, $header, $xfer_src, $dtcp_supp) = @_;
346 # simulate errors for xfail, below
348 $result = { result => "FAILED", errors => $errors };
349 return $steps->{'verify'}->();
352 # double-check the header; the Clerk should have checked this, so these
353 # are die's, for simplicity
355 $header->{'name'} eq $params{'dump'}->{'hostname'} &&
356 $header->{'disk'} eq $params{'dump'}->{'diskname'} &&
357 $header->{'datestamp'} eq $params{'dump'}->{'dump_timestamp'} &&
358 $header->{'dumplevel'} == $params{'dump'}->{'level'};
360 die if $params{'expect_directtcp_supported'} and !$dtcp_supp;
361 die if !$params{'expect_directtcp_supported'} and $dtcp_supp;
365 if ($params{'directtcp'}) {
366 $xfer_dest = Amanda::Xfer::Dest::DirectTCPListen->new();
368 $xfer_dest = Amanda::Xfer::Dest::Null->new($params{'seed'});
371 $xfer = Amanda::Xfer->new([ $xfer_src, $xfer_dest ]);
373 $xfer->start(sub { $clerk->handle_xmsg(@_); });
375 if ($params{'directtcp'}) {
376 # use another xfer to read from that directtcp connection and verify
378 my $dest_xfer = Amanda::Xfer->new([
379 Amanda::Xfer::Source::DirectTCPConnect->new($xfer_dest->get_addrs()),
380 Amanda::Xfer::Dest::Null->new($params{'seed'}),
383 $dest_xfer->start(sub {
384 my ($src, $msg, $xfer) = @_;
385 if ($msg->{type} == $XMSG_ERROR) {
386 die $msg->{elt} . " failed: " . $msg->{message};
388 if ($msg->{'type'} == $XMSG_DONE) {
389 $steps->{'maybe_done'}->();
394 $clerk->start_recovery(
396 recovery_cb => $steps->{'recovery_cb'});
399 step recovery_cb => sub {
401 $steps->{'maybe_done'}->();
404 step maybe_done => sub {
405 $steps->{'verify'}->() unless --$running_xfers;
410 my $msg = $params{'msg'};
411 if (@{$result->{'errors'}}) {
412 if ($params{'xfail'}) {
413 if ($result->{'result'} ne 'FAILED') {
414 diag("expected failure, but got $result->{result}");
417 is_deeply($result->{'errors'}, $params{'xfail'}, $msg);
420 for (@{$result->{'errors'}}) {
423 if ($result->{'result'} ne 'FAILED') {
424 diag("XXX and result is " . $result->{'result'});
429 if ($result->{'result'} ne 'DONE') {
430 diag("XXX no errors but result is " . $result->{'result'});
440 Amanda::MainLoop::run();
446 $clerk->quit(finished_cb => make_cb(finished_cb => sub {
450 Amanda::MainLoop::quit();
452 Amanda::MainLoop::run();
462 my @clerk_notif_parts;
463 my $chg = Amanda::Changer->new("chg-disk:$taperoot");
464 my $scan = Amanda::Recovery::Scan->new(chg => $chg);
466 $clerk = Amanda::Recovery::Clerk->new(scan => $scan, debug => 1);
471 dump => fake_dump("home", "/home", $datestamp, 0,
472 { label => 'TESTCONF01', filenum => 1 },
474 msg => "one-part recovery successful");
479 dump => fake_dump("usr", "/usr", $datestamp, 0,
480 { label => 'TESTCONF01', filenum => 2 },
481 { label => 'TESTCONF01', filenum => 3 },
482 { label => 'TESTCONF02', filenum => 1 },
484 msg => "multi-part recovery successful");
488 # recover from TESTCONF02, then 01, and then 02 again
490 @clerk_notif_parts = ();
491 $feedback = main::Feedback->new(
492 clerk_notif_part => sub {
493 push @clerk_notif_parts, [ $_[0], $_[1] ],
497 $clerk = Amanda::Recovery::Clerk->new(scan => $scan, debug => 1,
498 feedback => $feedback);
503 dump => fake_dump("games", "/games", $datestamp, 0,
504 { label => 'TESTCONF02', filenum => 2 },
505 { label => 'TESTCONF02', filenum => 3 },
507 msg => "two-part recovery from second tape successful");
509 is_deeply([ @clerk_notif_parts ], [
512 ], "..and clerk_notif_part calls are correct");
517 dump => fake_dump("usr", "/usr", $datestamp, 0,
518 { label => 'TESTCONF01', filenum => 2 },
519 { label => 'TESTCONF01', filenum => 3 },
520 { label => 'TESTCONF02', filenum => 1 },
522 msg => "multi-part recovery spanning tapes 1 and 2 successful");
527 dump => fake_dump("usr", "/usr", $datestamp, 0,
528 { label => 'TESTCONF01', filenum => 2 },
529 { label => 'TESTCONF01', filenum => 3 },
530 { label => 'TESTCONF02', filenum => 1 },
533 msg => "multi-part recovery spanning tapes 1 and 2 successful, with directtcp");
537 seed => $holding_key,
538 dump => fake_dump("heldhost", "/to/holding", '21001010101010', 1,
539 { holding_file => $holding_file },
541 msg => "holding-disk recovery");
545 seed => $holding_key,
546 dump => fake_dump("heldhost", "/to/holding", '21001010101010', 1,
547 { holding_file => $holding_file },
550 msg => "holding-disk recovery, with directtcp");
552 # try some expected failures
556 seed => $holding_key,
557 dump => fake_dump("weldtoast", "/to/holding", '21001010101010', 1,
558 { holding_file => $holding_file },
560 xfail => [ "header on '$holding_file' does not match expectations: " .
561 "got hostname 'heldhost'; expected 'weldtoast'" ],
562 msg => "holding-disk recovery expected failure on header disagreement");
567 dump => fake_dump("XXXgames", "/games", $datestamp, 0,
568 { label => 'TESTCONF02', filenum => 2 },
570 xfail => [ "header on 'TESTCONF02' file 2 does not match expectations: " .
571 "got hostname 'games'; expected 'XXXgames'" ],
572 msg => "mismatched hostname detected");
577 dump => fake_dump("games", "XXX/games", $datestamp, 0,
578 { label => 'TESTCONF02', filenum => 2 },
580 xfail => [ "header on 'TESTCONF02' file 2 does not match expectations: " .
581 "got disk '/games'; expected 'XXX/games'" ],
582 msg => "mismatched disk detected");
587 dump => fake_dump("games", "/games", "XXX", 0,
588 { label => 'TESTCONF02', filenum => 2 },
590 xfail => [ "header on 'TESTCONF02' file 2 does not match expectations: " .
591 "got datestamp '$datestamp'; expected 'XXX'" ],
592 msg => "mismatched datestamp detected");
597 dump => fake_dump("games", "/games", $datestamp, 13,
598 { label => 'TESTCONF02', filenum => 2 },
600 xfail => [ "header on 'TESTCONF02' file 2 does not match expectations: " .
601 "got dumplevel '0'; expected '13'" ],
602 msg => "mismatched level detected");
607 # try a recovery from a DirectTCP-capable device. Note that this is the only real
608 # test of Amanda::Xfer::Source::Recovery's directtcp mode
611 skip "not built with ndmp and full client/server", 5 unless
612 Amanda::Util::built_with_component("ndmp")
613 and Amanda::Util::built_with_component("client")
614 and Amanda::Util::built_with_component("server");
616 Installcheck::Dumpcache::load("ndmp");
618 my $ndmp = Installcheck::Mock::NdmpServer->new(no_reset => 1);
620 $ndmp->edit_config();
621 my $cfg_result = config_init($CONFIG_INIT_EXPLICIT_NAME, 'TESTCONF');
622 if ($cfg_result != $CFGERR_OK) {
623 my ($level, @errors) = Amanda::Config::config_errors();
624 die(join "\n", @errors);
627 my $tapelist = Amanda::Config::config_dir_relative("tapelist");
628 my $tl = Amanda::Tapelist->new($tapelist);
630 my $chg = Amanda::Changer->new();
631 my $scan = Amanda::Recovery::Scan->new(chg => $chg);
632 my $clerk = Amanda::Recovery::Clerk->new(scan => $scan, debug => 1);
636 seed => 0, # no verification
637 dump => fake_dump("localhost", $Installcheck::Run::diskname,
638 $Installcheck::Dumpcache::timestamps[0], 0,
639 { label => 'TESTCONF01', filenum => 1 },
642 expect_directtcp_supported => 1,
643 msg => "recovery of a real dump via NDMP and directtcp");
646 ## specification of the on-tape data
648 # length, random, name ]
649 [ 1024*160, 0xB000, "home" ],
652 # (note that slots 1 and 2 are i/e slots, and are initially empty)
654 [ 3, $xfer_info[0], 1 ],
655 [ 4, $xfer_info[0], 2 ],
656 [ 4, $xfer_info[0], 3 ],
659 setup_changer(\&Amanda::MainLoop::quit, "ndmp_server", \@to_write, 64*1024);
660 Amanda::MainLoop::run();
661 pass("successfully set up ndmp test data");
663 $chg = Amanda::Changer->new();
664 $scan = Amanda::Recovery::Scan->new(chg => $chg);
665 $clerk = Amanda::Recovery::Clerk->new(scan => $scan, debug => 1);
670 dump => fake_dump("home", "/home", $datestamp, 0,
671 { label => 'TESTCONF03', filenum => 1 },
672 { label => 'TESTCONF04', filenum => 1 },
673 { label => 'TESTCONF04', filenum => 2 },
675 msg => "multi-part ndmp recovery successful",
676 expect_directtcp_supported => 1);
682 unlink($holding_file);