]>
Commit | Line | Data |
---|---|---|
81ebc68f WL |
1 | #!/usr/bin/perl |
2 | ||
361481cf TL |
3 | use lib '..'; |
4 | ||
81ebc68f WL |
5 | use strict; |
6 | use warnings; | |
361481cf | 7 | |
81ebc68f WL |
8 | use Data::Dumper qw(Dumper); |
9 | use PVE::Storage; | |
10 | use PVE::Cluster; | |
11 | use PVE::Tools qw(run_command); | |
12 | use Cwd; | |
13 | $Data::Dumper::Sortkeys = 1; | |
14 | ||
15 | my $verbose = undef; | |
16 | ||
17 | my $storagename = "zfstank99"; | |
18 | my $subvol = 'regressiontest'; | |
dcefd9dd | 19 | my $mountpoint = "${subvol}_mnt"; |
81ebc68f WL |
20 | |
21 | #volsize in GB | |
22 | my $volsize = 1; | |
23 | my $vmdisk = "vm-102-disk-1"; | |
24 | my $vmbase = "base-100-disk-1"; | |
25 | my $vmlinked = "vm-101-disk-1"; | |
26 | my $ctdisk = "subvol-202-disk-1"; | |
27 | my $ctbase = "basevol-200-disk-1"; | |
28 | my $ctlinked = "subvol-201-disk-1"; | |
29 | ||
30 | my $basesnap = '@__base__'; | |
31 | my $tests = {}; | |
32 | ||
2acdffbb | 33 | #create zfs subvol for testing |
81ebc68f WL |
34 | my $pool = undef; |
35 | my $zpath = undef; | |
36 | my $cfg = undef; | |
37 | my $scfg = undef; | |
38 | my $count = 0; | |
3672677d | 39 | my $testnum = 19; |
46001581 WL |
40 | my $end_test = $testnum; |
41 | my $start_test = 1; | |
42 | ||
43 | if (@ARGV == 2) { | |
44 | $end_test = $ARGV[1]; | |
45 | $start_test = $ARGV[0]; | |
46 | } elsif (@ARGV == 1) { | |
47 | $start_test = $ARGV[0]; | |
48 | $end_test = $ARGV[0]; | |
49 | } | |
50 | ||
3672677d WL |
51 | my $test19 = sub { |
52 | ||
53 | print "\nrun test19 \"path\"\n"; | |
54 | ||
55 | my @res; | |
56 | my $fail = 0; | |
57 | eval { | |
58 | @res = PVE::Storage::path($cfg, "$storagename:$vmdisk"); | |
59 | if ($res[0] ne "\/dev\/zvol\/regressiontest\/$vmdisk") { | |
60 | $count++; | |
61 | $fail = 1; | |
62 | warn "Test 19 a: path is not correct: expected \'\/dev\/zvol\/regressiontest\/$vmdisk'\ get \'$res[0]\'"; | |
63 | } | |
64 | if ($res[1] ne "102") { | |
65 | if (!$fail) { | |
66 | $count++; | |
67 | $fail = 1; | |
68 | } | |
69 | warn "Test 19 a: owner is not correct: expected \'102\' get \'$res[1]\'"; | |
70 | } | |
71 | if ($res[2] ne "images") { | |
72 | if (!$fail) { | |
73 | $count++; | |
74 | $fail = 1; | |
75 | } | |
76 | warn "Test 19 a: owner is not correct: expected \'images\' get \'$res[2]\'"; | |
77 | } | |
78 | }; | |
79 | if ( $@ ) { | |
80 | $count++; | |
81 | warn "Test 19 a: $@"; | |
82 | } | |
83 | ||
84 | @res = undef; | |
85 | $fail = 0; | |
86 | eval { | |
87 | @res = PVE::Storage::path($cfg, "$storagename:$vmbase"); | |
88 | if ($res[0] ne "\/dev\/zvol\/regressiontest\/$vmbase") { | |
89 | $count++; | |
90 | $fail = 1; | |
91 | warn "Test 19 b: path is not correct: expected \'\/dev\/zvol\/regressiontest\/$vmbase'\ get \'$res[0]\'"; | |
92 | } | |
93 | if ($res[1] ne "100") { | |
94 | if (!$fail) { | |
95 | $count++; | |
96 | $fail = 1; | |
97 | } | |
98 | warn "Test 19 b: owner is not correct: expected \'100\' get \'$res[1]\'"; | |
99 | } | |
100 | if ($res[2] ne "images") { | |
101 | if (!$fail) { | |
102 | $count++; | |
103 | $fail = 1; | |
104 | } | |
105 | warn "Test 19 b: owner is not correct: expected \'images\' get \'$res[2]\'"; | |
106 | } | |
107 | }; | |
108 | if ( $@ ) { | |
109 | $count++; | |
110 | warn "Test 19 b: $@"; | |
111 | } | |
112 | ||
113 | @res = undef; | |
114 | $fail = 0; | |
115 | eval { | |
116 | @res = PVE::Storage::path($cfg, "$storagename:$vmbase\/$vmlinked"); | |
117 | if ($res[0] ne "\/dev\/zvol\/regressiontest\/$vmlinked") { | |
118 | $count++; | |
119 | $fail = 1; | |
120 | warn "Test 19 c: path is not correct: expected \'\/dev\/zvol\/regressiontest\/$vmlinked'\ get \'$res[0]\'"; | |
121 | } | |
122 | if ($res[1] ne "101") { | |
123 | if (!$fail) { | |
124 | $count++; | |
125 | $fail = 1; | |
126 | } | |
127 | warn "Test 19 c: owner is not correct: expected \'101\' get \'$res[1]\'"; | |
128 | } | |
129 | if ($res[2] ne "images") { | |
130 | if (!$fail) { | |
131 | $count++; | |
132 | $fail = 1; | |
133 | } | |
134 | warn "Test 19 c: owner is not correct: expected \'images\' get \'$res[2]\'"; | |
135 | } | |
136 | }; | |
137 | if ( $@ ) { | |
138 | $count++; | |
139 | warn "Test 19 c: $@"; | |
140 | } | |
141 | ||
142 | @res = undef; | |
143 | $fail = 0; | |
144 | eval { | |
145 | @res = PVE::Storage::path($cfg, "$storagename:$ctdisk"); | |
dcefd9dd | 146 | if ($res[0] ne "\/$mountpoint\/$ctdisk") { |
3672677d WL |
147 | $count++; |
148 | $fail = 1; | |
dcefd9dd | 149 | warn "Test 19 d: path is not correct: expected \'\/$mountpoint\/$ctdisk'\ get \'$res[0]\'"; |
3672677d WL |
150 | } |
151 | if ($res[1] ne "202") { | |
152 | if (!$fail) { | |
153 | $count++; | |
154 | $fail = 1; | |
155 | } | |
156 | warn "Test 19 d: owner is not correct: expected \'202\' get \'$res[1]\'"; | |
157 | } | |
158 | if ($res[2] ne "images") { | |
159 | if (!$fail) { | |
160 | $count++; | |
161 | $fail = 1; | |
162 | } | |
163 | warn "Test 19 d: owner is not correct: expected \'images\' get \'$res[2]\'"; | |
164 | } | |
165 | }; | |
166 | if ( $@ ) { | |
167 | $count++; | |
168 | warn "Test 19 d: $@"; | |
169 | } | |
170 | ||
171 | @res = undef; | |
172 | $fail = 0; | |
173 | eval { | |
174 | @res = PVE::Storage::path($cfg, "$storagename:$ctbase"); | |
dcefd9dd | 175 | if ($res[0] ne "\/$mountpoint\/$ctbase") { |
3672677d WL |
176 | $count++; |
177 | $fail = 1; | |
dcefd9dd | 178 | warn "Test 19 e: path is not correct: expected \'\/$mountpoint\/$ctbase'\ get \'$res[0]\'"; |
3672677d WL |
179 | } |
180 | if ($res[1] ne "200") { | |
181 | if (!$fail) { | |
182 | $count++; | |
183 | $fail = 1; | |
184 | } | |
185 | warn "Test 19 e: owner is not correct: expected \'200\' get \'$res[1]\'"; | |
186 | } | |
187 | if ($res[2] ne "images") { | |
188 | if (!$fail) { | |
189 | $count++; | |
190 | $fail = 1; | |
191 | } | |
192 | warn "Test 19 e: owner is not correct: expected \'images\' get \'$res[2]\'"; | |
193 | } | |
194 | }; | |
195 | if ( $@ ) { | |
196 | $count++; | |
197 | warn "Test 19 e: $@"; | |
198 | } | |
199 | ||
200 | @res = undef; | |
201 | $fail = 0; | |
202 | eval { | |
203 | @res = PVE::Storage::path($cfg, "$storagename:$ctbase\/$ctlinked"); | |
dcefd9dd | 204 | if ($res[0] ne "\/$mountpoint\/$ctlinked") { |
3672677d WL |
205 | $count++; |
206 | $fail = 1; | |
dcefd9dd | 207 | warn "Test 19 f: path is not correct: expected \'\/$mountpoint\/$ctlinked'\ get \'$res[0]\'"; |
3672677d WL |
208 | } |
209 | if ($res[1] ne "201") { | |
210 | if (!$fail) { | |
211 | $count++; | |
212 | $fail = 1; | |
213 | } | |
214 | warn "Test 19 f: owner is not correct: expected \'201\' get \'$res[1]\'"; | |
215 | } | |
216 | if ($res[2] ne "images") { | |
217 | if (!$fail) { | |
218 | $count++; | |
219 | $fail = 1; | |
220 | } | |
221 | warn "Test 19 f: owner is not correct: expected \'images\' get \'$res[2]\'"; | |
222 | } | |
223 | }; | |
224 | if ( $@ ) { | |
225 | $count++; | |
226 | warn "Test 19 f: $@"; | |
227 | } | |
228 | }; | |
229 | $tests->{19} = $test19; | |
81ebc68f WL |
230 | |
231 | my $test18 = sub { | |
232 | ||
2acdffbb | 233 | print "\nrun test18 \"scan_zfs\"\n"; |
81ebc68f WL |
234 | my $res; |
235 | ||
236 | eval { | |
237 | $res = PVE::Storage::scan_zfs($cfg, $storagename); | |
238 | ||
239 | my $exists = 0; | |
240 | foreach my $subvol (@$res){ | |
241 | if ($subvol->{pool} eq 'regressiontest') { | |
242 | $exists++; | |
243 | } | |
244 | } | |
245 | if (!$exists) { | |
246 | $count++; | |
247 | warn "Test 18 a: not pool"; | |
248 | } | |
249 | }; | |
250 | if ( $@ ) { | |
251 | $count++; | |
252 | warn "Test 18 a: $@"; | |
253 | } | |
254 | $res = undef; | |
255 | ||
256 | eval { | |
257 | $res = PVE::Storage::scan_zfs($cfg, $storagename); | |
258 | ||
259 | foreach my $subvol (@$res){ | |
260 | if ($subvol->{pool} eq 'zfspool/subvol') { | |
261 | $count++; | |
262 | warn "Test 18 b:"; | |
263 | } | |
264 | } | |
265 | ||
266 | foreach my $subvol (@$res){ | |
267 | if ($subvol->{pool} eq 'zfspool/basevol') { | |
268 | $count++; | |
269 | warn "Test 18 c"; | |
270 | } | |
271 | } | |
272 | }; | |
273 | if ( $@ ) { | |
274 | $count++; | |
275 | warn "Test 18 a: $@"; | |
276 | } | |
277 | }; | |
278 | $tests->{18} = $test18; | |
279 | ||
280 | my $test17 = sub { | |
281 | ||
282 | print "\nrun test17 \"deactivate_storage\"\n"; | |
283 | ||
284 | eval { | |
285 | PVE::Storage::activate_storage($cfg, $storagename); | |
91877ee0 | 286 | PVE::Storage::deactivate_storage($cfg, $storagename); |
81ebc68f WL |
287 | }; |
288 | if ($@) { | |
289 | $count++; | |
290 | warn "Test 17 a: $@"; | |
291 | } | |
292 | }; | |
293 | $tests->{17} = $test17; | |
294 | ||
295 | my $test16 = sub { | |
296 | ||
297 | print "\nrun test16 \"activate_storage\"\n"; | |
298 | ||
299 | eval { | |
300 | PVE::Storage::activate_storage($cfg, $storagename); | |
301 | }; | |
302 | if ($@) { | |
303 | $count++; | |
304 | warn "Test 16 a: $@"; | |
305 | } | |
306 | }; | |
307 | $tests->{16} = $test16; | |
308 | ||
309 | my $test15 = sub { | |
310 | ||
311 | print "\nrun test15 \"template_list and vdisk_list\"\n"; | |
312 | ||
313 | my $hash = Dumper {}; | |
314 | ||
315 | my $res = Dumper PVE::Storage::template_list($cfg, $storagename, "vztmpl"); | |
316 | if ( $hash ne $res ) { | |
317 | $count++; | |
318 | warn "Test 15 a failed\n"; | |
319 | } | |
320 | $res = undef; | |
321 | ||
322 | $res = Dumper PVE::Storage::template_list($cfg, $storagename, "iso"); | |
323 | if ( $hash ne $res ) { | |
324 | $count++; | |
325 | warn "Test 15 b failed\n"; | |
326 | } | |
327 | $res = undef; | |
328 | ||
329 | $res = Dumper PVE::Storage::template_list($cfg, $storagename, "backup"); | |
330 | if ( $hash ne $res ) { | |
331 | $count++; | |
332 | warn "Test 15 c failed\n"; | |
333 | } | |
334 | $res = undef; | |
335 | ||
336 | $hash = Dumper {'zfstank99' => [ | |
337 | { | |
338 | 'parent' => undef, | |
339 | 'volid' => 'zfstank99:base-100-disk-1', | |
340 | 'name' => 'base-100-disk-1', | |
341 | 'vmid' => '100', | |
342 | 'size' => 1073741824, | |
343 | 'format' => 'raw' | |
344 | } | |
345 | ]}; | |
346 | ||
347 | $res = Dumper PVE::Storage::vdisk_list($cfg, $storagename, 100, ["$storagename:$vmbase"]); | |
348 | ||
349 | if ( $hash ne $res ) { | |
350 | $count++; | |
351 | warn "Test 15 d failed\n"; | |
352 | } | |
353 | $res = undef; | |
354 | ||
355 | $hash = Dumper {'zfstank99' => [ | |
356 | { | |
357 | 'parent' => undef, | |
358 | 'volid' => 'zfstank99:vm-102-disk-1', | |
359 | 'name' => 'vm-102-disk-1', | |
360 | 'vmid' => '102', | |
361 | 'size' => 1073741824, | |
362 | 'format' => 'raw' | |
363 | } | |
364 | ]}; | |
365 | ||
366 | $res = Dumper PVE::Storage::vdisk_list($cfg, $storagename, 102, ["$storagename:$vmdisk"]); | |
367 | if ( $hash ne $res ) { | |
368 | $count++; | |
369 | warn "Test 15 e failed\n"; | |
370 | } | |
371 | $res = undef; | |
372 | ||
373 | $hash = Dumper {'zfstank99' => [ | |
374 | { | |
375 | 'parent' => 'base-100-disk-1@__base__', | |
376 | 'volid' => "$storagename:$vmbase\/$vmlinked", | |
377 | 'name' => 'vm-101-disk-1', | |
378 | 'vmid' => '101', | |
379 | 'size' => 1073741824, | |
380 | 'format' => 'raw' | |
381 | } | |
382 | ]}; | |
383 | ||
384 | $res = Dumper PVE::Storage::vdisk_list($cfg, $storagename, 101, ["$storagename:$vmbase\/$vmlinked"]); | |
385 | if ( $hash ne $res ) { | |
386 | $count++; | |
387 | warn "Test 15 f failed\n"; | |
388 | } | |
389 | $res = undef; | |
390 | ||
391 | $hash = Dumper {'zfstank99' => [ | |
392 | { | |
393 | 'parent' => undef, | |
394 | 'volid' => 'zfstank99:basevol-200-disk-1', | |
395 | 'name' => 'basevol-200-disk-1', | |
396 | 'vmid' => '200', | |
397 | 'size' => 1073741824, | |
398 | 'format' => 'subvol' | |
399 | } | |
400 | ]}; | |
401 | ||
402 | $res = Dumper PVE::Storage::vdisk_list($cfg, $storagename, 200, ["$storagename:$ctbase"]); | |
403 | if ( $hash ne $res ) { | |
404 | $count++; | |
405 | warn "Test 15 g failed\n"; | |
406 | } | |
407 | $res = undef; | |
408 | ||
409 | $hash = Dumper {'zfstank99' => [ | |
410 | { | |
411 | 'parent' => undef, | |
412 | 'volid' => 'zfstank99:subvol-202-disk-1', | |
413 | 'name' => 'subvol-202-disk-1', | |
414 | 'vmid' => '202', | |
415 | 'size' => 1073741824, | |
416 | 'format' => 'subvol' | |
417 | } | |
418 | ]}; | |
419 | ||
420 | $res = Dumper PVE::Storage::vdisk_list($cfg, $storagename, 202, ["$storagename:$ctdisk"]); | |
421 | if ( $hash ne $res ) { | |
422 | $count++; | |
423 | warn "Test 15 h failed\n"; | |
424 | } | |
425 | $res = undef; | |
426 | ||
427 | $hash = Dumper {'zfstank99' => [ | |
428 | { | |
429 | 'parent' => 'basevol-200-disk-1@__base__', | |
430 | 'volid' => "$storagename:$ctbase\/$ctlinked", | |
431 | 'name' => 'subvol-201-disk-1', | |
432 | 'vmid' => '201', | |
433 | 'size' => 1073741824, | |
434 | 'format' => 'subvol' | |
435 | } | |
436 | ]}; | |
437 | $res = Dumper PVE::Storage::vdisk_list($cfg, $storagename, 201, ["$storagename:$ctbase\/$ctlinked"]); | |
438 | if ( $hash ne $res ) { | |
439 | $count++; | |
440 | warn "Test 15 i failed\n"; | |
441 | } | |
442 | }; | |
443 | $tests->{15} = $test15; | |
444 | ||
445 | my $test14 = sub { | |
446 | ||
447 | print "\nrun test14 \"vdisk_free\"\n"; | |
448 | ||
449 | eval { | |
450 | PVE::Storage::vdisk_free($cfg, "$storagename:$vmdisk"); | |
451 | ||
452 | eval { | |
453 | run_command("zfs list $zpath\/$vmdisk", outfunc => sub {}, errfunc => sub {}); | |
454 | }; | |
455 | if (!$@) { | |
456 | $count++; | |
457 | warn "Test14 a: vdisk still exists\n"; | |
458 | } | |
459 | }; | |
460 | if ($@) { | |
461 | $count++; | |
462 | warn "Test14 a: $@"; | |
463 | } | |
464 | ||
465 | eval { | |
466 | PVE::Storage::vdisk_free($cfg, "$storagename:$vmbase"); | |
467 | }; | |
468 | if (!$@) { | |
469 | $count++; | |
470 | warn "Test14 b: free vdisk should not work\n"; | |
471 | } | |
472 | ||
473 | eval { | |
474 | PVE::Storage::vdisk_free($cfg, "$storagename:$vmbase\/$vmlinked"); | |
475 | ||
476 | eval { | |
477 | run_command("zfs list $zpath\/$vmlinked", outfunc => sub {}, errfunc => sub {}); | |
478 | }; | |
479 | if (!$@) { | |
480 | $count++; | |
481 | warn "Test14 c: vdisk still exists\n"; | |
482 | } | |
483 | }; | |
484 | if ($@) { | |
485 | $count++; | |
486 | warn "Test14 c: $@"; | |
487 | } | |
488 | ||
489 | eval { | |
490 | PVE::Storage::vdisk_free($cfg, "$storagename:$ctdisk"); | |
491 | ||
492 | eval { | |
493 | run_command("zfs list $zpath\/$ctdisk", outfunc => sub {}, errfunc => sub {}); | |
494 | }; | |
495 | if (!$@) { | |
496 | $count++; | |
497 | warn "Test14 d: vdisk still exists\n"; | |
498 | } | |
499 | }; | |
500 | if ($@) { | |
501 | $count++; | |
502 | warn "Test14 d: $@"; | |
503 | } | |
504 | ||
505 | eval { | |
506 | PVE::Storage::vdisk_free($cfg, "$storagename:$ctbase"); | |
507 | }; | |
508 | if (!$@) { | |
509 | $count++; | |
510 | warn "Test14 e: free vdisk should not work\n"; | |
511 | } | |
512 | ||
513 | eval { | |
514 | PVE::Storage::vdisk_free($cfg, "$storagename:$ctbase\/$ctlinked"); | |
515 | ||
516 | eval { | |
517 | run_command("zfs list $zpath\/$ctlinked", outfunc => sub {}, errfunc => sub {}); | |
518 | }; | |
519 | if (!$@) { | |
520 | $count++; | |
521 | warn "Test14 f: vdisk still exists\n"; | |
522 | } | |
523 | }; | |
524 | if ($@) { | |
525 | $count++; | |
526 | warn "Test14 f: $@"; | |
527 | } | |
528 | ||
529 | eval { | |
530 | PVE::Storage::vdisk_free($cfg, "$storagename:$vmbase"); | |
531 | ||
532 | eval { | |
533 | run_command("zfs list $zpath\/$vmbase", outfunc => sub {}, errfunc => sub {}); | |
534 | }; | |
535 | if (!$@) { | |
536 | $count++; | |
537 | warn "Test14 g: vdisk still exists\n"; | |
538 | } | |
539 | }; | |
540 | if ($@) { | |
541 | $count++; | |
542 | warn "Test14 g: $@"; | |
543 | } | |
544 | ||
545 | eval { | |
546 | PVE::Storage::vdisk_free($cfg, "$storagename:$ctbase"); | |
547 | ||
548 | eval { | |
549 | run_command("zfs list $zpath\/$ctbase", outfunc => sub {}, errfunc => sub {}); | |
550 | }; | |
551 | if (!$@) { | |
552 | $count++; | |
553 | warn "Test14 h: vdisk still exists\n"; | |
554 | } | |
555 | }; | |
556 | if ($@) { | |
557 | $count++; | |
558 | warn "Test14 h: $@"; | |
559 | } | |
560 | }; | |
561 | $tests->{14} = $test14; | |
562 | ||
563 | my $test13 = sub { | |
564 | ||
565 | print "\nrun test13 \"vdisk_alloc\"\n"; | |
566 | ||
567 | eval { | |
568 | my $tmp_volid = PVE::Storage::vdisk_alloc($cfg, $storagename, "112", "raw", undef ,1024 * 1024); | |
569 | ||
59fa9fd6 | 570 | if ($tmp_volid ne "$storagename:vm-112-disk-0") { |
81ebc68f WL |
571 | die "volname:$tmp_volid don't match\n"; |
572 | } | |
573 | eval { | |
59fa9fd6 | 574 | run_command("zfs get -H volsize $zpath\/vm-112-disk-0", outfunc => |
81ebc68f | 575 | sub { my $tmp = shift; |
59fa9fd6 | 576 | if ($tmp !~ m/^$zpath\/vm-112-disk-0.*volsize.*1G.*$/) { |
81ebc68f WL |
577 | die "size don't match\n"; |
578 | } | |
579 | }); | |
580 | }; | |
581 | if ($@) { | |
582 | $count++; | |
583 | warn "Test13 a: $@"; | |
584 | } | |
585 | }; | |
586 | if ($@) { | |
587 | $count++; | |
588 | warn "Test13 a: $@"; | |
589 | } | |
590 | ||
591 | eval { | |
592 | my $tmp_volid = PVE::Storage::vdisk_alloc($cfg, $storagename, "112", "raw", undef ,2048 * 1024); | |
593 | ||
59fa9fd6 | 594 | if ($tmp_volid ne "$storagename:vm-112-disk-1") { |
81ebc68f WL |
595 | die "volname:$tmp_volid don't match\n"; |
596 | } | |
597 | eval { | |
59fa9fd6 | 598 | run_command("zfs get -H volsize $zpath\/vm-112-disk-1", outfunc => |
81ebc68f | 599 | sub { my $tmp = shift; |
59fa9fd6 | 600 | if ($tmp !~ m/^$zpath\/vm-112-disk-1.*volsize.*2G.*$/) { |
81ebc68f WL |
601 | die "size don't match\n"; |
602 | } | |
603 | }); | |
604 | }; | |
605 | if ($@) { | |
606 | $count++; | |
607 | warn "Test13 b: $@"; | |
608 | } | |
609 | }; | |
610 | if ($@) { | |
611 | $count++; | |
612 | warn "Test13 b: $@"; | |
613 | } | |
614 | ||
615 | eval { | |
616 | my $tmp_volid = PVE::Storage::vdisk_alloc($cfg, $storagename, "113", "subvol", undef ,1024 * 1024); | |
617 | ||
59fa9fd6 | 618 | if ($tmp_volid ne "$storagename:subvol-113-disk-0") { |
81ebc68f WL |
619 | die "volname:$tmp_volid don't match\n"; |
620 | } | |
621 | eval { | |
59fa9fd6 | 622 | run_command("zfs get -H refquota $zpath\/subvol-113-disk-0", outfunc => |
81ebc68f | 623 | sub { my $tmp = shift; |
59fa9fd6 | 624 | if ($tmp !~ m/^$zpath\/subvol-113-disk-0.*refquota.*1G.*$/) { |
81ebc68f WL |
625 | die "size don't match\n"; |
626 | } | |
627 | }); | |
628 | }; | |
629 | if ($@) { | |
630 | $count++; | |
631 | warn "Test13 c: $@"; | |
632 | } | |
633 | }; | |
634 | if ($@) { | |
635 | $count++; | |
636 | warn "Test13 c: $@"; | |
637 | } | |
638 | ||
639 | eval { | |
640 | my $tmp_volid = PVE::Storage::vdisk_alloc($cfg, $storagename, "113", "subvol", undef ,2048 * 1024); | |
641 | ||
59fa9fd6 | 642 | if ($tmp_volid ne "$storagename:subvol-113-disk-1") { |
81ebc68f WL |
643 | die "volname:$tmp_volid don't match\n"; |
644 | } | |
645 | eval { | |
59fa9fd6 | 646 | run_command("zfs get -H refquota $zpath\/subvol-113-disk-1", outfunc => |
81ebc68f | 647 | sub { my $tmp = shift; |
59fa9fd6 | 648 | if ($tmp !~ m/^$zpath\/subvol-113-disk-1.*refquota.*G.*$/) { |
81ebc68f WL |
649 | die "size don't match\n"; |
650 | } | |
651 | }); | |
652 | }; | |
653 | if ($@) { | |
654 | $count++; | |
655 | warn "Test13 d: $@"; | |
656 | } | |
657 | }; | |
658 | if ($@) { | |
659 | $count++; | |
660 | warn "Test13 d: $@"; | |
661 | } | |
662 | }; | |
663 | $tests->{13} = $test13; | |
664 | ||
665 | my $test12 = sub { | |
666 | ||
667 | print "\nrun test12 \"vdisk_create_base\"\n"; | |
668 | ||
669 | eval { | |
670 | my $tmp_volid = PVE::Storage::vdisk_create_base($cfg, "$storagename:$vmdisk"); | |
671 | ||
672 | if ($tmp_volid ne "$storagename:base-102-disk-1") { | |
673 | die; | |
674 | } | |
675 | eval { | |
676 | run_command("zfs list $zpath\/base-102-disk-1", outfunc => sub {}); | |
677 | }; | |
678 | if ($@) { | |
679 | $count++; | |
680 | warn "Test12 a: $@"; | |
681 | } | |
682 | }; | |
683 | if ($@) { | |
684 | $count++; | |
685 | warn "Test12 a: $@"; | |
686 | } | |
687 | ||
688 | eval { | |
689 | my $tmp_volid = PVE::Storage::vdisk_create_base($cfg, "$storagename:$vmlinked"); | |
690 | ||
691 | if ($tmp_volid ne "$storagename:base-101-disk-1") { | |
692 | die; | |
693 | } | |
694 | eval { | |
695 | run_command("zfs list $zpath\/base-101-disk-1", outfunc => sub {}); | |
696 | }; | |
697 | if ($@) { | |
698 | $count++; | |
699 | warn "Test12 b: $@"; | |
700 | } | |
701 | }; | |
702 | if ($@) { | |
703 | $count++; | |
704 | warn "Test12 b: $@"; | |
705 | } | |
706 | ||
707 | eval { | |
708 | my $tmp_volid = PVE::Storage::vdisk_create_base($cfg, "$storagename:$ctdisk"); | |
709 | ||
710 | if ($tmp_volid ne "$storagename:basevol-202-disk-1") { | |
711 | die ; | |
712 | } | |
713 | eval { | |
714 | run_command("zfs list $zpath\/basevol-202-disk-1", outfunc => sub {}); | |
715 | }; | |
716 | if ($@) { | |
717 | $count++; | |
718 | warn "Test12 c: $@"; | |
719 | } | |
720 | }; | |
721 | if ($@) { | |
722 | $count++; | |
723 | warn "Test12 c: $@"; | |
724 | } | |
725 | ||
726 | eval { | |
727 | my $tmp_volid = PVE::Storage::vdisk_create_base($cfg, "$storagename:$ctlinked"); | |
728 | ||
729 | if ($tmp_volid ne "$storagename:basevol-201-disk-1") { | |
730 | die; | |
731 | } | |
732 | eval { | |
733 | run_command("zfs list $zpath\/basevol-201-disk-1", outfunc => sub {}); | |
734 | }; | |
735 | if ($@) { | |
736 | $count++; | |
737 | warn "Test12 d: $@"; | |
738 | } | |
739 | }; | |
740 | if ($@) { | |
741 | $count++; | |
742 | warn "Test12 d: $@"; | |
743 | } | |
744 | }; | |
745 | $tests->{12} = $test12; | |
746 | ||
747 | my $test11 = sub { | |
748 | ||
749 | print "\nrun test11 \"volume_is_base\"\n"; | |
750 | ||
751 | eval { | |
752 | PVE::Storage::vdisk_clone($cfg, "$storagename:$vmdisk", 110); | |
753 | }; | |
754 | if (!$@) { | |
755 | $count++; | |
756 | warn "Test11 a: clone_image only works on base images"; | |
757 | } | |
758 | ||
759 | eval { | |
59fa9fd6 | 760 | if ("$storagename:$vmbase\/vm-110-disk-0" ne |
81ebc68f WL |
761 | PVE::Storage::vdisk_clone($cfg, "$storagename:$vmbase", 110, '__base__')){ |
762 | $count++; | |
763 | warn "Test11 b"; | |
764 | } | |
59fa9fd6 | 765 | run_command("zfs list -H -o volsize $zpath\/vm-110-disk-0", outfunc => sub { |
81ebc68f WL |
766 | my $line = shift; |
767 | ||
768 | chomp($line); | |
769 | warn "Test11 b not correct volsize" if $line !~ m/$volsize/; | |
770 | }); | |
771 | }; | |
772 | if ($@) { | |
773 | $count++; | |
774 | warn "Test11 b: $@"; | |
775 | } | |
776 | ||
777 | eval { | |
778 | PVE::Storage::vdisk_clone($cfg, "$storagename:$vmbase\/$vmlinked", 111); | |
779 | }; | |
780 | if (!$@) { | |
781 | $count++; | |
782 | warn "Test11 c: clone_image only works on base images"; | |
783 | } | |
784 | ||
785 | eval { | |
786 | PVE::Storage::vdisk_clone($cfg, "$storagename:$ctdisk", 110); | |
787 | }; | |
788 | if (!$@) { | |
789 | $count++; | |
790 | warn "Test11 d: clone_image only works on base images"; | |
791 | } | |
792 | ||
793 | eval { | |
59fa9fd6 | 794 | if ( "$storagename:$ctbase\/subvol-210-disk-0" ne |
81ebc68f WL |
795 | PVE::Storage::vdisk_clone($cfg, "$storagename:$ctbase", 210, '__base__')){ |
796 | $count++; | |
797 | warn "Test11 e"; | |
798 | } | |
59fa9fd6 | 799 | run_command("zfs list -H -o refquota $zpath\/subvol-210-disk-0", outfunc => sub { |
81ebc68f WL |
800 | my $line = shift; |
801 | ||
802 | chomp($line); | |
803 | warn "Test11 e not correct volsize" if $line !~ m/$volsize/; | |
804 | }); | |
805 | }; | |
806 | if ($@) { | |
807 | $count++; | |
808 | warn "Test11 e: $@"; | |
809 | } | |
810 | ||
811 | eval { | |
812 | PVE::Storage::vdisk_clone($cfg, "$storagename:$ctbase\/$ctlinked", 211); | |
813 | }; | |
814 | if (!$@) { | |
815 | $count++; | |
816 | warn "Test11 f: clone_image only works on base images"; | |
817 | } | |
818 | }; | |
819 | $tests->{11} = $test11; | |
820 | ||
821 | my $test10 =sub { | |
822 | ||
823 | print "\nrun test10 \"volume_is_base\"\n"; | |
824 | ||
825 | eval { | |
9924228b | 826 | if (1 == volume_is_base($cfg, "$storagename:$vmdisk")) { |
81ebc68f WL |
827 | $count++; |
828 | warn "Test10 a: is no base"; | |
829 | } | |
830 | ||
831 | }; | |
832 | if ($@) { | |
833 | $count++; | |
834 | warn "Test10 a: $@"; | |
835 | } | |
836 | ||
837 | eval { | |
9924228b | 838 | if (0 == volume_is_base($cfg, "$storagename:$vmbase")) { |
81ebc68f WL |
839 | $count++; |
840 | warn "Test10 b: is base"; | |
841 | } | |
842 | ||
843 | }; | |
844 | if ($@) { | |
845 | $count++; | |
846 | warn "Test10 b: $@"; | |
847 | } | |
848 | ||
849 | eval { | |
9924228b | 850 | if (1 == volume_is_base($cfg, "$storagename:$vmbase\/$vmlinked")) { |
81ebc68f WL |
851 | $count++; |
852 | warn "Test10 c: is no base"; | |
853 | } | |
854 | ||
855 | }; | |
856 | if ($@) { | |
857 | $count++; | |
858 | warn "Test10 c: $@"; | |
859 | } | |
860 | ||
861 | eval { | |
9924228b | 862 | if (1 == volume_is_base($cfg, "$storagename:$ctdisk")) { |
81ebc68f WL |
863 | $count++; |
864 | warn "Test10 d: is no base"; | |
865 | } | |
866 | ||
867 | }; | |
868 | if ($@) { | |
869 | $count++; | |
870 | warn "Test10 d: $@"; | |
871 | } | |
872 | ||
873 | eval { | |
9924228b | 874 | if (0 == volume_is_base($cfg, "$storagename:$ctbase")) { |
81ebc68f WL |
875 | $count++; |
876 | warn "Test10 e: is base"; | |
877 | } | |
878 | ||
879 | }; | |
880 | if ($@) { | |
881 | $count++; | |
882 | warn "Test10 e: $@"; | |
883 | } | |
884 | ||
885 | eval { | |
9924228b | 886 | if (1 == volume_is_base($cfg, "$storagename:$ctbase\/$ctlinked")) { |
81ebc68f WL |
887 | $count++; |
888 | warn "Test10 f: is no base"; | |
889 | } | |
890 | ||
891 | }; | |
892 | if ($@) { | |
893 | $count++; | |
894 | warn "Test10 f: $@"; | |
895 | } | |
896 | }; | |
897 | $tests->{10} = $test10; | |
898 | ||
899 | my $test9 =sub { | |
900 | ||
a3b7bc37 | 901 | print "\nrun test9 \"parse_volume_id\"\n"; |
81ebc68f WL |
902 | |
903 | eval { | |
904 | my ($store, $disk) = PVE::Storage::parse_volume_id("$storagename:$vmdisk"); | |
905 | ||
906 | if ($store ne $storagename || $disk ne $vmdisk) { | |
907 | $count++; | |
908 | warn "Test9 a: parsing wrong"; | |
909 | } | |
910 | ||
911 | }; | |
912 | if ($@) { | |
913 | $count++; | |
914 | warn "Test9 a: $@"; | |
915 | } | |
916 | ||
917 | eval { | |
918 | my ($store, $disk) = PVE::Storage::parse_volume_id("$storagename:$vmbase"); | |
919 | ||
920 | if ($store ne $storagename || $disk ne $vmbase) { | |
921 | $count++; | |
922 | warn "Test9 b: parsing wrong"; | |
923 | } | |
924 | ||
925 | }; | |
926 | if ($@) { | |
927 | $count++; | |
928 | warn "Test9 b: $@"; | |
929 | } | |
930 | ||
931 | eval { | |
932 | my ($store, $disk) = PVE::Storage::parse_volume_id("$storagename:$vmbase\/$vmlinked"); | |
933 | ||
934 | if ($store ne $storagename || $disk ne "$vmbase\/$vmlinked") { | |
935 | $count++; | |
936 | warn "Test9 c: parsing wrong"; | |
937 | } | |
938 | ||
939 | }; | |
940 | if ($@) { | |
941 | $count++; | |
942 | warn "Test9 c: $@"; | |
943 | } | |
944 | ||
945 | eval { | |
946 | my ($store, $disk) = PVE::Storage::parse_volume_id("$storagename:$ctdisk"); | |
947 | ||
948 | if ($store ne $storagename || $disk ne $ctdisk) { | |
949 | $count++; | |
950 | warn "Test9 d: parsing wrong"; | |
951 | } | |
952 | ||
953 | }; | |
954 | if ($@) { | |
955 | $count++; | |
956 | warn "Test9 d: $@"; | |
957 | } | |
958 | ||
959 | eval { | |
960 | my ($store, $disk) = PVE::Storage::parse_volume_id("$storagename:$ctbase"); | |
961 | ||
962 | if ($store ne $storagename || $disk ne $ctbase) { | |
963 | $count++; | |
964 | warn "Test9 e: parsing wrong"; | |
965 | } | |
966 | ||
967 | }; | |
968 | if ($@) { | |
969 | $count++; | |
970 | warn "Test9 e: $@"; | |
971 | } | |
972 | ||
973 | eval { | |
974 | my ($store, $disk) = PVE::Storage::parse_volume_id("$storagename:$ctbase\/$ctlinked"); | |
975 | ||
976 | if ($store ne $storagename || $disk ne "$ctbase\/$ctlinked") { | |
977 | $count++; | |
978 | warn "Test9 f: parsing wrong"; | |
979 | } | |
980 | ||
981 | }; | |
982 | if ($@) { | |
983 | $count++; | |
984 | warn "Test9 f: $@"; | |
985 | } | |
986 | }; | |
987 | $tests->{9} = $test9; | |
988 | ||
989 | my $test8 = sub { | |
990 | ||
991 | print "\nrun test8 \"parse_volname\"\n"; | |
992 | ||
993 | eval { | |
994 | my ($vtype, $name, $vmid, $basename, $basevmid, $isBase, $format) = PVE::Storage::parse_volname($cfg, "$storagename:$vmdisk"); | |
995 | ||
996 | if ($vtype ne 'images' || $vmid ne '102' || $name ne $vmdisk || | |
b3bb525e | 997 | defined($basename) || defined($basevmid) || $isBase || |
81ebc68f WL |
998 | $format ne 'raw') { |
999 | $count++; | |
1000 | warn "Test8 a: parsing wrong"; | |
1001 | } | |
1002 | ||
1003 | }; | |
1004 | if ($@) { | |
1005 | $count++; | |
1006 | warn "Test8 a: $@"; | |
1007 | } | |
1008 | ||
1009 | eval { | |
1010 | my ($vtype, $name, $vmid, $basename, $basevmid, $isBase, $format) = PVE::Storage::parse_volname($cfg, "$storagename:$vmbase"); | |
1011 | ||
1012 | if ($vtype ne 'images' || $vmid ne '100' || $name ne $vmbase || | |
b3bb525e | 1013 | defined($basename) || defined($basevmid) || !$isBase || |
81ebc68f WL |
1014 | $format ne 'raw') { |
1015 | $count++; | |
1016 | warn "Test8 b: parsing wrong"; | |
1017 | } | |
1018 | }; | |
1019 | if ($@) { | |
1020 | $count++; | |
1021 | warn "Test8 b: $@"; | |
1022 | } | |
1023 | ||
1024 | eval { | |
1025 | my ($vtype, $name, $vmid, $basename, $basevmid, $isBase, $format) = PVE::Storage::parse_volname($cfg, "$storagename:$vmbase\/$vmlinked"); | |
1026 | ||
1027 | if ($vtype ne 'images' || $name ne $vmlinked || $vmid ne '101' || | |
b3bb525e | 1028 | $basename ne $vmbase || $basevmid ne '100' || $isBase || |
81ebc68f WL |
1029 | $format ne 'raw') { |
1030 | $count++; | |
1031 | warn "Test8 c: parsing wrong"; | |
1032 | } | |
1033 | }; | |
1034 | if ($@) { | |
1035 | $count++; | |
1036 | warn "Test8 c: $@"; | |
1037 | } | |
1038 | ||
1039 | eval { | |
1040 | my ($vtype, $name, $vmid, $basename, $basevmid, $isBase, $format) = PVE::Storage::parse_volname($cfg, "$storagename:$ctdisk"); | |
1041 | ||
1042 | if ($vtype ne 'images' || $vmid ne '202' || $name ne $ctdisk || | |
b3bb525e | 1043 | defined($basename) || defined($basevmid) || $isBase || |
81ebc68f WL |
1044 | $format ne 'subvol') { |
1045 | $count++; | |
1046 | warn "Test8 d: parsing wrong"; | |
1047 | } | |
1048 | ||
1049 | }; | |
1050 | if ($@) { | |
1051 | $count++; | |
1052 | warn "Test8 d: $@"; | |
1053 | } | |
1054 | ||
1055 | eval { | |
1056 | my ($vtype, $name, $vmid, $basename, $basevmid, $isBase, $format) = PVE::Storage::parse_volname($cfg, "$storagename:$ctbase"); | |
1057 | if ($vtype ne 'images' || $vmid ne '200' || $name ne $ctbase || | |
b3bb525e | 1058 | defined($basename) || defined($basevmid) || !$isBase || |
81ebc68f WL |
1059 | $format ne 'subvol') { |
1060 | $count++; | |
1061 | warn "Test8 e: parsing wrong"; | |
1062 | } | |
1063 | }; | |
1064 | if ($@) { | |
1065 | $count++; | |
1066 | warn "Test8 e: $@"; | |
1067 | } | |
1068 | ||
1069 | eval { | |
1070 | my ($vtype, $name, $vmid, $basename, $basevmid, $isBase, $format) = PVE::Storage::parse_volname($cfg, "$storagename:$ctbase\/$ctlinked"); | |
1071 | ||
1072 | if ($vtype ne 'images' || $name ne $ctlinked || $vmid ne '201' || | |
b3bb525e | 1073 | $basename ne $ctbase || $basevmid ne '200' || $isBase || |
81ebc68f WL |
1074 | $format ne 'subvol') { |
1075 | $count++; | |
1076 | warn "Test8 f: parsing wrong"; | |
1077 | } | |
1078 | }; | |
1079 | if ($@) { | |
1080 | $count++; | |
1081 | warn "Test8 f: $@"; | |
1082 | } | |
1083 | }; | |
1084 | $tests->{8} = $test8; | |
1085 | ||
1086 | my $test7 = sub { | |
1087 | ||
1088 | print "\nrun test7 \"volume_rollback\"\n"; | |
1089 | ||
1090 | my $tmp_guid; | |
1091 | my $parse_guid = sub { | |
1092 | my ($line) = shift; | |
1093 | ||
1094 | if ( $line =~ m/^Disk identifier \(GUID\)\: (.*)$/ ) { | |
1095 | $tmp_guid = $1; | |
1096 | } | |
1097 | }; | |
1098 | ||
1099 | eval { | |
56362cfb | 1100 | PVE::Storage::activate_volumes($cfg, ["$storagename:$vmdisk"]); |
81ebc68f WL |
1101 | run_command("sgdisk --randomize-guids \/dev\/zvol\/$zpath\/$vmdisk", outfunc => $parse_guid); |
1102 | run_command("sgdisk -p \/dev\/zvol\/$zpath\/$vmdisk", outfunc => $parse_guid); | |
1103 | ||
1104 | my $old_guid = $tmp_guid; | |
1105 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmdisk", 'snap1'); | |
1106 | ||
1107 | run_command("sgdisk --randomize-guids \/dev\/zvol\/$zpath\/$vmdisk", outfunc => $parse_guid); | |
1108 | eval { | |
1109 | PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$vmdisk", 'snap1'); | |
56362cfb | 1110 | PVE::Storage::activate_volumes($cfg, ["$storagename:$vmdisk"]); |
81ebc68f WL |
1111 | $tmp_guid = undef; |
1112 | run_command("sgdisk -p \/dev\/zvol\/$zpath\/$vmdisk", outfunc => $parse_guid); | |
1113 | if ($old_guid ne $tmp_guid) { | |
1114 | $count++; | |
1115 | warn "Test7 a: Zvol makes no rollback"; | |
1116 | } | |
1117 | }; | |
1118 | if ($@) { | |
1119 | $count++; | |
1120 | warn "Test7 a: $@"; | |
1121 | } | |
1122 | }; | |
1123 | if ($@) { | |
1124 | $count++; | |
1125 | warn "Test7 a: $@"; | |
1126 | } | |
1127 | $tmp_guid = undef; | |
1128 | ||
1129 | eval { | |
56362cfb | 1130 | PVE::Storage::activate_volumes($cfg, ["$storagename:$vmbase"]); |
81ebc68f WL |
1131 | run_command("sgdisk --randomize-guids \/dev\/zvol\/$zpath\/$vmbase", outfunc => $parse_guid); |
1132 | run_command("sgdisk -p \/dev\/zvol\/$zpath\/$vmbase", outfunc => $parse_guid); | |
1133 | ||
1134 | my $old_guid = $tmp_guid; | |
1135 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase", 'snap1'); | |
1136 | ||
1137 | run_command("sgdisk --randomize-guids \/dev\/zvol\/$zpath\/$vmbase", outfunc => $parse_guid); | |
1138 | eval { | |
1139 | PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$vmbase", 'snap1'); | |
56362cfb | 1140 | PVE::Storage::activate_volumes($cfg, ["$storagename:$vmbase"]); |
81ebc68f WL |
1141 | $tmp_guid = undef; |
1142 | run_command("sgdisk -p \/dev\/zvol\/$zpath\/$vmbase", outfunc => $parse_guid); | |
1143 | if ($old_guid ne $tmp_guid) { | |
1144 | $count++; | |
1145 | warn "Test7 b: Zvol makes no rollback"; | |
1146 | } | |
1147 | }; | |
1148 | if ($@) { | |
1149 | $count++; | |
1150 | warn "Test7 b: $@"; | |
1151 | } | |
1152 | }; | |
1153 | if ($@) { | |
1154 | $count++; | |
1155 | warn "Test7 b: $@"; | |
1156 | } | |
1157 | $tmp_guid = undef; | |
1158 | ||
1159 | eval { | |
56362cfb | 1160 | PVE::Storage::activate_volumes($cfg, ["$storagename:$vmbase/$vmlinked"]); |
81ebc68f WL |
1161 | run_command("sgdisk --randomize-guids \/dev\/zvol\/$zpath\/$vmlinked", outfunc => $parse_guid); |
1162 | run_command("sgdisk -p \/dev\/zvol\/$zpath\/$vmlinked", outfunc => $parse_guid); | |
1163 | ||
1164 | my $old_guid = $tmp_guid; | |
1165 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase\/$vmlinked", 'snap1'); | |
1166 | ||
1167 | run_command("sgdisk --randomize-guids \/dev\/zvol\/$zpath\/$vmlinked", outfunc => $parse_guid); | |
1168 | eval { | |
1169 | PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$vmbase\/$vmlinked", 'snap1'); | |
56362cfb | 1170 | PVE::Storage::activate_volumes($cfg, ["$storagename:$vmbase/$vmlinked"]); |
81ebc68f WL |
1171 | $tmp_guid = undef; |
1172 | run_command("sgdisk -p \/dev\/zvol\/$zpath\/$vmlinked", outfunc => $parse_guid); | |
1173 | if ($old_guid ne $tmp_guid) { | |
1174 | $count++; | |
1175 | warn "Test7 c: Zvol makes no rollback"; | |
1176 | } | |
1177 | }; | |
1178 | if ($@) { | |
1179 | $count++; | |
1180 | warn "Test7 c: $@"; | |
1181 | } | |
1182 | }; | |
1183 | if ($@) { | |
1184 | $count++; | |
1185 | warn "Test7 c: $@"; | |
1186 | } | |
1187 | $tmp_guid = undef; | |
1188 | ||
1189 | eval { | |
1190 | PVE::Storage::volume_snapshot($cfg, "$storagename:$ctdisk", 'snap1'); | |
1191 | ||
dcefd9dd | 1192 | run_command("touch \/$mountpoint\/$ctdisk\/test.txt", outfunc => $parse_guid); |
81ebc68f WL |
1193 | eval { |
1194 | PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$ctdisk", 'snap1'); | |
1195 | eval { | |
dcefd9dd | 1196 | run_command("ls \/$mountpoint\/$ctdisk\/test.txt", errofunc => sub {}); |
81ebc68f WL |
1197 | }; |
1198 | if (!$@) { | |
1199 | $count++; | |
1200 | warn "Test7 d: $@"; | |
1201 | } | |
1202 | }; | |
1203 | if ($@) { | |
1204 | $count++; | |
1205 | warn "Test7 d: $@"; | |
1206 | } | |
1207 | }; | |
1208 | if ($@) { | |
1209 | $count++; | |
1210 | warn "Test7 d: $@"; | |
1211 | } | |
1212 | ||
1213 | eval { | |
1214 | PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase", 'snap1'); | |
1215 | ||
dcefd9dd | 1216 | run_command("touch \/$mountpoint\/$ctbase\/test.txt", outfunc => $parse_guid); |
81ebc68f WL |
1217 | eval { |
1218 | PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$ctbase", 'snap1'); | |
1219 | eval { | |
dcefd9dd | 1220 | run_command("ls \/$mountpoint\/$ctbase\/test.txt", errofunc => sub {}); |
81ebc68f WL |
1221 | }; |
1222 | if (!$@) { | |
1223 | $count++; | |
1224 | warn "Test7 e: $@"; | |
1225 | } | |
1226 | }; | |
1227 | if ($@) { | |
1228 | $count++; | |
1229 | warn "Test7 e: $@"; | |
1230 | } | |
1231 | }; | |
1232 | if ($@) { | |
1233 | $count++; | |
1234 | warn "Test7 f: $@"; | |
1235 | } | |
1236 | ||
1237 | eval { | |
1238 | PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase/$ctlinked", 'snap1'); | |
1239 | ||
dcefd9dd | 1240 | run_command("touch \/$mountpoint\/$ctlinked\/test.txt", outfunc => $parse_guid); |
81ebc68f WL |
1241 | eval { |
1242 | PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$ctbase/$ctlinked", 'snap1'); | |
1243 | eval { | |
1244 | run_command("ls \/$zpath\/$ctlinked\/test.txt", errofunc => sub {}); | |
1245 | }; | |
1246 | if (!$@) { | |
1247 | $count++; | |
1248 | warn "Test7 g: $@"; | |
1249 | } | |
1250 | }; | |
1251 | if ($@) { | |
1252 | $count++; | |
1253 | warn "Test7 g: $@"; | |
1254 | } | |
1255 | }; | |
1256 | if ($@) { | |
1257 | $count++; | |
1258 | warn "Test7 g: $@"; | |
1259 | } | |
1260 | ||
1261 | eval { | |
1262 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmdisk", 'snap2'); | |
1263 | ||
1264 | eval { | |
1265 | PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$vmdisk", 'snap1'); | |
1266 | }; | |
1267 | if (!$@) { | |
1268 | $count++; | |
1269 | warn "Test7 h: Not allowed to rollback"; | |
1270 | } | |
1271 | }; | |
1272 | if ($@) { | |
1273 | $count++; | |
1274 | warn "Test7 h: $@"; | |
1275 | } | |
1276 | ||
1277 | eval { | |
1278 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase", 'snap2'); | |
1279 | ||
1280 | eval { | |
1281 | PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$vmbase", 'snap1'); | |
1282 | }; | |
1283 | if (!$@) { | |
1284 | $count++; | |
1285 | warn "Test7 i: Not allowed to rollback"; | |
1286 | } | |
1287 | }; | |
1288 | if ($@) { | |
1289 | $count++; | |
1290 | warn "Test7 i: $@"; | |
1291 | } | |
1292 | ||
1293 | eval { | |
1294 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase\/$vmlinked", 'snap2'); | |
1295 | ||
1296 | eval { | |
1297 | PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$vmbase\/$vmlinked", 'snap1'); | |
1298 | }; | |
1299 | if (!$@) { | |
1300 | $count++; | |
1301 | warn "Test7 j: Not allowed to rollback"; | |
1302 | } | |
1303 | }; | |
1304 | if ($@) { | |
1305 | $count++; | |
1306 | warn "Test7 j: $@"; | |
1307 | } | |
1308 | ||
1309 | eval { | |
1310 | PVE::Storage::volume_snapshot($cfg, "$storagename:$ctdisk", 'snap2'); | |
1311 | ||
1312 | eval { | |
1313 | PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$ctdisk", 'snap1'); | |
1314 | }; | |
1315 | if (!$@) { | |
1316 | $count++; | |
1317 | warn "Test7 k: Not allowed to rollback"; | |
1318 | } | |
1319 | }; | |
1320 | if ($@) { | |
1321 | $count++; | |
1322 | warn "Test7 k: $@"; | |
1323 | } | |
1324 | ||
1325 | eval { | |
1326 | PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase", 'snap2'); | |
1327 | ||
1328 | eval { | |
1329 | PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$ctbase", 'snap1'); | |
1330 | }; | |
1331 | if (!$@) { | |
1332 | $count++; | |
1333 | warn "Test7 l: Not allowed to rollback"; | |
1334 | } | |
1335 | }; | |
1336 | if ($@) { | |
1337 | $count++; | |
1338 | warn "Test7 l: $@"; | |
1339 | } | |
1340 | ||
1341 | eval { | |
1342 | PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase/$ctlinked", 'snap2'); | |
1343 | ||
1344 | eval { | |
1345 | PVE::Storage::volume_snapshot_rollback($cfg, "$storagename:$ctbase/$ctlinked", 'snap1'); | |
1346 | }; | |
1347 | if (!$@) { | |
1348 | $count++; | |
1349 | warn "Test7 m: Not allowed to rollback"; | |
1350 | } | |
1351 | }; | |
1352 | if ($@) { | |
1353 | $count++; | |
1354 | warn "Test7 m: $@"; | |
1355 | } | |
1356 | }; | |
1357 | $tests->{7} = $test7; | |
1358 | ||
1359 | my $test6 = sub { | |
1360 | ||
1361 | print "\nrun test6 \"volume_rollback_is_possible\"\n"; | |
1362 | ||
1363 | eval { | |
1364 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmdisk", 'snap1'); | |
665f61a2 FE |
1365 | |
1366 | my $blockers = []; | |
1367 | my $res = PVE::Storage::volume_rollback_is_possible( | |
1368 | $cfg, | |
1369 | "$storagename:$vmdisk", | |
1370 | 'snap1', | |
1371 | $blockers, | |
1372 | ); | |
1373 | if ($res != 1) { | |
1374 | $count++; | |
1375 | warn "Test6 a: Rollback should be possible"; | |
1376 | } | |
1377 | if (scalar($blockers->@*) != 0) { | |
81ebc68f | 1378 | $count++; |
665f61a2 | 1379 | warn "Test6 a: 'blockers' should be empty"; |
81ebc68f WL |
1380 | } |
1381 | }; | |
1382 | if ($@) { | |
1383 | $count++; | |
1384 | warn "Test6 a: $@"; | |
1385 | } | |
1386 | ||
1387 | eval { | |
1388 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase", 'snap1'); | |
1389 | if ( 1 != | |
1390 | PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$vmbase", 'snap1')) { | |
1391 | $count++; | |
665f61a2 | 1392 | warn "Test6 b: Rollback should be possible"; |
81ebc68f WL |
1393 | } |
1394 | }; | |
1395 | if ($@) { | |
1396 | $count++; | |
1397 | warn "Test6 b: $@"; | |
1398 | } | |
1399 | ||
1400 | eval { | |
1401 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmlinked", 'snap1'); | |
1402 | if ( 1 != | |
1403 | PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$vmbase\/$vmlinked", 'snap1')) { | |
1404 | $count++; | |
665f61a2 | 1405 | warn "Test6 c: Rollback should be possible"; |
81ebc68f WL |
1406 | } |
1407 | }; | |
1408 | if ($@) { | |
1409 | $count++; | |
1410 | warn "Test6 c: $@"; | |
1411 | } | |
1412 | ||
1413 | eval { | |
1414 | PVE::Storage::volume_snapshot($cfg, "$storagename:$ctdisk", 'snap1'); | |
1415 | if ( 1 != | |
1416 | PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$ctdisk", 'snap1')) { | |
1417 | $count++; | |
665f61a2 | 1418 | warn "Test6 d: Rollback should be possible"; |
81ebc68f WL |
1419 | } |
1420 | }; | |
1421 | if ($@) { | |
1422 | $count++; | |
1423 | warn "Test6 d: $@"; | |
1424 | } | |
1425 | ||
1426 | eval { | |
1427 | PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase", 'snap1'); | |
1428 | if ( 1 != | |
1429 | PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$ctbase", 'snap1')) { | |
1430 | $count++; | |
665f61a2 | 1431 | warn "Test6 e: Rollback should be possible"; |
81ebc68f WL |
1432 | } |
1433 | }; | |
1434 | if ($@) { | |
1435 | $count++; | |
1436 | warn "Test6 e: $@"; | |
1437 | } | |
1438 | ||
1439 | eval { | |
1440 | PVE::Storage::volume_snapshot($cfg, "$storagename:$ctlinked", 'snap1'); | |
1441 | if ( 1 != | |
1442 | PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$ctbase\/$ctlinked", 'snap1')) { | |
1443 | $count++; | |
665f61a2 | 1444 | warn "Test6 f: Rollback should be possible"; |
81ebc68f WL |
1445 | } |
1446 | }; | |
1447 | if ($@) { | |
1448 | $count++; | |
1449 | warn "Test6 f: $@"; | |
1450 | } | |
1451 | ||
665f61a2 | 1452 | my $blockers = []; |
81ebc68f WL |
1453 | eval { |
1454 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmdisk", 'snap2'); | |
665f61a2 | 1455 | PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$vmdisk", 'snap1', $blockers); |
81ebc68f WL |
1456 | }; |
1457 | if (!$@) { | |
1458 | $count++; | |
665f61a2 FE |
1459 | warn "Test6 g: Rollback should not be possible"; |
1460 | } elsif (scalar($blockers->@*) != 1 || $blockers->[0] ne 'snap2') { | |
1461 | $count++; | |
1462 | warn "Test6 g: 'blockers' should be ['snap2']"; | |
81ebc68f | 1463 | } |
665f61a2 | 1464 | undef $blockers; |
81ebc68f | 1465 | |
665f61a2 | 1466 | $blockers = []; |
81ebc68f WL |
1467 | eval { |
1468 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase", 'snap2'); | |
665f61a2 FE |
1469 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase", 'snap3'); |
1470 | PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$vmbase", 'snap1', $blockers); | |
81ebc68f WL |
1471 | }; |
1472 | if (!$@) { | |
1473 | $count++; | |
665f61a2 FE |
1474 | warn "Test6 h: Rollback should not be possible"; |
1475 | } else { | |
1476 | if (scalar($blockers->@*) != 2) { | |
1477 | $count++; | |
1478 | warn "Test6 g: 'blockers' should contain two elements"; | |
1479 | } | |
1480 | my $blockers_hash = { map { $_ => 1 } $blockers->@* }; | |
1481 | if (!$blockers_hash->{'snap2'}) { | |
1482 | $count++; | |
1483 | warn "Test6 g: 'blockers' should contain 'snap2'"; | |
1484 | } | |
1485 | if (!$blockers_hash->{'snap3'}) { | |
1486 | $count++; | |
1487 | warn "Test6 g: 'blockers' should contain 'snap3'"; | |
1488 | } | |
81ebc68f | 1489 | } |
665f61a2 | 1490 | undef $blockers; |
81ebc68f WL |
1491 | |
1492 | eval { | |
1493 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmlinked", 'snap2'); | |
1494 | PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$vmbase\/$vmlinked", 'snap1'); | |
1495 | }; | |
1496 | if (!$@) { | |
1497 | $count++; | |
665f61a2 | 1498 | warn "Test6 j: Rollback should not be possible"; |
81ebc68f WL |
1499 | } |
1500 | ||
1501 | eval { | |
1502 | PVE::Storage::volume_snapshot($cfg, "$storagename:$ctdisk", 'snap2'); | |
1503 | PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$ctdisk", 'snap1'); | |
1504 | }; | |
1505 | if (!$@) { | |
1506 | $count++; | |
665f61a2 | 1507 | warn "Test6 k: Rollback should not be possible"; |
81ebc68f WL |
1508 | } |
1509 | ||
1510 | eval { | |
1511 | PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase", 'snap2'); | |
1512 | PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$ctbase", 'snap1'); | |
1513 | }; | |
1514 | if (!$@) { | |
1515 | $count++; | |
665f61a2 | 1516 | warn "Test6 l: Rollback should not be possible"; |
81ebc68f WL |
1517 | } |
1518 | ||
1519 | eval { | |
1520 | PVE::Storage::volume_snapshot($cfg, "$storagename:$ctlinked", 'snap2'); | |
1521 | PVE::Storage::volume_rollback_is_possible($cfg, "$storagename:$ctbase\/$ctlinked", 'snap1'); | |
1522 | }; | |
1523 | if (!$@) { | |
1524 | $count++; | |
665f61a2 | 1525 | warn "Test6 m: Rollback should not be possible"; |
81ebc68f WL |
1526 | } |
1527 | }; | |
1528 | $tests->{6} = $test6; | |
1529 | ||
1530 | my $test5 = sub { | |
1531 | ||
1532 | print "\nrun test5 \"volume_snapshot_delete\"\n"; | |
1533 | my $out = sub{my $tmp = shift;}; | |
1534 | ||
1535 | eval { | |
1536 | run_command("zfs snapshot $zpath\/$vmdisk\@snap"); | |
1537 | eval{ | |
1538 | PVE::Storage::volume_snapshot_delete($cfg, "$storagename:$vmdisk", 'snap'); | |
1539 | eval{ | |
1540 | run_command("zfs list $zpath\/$vmdisk\@snap", errfunc => $out, outfunc => $out); | |
1541 | }; | |
1542 | if (!$@) { | |
1543 | $count++; | |
1544 | warn "Test5 a: snapshot still exists"; | |
1545 | } | |
1546 | }; | |
1547 | if ($@) { | |
1548 | $count++; | |
1549 | warn "Test5 PVE a: $@"; | |
1550 | } | |
1551 | }; | |
1552 | if ($@) { | |
1553 | $count++; | |
1554 | warn "Test5 a: $@"; | |
1555 | } | |
1556 | ||
1557 | eval { | |
1558 | run_command("zfs snapshot $zpath\/$vmbase\@snap"); | |
1559 | eval{ | |
1560 | PVE::Storage::volume_snapshot_delete($cfg, "$storagename:$vmbase", 'snap'); | |
1561 | eval{ | |
1562 | run_command("zfs list $zpath\/$vmbase\@snap", errmsg => $out, outfunc => $out); | |
1563 | }; | |
1564 | if (!$@) { | |
1565 | $count++; | |
1566 | warn "Test5 b: snapshot still exists"; | |
1567 | } | |
1568 | }; | |
1569 | if ($@) { | |
1570 | $count++; | |
1571 | warn "Test5 PVE b: $@"; | |
1572 | } | |
1573 | }; | |
1574 | if ($@) { | |
1575 | $count++; | |
1576 | warn "Test5 b: $@"; | |
1577 | } | |
1578 | ||
1579 | eval { | |
1580 | run_command("zfs snapshot $zpath\/$vmlinked\@snap"); | |
1581 | eval{ | |
1582 | PVE::Storage::volume_snapshot_delete($cfg, "$storagename:$vmbase\/$vmlinked", 'snap'); | |
1583 | eval{ | |
1584 | run_command("zfs list $zpath\/$vmlinked\@snap", errmsg => $out, outfunc => $out); | |
1585 | }; | |
1586 | if (!$@) { | |
1587 | $count++; | |
1588 | warn "Test5 c: snapshot still exists"; | |
1589 | } | |
1590 | }; | |
1591 | if ($@) { | |
1592 | $count++; | |
1593 | warn "Test5 PVE c: $@"; | |
1594 | } | |
1595 | }; | |
1596 | if ($@) { | |
1597 | $count++; | |
1598 | warn "Test5 c: $@"; | |
1599 | } | |
1600 | ||
1601 | eval { | |
1602 | run_command("zfs snapshot $zpath\/$ctdisk\@snap"); | |
1603 | eval{ | |
1604 | PVE::Storage::volume_snapshot_delete($cfg, "$storagename:$ctdisk", 'snap'); | |
1605 | eval{ | |
1606 | run_command("zfs list $zpath\/$ctdisk\@snap", errmsg => $out, outfunc => $out); | |
1607 | }; | |
1608 | if (!$@) { | |
1609 | $count++; | |
1610 | warn "Test5 d: snapshot still exists"; | |
1611 | } | |
1612 | }; | |
1613 | if ($@) { | |
1614 | $count++; | |
1615 | warn "Test5 PVE d: $@"; | |
1616 | } | |
1617 | }; | |
1618 | if ($@) { | |
1619 | $count++; | |
1620 | warn "Test5 d: $@"; | |
1621 | } | |
1622 | ||
1623 | eval { | |
1624 | run_command("zfs snapshot $zpath\/$ctbase\@snap"); | |
1625 | eval{ | |
1626 | PVE::Storage::volume_snapshot_delete($cfg, "$storagename:$ctbase", 'snap'); | |
1627 | eval{ | |
1628 | run_command("zfs list $zpath\/$ctbase\@snap", errmsg => $out, outfunc => $out); | |
1629 | }; | |
1630 | if (!$@) { | |
1631 | $count++; | |
1632 | warn "Test5 e: snapshot still exists"; | |
1633 | } | |
1634 | }; | |
1635 | if ($@) { | |
1636 | $count++; | |
1637 | warn "Test5 PVE e: $@"; | |
1638 | } | |
1639 | }; | |
1640 | if ($@) { | |
1641 | $count++; | |
1642 | warn "Test5 e: $@"; | |
1643 | } | |
1644 | ||
1645 | eval { | |
1646 | run_command("zfs snapshot $zpath\/$ctlinked\@snap"); | |
1647 | eval{ | |
1648 | PVE::Storage::volume_snapshot_delete($cfg, "$storagename:$ctbase\/$ctlinked", 'snap'); | |
1649 | eval{ | |
1650 | run_command("zfs list $zpath\/$ctlinked\@snap", errmsg => $out, outfunc => $out); | |
1651 | }; | |
1652 | if (!$@) { | |
1653 | $count++; | |
1654 | warn "Test5 f: snapshot still exists"; | |
1655 | } | |
1656 | }; | |
1657 | if ($@) { | |
1658 | $count++; | |
1659 | warn "Test5 PVE f: $@"; | |
1660 | } | |
1661 | }; | |
1662 | if ($@) { | |
1663 | $count++; | |
1664 | warn "Test5 f: $@"; | |
1665 | } | |
2acdffbb | 1666 | print "######Ignore Output if no Test5 g: is included######\n"; |
81ebc68f WL |
1667 | eval{ |
1668 | PVE::Storage::volume_snapshot_delete($cfg, "$storagename:$vmbase", '__base__'); | |
1669 | eval{ | |
1670 | run_command("zfs list $zpath\/$vmbase\@__base__", outfunc => $out); | |
1671 | }; | |
1672 | if ($@) { | |
1673 | $count++; | |
1674 | warn "Test5 g: $@"; | |
1675 | } | |
1676 | }; | |
1677 | if (!$@) { | |
1678 | $count++; | |
1679 | warn "Test5 PVE g: snapshot __base__ can be erased"; | |
1680 | } | |
2acdffbb | 1681 | print "######End Ignore#######\n"; |
81ebc68f WL |
1682 | }; |
1683 | $tests->{5} = $test5; | |
1684 | ||
1685 | my $test4 = sub { | |
1686 | ||
1687 | print "\nrun test4 \"volume_snapshot\"\n"; | |
1688 | my $out = sub{}; | |
1689 | ||
1690 | eval { | |
1691 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmdisk", 'snap'); | |
1692 | eval{ | |
1693 | run_command("zfs list $zpath\/$vmdisk\@snap", errmsg => $out, outfunc => $out); | |
1694 | }; | |
1695 | if ($@) { | |
1696 | $count++; | |
1697 | warn "Test4 a: $@"; | |
1698 | } | |
1699 | }; | |
1700 | if ($@) { | |
1701 | $count++; | |
1702 | warn "Test4 a: $@"; | |
1703 | } | |
1704 | ||
1705 | eval { | |
1706 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase", 'snap'); | |
1707 | eval{ | |
1708 | run_command("zfs list $zpath\/$vmbase\@snap", errmsg => $out, outfunc => $out); | |
1709 | }; | |
1710 | if ($@) { | |
1711 | $count++; | |
1712 | warn "Test4 b: $@"; | |
1713 | } | |
1714 | }; | |
1715 | if ($@) { | |
1716 | $count++; | |
1717 | warn "Test4 c: $@"; | |
1718 | } | |
1719 | ||
1720 | eval { | |
1721 | PVE::Storage::volume_snapshot($cfg, "$storagename:$vmbase\/$vmlinked", 'snap'); | |
1722 | eval{ | |
1723 | run_command("zfs list $zpath\/$vmdisk\@snap", errmsg => $out, outfunc => $out); | |
1724 | }; | |
1725 | if ($@) { | |
1726 | $count++; | |
1727 | warn "Test4 c: $@"; | |
1728 | } | |
1729 | }; | |
1730 | if ($@) { | |
1731 | $count++; | |
1732 | warn "Test4 c: $@"; | |
1733 | } | |
1734 | ||
1735 | eval { | |
1736 | PVE::Storage::volume_snapshot($cfg, "$storagename:$ctdisk", 'snap'); | |
1737 | eval{ | |
1738 | run_command("zfs list $zpath\/$ctdisk\@snap", errmsg => $out, outfunc => $out); | |
1739 | }; | |
1740 | if ($@) { | |
1741 | $count++; | |
1742 | warn "Test4 d: $@"; | |
1743 | } | |
1744 | }; | |
1745 | if ($@) { | |
1746 | $count++; | |
1747 | warn "Test4 d: $@"; | |
1748 | } | |
1749 | ||
1750 | eval { | |
1751 | PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase", 'snap'); | |
1752 | eval{ | |
1753 | run_command("zfs list $zpath\/$ctbase\@snap", errmsg => $out, outfunc => $out); | |
1754 | }; | |
1755 | if ($@) { | |
1756 | $count++; | |
1757 | warn "Test4 e: $@"; | |
1758 | } | |
1759 | }; | |
1760 | if ($@) { | |
1761 | $count++; | |
1762 | warn "Test4 e: $@"; | |
1763 | } | |
1764 | ||
1765 | eval { | |
1766 | PVE::Storage::volume_snapshot($cfg, "$storagename:$ctbase\/$ctlinked", 'snap'); | |
1767 | eval{ | |
1768 | run_command("zfs list $zpath\/$ctdisk\@snap", errmsg => $out, outfunc => $out); | |
1769 | }; | |
1770 | if ($@) { | |
1771 | $count++; | |
1772 | warn "Test4 f: $@"; | |
1773 | } | |
1774 | }; | |
1775 | if ($@) { | |
1776 | $count++; | |
1777 | warn "Test4 f: $@"; | |
1778 | } | |
1779 | }; | |
1780 | $tests->{4} = $test4; | |
1781 | ||
1782 | my $test3 = sub { | |
1783 | ||
1784 | print "\nrun test3 \"volume_has_feature\"\n"; | |
1785 | ||
1786 | eval { | |
1787 | if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$vmdisk", undef, 0)) { | |
1788 | $count++; | |
1789 | warn "Test3 a failed"; | |
1790 | } | |
1791 | }; | |
1792 | if ($@) { | |
1793 | $count++; | |
1794 | warn "Test3 a: $@"; | |
1795 | } | |
1796 | ||
1797 | eval { | |
1798 | if (PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$vmbase", undef, 0)) { | |
1799 | $count++; | |
1800 | warn "Test3 b failed"; | |
1801 | } | |
1802 | }; | |
1803 | if ($@) { | |
1804 | $count++; | |
1805 | warn "Test3 b: $@"; | |
1806 | } | |
1807 | ||
1808 | eval { | |
1809 | if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$vmbase\/$vmlinked", undef, 0)) { | |
1810 | $count++; | |
1811 | warn "Test3 c failed"; | |
1812 | } | |
1813 | }; | |
1814 | if ($@) { | |
1815 | $count++; | |
1816 | warn "Test3 c: $@"; | |
1817 | } | |
1818 | ||
1819 | eval { | |
1820 | if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$ctdisk", undef, 0)) { | |
1821 | $count++; | |
1822 | warn "Test3 d failed"; | |
1823 | } | |
1824 | }; | |
1825 | if ($@) { | |
1826 | $count++; | |
1827 | warn "Test3 d: $@"; | |
1828 | } | |
1829 | ||
1830 | eval { | |
1831 | if (PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$ctbase", undef, 0)) { | |
1832 | $count++; | |
1833 | warn "Test3 e failed"; | |
1834 | } | |
1835 | }; | |
1836 | if ($@) { | |
1837 | $count++; | |
1838 | warn "Test3 e: $@"; | |
1839 | } | |
1840 | ||
1841 | eval { | |
1842 | if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$ctbase\/$ctlinked", undef, 0)) { | |
1843 | $count++; | |
1844 | warn "Test3 f failed"; | |
1845 | } | |
1846 | }; | |
1847 | if ($@) { | |
1848 | $count++; | |
1849 | warn "Test3 f: $@"; | |
1850 | } | |
1851 | ||
1852 | eval { | |
1853 | if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$vmdisk", undef, 0)) { | |
1854 | $count++; | |
1855 | warn "Test3 g failed"; | |
1856 | } | |
1857 | }; | |
1858 | if ($@) { | |
1859 | $count++; | |
1860 | warn "Test3 g: $@"; | |
1861 | } | |
1862 | ||
1863 | eval { | |
1864 | if (!PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$vmbase", undef, 0)) { | |
1865 | $count++; | |
1866 | warn "Test3 h failed"; | |
1867 | } | |
1868 | }; | |
1869 | if ($@) { | |
1870 | $count++; | |
1871 | warn "Test3 h: $@"; | |
1872 | } | |
1873 | ||
1874 | eval { | |
1875 | if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$vmbase\/$vmlinked", undef, 0)) { | |
1876 | $count++; | |
1877 | warn "Test3 h failed"; | |
1878 | } | |
1879 | }; | |
1880 | if ($@) { | |
1881 | $count++; | |
1882 | warn "Test3 h: $@"; | |
1883 | } | |
1884 | ||
1885 | eval { | |
1886 | if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$ctdisk", undef, 0)) { | |
1887 | $count++; | |
1888 | warn "Test3 i failed"; | |
1889 | } | |
1890 | }; | |
1891 | if ($@) { | |
1892 | $count++; | |
1893 | warn "Test3 i: $@"; | |
1894 | } | |
1895 | ||
1896 | eval { | |
1897 | if (!PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$ctbase", undef, 0)) { | |
1898 | $count++; | |
1899 | warn "Test3 j failed"; | |
1900 | } | |
1901 | }; | |
1902 | if ($@) { | |
1903 | $count++; | |
1904 | warn "Test3 j: $@"; | |
1905 | } | |
1906 | ||
1907 | eval { | |
1908 | if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$ctbase\/$ctlinked", undef, 0)) { | |
1909 | $count++; | |
1910 | warn "Test3 k failed"; | |
1911 | } | |
1912 | }; | |
1913 | if ($@) { | |
1914 | $count++; | |
1915 | warn "Test3 k: $@"; | |
1916 | } | |
1917 | ||
1918 | eval { | |
1919 | if (!PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$vmdisk", undef, 0)) { | |
1920 | $count++; | |
1921 | warn "Test3 l failed"; | |
1922 | } | |
1923 | }; | |
1924 | if ($@) { | |
1925 | $count++; | |
1926 | warn "Test3 l: $@"; | |
1927 | } | |
1928 | ||
1929 | eval { | |
1930 | if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$vmbase", undef, 0)) { | |
1931 | $count++; | |
1932 | warn "Test3 m failed"; | |
1933 | } | |
1934 | }; | |
1935 | if ($@) { | |
1936 | $count++; | |
1937 | warn "Test3 m: $@"; | |
1938 | } | |
1939 | ||
1940 | eval { | |
1941 | if (!PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$vmbase\/$vmlinked", undef, 0)) { | |
1942 | $count++; | |
1943 | warn "Test3 n failed"; | |
1944 | } | |
1945 | }; | |
1946 | if ($@) { | |
1947 | $count++; | |
1948 | warn "Test3 n: $@"; | |
1949 | } | |
1950 | ||
1951 | eval { | |
1952 | if (!PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$ctdisk", undef, 0)) { | |
1953 | $count++; | |
1954 | warn "Test3 o failed"; | |
1955 | } | |
1956 | }; | |
1957 | if ($@) { | |
1958 | $count++; | |
1959 | warn "Test3 o: $@"; | |
1960 | } | |
1961 | ||
1962 | eval { | |
1963 | if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$ctbase", undef, 0)) { | |
1964 | $count++; | |
1965 | warn "Test3 p failed"; | |
1966 | } | |
1967 | }; | |
1968 | if ($@) { | |
1969 | $count++; | |
1970 | warn "Test3 p: $@"; | |
1971 | } | |
1972 | ||
1973 | eval { | |
1974 | if (!PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$ctbase\/$ctlinked", undef, 0)) { | |
1975 | $count++; | |
1976 | warn "Test3 q failed"; | |
1977 | } | |
1978 | }; | |
1979 | if ($@) { | |
1980 | $count++; | |
1981 | warn "Test3 q: $@"; | |
1982 | } | |
1983 | ||
1984 | eval { | |
1985 | if (!PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$vmdisk", undef, 0)) { | |
1986 | $count++; | |
1987 | warn "Test3 r failed"; | |
1988 | } | |
1989 | }; | |
1990 | if ($@) { | |
1991 | $count++; | |
1992 | warn "Test3 r: $@"; | |
1993 | } | |
1994 | ||
1995 | eval { | |
1996 | if (!PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$vmbase", undef, 0)) { | |
1997 | $count++; | |
1998 | warn "Test3 s failed"; | |
1999 | } | |
2000 | }; | |
2001 | if ($@) { | |
2002 | $count++; | |
2003 | warn "Test3 s: $@"; | |
2004 | } | |
2005 | ||
2006 | eval { | |
2007 | if (!PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$vmbase\/$vmlinked", undef, 0)) { | |
2008 | $count++; | |
2009 | warn "Test3 t failed"; | |
2010 | } | |
2011 | }; | |
2012 | if ($@) { | |
2013 | $count++; | |
2014 | warn "Test3 t: $@"; | |
2015 | } | |
2016 | ||
2017 | eval { | |
2018 | if (!PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$ctdisk", undef, 0)) { | |
2019 | $count++; | |
2020 | warn "Test3 u failed"; | |
2021 | } | |
2022 | }; | |
2023 | if ($@) { | |
2024 | $count++; | |
2025 | warn "Test3 u: $@"; | |
2026 | } | |
2027 | ||
2028 | eval { | |
2029 | if (!PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$ctbase", undef, 0)) { | |
2030 | $count++; | |
2031 | warn "Test3 v failed"; | |
2032 | } | |
2033 | }; | |
2034 | if ($@) { | |
2035 | $count++; | |
2036 | warn "Test3 v: $@"; | |
2037 | } | |
2038 | ||
2039 | eval { | |
2040 | if (!PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$ctbase\/$ctlinked", undef, 0)) { | |
2041 | $count++; | |
2042 | warn "Test3 w failed"; | |
2043 | } | |
2044 | }; | |
2045 | if ($@) { | |
2046 | $count++; | |
2047 | warn "Test3 w: $@"; | |
2048 | } | |
2049 | ||
2050 | eval { | |
2051 | if (!PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$vmdisk", undef, 0)) { | |
2052 | $count++; | |
2053 | warn "Test3 x failed"; | |
2054 | } | |
2055 | }; | |
2056 | if ($@) { | |
2057 | $count++; | |
2058 | warn "Test3 x: $@"; | |
2059 | } | |
2060 | ||
2061 | eval { | |
2062 | if (!PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$vmbase", undef, 0)) { | |
2063 | $count++; | |
2064 | warn "Test3 y failed"; | |
2065 | } | |
2066 | }; | |
2067 | if ($@) { | |
2068 | $count++; | |
2069 | warn "Test3 y: $@"; | |
2070 | } | |
2071 | ||
2072 | eval { | |
2073 | if (!PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$vmbase\/$vmlinked", undef, 0)) { | |
2074 | $count++; | |
2075 | warn "Test3 z failed"; | |
2076 | } | |
2077 | }; | |
2078 | if ($@) { | |
2079 | $count++; | |
2080 | warn "Test3 z: $@"; | |
2081 | } | |
2082 | ||
2083 | eval { | |
2084 | if (!PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$ctdisk", undef, 0)) { | |
2085 | $count++; | |
2086 | warn "Test3 A failed"; | |
2087 | } | |
2088 | }; | |
2089 | if ($@) { | |
2090 | $count++; | |
2091 | warn "Test3 A: $@"; | |
2092 | } | |
2093 | ||
2094 | eval { | |
2095 | if (!PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$ctbase", undef, 0)) { | |
2096 | $count++; | |
2097 | warn "Test3 B failed"; | |
2098 | } | |
2099 | }; | |
2100 | if ($@) { | |
2101 | $count++; | |
2102 | warn "Test3 B: $@"; | |
2103 | } | |
2104 | ||
2105 | eval { | |
2106 | if (!PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$ctbase\/$ctlinked", undef, 0)) { | |
2107 | $count++; | |
2108 | warn "Test3 C failed"; | |
2109 | } | |
2110 | }; | |
2111 | if ($@) { | |
2112 | $count++; | |
2113 | warn "Test3 C: $@"; | |
2114 | } | |
2115 | ||
2116 | eval { | |
2117 | if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$vmdisk", 'test', 0)) { | |
2118 | $count++; | |
2119 | warn "Test3 a1 failed"; | |
2120 | } | |
2121 | }; | |
2122 | if ($@) { | |
2123 | $count++; | |
2124 | warn "Test3 a1: $@"; | |
2125 | } | |
2126 | ||
2127 | eval { | |
2128 | if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$vmbase", 'test', 0)) { | |
2129 | $count++; | |
2130 | warn "Test3 b1 failed"; | |
2131 | } | |
2132 | }; | |
2133 | if ($@) { | |
2134 | $count++; | |
2135 | warn "Test3 b1: $@"; | |
2136 | } | |
2137 | ||
2138 | eval { | |
2139 | if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$vmbase\/$vmlinked", 'test', 0)) { | |
2140 | $count++; | |
2141 | warn "Test3 c1 failed"; | |
2142 | } | |
2143 | }; | |
2144 | if ($@) { | |
2145 | $count++; | |
2146 | warn "Test3 c1: $@"; | |
2147 | } | |
2148 | ||
2149 | eval { | |
2150 | if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$ctdisk", 'test', 0)) { | |
2151 | $count++; | |
2152 | warn "Test3 d1 failed"; | |
2153 | } | |
2154 | }; | |
2155 | if ($@) { | |
2156 | $count++; | |
2157 | warn "Test3 d1: $@"; | |
2158 | } | |
2159 | ||
2160 | eval { | |
2161 | if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$ctbase", 'test', 0)) { | |
2162 | $count++; | |
2163 | warn "Test3 e1 failed"; | |
2164 | } | |
2165 | }; | |
2166 | if ($@) { | |
2167 | $count++; | |
2168 | warn "Test3 e1: $@"; | |
2169 | } | |
2170 | ||
2171 | eval { | |
2172 | if (!PVE::Storage::volume_has_feature($cfg, 'snapshot', "$storagename:$ctbase\/$ctlinked", 'test', 0)) { | |
2173 | $count++; | |
2174 | warn "Test3 f1 failed"; | |
2175 | } | |
2176 | }; | |
2177 | if ($@) { | |
2178 | $count++; | |
2179 | warn "Test3 f1: $@"; | |
2180 | } | |
2181 | ||
2182 | eval { | |
2183 | if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$vmdisk", 'test', 0)) { | |
2184 | $count++; | |
2185 | warn "Test3 g1 failed"; | |
2186 | } | |
2187 | }; | |
2188 | if ($@) { | |
2189 | $count++; | |
2190 | warn "Test3 g1: $@"; | |
2191 | } | |
2192 | ||
2193 | eval { | |
2194 | if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$vmbase", 'test', 0)) { | |
2195 | $count++; | |
2196 | warn "Test3 h1 failed"; | |
2197 | } | |
2198 | }; | |
2199 | if ($@) { | |
2200 | $count++; | |
2201 | warn "Test3 h1: $@"; | |
2202 | } | |
2203 | ||
2204 | eval { | |
2205 | if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$vmbase\/$vmlinked", 'test', 0)) { | |
2206 | $count++; | |
2207 | warn "Test3 h1 failed"; | |
2208 | } | |
2209 | }; | |
2210 | if ($@) { | |
2211 | $count++; | |
2212 | warn "Test3 h1: $@"; | |
2213 | } | |
2214 | ||
2215 | eval { | |
2216 | if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$ctdisk", 'test', 0)) { | |
2217 | $count++; | |
2218 | warn "Test3 i1 failed"; | |
2219 | } | |
2220 | }; | |
2221 | if ($@) { | |
2222 | $count++; | |
2223 | warn "Test3 i1: $@"; | |
2224 | } | |
2225 | ||
2226 | eval { | |
2227 | if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$ctbase", 'test', 0)) { | |
2228 | $count++; | |
2229 | warn "Test3 j1 failed"; | |
2230 | } | |
2231 | }; | |
2232 | if ($@) { | |
2233 | $count++; | |
2234 | warn "Test3 j1: $@"; | |
2235 | } | |
2236 | ||
2237 | eval { | |
2238 | if (PVE::Storage::volume_has_feature($cfg, 'clone', "$storagename:$ctbase\/$ctlinked", 'test', 0)) { | |
2239 | $count++; | |
2240 | warn "Test3 k1 failed"; | |
2241 | } | |
2242 | }; | |
2243 | if ($@) { | |
2244 | $count++; | |
2245 | warn "Test3 k1: $@"; | |
2246 | } | |
2247 | ||
2248 | eval { | |
2249 | if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$vmdisk", 'test', 0)) { | |
2250 | $count++; | |
2251 | warn "Test3 l1 failed"; | |
2252 | } | |
2253 | }; | |
2254 | if ($@) { | |
2255 | $count++; | |
2256 | warn "Test3 l1: $@"; | |
2257 | } | |
2258 | ||
2259 | eval { | |
2260 | if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$vmbase", 'test', 0)) { | |
2261 | $count++; | |
2262 | warn "Test3 m1 failed"; | |
2263 | } | |
2264 | }; | |
2265 | if ($@) { | |
2266 | $count++; | |
2267 | warn "Test3 m1: $@"; | |
2268 | } | |
2269 | ||
2270 | eval { | |
2271 | if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$vmbase\/$vmlinked", 'test', 0)) { | |
2272 | $count++; | |
2273 | warn "Test3 n1 failed"; | |
2274 | } | |
2275 | }; | |
2276 | if ($@) { | |
2277 | $count++; | |
2278 | warn "Test3 n1: $@"; | |
2279 | } | |
2280 | ||
2281 | eval { | |
2282 | if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$ctdisk", 'test', 0)) { | |
2283 | $count++; | |
2284 | warn "Test3 o1 failed"; | |
2285 | } | |
2286 | }; | |
2287 | if ($@) { | |
2288 | $count++; | |
2289 | warn "Test3 o1: $@"; | |
2290 | } | |
2291 | ||
2292 | eval { | |
2293 | if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$ctbase", 'test', 0)) { | |
2294 | $count++; | |
2295 | warn "Test3 p1 failed"; | |
2296 | } | |
2297 | }; | |
2298 | if ($@) { | |
2299 | $count++; | |
2300 | warn "Test3 p1: $@"; | |
2301 | } | |
2302 | ||
2303 | eval { | |
2304 | if (PVE::Storage::volume_has_feature($cfg, 'template', "$storagename:$ctbase\/$ctlinked", 'test', 0)) { | |
2305 | $count++; | |
2306 | warn "Test3 q1 failed"; | |
2307 | } | |
2308 | }; | |
2309 | if ($@) { | |
2310 | $count++; | |
2311 | warn "Test3 q1: $@"; | |
2312 | } | |
2313 | ||
2314 | eval { | |
2315 | if (PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$vmdisk", 'test', 0)) { | |
2316 | $count++; | |
2317 | warn "Test3 r1 failed"; | |
2318 | } | |
2319 | }; | |
2320 | if ($@) { | |
2321 | $count++; | |
2322 | warn "Test3 r1: $@"; | |
2323 | } | |
2324 | ||
2325 | eval { | |
2326 | if (PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$vmbase", 'test', 0)) { | |
2327 | $count++; | |
2328 | warn "Test3 s1 failed"; | |
2329 | } | |
2330 | }; | |
2331 | if ($@) { | |
2332 | $count++; | |
2333 | warn "Test3 s1: $@"; | |
2334 | } | |
2335 | ||
2336 | eval { | |
2337 | if (PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$vmbase\/$vmlinked", 'test', 0)) { | |
2338 | $count++; | |
2339 | warn "Test3 t1 failed"; | |
2340 | } | |
2341 | }; | |
2342 | if ($@) { | |
2343 | $count++; | |
2344 | warn "Test3 t1: $@"; | |
2345 | } | |
2346 | ||
2347 | eval { | |
2348 | if (PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$ctdisk", 'test', 0)) { | |
2349 | $count++; | |
2350 | warn "Test3 u1 failed"; | |
2351 | } | |
2352 | }; | |
2353 | if ($@) { | |
2354 | $count++; | |
2355 | warn "Test3 u1: $@"; | |
2356 | } | |
2357 | ||
2358 | eval { | |
2359 | if (PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$ctbase", 'test', 0)) { | |
2360 | $count++; | |
2361 | warn "Test3 v1 failed"; | |
2362 | } | |
2363 | }; | |
2364 | if ($@) { | |
2365 | $count++; | |
2366 | warn "Test3 v1: $@"; | |
2367 | } | |
2368 | ||
2369 | eval { | |
2370 | if (PVE::Storage::volume_has_feature($cfg, 'copy', "$storagename:$ctbase\/$ctlinked", 'test', 0)) { | |
2371 | $count++; | |
2372 | warn "Test3 w1 failed"; | |
2373 | } | |
2374 | }; | |
2375 | if ($@) { | |
2376 | $count++; | |
2377 | warn "Test3 w1: $@"; | |
2378 | } | |
2379 | ||
2380 | eval { | |
2381 | if (PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$vmdisk", 'test', 0)) { | |
2382 | $count++; | |
2383 | warn "Test3 x1 failed"; | |
2384 | } | |
2385 | }; | |
2386 | if ($@) { | |
2387 | $count++; | |
2388 | warn "Test3 x1: $@"; | |
2389 | } | |
2390 | ||
2391 | eval { | |
2392 | if (PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$vmbase", 'test', 0)) { | |
2393 | $count++; | |
2394 | warn "Test3 y1 failed"; | |
2395 | } | |
2396 | }; | |
2397 | if ($@) { | |
2398 | $count++; | |
2399 | warn "Test3 y1: $@"; | |
2400 | } | |
2401 | ||
2402 | eval { | |
2403 | if (PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$vmbase\/$vmlinked", 'test', 0)) { | |
2404 | $count++; | |
2405 | warn "Test3 z1 failed"; | |
2406 | } | |
2407 | }; | |
2408 | if ($@) { | |
2409 | $count++; | |
2410 | warn "Test3 z1: $@"; | |
2411 | } | |
2412 | ||
2413 | eval { | |
2414 | if (PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$ctdisk", 'test', 0)) { | |
2415 | $count++; | |
2416 | warn "Test3 A1 failed"; | |
2417 | } | |
2418 | }; | |
2419 | if ($@) { | |
2420 | $count++; | |
2421 | warn "Test3 A1: $@"; | |
2422 | } | |
2423 | ||
2424 | eval { | |
2425 | if (PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$ctbase", 'test', 0)) { | |
2426 | $count++; | |
2427 | warn "Test3 B1 failed"; | |
2428 | } | |
2429 | }; | |
2430 | if ($@) { | |
2431 | $count++; | |
2432 | warn "Test3 B1: $@"; | |
2433 | } | |
2434 | ||
2435 | eval { | |
2436 | if (PVE::Storage::volume_has_feature($cfg, 'sparseinit', "$storagename:$ctbase\/$ctlinked", 'test', 0)) { | |
2437 | $count++; | |
2438 | warn "Test3 C1 failed"; | |
2439 | } | |
2440 | }; | |
2441 | if ($@) { | |
2442 | $count++; | |
2443 | warn "Test3 C1: $@"; | |
2444 | } | |
2445 | }; | |
2446 | $tests->{3} = $test3; | |
2447 | ||
2448 | my $test2 = sub { | |
2449 | ||
2450 | print "\nrun test2 \"volume_resize\"\n"; | |
2451 | my $newsize = ($volsize + 1) * 1024 * 1024 * 1024; | |
2452 | ||
2453 | eval { | |
2454 | if (($newsize/1024) != | |
2455 | PVE::Storage::volume_resize($cfg, "$storagename:$vmdisk", $newsize, 0)) { | |
2456 | $count++; | |
2457 | warn "Test2 a failed"; | |
2458 | } | |
2459 | if ($newsize != | |
2460 | PVE::Storage::volume_size_info($cfg, "$storagename:$vmdisk")) { | |
2461 | $count++; | |
2462 | warn "Test2 a failed"; | |
2463 | } | |
2464 | }; | |
2465 | if ($@) { | |
2466 | $count++; | |
2467 | warn "Test2 a: $@"; | |
2468 | } | |
2469 | ||
2470 | eval { | |
2471 | warn "Test2 b failed" if ($newsize/1024) != PVE::Storage::volume_resize($cfg, "$storagename:$vmbase", $newsize, 0); | |
2472 | warn "Test2 b failed" if $newsize != | |
2473 | PVE::Storage::volume_size_info($cfg, "$storagename:$vmbase"); | |
2474 | }; | |
2475 | if ($@) { | |
2476 | $count++; | |
2477 | warn "Test2 b: $@"; | |
2478 | } | |
2479 | ||
2480 | eval { | |
2481 | if (($newsize/1024) != PVE::Storage::volume_resize($cfg, "$storagename:$vmbase\/$vmlinked", $newsize, 0)) { | |
2482 | $count++; | |
2483 | warn "Test2 c failed"; | |
2484 | } | |
2485 | if ($newsize != | |
2486 | PVE::Storage::volume_size_info($cfg, "$storagename:$vmbase\/$vmlinked")) { | |
2487 | $count++; | |
2488 | warn "Test2 c failed"; | |
2489 | } | |
2490 | }; | |
2491 | if ($@) { | |
2492 | $count++; | |
2493 | warn "Test2 c: $@"; | |
2494 | } | |
2495 | ||
2496 | eval { | |
2497 | if (($newsize/1024) != PVE::Storage::volume_resize($cfg, "$storagename:$ctdisk", $newsize, 0)) { | |
2498 | $count++; | |
2499 | warn "Test2 d failed"; | |
2500 | } | |
2501 | if ($newsize != | |
2502 | PVE::Storage::volume_size_info($cfg, "$storagename:$ctdisk")) { | |
2503 | $count++; | |
2504 | warn "Test2 d failed" | |
2505 | } | |
2506 | }; | |
2507 | if ($@) { | |
2508 | $count++; | |
2509 | warn "Test2 d: $@"; | |
2510 | } | |
2511 | ||
2512 | eval { | |
2513 | if (($newsize/1024) != | |
2514 | PVE::Storage::volume_resize($cfg, "$storagename:$ctbase", $newsize, 0)) { | |
2515 | $count++; | |
2516 | warn "Test2 e failed"; | |
2517 | } | |
2518 | if ($newsize != | |
2519 | PVE::Storage::volume_size_info($cfg, "$storagename:$ctbase")) { | |
2520 | $count++; | |
2521 | warn "Test2 e failed"; | |
2522 | } | |
2523 | }; | |
2524 | if ($@) { | |
2525 | $count++; | |
2526 | warn "Test2 e: $@"; | |
2527 | } | |
2528 | ||
2529 | eval { | |
2530 | if (($newsize/1024) != | |
2531 | PVE::Storage::volume_resize($cfg, "$storagename:$ctbase\/$ctlinked", $newsize, 0)) { | |
2532 | $count++; | |
2533 | warn "Test2 f failed"; | |
2534 | } | |
2535 | if ($newsize != | |
2536 | PVE::Storage::volume_size_info($cfg, "$storagename:$ctbase\/$ctlinked")) { | |
2537 | $count++; | |
2538 | warn "Test2 f failed"; | |
2539 | } | |
2540 | }; | |
2541 | if ($@) { | |
2542 | $count++; | |
2543 | warn "Test2 f: $@"; | |
2544 | } | |
2545 | }; | |
2546 | $tests->{2} = $test2; | |
2547 | ||
2548 | my $test1 = sub { | |
2549 | ||
2550 | print "\nrun test1 \"volume_size_info\"\n"; | |
2551 | my $size = ($volsize * 1024 * 1024 * 1024); | |
2552 | ||
2553 | eval { | |
2554 | if ($size != PVE::Storage::volume_size_info($cfg, "$storagename:$vmdisk")) { | |
2555 | $count++; | |
2556 | warn "Test1 a failed"; | |
2557 | } | |
2558 | }; | |
2559 | if ($@) { | |
2560 | $count++; | |
2561 | warn "Test1 a : $@"; | |
2562 | } | |
2563 | ||
2564 | eval { | |
2565 | if ($size != PVE::Storage::volume_size_info($cfg, "$storagename:$vmbase")) { | |
2566 | $count++; | |
2567 | warn "Test1 b failed"; | |
2568 | } | |
2569 | ||
2570 | }; | |
2571 | if ($@) { | |
2572 | $count++; | |
2573 | warn "Test1 b : $@"; | |
2574 | } | |
2575 | ||
2576 | eval { | |
2577 | if ($size != | |
2578 | PVE::Storage::volume_size_info($cfg, "$storagename:$vmbase\/$vmlinked")) { | |
2579 | $count++; | |
2580 | warn "Test1 c failed"; | |
2581 | } | |
2582 | }; | |
2583 | if ($@) { | |
2584 | $count++; | |
2585 | warn "Test1 c : $@"; | |
2586 | } | |
2587 | ||
2588 | eval { | |
2589 | if ($size != | |
2590 | PVE::Storage::volume_size_info($cfg, "$storagename:$ctdisk")) { | |
2591 | $count++; | |
2592 | warn "Test1 d failed"; | |
2593 | } | |
2594 | }; | |
2595 | if ($@) { | |
2596 | $count++; | |
2597 | warn "Test1 d : $@"; | |
2598 | } | |
2599 | ||
2600 | eval { | |
2601 | if ($size != | |
2602 | PVE::Storage::volume_size_info($cfg, "$storagename:$ctbase")) { | |
2603 | $count++; | |
2604 | warn "Test1 e failed"; | |
2605 | } | |
2606 | }; | |
2607 | if ($@) { | |
2608 | $count++; | |
2609 | warn "Test1 e : $@"; | |
2610 | } | |
2611 | ||
2612 | eval { | |
2613 | if ($size != | |
2614 | PVE::Storage::volume_size_info($cfg, "$storagename:$vmbase\/$vmlinked")) { | |
2615 | $count++; | |
2616 | warn "Test1 f failed" | |
2617 | } | |
2618 | }; | |
2619 | if ($@) { | |
2620 | $count++; | |
2621 | warn "Test1 f : $@"; | |
2622 | } | |
2623 | ||
2624 | }; | |
2625 | $tests->{1} = $test1; | |
2626 | ||
2627 | sub setup_zfs { | |
81ebc68f WL |
2628 | #create VM zvol |
2629 | print "create zvol $vmdisk\n" if $verbose; | |
2630 | run_command("zfs create -V${volsize}G $zpath\/$vmdisk"); | |
2631 | ||
2632 | print "create zvol $vmbase\n" if $verbose; | |
2633 | run_command("zfs create -V${volsize}G $zpath\/$vmbase"); | |
2634 | run_command("zfs snapshot $zpath\/$vmbase$basesnap"); | |
2635 | ||
2636 | print "create linked clone $vmlinked\n" if $verbose; | |
2637 | run_command("zfs clone $zpath\/$vmbase$basesnap $zpath\/$vmlinked"); | |
2638 | ||
2639 | #create CT subvol | |
2640 | print "create subvol $ctdisk\n" if $verbose; | |
2641 | run_command("zfs create -o refquota=${volsize}G $zpath\/$ctdisk"); | |
2642 | ||
56362cfb | 2643 | print "create subvol $ctbase\n" if $verbose; |
81ebc68f WL |
2644 | run_command("zfs create -o refquota=${volsize}G $zpath\/$ctbase"); |
2645 | run_command("zfs snapshot $zpath\/$ctbase$basesnap"); | |
2646 | ||
56362cfb | 2647 | print "create linked clone $ctlinked\n" if $verbose; |
81ebc68f | 2648 | run_command("zfs clone $zpath\/$ctbase$basesnap $zpath\/$ctlinked -o refquota=${volsize}G"); |
56362cfb FG |
2649 | |
2650 | my $vollist = [ | |
2651 | "$storagename:$vmdisk", | |
2652 | "$storagename:$vmbase", | |
2653 | "$storagename:$vmbase/$vmlinked", | |
2654 | "$storagename:$ctdisk", | |
2655 | "$storagename:$ctbase", | |
2656 | "$storagename:$ctbase/$ctlinked", | |
2657 | ]; | |
2658 | ||
2659 | PVE::Storage::activate_volumes($cfg, $vollist); | |
81ebc68f WL |
2660 | } |
2661 | ||
2662 | sub cleanup_zfs { | |
2663 | ||
2664 | print "destroy $pool\/$subvol\n" if $verbose; | |
b13cf561 FG |
2665 | eval { run_command("zfs destroy $zpath -r"); }; |
2666 | if ($@) { | |
2667 | print "cleanup failed: $@\nretrying once\n" if $verbose; | |
2668 | eval { run_command("zfs destroy $zpath -r"); }; | |
2669 | if ($@) { | |
2670 | clean_up_zpool(); | |
2671 | setup_zpool(); | |
2672 | } | |
2673 | } | |
81ebc68f WL |
2674 | } |
2675 | ||
2676 | sub setup_zpool { | |
2677 | ||
b13cf561 | 2678 | unlink 'zpool.img'; |
81ebc68f | 2679 | eval { |
ca276fcb | 2680 | run_command("truncate -s 8G zpool.img"); |
81ebc68f WL |
2681 | }; |
2682 | if ($@) { | |
2683 | clean_up_zpool(); | |
2684 | } | |
2685 | my $pwd = cwd(); | |
2686 | eval { | |
dcefd9dd | 2687 | run_command("zpool create -m \/$mountpoint $subvol $pwd\/zpool.img"); |
81ebc68f WL |
2688 | }; |
2689 | if ($@) { | |
2690 | clean_up_zpool(); | |
2691 | } | |
2692 | } | |
2693 | ||
2694 | sub clean_up_zpool { | |
2695 | ||
2696 | eval { | |
c7b06c4f | 2697 | run_command("zpool destroy -f $subvol"); |
81ebc68f WL |
2698 | }; |
2699 | if ($@) { | |
2700 | warn $@;} | |
2701 | unlink 'zpool.img'; | |
2702 | } | |
2703 | ||
9924228b FG |
2704 | sub volume_is_base { |
2705 | my ($cfg, $volid) = @_; | |
2706 | ||
2707 | my (undef, undef, undef, undef, undef, $isBase, undef) = PVE::Storage::parse_volname($cfg, $volid); | |
2708 | ||
2709 | return $isBase; | |
2710 | } | |
2711 | ||
1b8efb42 DC |
2712 | if ($> != 0) { #EUID |
2713 | warn "not root, skipping zfs tests\n"; | |
2714 | exit 0; | |
2715 | } | |
2716 | ||
722eb1fe FG |
2717 | eval { run_command("zpool status"); }; |
2718 | if ($@) { | |
2719 | warn "zpool status failed, not running tests: $@\n"; | |
2720 | exit 0; | |
2721 | } | |
9924228b | 2722 | |
81ebc68f WL |
2723 | setup_zpool(); |
2724 | ||
2725 | my $time = time; | |
2726 | print "Start tests for ZFSPoolPlugin\n"; | |
2727 | ||
2728 | $cfg = {'ids' => { | |
2729 | $storagename => { | |
2730 | 'content' => { | |
2731 | 'images' => 1, | |
2732 | 'rootdir' => 1 | |
2733 | }, | |
2734 | 'pool' => $subvol, | |
dcefd9dd | 2735 | 'mountpoint' => "\/$mountpoint", |
81ebc68f WL |
2736 | 'type' => 'zfspool' |
2737 | }, | |
2738 | }, | |
2739 | 'order' => {'zfstank99' => 1,} | |
2740 | }; | |
2741 | ||
2742 | $zpath = $subvol; | |
2743 | ||
46001581 | 2744 | for (my $i = $start_test; $i <= $end_test; $i++) { |
81ebc68f WL |
2745 | setup_zfs(); |
2746 | ||
2747 | eval { | |
2748 | $tests->{$i}(); | |
2749 | }; | |
061c7e5e FE |
2750 | if (my $err = $@) { |
2751 | warn $err; | |
2752 | $count++; | |
2753 | } | |
81ebc68f WL |
2754 | cleanup_zfs(); |
2755 | } | |
2756 | ||
2757 | clean_up_zpool(); | |
2758 | ||
2759 | $time = time - $time; | |
2760 | ||
2761 | print "Stop tests for ZFSPoolPlugin\n"; | |
2762 | print "$count tests failed\n"; | |
2763 | print "Time: ${time}s\n"; | |
e93e1bed FG |
2764 | |
2765 | exit -1 if $count > 0; |