From 81ebc68f34146da07421d5dfe5d58cfeed77747a Mon Sep 17 00:00:00 2001 From: Wolfgang Link Date: Thu, 31 Mar 2016 09:10:23 +0200 Subject: [PATCH] Add Tests for ZFSPoolPlugin --- test/Makefile | 6 + test/run_test_zfspoolplugin.pl | 2490 ++++++++++++++++++++++++++++++++ 2 files changed, 2496 insertions(+) create mode 100644 test/Makefile create mode 100755 test/run_test_zfspoolplugin.pl diff --git a/test/Makefile b/test/Makefile new file mode 100644 index 0000000..33d5ff8 --- /dev/null +++ b/test/Makefile @@ -0,0 +1,6 @@ +all: test + +test: test_zfspoolplugin + +test_zfspoolplugin: run_test_zfspoolplugin.pl + ./run_test_zfspoolplugin.pl diff --git a/test/run_test_zfspoolplugin.pl b/test/run_test_zfspoolplugin.pl new file mode 100755 index 0000000..df390e0 --- /dev/null +++ b/test/run_test_zfspoolplugin.pl @@ -0,0 +1,2490 @@ +#!/usr/bin/perl + +use strict; +use warnings; +use Data::Dumper qw(Dumper); +use PVE::Storage; +use PVE::Cluster; +use PVE::Tools qw(run_command); +use Cwd; +$Data::Dumper::Sortkeys = 1; + +my $verbose = undef; + +my $storagename = "zfstank99"; +my $subvol = 'regressiontest'; + +#volsize in GB +my $volsize = 1; +my $vmdisk = "vm-102-disk-1"; +my $vmbase = "base-100-disk-1"; +my $vmlinked = "vm-101-disk-1"; +my $ctdisk = "subvol-202-disk-1"; +my $ctbase = "basevol-200-disk-1"; +my $ctlinked = "subvol-201-disk-1"; + +my $basesnap = '@__base__'; +my $tests = {}; + +#create zfs suvol for testing + +my $pool = undef; +my $zpath = undef; +my $cfg = undef; +my $scfg = undef; +my $count = 0; +my $testnum = 18; + +my $test18 = sub { + + print "\nrun test17 \"scan_zfs\"\n"; + my $res; + + eval { + $res = PVE::Storage::scan_zfs($cfg, $storagename); + + my $exists = 0; + foreach my $subvol (@$res){ + if ($subvol->{pool} eq 'regressiontest') { + $exists++; + } + } + if (!$exists) { + $count++; + warn "Test 18 a: not pool"; + } + }; + if ( $@ ) { + $count++; + warn "Test 18 a: $@"; + } + $res = undef; + + eval { + $res = PVE::Storage::scan_zfs($cfg, $storagename); + + foreach my $subvol (@$res){ + if ($subvol->{pool} eq 'zfspool/subvol') { + $count++; + warn "Test 18 b:"; + } + } + + foreach my $subvol (@$res){ + if ($subvol->{pool} eq 'zfspool/basevol') { + $count++; + warn "Test 18 c"; + } + } + }; + if ( $@ ) { + $count++; + warn "Test 18 a: $@"; + } +}; +$tests->{18} = $test18; + +my $test17 = sub { + + print "\nrun test17 \"deactivate_storage\"\n"; + + eval { + PVE::Storage::activate_storage($cfg, $storagename); + }; + if ($@) { + $count++; + warn "Test 17 a: $@"; + } +}; +$tests->{17} = $test17; + +my $test16 = sub { + + print "\nrun test16 \"activate_storage\"\n"; + + eval { + PVE::Storage::activate_storage($cfg, $storagename); + }; + if ($@) { + $count++; + warn "Test 16 a: $@"; + } +}; +$tests->{16} = $test16; + +my $test15 = sub { + + print "\nrun test15 \"template_list and vdisk_list\"\n"; + + my $hash = Dumper {}; + + my $res = Dumper PVE::Storage::template_list($cfg, $storagename, "vztmpl"); + if ( $hash ne $res ) { + $count++; + warn "Test 15 a failed\n"; + } + $res = undef; + + $res = Dumper PVE::Storage::template_list($cfg, $storagename, "iso"); + if ( $hash ne $res ) { + $count++; + warn "Test 15 b failed\n"; + } + $res = undef; + + $res = Dumper PVE::Storage::template_list($cfg, $storagename, "backup"); + if ( $hash ne $res ) { + $count++; + warn "Test 15 c failed\n"; + } + $res = undef; + + $hash = Dumper {'zfstank99' => [ + { + 'parent' => undef, + 'volid' => 'zfstank99:base-100-disk-1', + 'name' => 'base-100-disk-1', + 'vmid' => '100', + 'size' => 1073741824, + 'format' => 'raw' + } + ]}; + + $res = Dumper PVE::Storage::vdisk_list($cfg, $storagename, 100, ["$storagename:$vmbase"]); + + if ( $hash ne $res ) { + $count++; + warn "Test 15 d failed\n"; + } + $res = undef; + + $hash = Dumper {'zfstank99' => [ + { + 'parent' => undef, + 'volid' => 'zfstank99:vm-102-disk-1', + 'name' => 'vm-102-disk-1', + 'vmid' => '102', + 'size' => 1073741824, + 'format' => 'raw' + } + ]}; + + $res = Dumper PVE::Storage::vdisk_list($cfg, $storagename, 102, ["$storagename:$vmdisk"]); + if ( $hash ne $res ) { + $count++; + warn "Test 15 e failed\n"; + } + $res = undef; + + $hash = Dumper {'zfstank99' => [ + { + 'parent' => 'base-100-disk-1@__base__', + 'volid' => "$storagename:$vmbase\/$vmlinked", + 'name' => 'vm-101-disk-1', + 'vmid' => '101', + 'size' => 1073741824, + 'format' => 'raw' + } + ]}; + + $res = Dumper PVE::Storage::vdisk_list($cfg, $storagename, 101, ["$storagename:$vmbase\/$vmlinked"]); + if ( $hash ne $res ) { + $count++; + warn "Test 15 f failed\n"; + } + $res = undef; + + $hash = Dumper {'zfstank99' => [ + { + 'parent' => undef, + 'volid' => 'zfstank99:basevol-200-disk-1', + 'name' => 'basevol-200-disk-1', + 'vmid' => '200', + 'size' => 1073741824, + 'format' => 'subvol' + } + ]}; + + $res = Dumper PVE::Storage::vdisk_list($cfg, $storagename, 200, ["$storagename:$ctbase"]); + if ( $hash ne $res ) { + $count++; + warn "Test 15 g failed\n"; + } + $res = undef; + + $hash = Dumper {'zfstank99' => [ + { + 'parent' => undef, + 'volid' => 'zfstank99:subvol-202-disk-1', + 'name' => 'subvol-202-disk-1', + 'vmid' => '202', + 'size' => 1073741824, + 'format' => 'subvol' + } + ]}; + + $res = Dumper PVE::Storage::vdisk_list($cfg, $storagename, 202, ["$storagename:$ctdisk"]); + if ( $hash ne $res ) { + $count++; + warn "Test 15 h failed\n"; + } + $res = undef; + + $hash = Dumper {'zfstank99' => [ + { + 'parent' => 'basevol-200-disk-1@__base__', + 'volid' => "$storagename:$ctbase\/$ctlinked", + 'name' => 'subvol-201-disk-1', + 'vmid' => '201', + 'size' => 1073741824, + 'format' => 'subvol' + } + ]}; + $res = Dumper PVE::Storage::vdisk_list($cfg, $storagename, 201, ["$storagename:$ctbase\/$ctlinked"]); + if ( $hash ne $res ) { + $count++; + warn "Test 15 i failed\n"; + } +}; +$tests->{15} = $test15; + +my $test14 = sub { + + print "\nrun test14 \"vdisk_free\"\n"; + + eval { + PVE::Storage::vdisk_free($cfg, "$storagename:$vmdisk"); + + eval { + run_command("zfs list $zpath\/$vmdisk", outfunc => sub {}, errfunc => sub {}); + }; + if (!$@) { + $count++; + warn "Test14 a: vdisk still exists\n"; + } + }; + if ($@) { + $count++; + warn "Test14 a: $@"; + } + + eval { + PVE::Storage::vdisk_free($cfg, "$storagename:$vmbase"); + }; + if (!$@) { + $count++; + warn "Test14 b: free vdisk should not work\n"; + } + + eval { + PVE::Storage::vdisk_free($cfg, "$storagename:$vmbase\/$vmlinked"); + + eval { + run_command("zfs list $zpath\/$vmlinked", outfunc => sub {}, errfunc => sub {}); + }; + if (!$@) { + $count++; + warn "Test14 c: vdisk still exists\n"; + } + }; + if ($@) { + $count++; + warn "Test14 c: $@"; + } + + eval { + PVE::Storage::vdisk_free($cfg, "$storagename:$ctdisk"); + + eval { + run_command("zfs list $zpath\/$ctdisk", outfunc => sub {}, errfunc => sub {}); + }; + if (!$@) { + $count++; + warn "Test14 d: vdisk still exists\n"; + } + }; + if ($@) { + $count++; + warn "Test14 d: $@"; + } + + eval { + PVE::Storage::vdisk_free($cfg, "$storagename:$ctbase"); + }; + if (!$@) { + $count++; + warn "Test14 e: free vdisk should not work\n"; + } + + eval { + PVE::Storage::vdisk_free($cfg, "$storagename:$ctbase\/$ctlinked"); + + eval { + run_command("zfs list $zpath\/$ctlinked", outfunc => sub {}, errfunc => sub {}); + }; + if (!$@) { + $count++; + warn "Test14 f: vdisk still exists\n"; + } + }; + if ($@) { + $count++; + warn "Test14 f: $@"; + } + + eval { + PVE::Storage::vdisk_free($cfg, "$storagename:$vmbase"); + + eval { + run_command("zfs list $zpath\/$vmbase", outfunc => sub {}, errfunc => sub {}); + }; + if (!$@) { + $count++; + warn "Test14 g: vdisk still exists\n"; + } + }; + if ($@) { + $count++; + warn "Test14 g: $@"; + } + + eval { + PVE::Storage::vdisk_free($cfg, "$storagename:$ctbase"); + + eval { + run_command("zfs list $zpath\/$ctbase", outfunc => sub {}, errfunc => sub {}); + }; + if (!$@) { + $count++; + warn "Test14 h: vdisk still exists\n"; + } + }; + if ($@) { + $count++; + warn "Test14 h: $@"; + } +}; +$tests->{14} = $test14; + +my $test13 = sub { + + print "\nrun test13 \"vdisk_alloc\"\n"; + + eval { + my $tmp_volid = PVE::Storage::vdisk_alloc($cfg, $storagename, "112", "raw", undef ,1024 * 1024); + + if ($tmp_volid ne "$storagename:vm-112-disk-1") { + die "volname:$tmp_volid don't match\n"; + } + eval { + run_command("zfs get -H volsize $zpath\/vm-112-disk-1", outfunc => + sub { my $tmp = shift; + if ($tmp !~ m/^$zpath\/vm-112-disk-1.*volsize.*1G.*$/) { + die "size don't match\n"; + } + }); + }; + if ($@) { + $count++; + warn "Test13 a: $@"; + } + }; + if ($@) { + $count++; + warn "Test13 a: $@"; + } + + eval { + my $tmp_volid = PVE::Storage::vdisk_alloc($cfg, $storagename, "112", "raw", undef ,2048 * 1024); + + if ($tmp_volid ne "$storagename:vm-112-disk-2") { + die "volname:$tmp_volid don't match\n"; + } + eval { + run_command("zfs get -H volsize $zpath\/vm-112-disk-2", outfunc => + sub { my $tmp = shift; + if ($tmp !~ m/^$zpath\/vm-112-disk-2.*volsize.*2G.*$/) { + die "size don't match\n"; + } + }); + }; + if ($@) { + $count++; + warn "Test13 b: $@"; + } + }; + if ($@) { + $count++; + warn "Test13 b: $@"; + } + + eval { + my $tmp_volid = PVE::Storage::vdisk_alloc($cfg, $storagename, "113", "subvol", undef ,1024 * 1024); + + if ($tmp_volid ne "$storagename:subvol-113-disk-1") { + die "volname:$tmp_volid don't match\n"; + } + eval { + run_command("zfs get -H refquota $zpath\/subvol-113-disk-1", outfunc => + sub { my $tmp = shift; + if ($tmp !~ m/^$zpath\/subvol-113-disk-1.*refquota.*1G.*$/) { + die "size don't match\n"; + } + }); + }; + if ($@) { + $count++; + warn "Test13 c: $@"; + } + }; + if ($@) { + $count++; + warn "Test13 c: $@"; + } + + eval { + my $tmp_volid = PVE::Storage::vdisk_alloc($cfg, $storagename, "113", "subvol", undef ,2048 * 1024); + + if ($tmp_volid ne "$storagename:subvol-113-disk-2") { + die "volname:$tmp_volid don't match\n"; + } + eval { + run_command("zfs get -H refquota $zpath\/subvol-113-disk-2", outfunc => + sub { my $tmp = shift; + if ($tmp !~ m/^$zpath\/subvol-113-disk-2.*refquota.*G.*$/) { + die "size don't match\n"; + } + }); + }; + if ($@) { + $count++; + warn "Test13 d: $@"; + } + }; + if ($@) { + $count++; + warn "Test13 d: $@"; + } +}; +$tests->{13} = $test13; + +my $test12 = sub { + + print "\nrun test12 \"vdisk_create_base\"\n"; + + eval { + my $tmp_volid = PVE::Storage::vdisk_create_base($cfg, "$storagename:$vmdisk"); + + if ($tmp_volid ne "$storagename:base-102-disk-1") { + die; + } + eval { + run_command("zfs list $zpath\/base-102-disk-1", outfunc => sub {}); + }; + if ($@) { + $count++; + warn "Test12 a: $@"; + } + }; + if ($@) { + $count++; + warn "Test12 a: $@"; + } + + eval { + my $tmp_volid = PVE::Storage::vdisk_create_base($cfg, "$storagename:$vmlinked"); + + if ($tmp_volid ne "$storagename:base-101-disk-1") { + die; + } + eval { + run_command("zfs list $zpath\/base-101-disk-1", outfunc => sub {}); + }; + if ($@) { + $count++; + warn "Test12 b: $@"; + } + }; + if ($@) { + $count++; + warn "Test12 b: $@"; + } + + eval { + my $tmp_volid = PVE::Storage::vdisk_create_base($cfg, "$storagename:$ctdisk"); + + if ($tmp_volid ne "$storagename:basevol-202-disk-1") { + die ; + } + eval { + run_command("zfs list $zpath\/basevol-202-disk-1", outfunc => sub {}); + }; + if ($@) { + $count++; + warn "Test12 c: $@"; + } + }; + if ($@) { + $count++; + warn "Test12 c: $@"; + } + + eval { + my $tmp_volid = PVE::Storage::vdisk_create_base($cfg, "$storagename:$ctlinked"); + + if ($tmp_volid ne "$storagename:basevol-201-disk-1") { + die; + } + eval { + run_command("zfs list $zpath\/basevol-201-disk-1", outfunc => sub {}); + }; + if ($@) { + $count++; + warn "Test12 d: $@"; + } + }; + if ($@) { + $count++; + warn "Test12 d: $@"; + } +}; +$tests->{12} = $test12; + +my $test11 = sub { + + print "\nrun test11 \"volume_is_base\"\n"; + + eval { + PVE::Storage::vdisk_clone($cfg, "$storagename:$vmdisk", 110); + }; + if (!$@) { + $count++; + warn "Test11 a: clone_image only works on base images"; + } + + eval { + if ("$storagename:$vmbase\/vm-110-disk-1" ne + PVE::Storage::vdisk_clone($cfg, "$storagename:$vmbase", 110, '__base__')){ + $count++; + warn "Test11 b"; + } + run_command("zfs list -H -o volsize $zpath\/vm-110-disk-1", outfunc => sub { + my $line = shift; + + chomp($line); + warn "Test11 b not correct volsize" if $line !~ m/$volsize/; + }); + }; + if ($@) { + $count++; + warn "Test11 b: $@"; + } + + eval { + PVE::Storage::vdisk_clone($cfg, "$storagename:$vmbase\/$vmlinked", 111); + }; + if (!$@) { + $count++; + warn "Test11 c: clone_image only works on base images"; + } + + eval { + PVE::Storage::vdisk_clone($cfg, "$storagename:$ctdisk", 110); + }; + if (!$@) { + $count++; + warn "Test11 d: clone_image only works on base images"; + } + + eval { + if ( "$storagename:$ctbase\/subvol-210-disk-1" ne + PVE::Storage::vdisk_clone($cfg, "$storagename:$ctbase", 210, '__base__')){ + $count++; + warn "Test11 e"; + } + run_command("zfs list -H -o refquota $zpath\/subvol-210-disk-1", outfunc => sub { + my $line = shift; + + chomp($line); + warn "Test11 e not correct volsize" if $line !~ m/$volsize/; + }); + }; + if ($@) { + $count++; + warn "Test11 e: $@"; + } + + eval { + PVE::Storage::vdisk_clone($cfg, "$storagename:$ctbase\/$ctlinked", 211); + }; + if (!$@) { + $count++; + warn "Test11 f: clone_image only works on base images"; + } +}; +$tests->{11} = $test11; + +my $test10 =sub { + + print "\nrun test10 \"volume_is_base\"\n"; + + eval { + if (1 == PVE::Storage::volume_is_base($cfg, "$storagename:$vmdisk")) { + $count++; + warn "Test10 a: is no base"; + } + + }; + if ($@) { + $count++; + warn "Test10 a: $@"; + } + + eval { + if (0 == PVE::Storage::volume_is_base($cfg, "$storagename:$vmbase")) { + $count++; + warn "Test10 b: is base"; + } + + }; + if ($@) { + $count++; + warn "Test10 b: $@"; + } + + eval { + if (1 == PVE::Storage::volume_is_base($cfg, "$storagename:$vmbase\/$vmlinked")) { + $count++; + warn "Test10 c: is no base"; + } + + }; + if ($@) { + $count++; + warn "Test10 c: $@"; + } + + eval { + if (1 == PVE::Storage::volume_is_base($cfg, "$storagename:$ctdisk")) { + $count++; + warn "Test10 d: is no base"; + } + + }; + if ($@) { + $count++; + warn "Test10 d: $@"; + } + + eval { + if (0 == PVE::Storage::volume_is_base($cfg, "$storagename:$ctbase")) { + $count++; + warn "Test10 e: is base"; + } + + }; + if ($@) { + $count++; + warn "Test10 e: $@"; + } + + eval { + if (1 == PVE::Storage::volume_is_base($cfg, "$storagename:$ctbase\/$ctlinked")) { + $count++; + warn "Test10 f: is no base"; + } + + }; + if ($@) { + $count++; + warn "Test10 f: $@"; + } +}; +$tests->{10} = $test10; + +my $test9 =sub { + + print "\nrun test9 \"parse_volname\"\n"; + + eval { + my ($store, $disk) = PVE::Storage::parse_volume_id("$storagename:$vmdisk"); + + if ($store ne $storagename || $disk ne $vmdisk) { + $count++; + warn "Test9 a: parsing wrong"; + } + + }; + if ($@) { + $count++; + warn "Test9 a: $@"; + } + + eval { + my ($store, $disk) = PVE::Storage::parse_volume_id("$storagename:$vmbase"); + + if ($store ne $storagename || $disk ne $vmbase) { + $count++; + warn "Test9 b: parsing wrong"; + } + + }; + if ($@) { + $count++; + warn "Test9 b: $@"; + } + + eval { + my ($store, $disk) = PVE::Storage::parse_volume_id("$storagename:$vmbase\/$vmlinked"); + + if ($store ne $storagename || $disk ne "$vmbase\/$vmlinked") { + $count++; + warn "Test9 c: parsing wrong"; + } + + }; + if ($@) { + $count++; + warn "Test9 c: $@"; + } + + eval { + my ($store, $disk) = PVE::Storage::parse_volume_id("$storagename:$ctdisk"); + + if ($store ne $storagename || $disk ne $ctdisk) { + $count++; + warn "Test9 d: parsing wrong"; + } + + }; + if ($@) { + $count++; + warn "Test9 d: $@"; + } + + eval { + my ($store, $disk) = PVE::Storage::parse_volume_id("$storagename:$ctbase"); + + if ($store ne $storagename || $disk ne $ctbase) { + $count++; + warn "Test9 e: parsing wrong"; + } + + }; + if ($@) { + $count++; + warn "Test9 e: $@"; + } + + eval { + my ($store, $disk) = PVE::Storage::parse_volume_id("$storagename:$ctbase\/$ctlinked"); + + if ($store ne $storagename || $disk ne "$ctbase\/$ctlinked") { + $count++; + warn "Test9 f: parsing wrong"; + } + + }; + if ($@) { + $count++; + warn "Test9 f: $@"; + } +}; +$tests->{9} = $test9; + +my $test8 = sub { + + print "\nrun test8 \"parse_volname\"\n"; + + eval { + my ($vtype, $name, $vmid, $basename, $basevmid, $isBase, $format) = PVE::Storage::parse_volname($cfg, "$storagename:$vmdisk"); + + if ($vtype ne 'images' || $vmid ne '102' || $name ne $vmdisk || + defined($basename) || defined($basevmid) || defined($isBase) || + $format ne 'raw') { + $count++; + warn "Test8 a: parsing wrong"; + } + + }; + if ($@) { + $count++; + warn "Test8 a: $@"; + } + + eval { + my ($vtype, $name, $vmid, $basename, $basevmid, $isBase, $format) = PVE::Storage::parse_volname($cfg, "$storagename:$vmbase"); + + if ($vtype ne 'images' || $vmid ne '100' || $name ne $vmbase || + defined($basename) || defined($basevmid) || $isBase ne 'base' || + $format ne 'raw') { + $count++; + warn "Test8 b: parsing wrong"; + } + }; + if ($@) { + $count++; + warn "Test8 b: $@"; + } + + eval { + my ($vtype, $name, $vmid, $basename, $basevmid, $isBase, $format) = PVE::Storage::parse_volname($cfg, "$storagename:$vmbase\/$vmlinked"); + + if ($vtype ne 'images' || $name ne $vmlinked || $vmid ne '101' || + $basename ne $vmbase || $basevmid ne '100' || defined($isBase) || + $format ne 'raw') { + $count++; + warn "Test8 c: parsing wrong"; + } + }; + if ($@) { + $count++; + warn "Test8 c: $@"; + } + + eval { + my ($vtype, $name, $vmid, $basename, $basevmid, $isBase, $format) = PVE::Storage::parse_volname($cfg, "$storagename:$ctdisk"); + + if ($vtype ne 'images' || $vmid ne '202' || $name ne $ctdisk || + defined($basename) || defined($basevmid) || defined($isBase) || + $format ne 'subvol') { + $count++; + warn "Test8 d: parsing wrong"; + } + + }; + if ($@) { + $count++; + warn "Test8 d: $@"; + } + + eval { + my ($vtype, $name, $vmid, $basename, $basevmid, $isBase, $format) = PVE::Storage::parse_volname($cfg, "$storagename:$ctbase"); + if ($vtype ne 'images' || $vmid ne '200' || $name ne $ctbase || + defined($basename) || defined($basevmid) || $isBase ne 'basevol' || + $format ne 'subvol') { + $count++; + warn "Test8 e: parsing wrong"; + } + }; + if ($@) { + $count++; + warn "Test8 e: $@"; + } + + eval { + my ($vtype, $name, $vmid, $basename, $basevmid, $isBase, $format) = PVE::Storage::parse_volname($cfg, "$storagename:$ctbase\/$ctlinked"); + + if ($vtype ne 'images' || $name ne $ctlinked || $vmid ne '201' || + $basename ne $ctbase || $basevmid ne '200' || defined($isBase) || + $format ne 'subvol') { + $count++; + warn "Test8 f: parsing wrong"; + } + }; + if ($@) { + $count++; + warn "Test8 f: $@"; + } +}; +$tests->{8} = $test8; + +my $test7 = sub { + + print "\nrun test7 \"volume_rollback\"\n"; + + my $tmp_guid; + my $parse_guid = sub { + my ($line) = shift; + + if ( $line =~ m/^Disk identifier \(GUID\)\: (.*)$/ ) { + $tmp_guid = $1; + } + }; + + eval { + run_command("sgdisk --randomize-guids \/dev\/zvol\/$zpath\/$vmdisk", outfunc => $parse_guid); + run_command("sgdisk -p \/dev\/zvol\/$zpath\/$vmdisk", outfunc => $parse_guid); + + my $old_guid = $tmp_guid; + PVE::Storage::volume_snapshot($cfg, "$storagename:$vmdisk", 'snap1'); + + run_command("sgdisk --randomize-guids \/dev\/zvol\/$zpath\/$vmdisk", outfunc => $parse_guid); + eval { + PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$vmdisk", 'snap1'); + $tmp_guid = undef; + run_command("sgdisk -p \/dev\/zvol\/$zpath\/$vmdisk", outfunc => $parse_guid); + if ($old_guid ne $tmp_guid) { + $count++; + warn "Test7 a: Zvol makes no rollback"; + } + }; + if ($@) { + $count++; + warn "Test7 a: $@"; + } + }; + if ($@) { + $count++; + warn "Test7 a: $@"; + } + $tmp_guid = undef; + + eval { + run_command("sgdisk --randomize-guids \/dev\/zvol\/$zpath\/$vmbase", outfunc => $parse_guid); + run_command("sgdisk -p \/dev\/zvol\/$zpath\/$vmbase", outfunc => $parse_guid); + + my $old_guid = $tmp_guid; + PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase", 'snap1'); + + run_command("sgdisk --randomize-guids \/dev\/zvol\/$zpath\/$vmbase", outfunc => $parse_guid); + eval { + PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$vmbase", 'snap1'); + $tmp_guid = undef; + run_command("sgdisk -p \/dev\/zvol\/$zpath\/$vmbase", outfunc => $parse_guid); + if ($old_guid ne $tmp_guid) { + $count++; + warn "Test7 b: Zvol makes no rollback"; + } + }; + if ($@) { + $count++; + warn "Test7 b: $@"; + } + }; + if ($@) { + $count++; + warn "Test7 b: $@"; + } + $tmp_guid = undef; + + eval { + run_command("sgdisk --randomize-guids \/dev\/zvol\/$zpath\/$vmlinked", outfunc => $parse_guid); + run_command("sgdisk -p \/dev\/zvol\/$zpath\/$vmlinked", outfunc => $parse_guid); + + my $old_guid = $tmp_guid; + PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase\/$vmlinked", 'snap1'); + + run_command("sgdisk --randomize-guids \/dev\/zvol\/$zpath\/$vmlinked", outfunc => $parse_guid); + eval { + PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$vmbase\/$vmlinked", 'snap1'); + $tmp_guid = undef; + run_command("sgdisk -p \/dev\/zvol\/$zpath\/$vmlinked", outfunc => $parse_guid); + if ($old_guid ne $tmp_guid) { + $count++; + warn "Test7 c: Zvol makes no rollback"; + } + }; + if ($@) { + $count++; + warn "Test7 c: $@"; + } + }; + if ($@) { + $count++; + warn "Test7 c: $@"; + } + $tmp_guid = undef; + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$ctdisk", 'snap1'); + + run_command("touch \/$zpath\/$ctdisk\/test.txt", outfunc => $parse_guid); + eval { + PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$ctdisk", 'snap1'); + eval { + run_command("ls \/$zpath\/$ctdisk\/test.txt", errofunc => sub {}); + }; + if (!$@) { + $count++; + warn "Test7 d: $@"; + } + }; + if ($@) { + $count++; + warn "Test7 d: $@"; + } + }; + if ($@) { + $count++; + warn "Test7 d: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase", 'snap1'); + + run_command("touch \/$zpath\/$ctbase\/test.txt", outfunc => $parse_guid); + eval { + PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$ctbase", 'snap1'); + eval { + run_command("ls \/$zpath\/$ctbase\/test.txt", errofunc => sub {}); + }; + if (!$@) { + $count++; + warn "Test7 e: $@"; + } + }; + if ($@) { + $count++; + warn "Test7 e: $@"; + } + }; + if ($@) { + $count++; + warn "Test7 f: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase/$ctlinked", 'snap1'); + + run_command("touch \/$zpath\/$ctlinked\/test.txt", outfunc => $parse_guid); + eval { + PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$ctbase/$ctlinked", 'snap1'); + eval { + run_command("ls \/$zpath\/$ctlinked\/test.txt", errofunc => sub {}); + }; + if (!$@) { + $count++; + warn "Test7 g: $@"; + } + }; + if ($@) { + $count++; + warn "Test7 g: $@"; + } + }; + if ($@) { + $count++; + warn "Test7 g: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$vmdisk", 'snap2'); + + eval { + PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$vmdisk", 'snap1'); + }; + if (!$@) { + $count++; + warn "Test7 h: Not allowed to rollback"; + } + }; + if ($@) { + $count++; + warn "Test7 h: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase", 'snap2'); + + eval { + PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$vmbase", 'snap1'); + }; + if (!$@) { + $count++; + warn "Test7 i: Not allowed to rollback"; + } + }; + if ($@) { + $count++; + warn "Test7 i: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase\/$vmlinked", 'snap2'); + + eval { + PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$vmbase\/$vmlinked", 'snap1'); + }; + if (!$@) { + $count++; + warn "Test7 j: Not allowed to rollback"; + } + }; + if ($@) { + $count++; + warn "Test7 j: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$ctdisk", 'snap2'); + + eval { + PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$ctdisk", 'snap1'); + }; + if (!$@) { + $count++; + warn "Test7 k: Not allowed to rollback"; + } + }; + if ($@) { + $count++; + warn "Test7 k: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase", 'snap2'); + + eval { + PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$ctbase", 'snap1'); + }; + if (!$@) { + $count++; + warn "Test7 l: Not allowed to rollback"; + } + }; + if ($@) { + $count++; + warn "Test7 l: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase/$ctlinked", 'snap2'); + + eval { + PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$ctbase/$ctlinked", 'snap1'); + }; + if (!$@) { + $count++; + warn "Test7 m: Not allowed to rollback"; + } + }; + if ($@) { + $count++; + warn "Test7 m: $@"; + } +}; +$tests->{7} = $test7; + +my $test6 = sub { + + print "\nrun test6 \"volume_rollback_is_possible\"\n"; + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$vmdisk", 'snap1'); + if ( 1 != + PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$vmdisk", 'snap1')) { + $count++; + warn "Test6 a: Rollback sould possible" + } + }; + if ($@) { + $count++; + warn "Test6 a: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase", 'snap1'); + if ( 1 != + PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$vmbase", 'snap1')) { + $count++; + warn "Test6 b: Rollback sould possible" + } + }; + if ($@) { + $count++; + warn "Test6 b: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$vmlinked", 'snap1'); + if ( 1 != + PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$vmbase\/$vmlinked", 'snap1')) { + $count++; + warn "Test6 c: Rollback sould possible" + } + }; + if ($@) { + $count++; + warn "Test6 c: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$ctdisk", 'snap1'); + if ( 1 != + PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$ctdisk", 'snap1')) { + $count++; + warn "Test6 d: Rollback sould possible" + } + }; + if ($@) { + $count++; + warn "Test6 d: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase", 'snap1'); + if ( 1 != + PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$ctbase", 'snap1')) { + $count++; + warn "Test6 e: Rollback sould possible" + } + }; + if ($@) { + $count++; + warn "Test6 e: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$ctlinked", 'snap1'); + if ( 1 != + PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$ctbase\/$ctlinked", 'snap1')) { + $count++; + warn "Test6 f: Rollback sould possible" + } + }; + if ($@) { + $count++; + warn "Test6 f: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$vmdisk", 'snap2'); + PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$vmdisk", 'snap1'); + }; + if (!$@) { + $count++; + warn "Test6 g: Rollback should not possible"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase", 'snap2'); + PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$vmbase", 'snap1'); + }; + if (!$@) { + $count++; + warn "Test6 h: Rollback should not possible"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$vmlinked", 'snap2'); + PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$vmbase\/$vmlinked", 'snap1'); + }; + if (!$@) { + $count++; + warn "Test6 j: Rollback should not possible"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$ctdisk", 'snap2'); + PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$ctdisk", 'snap1'); + }; + if (!$@) { + $count++; + warn "Test6 k: Rollback should not possible"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase", 'snap2'); + PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$ctbase", 'snap1'); + }; + if (!$@) { + $count++; + warn "Test6 l: Rollback should not possible"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$ctlinked", 'snap2'); + PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$ctbase\/$ctlinked", 'snap1'); + }; + if (!$@) { + $count++; + warn "Test6 m: Rollback should not possible"; + } +}; +$tests->{6} = $test6; + +my $test5 = sub { + + print "\nrun test5 \"volume_snapshot_delete\"\n"; + my $out = sub{my $tmp = shift;}; + + eval { + run_command("zfs snapshot $zpath\/$vmdisk\@snap"); + eval{ + PVE::Storage::volume_snapshot_delete($cfg, "$storagename:$vmdisk", 'snap'); + eval{ + run_command("zfs list $zpath\/$vmdisk\@snap", errfunc => $out, outfunc => $out); + }; + if (!$@) { + $count++; + warn "Test5 a: snapshot still exists"; + } + }; + if ($@) { + $count++; + warn "Test5 PVE a: $@"; + } + }; + if ($@) { + $count++; + warn "Test5 a: $@"; + } + + eval { + run_command("zfs snapshot $zpath\/$vmbase\@snap"); + eval{ + PVE::Storage::volume_snapshot_delete($cfg, "$storagename:$vmbase", 'snap'); + eval{ + run_command("zfs list $zpath\/$vmbase\@snap", errmsg => $out, outfunc => $out); + }; + if (!$@) { + $count++; + warn "Test5 b: snapshot still exists"; + } + }; + if ($@) { + $count++; + warn "Test5 PVE b: $@"; + } + }; + if ($@) { + $count++; + warn "Test5 b: $@"; + } + + eval { + run_command("zfs snapshot $zpath\/$vmlinked\@snap"); + eval{ + PVE::Storage::volume_snapshot_delete($cfg, "$storagename:$vmbase\/$vmlinked", 'snap'); + eval{ + run_command("zfs list $zpath\/$vmlinked\@snap", errmsg => $out, outfunc => $out); + }; + if (!$@) { + $count++; + warn "Test5 c: snapshot still exists"; + } + }; + if ($@) { + $count++; + warn "Test5 PVE c: $@"; + } + }; + if ($@) { + $count++; + warn "Test5 c: $@"; + } + + eval { + run_command("zfs snapshot $zpath\/$ctdisk\@snap"); + eval{ + PVE::Storage::volume_snapshot_delete($cfg, "$storagename:$ctdisk", 'snap'); + eval{ + run_command("zfs list $zpath\/$ctdisk\@snap", errmsg => $out, outfunc => $out); + }; + if (!$@) { + $count++; + warn "Test5 d: snapshot still exists"; + } + }; + if ($@) { + $count++; + warn "Test5 PVE d: $@"; + } + }; + if ($@) { + $count++; + warn "Test5 d: $@"; + } + + eval { + run_command("zfs snapshot $zpath\/$ctbase\@snap"); + eval{ + PVE::Storage::volume_snapshot_delete($cfg, "$storagename:$ctbase", 'snap'); + eval{ + run_command("zfs list $zpath\/$ctbase\@snap", errmsg => $out, outfunc => $out); + }; + if (!$@) { + $count++; + warn "Test5 e: snapshot still exists"; + } + }; + if ($@) { + $count++; + warn "Test5 PVE e: $@"; + } + }; + if ($@) { + $count++; + warn "Test5 e: $@"; + } + + eval { + run_command("zfs snapshot $zpath\/$ctlinked\@snap"); + eval{ + PVE::Storage::volume_snapshot_delete($cfg, "$storagename:$ctbase\/$ctlinked", 'snap'); + eval{ + run_command("zfs list $zpath\/$ctlinked\@snap", errmsg => $out, outfunc => $out); + }; + if (!$@) { + $count++; + warn "Test5 f: snapshot still exists"; + } + }; + if ($@) { + $count++; + warn "Test5 PVE f: $@"; + } + }; + if ($@) { + $count++; + warn "Test5 f: $@"; + } + print "######Ignore Output if no Test5 g: is includet######\n"; + eval{ + PVE::Storage::volume_snapshot_delete($cfg, "$storagename:$vmbase", '__base__'); + eval{ + run_command("zfs list $zpath\/$vmbase\@__base__", outfunc => $out); + }; + if ($@) { + $count++; + warn "Test5 g: $@"; + } + }; + if (!$@) { + $count++; + warn "Test5 PVE g: snapshot __base__ can be erased"; + } + print "######End Ignroe#######\n"; +}; +$tests->{5} = $test5; + +my $test4 = sub { + + print "\nrun test4 \"volume_snapshot\"\n"; + my $out = sub{}; + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$vmdisk", 'snap'); + eval{ + run_command("zfs list $zpath\/$vmdisk\@snap", errmsg => $out, outfunc => $out); + }; + if ($@) { + $count++; + warn "Test4 a: $@"; + } + }; + if ($@) { + $count++; + warn "Test4 a: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase", 'snap'); + eval{ + run_command("zfs list $zpath\/$vmbase\@snap", errmsg => $out, outfunc => $out); + }; + if ($@) { + $count++; + warn "Test4 b: $@"; + } + }; + if ($@) { + $count++; + warn "Test4 c: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase\/$vmlinked", 'snap'); + eval{ + run_command("zfs list $zpath\/$vmdisk\@snap", errmsg => $out, outfunc => $out); + }; + if ($@) { + $count++; + warn "Test4 c: $@"; + } + }; + if ($@) { + $count++; + warn "Test4 c: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$ctdisk", 'snap'); + eval{ + run_command("zfs list $zpath\/$ctdisk\@snap", errmsg => $out, outfunc => $out); + }; + if ($@) { + $count++; + warn "Test4 d: $@"; + } + }; + if ($@) { + $count++; + warn "Test4 d: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase", 'snap'); + eval{ + run_command("zfs list $zpath\/$ctbase\@snap", errmsg => $out, outfunc => $out); + }; + if ($@) { + $count++; + warn "Test4 e: $@"; + } + }; + if ($@) { + $count++; + warn "Test4 e: $@"; + } + + eval { + PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase\/$ctlinked", 'snap'); + eval{ + run_command("zfs list $zpath\/$ctdisk\@snap", errmsg => $out, outfunc => $out); + }; + if ($@) { + $count++; + warn "Test4 f: $@"; + } + }; + if ($@) { + $count++; + warn "Test4 f: $@"; + } +}; +$tests->{4} = $test4; + +my $test3 = sub { + + print "\nrun test3 \"volume_has_feature\"\n"; + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$vmdisk", undef, 0)) { + $count++; + warn "Test3 a failed"; + } + }; + if ($@) { + $count++; + warn "Test3 a: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$vmbase", undef, 0)) { + $count++; + warn "Test3 b failed"; + } + }; + if ($@) { + $count++; + warn "Test3 b: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$vmbase\/$vmlinked", undef, 0)) { + $count++; + warn "Test3 c failed"; + } + }; + if ($@) { + $count++; + warn "Test3 c: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$ctdisk", undef, 0)) { + $count++; + warn "Test3 d failed"; + } + }; + if ($@) { + $count++; + warn "Test3 d: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$ctbase", undef, 0)) { + $count++; + warn "Test3 e failed"; + } + }; + if ($@) { + $count++; + warn "Test3 e: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$ctbase\/$ctlinked", undef, 0)) { + $count++; + warn "Test3 f failed"; + } + }; + if ($@) { + $count++; + warn "Test3 f: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$vmdisk", undef, 0)) { + $count++; + warn "Test3 g failed"; + } + }; + if ($@) { + $count++; + warn "Test3 g: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$vmbase", undef, 0)) { + $count++; + warn "Test3 h failed"; + } + }; + if ($@) { + $count++; + warn "Test3 h: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$vmbase\/$vmlinked", undef, 0)) { + $count++; + warn "Test3 h failed"; + } + }; + if ($@) { + $count++; + warn "Test3 h: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$ctdisk", undef, 0)) { + $count++; + warn "Test3 i failed"; + } + }; + if ($@) { + $count++; + warn "Test3 i: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$ctbase", undef, 0)) { + $count++; + warn "Test3 j failed"; + } + }; + if ($@) { + $count++; + warn "Test3 j: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$ctbase\/$ctlinked", undef, 0)) { + $count++; + warn "Test3 k failed"; + } + }; + if ($@) { + $count++; + warn "Test3 k: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$vmdisk", undef, 0)) { + $count++; + warn "Test3 l failed"; + } + }; + if ($@) { + $count++; + warn "Test3 l: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$vmbase", undef, 0)) { + $count++; + warn "Test3 m failed"; + } + }; + if ($@) { + $count++; + warn "Test3 m: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$vmbase\/$vmlinked", undef, 0)) { + $count++; + warn "Test3 n failed"; + } + }; + if ($@) { + $count++; + warn "Test3 n: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$ctdisk", undef, 0)) { + $count++; + warn "Test3 o failed"; + } + }; + if ($@) { + $count++; + warn "Test3 o: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$ctbase", undef, 0)) { + $count++; + warn "Test3 p failed"; + } + }; + if ($@) { + $count++; + warn "Test3 p: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$ctbase\/$ctlinked", undef, 0)) { + $count++; + warn "Test3 q failed"; + } + }; + if ($@) { + $count++; + warn "Test3 q: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$vmdisk", undef, 0)) { + $count++; + warn "Test3 r failed"; + } + }; + if ($@) { + $count++; + warn "Test3 r: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$vmbase", undef, 0)) { + $count++; + warn "Test3 s failed"; + } + }; + if ($@) { + $count++; + warn "Test3 s: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$vmbase\/$vmlinked", undef, 0)) { + $count++; + warn "Test3 t failed"; + } + }; + if ($@) { + $count++; + warn "Test3 t: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$ctdisk", undef, 0)) { + $count++; + warn "Test3 u failed"; + } + }; + if ($@) { + $count++; + warn "Test3 u: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$ctbase", undef, 0)) { + $count++; + warn "Test3 v failed"; + } + }; + if ($@) { + $count++; + warn "Test3 v: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$ctbase\/$ctlinked", undef, 0)) { + $count++; + warn "Test3 w failed"; + } + }; + if ($@) { + $count++; + warn "Test3 w: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$vmdisk", undef, 0)) { + $count++; + warn "Test3 x failed"; + } + }; + if ($@) { + $count++; + warn "Test3 x: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$vmbase", undef, 0)) { + $count++; + warn "Test3 y failed"; + } + }; + if ($@) { + $count++; + warn "Test3 y: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$vmbase\/$vmlinked", undef, 0)) { + $count++; + warn "Test3 z failed"; + } + }; + if ($@) { + $count++; + warn "Test3 z: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$ctdisk", undef, 0)) { + $count++; + warn "Test3 A failed"; + } + }; + if ($@) { + $count++; + warn "Test3 A: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$ctbase", undef, 0)) { + $count++; + warn "Test3 B failed"; + } + }; + if ($@) { + $count++; + warn "Test3 B: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$ctbase\/$ctlinked", undef, 0)) { + $count++; + warn "Test3 C failed"; + } + }; + if ($@) { + $count++; + warn "Test3 C: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$vmdisk", 'test', 0)) { + $count++; + warn "Test3 a1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 a1: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$vmbase", 'test', 0)) { + $count++; + warn "Test3 b1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 b1: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$vmbase\/$vmlinked", 'test', 0)) { + $count++; + warn "Test3 c1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 c1: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$ctdisk", 'test', 0)) { + $count++; + warn "Test3 d1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 d1: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$ctbase", 'test', 0)) { + $count++; + warn "Test3 e1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 e1: $@"; + } + + eval { + if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$ctbase\/$ctlinked", 'test', 0)) { + $count++; + warn "Test3 f1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 f1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$vmdisk", 'test', 0)) { + $count++; + warn "Test3 g1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 g1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$vmbase", 'test', 0)) { + $count++; + warn "Test3 h1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 h1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$vmbase\/$vmlinked", 'test', 0)) { + $count++; + warn "Test3 h1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 h1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$ctdisk", 'test', 0)) { + $count++; + warn "Test3 i1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 i1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$ctbase", 'test', 0)) { + $count++; + warn "Test3 j1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 j1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$ctbase\/$ctlinked", 'test', 0)) { + $count++; + warn "Test3 k1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 k1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$vmdisk", 'test', 0)) { + $count++; + warn "Test3 l1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 l1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$vmbase", 'test', 0)) { + $count++; + warn "Test3 m1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 m1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$vmbase\/$vmlinked", 'test', 0)) { + $count++; + warn "Test3 n1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 n1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$ctdisk", 'test', 0)) { + $count++; + warn "Test3 o1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 o1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$ctbase", 'test', 0)) { + $count++; + warn "Test3 p1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 p1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$ctbase\/$ctlinked", 'test', 0)) { + $count++; + warn "Test3 q1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 q1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$vmdisk", 'test', 0)) { + $count++; + warn "Test3 r1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 r1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$vmbase", 'test', 0)) { + $count++; + warn "Test3 s1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 s1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$vmbase\/$vmlinked", 'test', 0)) { + $count++; + warn "Test3 t1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 t1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$ctdisk", 'test', 0)) { + $count++; + warn "Test3 u1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 u1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$ctbase", 'test', 0)) { + $count++; + warn "Test3 v1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 v1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$ctbase\/$ctlinked", 'test', 0)) { + $count++; + warn "Test3 w1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 w1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$vmdisk", 'test', 0)) { + $count++; + warn "Test3 x1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 x1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$vmbase", 'test', 0)) { + $count++; + warn "Test3 y1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 y1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$vmbase\/$vmlinked", 'test', 0)) { + $count++; + warn "Test3 z1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 z1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$ctdisk", 'test', 0)) { + $count++; + warn "Test3 A1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 A1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$ctbase", 'test', 0)) { + $count++; + warn "Test3 B1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 B1: $@"; + } + + eval { + if (PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$ctbase\/$ctlinked", 'test', 0)) { + $count++; + warn "Test3 C1 failed"; + } + }; + if ($@) { + $count++; + warn "Test3 C1: $@"; + } +}; +$tests->{3} = $test3; + +my $test2 = sub { + + print "\nrun test2 \"volume_resize\"\n"; + my $newsize = ($volsize + 1) * 1024 * 1024 * 1024; + + eval { + if (($newsize/1024) != + PVE::Storage::volume_resize($cfg, "$storagename:$vmdisk", $newsize, 0)) { + $count++; + warn "Test2 a failed"; + } + if ($newsize != + PVE::Storage::volume_size_info($cfg, "$storagename:$vmdisk")) { + $count++; + warn "Test2 a failed"; + } + }; + if ($@) { + $count++; + warn "Test2 a: $@"; + } + + eval { + warn "Test2 b failed" if ($newsize/1024) != PVE::Storage::volume_resize($cfg, "$storagename:$vmbase", $newsize, 0); + warn "Test2 b failed" if $newsize != + PVE::Storage::volume_size_info($cfg, "$storagename:$vmbase"); + }; + if ($@) { + $count++; + warn "Test2 b: $@"; + } + + eval { + if (($newsize/1024) != PVE::Storage::volume_resize($cfg, "$storagename:$vmbase\/$vmlinked", $newsize, 0)) { + $count++; + warn "Test2 c failed"; + } + if ($newsize != + PVE::Storage::volume_size_info($cfg, "$storagename:$vmbase\/$vmlinked")) { + $count++; + warn "Test2 c failed"; + } + }; + if ($@) { + $count++; + warn "Test2 c: $@"; + } + + eval { + if (($newsize/1024) != PVE::Storage::volume_resize($cfg, "$storagename:$ctdisk", $newsize, 0)) { + $count++; + warn "Test2 d failed"; + } + if ($newsize != + PVE::Storage::volume_size_info($cfg, "$storagename:$ctdisk")) { + $count++; + warn "Test2 d failed" + } + }; + if ($@) { + $count++; + warn "Test2 d: $@"; + } + + eval { + if (($newsize/1024) != + PVE::Storage::volume_resize($cfg, "$storagename:$ctbase", $newsize, 0)) { + $count++; + warn "Test2 e failed"; + } + if ($newsize != + PVE::Storage::volume_size_info($cfg, "$storagename:$ctbase")) { + $count++; + warn "Test2 e failed"; + } + }; + if ($@) { + $count++; + warn "Test2 e: $@"; + } + + eval { + if (($newsize/1024) != + PVE::Storage::volume_resize($cfg, "$storagename:$ctbase\/$ctlinked", $newsize, 0)) { + $count++; + warn "Test2 f failed"; + } + if ($newsize != + PVE::Storage::volume_size_info($cfg, "$storagename:$ctbase\/$ctlinked")) { + $count++; + warn "Test2 f failed"; + } + }; + if ($@) { + $count++; + warn "Test2 f: $@"; + } +}; +$tests->{2} = $test2; + +my $test1 = sub { + + print "\nrun test1 \"volume_size_info\"\n"; + my $size = ($volsize * 1024 * 1024 * 1024); + + eval { + if ($size != PVE::Storage::volume_size_info($cfg, "$storagename:$vmdisk")) { + $count++; + warn "Test1 a failed"; + } + }; + if ($@) { + $count++; + warn "Test1 a : $@"; + } + + eval { + if ($size != PVE::Storage::volume_size_info($cfg, "$storagename:$vmbase")) { + $count++; + warn "Test1 b failed"; + } + + }; + if ($@) { + $count++; + warn "Test1 b : $@"; + } + + eval { + if ($size != + PVE::Storage::volume_size_info($cfg, "$storagename:$vmbase\/$vmlinked")) { + $count++; + warn "Test1 c failed"; + } + }; + if ($@) { + $count++; + warn "Test1 c : $@"; + } + + eval { + if ($size != + PVE::Storage::volume_size_info($cfg, "$storagename:$ctdisk")) { + $count++; + warn "Test1 d failed"; + } + }; + if ($@) { + $count++; + warn "Test1 d : $@"; + } + + eval { + if ($size != + PVE::Storage::volume_size_info($cfg, "$storagename:$ctbase")) { + $count++; + warn "Test1 e failed"; + } + }; + if ($@) { + $count++; + warn "Test1 e : $@"; + } + + eval { + if ($size != + PVE::Storage::volume_size_info($cfg, "$storagename:$vmbase\/$vmlinked")) { + $count++; + warn "Test1 f failed" + } + }; + if ($@) { + $count++; + warn "Test1 f : $@"; + } + +}; +$tests->{1} = $test1; + +sub setup_zfs { + + my $tmp = undef; + + #create VM zvol + print "create zvol $vmdisk\n" if $verbose; + run_command("zfs create -V${volsize}G $zpath\/$vmdisk"); + + print "create zvol $vmbase\n" if $verbose; + run_command("zfs create -V${volsize}G $zpath\/$vmbase"); + run_command("zfs snapshot $zpath\/$vmbase$basesnap"); + + print "create linked clone $vmlinked\n" if $verbose; + run_command("zfs clone $zpath\/$vmbase$basesnap $zpath\/$vmlinked"); + + #create CT subvol + print "create subvol $ctdisk\n" if $verbose; + run_command("zfs create -o refquota=${volsize}G $zpath\/$ctdisk"); + + print "create subvol $vmbase\n" if $verbose; + run_command("zfs create -o refquota=${volsize}G $zpath\/$ctbase"); + run_command("zfs snapshot $zpath\/$ctbase$basesnap"); + + print "create linked clone $vmlinked\n" if $verbose; + run_command("zfs clone $zpath\/$ctbase$basesnap $zpath\/$ctlinked -o refquota=${volsize}G"); +} + +sub cleanup_zfs { + + print "destroy $pool\/$subvol\n" if $verbose; + run_command("zfs destroy $zpath -r"); +} + +sub setup_zpool { + + eval { + run_command("dd if=/dev/zero of=zpool.img bs=1M count=8000 "); + }; + if ($@) { + clean_up_zpool(); + } + my $pwd = cwd(); + eval { + run_command("zpool create $subvol $pwd\/zpool.img"); + }; + if ($@) { + clean_up_zpool(); + } +} + +sub clean_up_zpool { + + eval { + run_command("zpool destroy $subvol"); + }; + if ($@) { + warn $@;} + unlink 'zpool.img'; +} + +setup_zpool(); + +my $time = time; +print "Start tests for ZFSPoolPlugin\n"; + +$cfg = {'ids' => { + $storagename => { + 'content' => { + 'images' => 1, + 'rootdir' => 1 + }, + 'pool' => $subvol, + 'type' => 'zfspool' + }, + }, + 'order' => {'zfstank99' => 1,} +}; + +$zpath = $subvol; + +for (my $i = 1; $i <= $testnum; $i++) { + setup_zfs(); + + eval { + $tests->{$i}(); + }; + warn $@ if $@; + cleanup_zfs(); +} + +clean_up_zpool(); + +$time = time - $time; + +print "Stop tests for ZFSPoolPlugin\n"; +print "$count tests failed\n"; +print "Time: ${time}s\n";