src/test/snapshot-test.pm

   1 package PVE::LXC::Test;
   2
   3 use strict;
   4 use warnings;
   5
   6 use lib qw(..);
   7
   8 use PVE::Storage;
   9 use PVE::Storage::Plugin;
  10 use PVE::LXC;
  11 use PVE::LXC::Config;
  12 use PVE::Tools;
  13 use PVE::ReplicationConfig;
  14
  15 use Test::MockModule;
  16 use Test::More;
  17
  18 my $nodename;
  19 my $snapshot_possible;
  20 my $vol_snapshot_possible = {};
  21 my $vol_snapshot_delete_possible = {};
  22 my $vol_snapshot_rollback_possible = {};
  23 my $vol_snapshot_rollback_enabled = {};
  24 my $vol_snapshot = {};
  25 my $vol_snapshot_delete = {};
  26 my $vol_snapshot_rollback = {};
  27 my $running;
  28 my $freeze_possible;
  29 my $kill_possible;
  30
  31 # Mocked methods
  32
  33 sub mocked_has_feature {
  34     my ($feature, $conf, $storecfg, $snapname) = @_;
  35     return $snapshot_possible;
  36 }
  37
  38 sub mocked_check_running {
  39     return $running;
  40 }
  41
  42 sub mocked_volume_snapshot {
  43     my ($storecfg, $volid, $snapname) = @_;
  44     die "Storage config not mocked! aborting\n"
  45         if defined($storecfg);
  46     die "volid undefined\n"
  47         if !defined($volid);
  48     die "snapname undefined\n"
  49         if !defined($snapname);
  50     if ($vol_snapshot_possible->{$volid}) {
  51         if (defined($vol_snapshot->{$volid})) {
  52             $vol_snapshot->{$volid} .= ",$snapname";
  53         } else {
  54             $vol_snapshot->{$volid} = $snapname;
  55         }
  56         return 1;
  57     } else {
  58         die "volume snapshot disabled\n";
  59     }
  60 }
  61
  62 sub mocked_volume_snapshot_delete {
  63     my ($storecfg, $volid, $snapname) = @_;
  64     die "Storage config not mocked! aborting\n"
  65         if defined($storecfg);
  66     die "volid undefined\n"
  67         if !defined($volid);
  68     die "snapname undefined\n"
  69         if !defined($snapname);
  70     if ($vol_snapshot_delete_possible->{$volid}) {
  71         if (defined($vol_snapshot_delete->{$volid})) {
  72             $vol_snapshot_delete->{$volid} .= ",$snapname";
  73         } else {
  74             $vol_snapshot_delete->{$volid} = $snapname;
  75         }
  76         return 1;
  77     } else {
  78         die "volume snapshot delete disabled\n";
  79     }
  80 }
  81
  82 sub mocked_volume_snapshot_rollback {
  83     my ($storecfg, $volid, $snapname) = @_;
  84     die "Storage config not mocked! aborting\n"
  85         if defined($storecfg);
  86     die "volid undefined\n"
  87         if !defined($volid);
  88     die "snapname undefined\n"
  89         if !defined($snapname);
  90     if ($vol_snapshot_rollback_enabled->{$volid}) {
  91         if (defined($vol_snapshot_rollback->{$volid})) {
  92             $vol_snapshot_rollback->{$volid} .= ",$snapname";
  93         } else {
  94             $vol_snapshot_rollback->{$volid} = $snapname;
  95         }
  96         return 1;
  97     } else {
  98         die "volume snapshot rollback disabled\n";
  99     }
 100 }
 101
 102 sub mocked_volume_rollback_is_possible {
 103     my ($storecfg, $volid, $snapname) = @_;
 104     die "Storage config not mocked! aborting\n"
 105         if defined($storecfg);
 106     die "volid undefined\n"
 107         if !defined($volid);
 108     die "snapname undefined\n"
 109         if !defined($snapname);
 110     return $vol_snapshot_rollback_possible->{$volid}
 111         if ($vol_snapshot_rollback_possible->{$volid});
 112     die "volume_rollback_is_possible failed\n";
 113 }
 114
 115 sub mocked_run_command {
 116     my ($cmd, %param) = @_;
 117     my $cmdstring;
 118     if (my $ref = ref($cmd)) {
 119         $cmdstring = PVE::Tools::cmd2string($cmd);
 120         if ($cmdstring =~ m/.*\/lxc-(un)?freeze.*/) {
 121             return 1 if $freeze_possible;
 122             die "lxc-[un]freeze disabled\n";
 123         }
 124         if ($cmdstring =~ m/.*\/lxc-stop.*--kill.*/) {
 125             if ($kill_possible) {
 126                 $running = 0;
 127                 return 1;
 128             } else {
 129                 return 0;
 130             }
 131         }
 132     }
 133     die "unexpected run_command call: '$cmdstring', aborting\n";
 134 }
 135
 136 # Testing methods
 137
 138 sub test_file {
 139     my ($exp_fn, $real_fn) = @_;
 140     my $ret;
 141     eval {
 142         $ret = system("diff -u '$exp_fn' '$real_fn'");
 143     };
 144     die if $@;
 145     return !$ret;
 146 }
 147
 148 sub testcase_prepare {
 149     my ($vmid, $snapname, $save_vmstate, $comment, $exp_err) = @_;
 150     subtest "Preparing snapshot '$snapname' for vm '$vmid'" => sub {
 151         plan tests => 2;
 152         $@ = undef;
 153         eval {
 154             PVE::LXC::Config->__snapshot_prepare($vmid, $snapname, $save_vmstate, $comment);
 155         };
 156         is($@, $exp_err, "\$@ correct");
 157         ok(test_file("snapshot-expected/prepare/lxc/$vmid.conf", "snapshot-working/prepare/lxc/$vmid.conf"), "config file correct");
 158     };
 159 }
 160
 161 sub testcase_commit {
 162     my ($vmid, $snapname, $exp_err) = @_;
 163     subtest "Committing snapshot '$snapname' for vm '$vmid'" => sub {
 164         plan tests => 2;
 165         $@ = undef;
 166         eval {
 167             PVE::LXC::Config->__snapshot_commit($vmid, $snapname);
 168         };
 169         is($@, $exp_err, "\$@ correct");
 170         ok(test_file("snapshot-expected/commit/lxc/$vmid.conf", "snapshot-working/commit/lxc/$vmid.conf"), "config file correct");
 171     }
 172 }
 173
 174 sub testcase_create {
 175     my ($vmid, $snapname, $save_vmstate, $comment, $exp_err, $exp_vol_snap, $exp_vol_snap_delete) = @_;
 176     subtest "Creating snapshot '$snapname' for vm '$vmid'" => sub {
 177         plan tests => 4;
 178         $vol_snapshot = {};
 179         $vol_snapshot_delete = {};
 180         $exp_vol_snap = {} if !defined($exp_vol_snap);
 181         $exp_vol_snap_delete = {} if !defined($exp_vol_snap_delete);
 182         $@ = undef;
 183         eval {
 184             PVE::LXC::Config->snapshot_create($vmid, $snapname, $save_vmstate, $comment);
 185         };
 186         is($@, $exp_err, "\$@ correct");
 187         is_deeply($vol_snapshot, $exp_vol_snap, "created correct volume snapshots");
 188         is_deeply($vol_snapshot_delete, $exp_vol_snap_delete, "deleted correct volume snapshots");
 189         ok(test_file("snapshot-expected/create/lxc/$vmid.conf", "snapshot-working/create/lxc/$vmid.conf"), "config file correct");
 190     };
 191 }
 192
 193 sub testcase_delete {
 194     my ($vmid, $snapname, $force, $exp_err, $exp_vol_snap_delete) = @_;
 195     subtest "Deleting snapshot '$snapname' of vm '$vmid'" => sub {
 196         plan tests => 3;
 197         $vol_snapshot_delete = {};
 198         $exp_vol_snap_delete = {} if !defined($exp_vol_snap_delete);
 199         $@ = undef;
 200         eval {
 201             PVE::LXC::Config->snapshot_delete($vmid, $snapname, $force);
 202         };
 203         is($@, $exp_err, "\$@ correct");
 204         is_deeply($vol_snapshot_delete, $exp_vol_snap_delete, "deleted correct volume snapshots");
 205         ok(test_file("snapshot-expected/delete/lxc/$vmid.conf", "snapshot-working/delete/lxc/$vmid.conf"), "config file correct");
 206     };
 207 }
 208
 209 sub testcase_rollback {
 210     my ($vmid, $snapname, $exp_err, $exp_vol_snap_rollback) = @_;
 211     subtest "Rolling back to snapshot '$snapname' of vm '$vmid'" => sub {
 212         plan tests => 3;
 213         $vol_snapshot_rollback = {};
 214         $running = 1;
 215         $exp_vol_snap_rollback = {} if !defined($exp_vol_snap_rollback);
 216         $@ = undef;
 217         eval {
 218             PVE::LXC::Config->snapshot_rollback($vmid, $snapname);
 219         };
 220         is($@, $exp_err, "\$@ correct");
 221         is_deeply($vol_snapshot_rollback, $exp_vol_snap_rollback, "rolled back to correct volume snapshots");
 222         ok(test_file("snapshot-expected/rollback/lxc/$vmid.conf", "snapshot-working/rollback/lxc/$vmid.conf"), "config file correct");
 223     };
 224 }
 225
 226 # BEGIN mocked PVE::LXC::Config methods
 227 sub mocked_config_file_lock {
 228     return "snapshot-working/pve-test.lock";
 229 }
 230
 231 sub mocked_cfs_config_path {
 232     my ($class, $vmid, $node) = @_;
 233
 234     $node = $nodename if !$node;
 235     return "snapshot-working/$node/lxc/$vmid.conf";
 236 }
 237
 238 sub mocked_load_config {
 239     my ($class, $vmid, $node) = @_;
 240
 241     my $filename = PVE::LXC::Config->cfs_config_path($vmid, $node);
 242
 243     my $raw = PVE::Tools::file_get_contents($filename);
 244
 245     my $conf = PVE::LXC::Config::parse_pct_config($filename, $raw);
 246     return $conf;
 247 }
 248
 249 sub mocked_write_config {
 250     my ($class, $vmid, $conf) = @_;
 251
 252     my $filename = PVE::LXC::Config->cfs_config_path($vmid);
 253
 254     if ($conf->{snapshots}) {
 255         foreach my $snapname (keys %{$conf->{snapshots}}) {
 256             $conf->{snapshots}->{$snapname}->{snaptime} = "1234567890"
 257                 if $conf->{snapshots}->{$snapname}->{snaptime};
 258         }
 259     }
 260
 261     my $raw = PVE::LXC::Config::write_pct_config($filename, $conf);
 262
 263     PVE::Tools::file_set_contents($filename, $raw);
 264 }
 265
 266 # END mocked PVE::LXC methods
 267
 268
 269 PVE::Tools::run_command("rm -rf snapshot-working");
 270 PVE::Tools::run_command("cp -a snapshot-input snapshot-working");
 271
 272 printf("\n");
 273 printf("Setting up Mocking for PVE::LXC and PVE::LXC::Config\n");
 274 my $lxc_module = new Test::MockModule('PVE::LXC');
 275 $lxc_module->mock('sync_container_namespace', sub { return; });
 276 $lxc_module->mock('check_running', \&mocked_check_running);
 277
 278 my $lxc_config_module = new Test::MockModule('PVE::LXC::Config');
 279 $lxc_config_module->mock('config_file_lock', sub { return "snapshot-working/pve-test.lock"; });
 280 $lxc_config_module->mock('cfs_config_path', \&mocked_cfs_config_path);
 281 $lxc_config_module->mock('load_config', \&mocked_load_config);
 282 $lxc_config_module->mock('write_config', \&mocked_write_config);
 283 $lxc_config_module->mock('has_feature', \&mocked_has_feature);
 284
 285 # ignore existing replication config
 286 my $repl_config_module = new Test::MockModule('PVE::ReplicationConfig');
 287 $repl_config_module->mock('check_for_existing_jobs' => sub { return undef });
 288
 289 $running = 1;
 290 $freeze_possible = 1;
 291
 292 printf("\n");
 293 printf("Running prepare tests\n");
 294 printf("\n");
 295 $nodename = "prepare";
 296
 297 printf("\n");
 298 printf("Setting has_feature to return true\n");
 299 printf("\n");
 300 $snapshot_possible = 1;
 301
 302 printf("Successful snapshot_prepare with no existing snapshots\n");
 303 testcase_prepare("101", "test", 0, "test comment", '');
 304
 305 printf("Successful snapshot_prepare with one existing snapshot\n");
 306 testcase_prepare("102", "test2", 0, "test comment", "");
 307
 308 printf("Expected error for snapshot_prepare on locked container\n");
 309 testcase_prepare("200", "test", 0, "test comment", "CT is locked (snapshot)\n");
 310
 311 printf("Expected error for snapshot_prepare with duplicate snapshot name\n");
 312 testcase_prepare("201", "test", 0, "test comment", "snapshot name 'test' already used\n");
 313
 314 printf("Expected error for snapshot_prepare with save_vmstate\n");
 315 testcase_prepare("202", "test", 1, "test comment", "implement me - snapshot_save_vmstate\n");
 316
 317 printf("\n");
 318 printf("Setting has_feature to return false\n");
 319 printf("\n");
 320 $snapshot_possible = 0;
 321
 322 printf("Expected error for snapshot_prepare if snapshots not possible\n");
 323 testcase_prepare("300", "test", 0, "test comment", "snapshot feature is not available\n");
 324
 325 printf("\n");
 326 printf("Running commit tests\n");
 327 printf("\n");
 328 $nodename = "commit";
 329
 330 printf("\n");
 331 printf("Setting has_feature to return true\n");
 332 printf("\n");
 333 $snapshot_possible = 1;
 334
 335 printf("Successful snapshot_commit with one prepared snapshot\n");
 336 testcase_commit("101", "test", "");
 337
 338 printf("Successful snapshot_commit with one committed and one prepared snapshot\n");
 339 testcase_commit("102", "test2", "");
 340
 341 printf("Expected error for snapshot_commit with no snapshot lock\n");
 342 testcase_commit("201", "test", "missing snapshot lock\n");
 343
 344 printf("Expected error for snapshot_commit with invalid snapshot name\n");
 345 testcase_commit("202", "test", "snapshot 'test' does not exist\n");
 346
 347 printf("Expected error for snapshot_commit with invalid snapshot state\n");
 348 testcase_commit("203", "test", "wrong snapshot state\n");
 349
 350 $vol_snapshot_possible->{"local:snapshotable-disk-1"} = 1;
 351 $vol_snapshot_possible->{"local:snapshotable-disk-2"} = 1;
 352 $vol_snapshot_possible->{"local:snapshotable-disk-3"} = 1;
 353 $vol_snapshot_delete_possible->{"local:snapshotable-disk-1"} = 1;
 354 $vol_snapshot_rollback_enabled->{"local:snapshotable-disk-1"} = 1;
 355 $vol_snapshot_rollback_enabled->{"local:snapshotable-disk-2"} = 1;
 356 $vol_snapshot_rollback_enabled->{"local:snapshotable-disk-3"} = 1;
 357 $vol_snapshot_rollback_possible->{"local:snapshotable-disk-1"} = 1;
 358 $vol_snapshot_rollback_possible->{"local:snapshotable-disk-2"} = 1;
 359 $vol_snapshot_rollback_possible->{"local:snapshotable-disk-3"} = 1;
 360
 361 # possible, but fails
 362 $vol_snapshot_rollback_possible->{"local:snapshotable-disk-4"} = 1;
 363
 364 printf("\n");
 365 printf("Setting up Mocking for PVE::Storage\n");
 366 my $storage_module = new Test::MockModule('PVE::Storage');
 367 $storage_module->mock('config', sub { return undef; });
 368 $storage_module->mock('volume_snapshot', \&mocked_volume_snapshot);
 369 $storage_module->mock('volume_snapshot_delete', \&mocked_volume_snapshot_delete);
 370 $storage_module->mock('volume_snapshot_rollback', \&mocked_volume_snapshot_rollback);
 371 $storage_module->mock('volume_rollback_is_possible', \&mocked_volume_rollback_is_possible);
 372 printf("\tconfig(), volume_snapshot(), volume_snapshot_delete(), volume_snapshot_rollback() and volume_rollback_is_possible() mocked\n");
 373
 374 printf("\n");
 375 printf("Setting up Mocking for PVE::Tools\n");
 376 my $tools_module = new Test::MockModule('PVE::Tools');
 377 $tools_module->mock('run_command' => \&mocked_run_command);
 378 printf("\trun_command() mocked\n");
 379
 380 $nodename = "create";
 381 printf("\n");
 382 printf("Running create tests\n");
 383 printf("\n");
 384
 385 printf("Successful snapshot_create with no existing snapshots\n");
 386 testcase_create("101", "test", 0, "test comment", "", { "local:snapshotable-disk-1" => "test" });
 387
 388 printf("Successful snapshot_create with one existing snapshots\n");
 389 testcase_create("102", "test2", 0, "test comment", "", { "local:snapshotable-disk-1" => "test2" });
 390
 391 printf("Successful snapshot_create with multiple mps\n");
 392 testcase_create("103", "test", 0, "test comment", "", { "local:snapshotable-disk-1" => "test", "local:snapshotable-disk-2" => "test", "local:snapshotable-disk-3" => "test" });
 393
 394 printf("Expected error for snapshot_create when volume snapshot is not possible\n");
 395 testcase_create("201", "test", 0, "test comment", "volume snapshot disabled\n\n");
 396
 397 printf("Expected error for snapshot_create with broken lxc-freeze\n");
 398 $freeze_possible = 0;
 399 testcase_create("202", "test", 0, "test comment", "lxc-[un]freeze disabled\n\n");
 400 $freeze_possible = 1;
 401
 402 printf("Expected error for snapshot_create when mp volume snapshot is not possible\n");
 403 testcase_create("203", "test", 0, "test comment", "volume snapshot disabled\n\n", { "local:snapshotable-disk-1" => "test" }, { "local:snapshotable-disk-1" => "test" });
 404
 405 $nodename = "delete";
 406 printf("\n");
 407 printf("Running delete tests\n");
 408 printf("\n");
 409
 410 printf("Successful snapshot_delete of only existing snapshot\n");
 411 testcase_delete("101", "test", 0, "", { "local:snapshotable-disk-1" => "test" });
 412
 413 printf("Successful snapshot_delete of leaf snapshot\n");
 414 testcase_delete("102", "test2", 0, "", { "local:snapshotable-disk-1" => "test2" });
 415
 416 printf("Successful snapshot_delete of root snapshot\n");
 417 testcase_delete("103", "test", 0, "", { "local:snapshotable-disk-1" => "test" });
 418
 419 printf("Successful snapshot_delete of intermediate snapshot\n");
 420 testcase_delete("104", "test2", 0, "", { "local:snapshotable-disk-1" => "test2" });
 421
 422 printf("Successful snapshot_delete with broken volume_snapshot_delete and force=1\n");
 423 testcase_delete("105", "test", 1, "");
 424
 425 printf("Successful snapshot_delete with mp broken volume_snapshot_delete and force=1\n");
 426 testcase_delete("106", "test", 1, "", { "local:snapshotable-disk-1" => "test" });
 427
 428 printf("Expected error when snapshot_delete fails with broken volume_snapshot_delete and force=0\n");
 429 testcase_delete("201", "test", 0, "volume snapshot delete disabled\n");
 430
 431 printf("Expected error when snapshot_delete fails with broken mp volume_snapshot_delete and force=0\n");
 432 testcase_delete("203", "test", 0, "volume snapshot delete disabled\n", { "local:snapshotable-disk-1" => "test" });
 433
 434 printf("Expected error for snapshot_delete with locked config\n");
 435 testcase_delete("202", "test", 0, "CT is locked (backup)\n");
 436
 437 $nodename = "rollback";
 438 printf("\n");
 439 printf("Running rollback tests\n");
 440 printf("\n");
 441
 442 $kill_possible = 1;
 443
 444 printf("Successful snapshot_rollback to only existing snapshot\n");
 445 testcase_rollback("101", "test", "", { "local:snapshotable-disk-1" => "test" });
 446
 447 printf("Successful snapshot_rollback to leaf snapshot\n");
 448 testcase_rollback("102", "test2", "", { "local:snapshotable-disk-1" => "test2" });
 449
 450 printf("Successful snapshot_rollback to root snapshot\n");
 451 testcase_rollback("103", "test", "", { "local:snapshotable-disk-1" => "test" });
 452
 453 printf("Successful snapshot_rollback to intermediate snapshot\n");
 454 testcase_rollback("104", "test2", "", { "local:snapshotable-disk-1" => "test2" });
 455
 456 printf("Successful snapshot_rollback with multiple mp\n");
 457 testcase_rollback("105", "test", "", { "local:snapshotable-disk-1" => "test", "local:snapshotable-disk-2" => "test", "local:snapshotable-disk-3" => "test" });
 458
 459 printf("Expected error for snapshot_rollback with non-existing snapshot\n");
 460 testcase_rollback("201", "test2", "snapshot 'test2' does not exist\n");
 461
 462 printf("Expected error for snapshot_rollback if volume rollback not possible\n");
 463 testcase_rollback("202", "test", "volume_rollback_is_possible failed\n");
 464
 465 printf("Expected error for snapshot_rollback with incomplete snapshot\n");
 466 testcase_rollback("203", "test", "unable to rollback to incomplete snapshot (snapstate = delete)\n");
 467
 468 printf("Expected error for snapshot_rollback with lock\n");
 469 testcase_rollback("204", "test", "CT is locked (backup)\n");
 470
 471 printf("Expected error for snapshot_rollback with saved vmstate\n");
 472 testcase_rollback("205", "test", "implement me - save vmstate\n", { "local:snapshotable-disk-1" => "test" });
 473
 474 $kill_possible = 0;
 475
 476 printf("Expected error for snapshot_rollback with unkillable container\n");
 477 testcase_rollback("206", "test", "unable to rollback vm 206: vm is running\n");
 478
 479 $kill_possible = 1;
 480
 481 printf("Expected error for snapshot_rollback with mp rollback_is_possible failure\n");
 482 testcase_rollback("207", "test", "volume_rollback_is_possible failed\n");
 483
 484 printf("Expected error for snapshot_rollback with mp rollback failure (results in inconsistent state)\n");
 485 testcase_rollback("208", "test", "volume snapshot rollback disabled\n", { "local:snapshotable-disk-1" => "test", "local:snapshotable-disk-2" => "test" });
 486
 487 done_testing();