/[smeserver]/rpms/e-smith-backup/sme10/e-smith-backup-2.6.0-bz9299-consoleBackupBlockDevice.patch
ViewVC logotype

Contents of /rpms/e-smith-backup/sme10/e-smith-backup-2.6.0-bz9299-consoleBackupBlockDevice.patch

Parent Directory Parent Directory | Revision Log Revision Log | View Revision Graph Revision Graph


Revision 1.2 - (show annotations) (download)
Sat Apr 15 03:54:54 2017 UTC (7 years, 6 months ago) by unnilennium
Branch: MAIN
CVS Tags: e-smith-backup-2_6_0-24_el7_sme, e-smith-backup-2_6_0-19_el7_sme, e-smith-backup-2_6_0-17_el7_sme, e-smith-backup-2_6_0-30_el7_sme, e-smith-backup-2_6_0-29_el7_sme, e-smith-backup-2_6_0-9_el7_sme, e-smith-backup-2_6_0-15_el7_sme, e-smith-backup-2_6_0-18_el7_sme, e-smith-backup-2_6_0-16_el7_sme, e-smith-backup-2_6_0-11_el7_sme, e-smith-backup-2_6_0-14_el7_sme, e-smith-backup-2_6_0-20_el7_sme, e-smith-backup-2_6_0-23_el7_sme, e-smith-backup-2_6_0-10_el7_sme, e-smith-backup-2_6_0-21_el7_sme, e-smith-backup-2_6_0-13_el7_sme, e-smith-backup-2_6_0-28_el7_sme, e-smith-backup-2_6_0-12_el7_sme, e-smith-backup-2_6_0-22_el7_sme, e-smith-backup-2_6_0-27_el7_sme, e-smith-backup-2_6_0-25_el7_sme, e-smith-backup-2_6_0-26_el7_sme, HEAD
Changes since 1.1: +1 -1 lines
* Fri Apr 14 2017 Jean-Philipe Pialasse <tests@pialasse.com> 2.6.0-9.sme
- added support back to ext2 and ext3 [SME: 9299]

1 --- e-smith-backup-2.6.0/root/usr/share/perl5/vendor_perl/esmith/console/perform_backup.pm.devdetection 2017-02-17 14:37:15.000000000 -0500
2 +++ e-smith-backup-2.6.0/root/usr/share/perl5/vendor_perl/esmith/console/perform_backup.pm 2017-02-24 14:46:06.777798717 -0500
3 @@ -6,8 +6,14 @@
4 use esmith::util;
5 use Locale::gettext;
6 use esmith::Backup;
7 -#use Filesys::DiskFree;
8 -#use Sys::Filesystem;
9 +use Carp;
10 +use feature qw( say );
11 +use esmith::BlockDevices;
12 +use POSIX qw(:sys_wait_h strftime);
13 +use File::stat;
14 +use Taint::Util;
15 +
16 +my $EMPTY = q{};
17
18 sub new
19 {
20 @@ -43,22 +49,10 @@
21 my $fh = shift;
22 my @backup_list = esmith::Backup->restore_list;
23 my @backup_excludes = esmith::Backup->excludes;
24 -
25 - unless (open(DU, "-|"))
26 - {
27 - open(STDERR, ">/dev/null");
28 - exec qw(/usr/bin/du -sb), map { "/$_" } @backup_list;
29 - }
30 - my $backup_size = 0;
31 - while (<DU>)
32 - {
33 - next unless (/^(\d+)/);
34 - $backup_size += $1;
35 - }
36 - close DU;
37 + my $backup_size = backupSize (@backup_list);
38
39 open(OLDSTDOUT, ">&STDOUT");
40 - unless (open(STDOUT, ">/mnt/bootstrap-console-backup/smeserver.tgz"))
41 + unless (open(STDOUT, ">$device/smeserver.tgz"))
42 {
43 return gettext("Could not create backup file on device").": $!\n";
44 }
45 @@ -133,20 +127,85 @@
46 my ($self, $console, $db) = @_;
47 my @backup_list = esmith::Backup->restore_list;
48 my @backup_excludes = esmith::Backup->excludes;
49 + my $compressionLevel = $db->get_prop('backupconsole', 'CompressionLevel') || '-6';
50 + my $mountpoint = $db->get_prop('backupconsole', 'Mountpoint') || '/mnt/bootstrap-console-backup';
51 + my $allowMounted = $db->get_prop('backupconsole', 'AllowMounted') || 'disabled'; ### For future use
52
53 $ENV{PATH} = "/bin:/usr/bin";
54 $ENV{HOME} = "/root";
55
56 - my $compressionLevel = $db->get_prop("backupconsole", "CompressionLevel") || "-6";
57 + my $devices = esmith::BlockDevices->new ('mount' => $mountpoint, 'allowmount' => $allowMounted);
58 +
59 + INITIATE_BACKUP:
60 my ($rc, $choice) = $console->yesno_page
61 (
62 title => gettext("Create Backup to removable media"),
63 defaultno => 1,
64 - text =>
65 - gettext("Do you wish to create backup on removable media?"),
66 - );
67 - return unless $rc == 0;
68 + text => gettext('Do you wish to create a backup on removable media?')."\n\n".
69 + gettext('Insert removable media before proceeding.')."\n".
70 + gettext('It may take many seconds to scan for media.'),
71 + );
72 + if ($rc != 0)
73 + {
74 + $devices->destroy;
75 + return;
76 + }
77 + ### determine which filesystems are valid or not for backups
78 + # check expected backup size
79 + my $backup_size = backupSize (@backup_list);
80 + # validate each filesystem
81 + my ($valid, $invalid) = $devices->checkBackupDrives ($backup_size);
82 + my $text = $EMPTY;
83 +
84 + if (${$invalid}[0]) # If there are filesystems that are not valid.
85 + {
86 + $text .= gettext ('These filesystems are not valid:')."\n";
87 + foreach my $drive (sort @{$invalid})
88 + {
89 + $text .= "$drive ".$devices->desc($drive).' '.gettext ('Reason').': '.$devices->reason($drive)."\n";
90 + }
91 + $text .= "\n";
92 + }
93 + unless (${$valid}[0]) # Unless a device is found show error page
94 + {
95 + my $title = gettext('No valid backup device found').' '.gettext('size').' '.esmith::BlockDevices::scaleIt($backup_size);
96 + $text .= "\n$title, ".gettext('please try again');
97 + ($rc, $choice) = $console->yesno_page
98 + (
99 + title => $title,
100 + text => $text,
101 + left => gettext('Try again'),
102 + right => gettext('Cancel'),
103 + );
104 + if ($rc == 0) # Try Again
105 + {
106 + goto INITIATE_BACKUP;
107 + }
108 + else
109 + {
110 + $devices->destroy;
111 + return;
112 + }
113 + }
114 + $text .= gettext ('The following are valid for backup').' (';
115 + $text .= gettext ('size').' '.esmith::BlockDevices::scaleIt($backup_size).')';
116
117 + #ToDo when valid + invalid > 13 then may need to limit the information
118 + my @args = map { $_ => $devices->desc($_) } @{$valid};
119 +
120 + # Display the available backup destinations.
121 + ($rc, $choice) = $console->menu_page
122 + (
123 + title => gettext('Choose device to use for backup').' '.gettext('size').' '.esmith::BlockDevices::scaleIt($backup_size),
124 + text => $text,
125 + argsref => \@args,
126 + left => gettext('Cancel'),
127 + right => gettext('OK'),
128 + );
129 + goto INITIATE_BACKUP unless ($rc == 0);
130 + untaint $choice;
131 + $devices->mount ($choice); # mount the chosen filesystem
132 +
133 if (@backup_excludes) {
134 my $backupexclude = join ("\n/", sort @backup_excludes);
135 ($rc, $choice) = $console->yesno_page
136 @@ -159,124 +218,44 @@
137 return unless $rc == 0;
138 }
139
140 - INITIATE_BACKUP:
141 - ($rc, $choice) = $console->yesno_page
142 - (
143 - title => gettext("Insert media to use for backup"),
144 - left => gettext("Next"),
145 - right => gettext("Cancel"),
146 - text =>
147 - gettext("Insert removable media, then hit the enter key."),
148 - );
149 - return unless $rc == 0;
150 - sleep(3);
151 - my @dirs = ();
152 - my @labels = ();
153 - foreach my $udi (qx(hal-find-by-property --key volume.fsusage --string filesystem)) {
154 - $udi =~ m/^(\S+)/;
155 -
156 - my $is_readonly = qx(hal-get-property --udi $1 --key volume.is_mounted_read_only);
157 -
158 - if ($is_readonly eq "false\n") {
159 -
160 - my $is_mounted = qx(hal-get-property --udi $1 --key volume.is_mounted);
161 -
162 - if ($is_mounted eq "false\n") {
163 - my $blkdev = qx(hal-get-property --udi $1 --key block.device);
164 - $blkdev =~ m/^(\S+)/;
165 - push @dirs, $1;
166 - }
167 - if ($is_mounted eq "false\n") {
168 - my $vollbl = qx(hal-get-property --udi $1 --key volume.label);
169 - $vollbl =~ m/^(\S+)/;
170 - if ($vollbl =~ /^\s/) {$vollbl = 'nolabel';}
171 - chomp $vollbl;
172 - push @labels, lc($vollbl);
173 - }
174 - }
175 - }
176 - unless ($dirs[0])
177 - {
178 - ($rc, $choice) = $console->message_page
179 - (
180 - title => gettext("Writable backup medium not found"),
181 - right => gettext("Back"),
182 - text =>
183 - gettext("No removable and/or writable media or device found"),
184 - );
185 - goto INITIATE_BACKUP;
186 - }
187 - mkdir("/mnt/bootstrap-console-backup");
188 -
189 - my $device = $dirs[0];
190 - if (defined $dirs[1])
191 - {
192 - my $count=1;
193 - my @args = map { $count++ . '.' => $_ } @dirs;
194 -
195 - my ($rc, $choice) = $console->menu_page
196 - (
197 - title => gettext("Choose device to use for backup"),
198 - text => ("@dirs \n @labels"),
199 - argsref => \@args,
200 - left => gettext("Cancel"),
201 - right => gettext("OK"),
202 - );
203 - goto INITIATE_BACKUP unless ($rc == 0);
204 - my %args_hash = ( @args );
205 - $device = $args_hash{$choice};
206 - }
207 - unless ( system("/bin/mount", "$device", "/mnt/bootstrap-console-backup") == '0' )
208 - {
209 - ($rc, $choice) = $console->message_page
210 - (
211 - title => gettext("No mountable backup medium"),
212 - right => gettext("Back"),
213 - text =>
214 - gettext("Unable to mount removable media, please check the file system format (default : Vfat,Ext2,Ext3,Ext4)"),
215 - );
216 - goto INITIATE_BACKUP;
217 - }
218 -
219 - use File::stat;
220 - my $st = stat("/mnt/bootstrap-console-backup/smeserver.tgz");
221 - if ($st)
222 - {
223 -# TODO
224 -# old backup exists - what do we want to do with it?
225 - my $size = $st->size;
226 - }
227 -
228 $console->infobox(
229 title => gettext("Preparing for backup"),
230 text => gettext("Please stand by while the system is prepared for backup..."),
231 );
232
233 - my $backup_size = 0;
234 system("/sbin/e-smith/signal-event", "pre-backup");
235 +
236 + $console->gauge(make_backup_callback($mountpoint,$compressionLevel), 'title' => gettext('Creating backup file'));
237 +
238 + $devices->destroy;
239 +
240 + system("/sbin/e-smith/signal-event", 'post-backup');
241 + $console->message_page
242 + (
243 + title => gettext('Backup complete'),
244 + text => gettext('Remove backup media.'),
245 + );
246 + return;
247 +}
248 +
249 +
250 +sub backupSize
251 +{
252 + my $size;
253 +
254 unless (open(DU, "-|"))
255 {
256 open(STDERR, ">/dev/null");
257 - exec qw(/usr/bin/du -sb), map { "/$_" } @backup_list;
258 + exec qw(/usr/bin/du -sb), map { "/$_" } @_;
259 }
260 while (<DU>)
261 {
262 next unless (/^(\d+)/);
263 - $backup_size += $1;
264 + $size += $1;
265 }
266 close DU;
267 -
268 - $console->gauge(make_backup_callback("/mnt/bootstrap-console-backup",$compressionLevel), 'title' => gettext("Creating backup file"));
269 -
270 - system("/bin/umount", "/mnt/bootstrap-console-backup");
271 - rmdir("/mnt/bootstrap-console-backup");
272 - system("/sbin/e-smith/signal-event", "post-backup");
273 - ($rc, $choice) = $console->message_page
274 - (
275 - title => gettext("Backup complete"),
276 - text =>
277 - gettext("Remove removable media, then hit the enter key."),
278 - );
279 +
280 + return $size;
281 }
282
283 #use esmith::console;
284 --- e-smith-backup-2.6.0/root/usr/share/perl5/vendor_perl/esmith/console/perform_restore.pm.devdetection 2017-02-17 14:37:15.000000000 -0500
285 +++ e-smith-backup-2.6.0/root/usr/share/perl5/vendor_perl/esmith/console/perform_restore.pm 2017-02-20 17:25:38.438280203 -0500
286 @@ -4,6 +4,12 @@
287 use esmith::ConfigDB;
288 use esmith::console;
289 use Locale::gettext;
290 +use Carp;
291 +use feature qw( say );
292 +use esmith::BlockDevices;
293 +use Taint::Util;
294 +
295 +my $EMPTY = q{};
296
297 sub new
298 {
299 @@ -18,7 +24,6 @@
300 return $self;
301 }
302
303 -
304 sub name
305 {
306 return $_[0]->{name};
307 @@ -32,137 +37,164 @@
308 sub doit
309 {
310 my ($self, $console, $db) = @_;
311 + my $compressionLevel = $db->get_prop('backupconsole', 'CompressionLevel') || '-6';
312 + my $mountpoint = $db->get_prop('backupconsole', 'Mountpoint') || '/mnt/bootstrap-console-backup';
313 + my $allowMounted = $db->get_prop('backupconsole', 'AllowMounted') || 'disabled'; ### For future use
314 + my $restoreMaxDepth = $db->get_prop('backupconsole', 'MaxDepth') || 1; ### For future use
315 + my %found;
316 + my $backupcount = 0;
317 + my $backupdrive; # Which filesystem holds the backup
318 + my $backupfile; # full path to the backup
319 + my ($time, $size); # time and size of chosen backup
320 +
321 return if (($db->get_prop('bootstrap-console', 'Run') eq 'no') && $self->{bootstrap} ); # regular reboot
322 if ($db->get_prop('bootstrap-console', 'Run') eq 'yes') # called from bootstrap console
323 {
324 return if ($db->get_value('PasswordSet') eq 'yes'); # too late
325 }
326 return if ($db->get_prop('bootstrap-console', 'Restore') eq 'disabled');
327 +
328 + my $devices = esmith::BlockDevices->new ('mount' => $mountpoint, 'allowmount' => $allowMounted);
329 +
330 + INITIATE_RESTORE:
331 my ($rc, $choice) = $console->yesno_page
332 (
333 title => gettext("Restore From Backup"),
334 defaultno => 1,
335 - text =>
336 - gettext("Do you wish to restore from backup?"),
337 - );
338 - return unless $rc == 0;
339 - mkdir("/mnt/bootstrap-console-backup");
340 - system("/etc/init.d/messagebus", "start");
341 - system("/etc/init.d/haldaemon", "start");
342 - INITIATE_RESTORE:
343 - ($rc, $choice) = $console->yesno_page
344 - (
345 - title => gettext("Insert media containing backup"),
346 - left => gettext("Next"),
347 - right => gettext("Cancel"),
348 - text =>
349 - gettext("Insert removable media containing your backup file, then hit the enter key."),
350 - );
351 - unless ($rc == 0) {
352 - system("/etc/init.d/haldaemon", "stop");
353 - system("/etc/init.d/messagebus", "stop");
354 - rmdir("/mnt/bootstrap-console-backup");
355 + text => gettext('Do you wish to restore from backup?')."\n\n".
356 + gettext('Insert removable media before proceeding.')."\n".
357 + gettext('It may take many seconds to scan for media.'),
358 + ); # Buttons are Yes & No
359 + if ($rc != 0) # choice was not Yes
360 + {
361 + $devices->destroy;
362 return;
363 }
364 - sleep(3);
365 - my @dirs;
366 - @dirs = ();
367 - foreach my $udi (qx(hal-find-by-property --key volume.fsusage --string filesystem)) {
368 - $udi =~ m/^(\S+)/;
369 - my $is_mounted = qx(hal-get-property --udi $1 --key volume.is_mounted);
370 -
371 - if ($is_mounted eq "false\n") {
372 - my $blkdev = qx(hal-get-property --udi $1 --key block.device);
373 - $blkdev =~ m/^(\S+)/;
374 - push @dirs, $1;
375 + ### determine which filesystems are valid or not for backups
376 +
377 + # validate each filesystem
378 + my ($valid, $invalid) = $devices->checkBackupDrives ($EMPTY);
379 + my $text = $EMPTY;
380 +
381 + if (${$valid}[0]) # There are filesystems that could hold a backup.
382 + {
383 + $text .= gettext ('These filesystems could hold backups')."\n";
384 + foreach my $drive (sort @{$valid})
385 + {
386 + $text .= "$drive ".$devices->desc($drive)."\n";
387 + $devices->findBackup ($drive, \%found, $restoreMaxDepth, \$backupcount);
388 }
389 + $text .= "\n";
390 }
391 - unless ($dirs[0])
392 - {
393 - ($rc, $choice) = $console->message_page
394 - (
395 - title => gettext("Backup medium not found"),
396 - right => "Try again",
397 - text =>
398 - gettext("No removable media or device found"),
399 - );
400 - goto INITIATE_RESTORE;
401 - }
402 - my $device = $dirs[0];
403 - if (defined $dirs[1])
404 - {
405 - my $count=1;
406 - # FIXME use better regexp
407 - my @args = map { /(.*)/; $count++ . '.' => $1 } @dirs;
408
409 - my ($rc, $choice) = $console->menu_page
410 - (
411 - title => gettext("Choose device to restore from"),
412 - text => gettext("Please select which device contains the backup file you wish to restore from."),
413 - argsref => \@args,
414 - left => gettext("Cancel"),
415 - right => gettext("OK"),
416 - );
417 + unless ($backupcount) # Unless a valid backup is found show error page
418 + {
419 + if (${$invalid}[0]) # If there are filesystems that are not valid.
420 + {
421 + $text .= gettext ('These filesystems are not valid:')."\n";
422 + foreach my $drive (sort @{$invalid})
423 + {
424 + $text .= "$drive ".$devices->desc($drive).' '.gettext ('Reason').': '.$devices->reason($drive)."\n";
425 + }
426 + $text .= "\n";
427 + }
428 + my $title = gettext('No valid backup device found');
429 + $text .= "\n$title, ".gettext('please try again');
430 + ($rc, $choice) = $console->yesno_page
431 + (
432 + title => $title,
433 + text => $text,
434 + left => gettext('Try again'),
435 + right => gettext('Cancel'),
436 + );
437 + if ($rc == 0) # Try Again
438 + {
439 + goto INITIATE_RESTORE;
440 + }
441 + else
442 + {
443 + $devices->destroy;
444 + return;
445 + }
446 + }
447 + # %found contains $backupcount backups.
448 + if ($backupcount == 1)
449 + {
450 + # One backup found, so simple yes/no choice
451 + $backupdrive = $found{1}{device}; # Find the (only) device that a backup was found on
452 + $backupfile = $found{1}{path}; # find the actual backup
453 + $time = gettext('Date') .' '. $found{1}{time};
454 + $size = gettext('Size') .' '. $found{1}{sizeH};
455 +
456 + ($rc, $choice) = $console->yesno_page
457 + (
458 + title => gettext('Start restore from backup'),
459 + text =>
460 + gettext('Backup found on device').
461 + "\n$backupdrive ".$devices->desc($backupdrive)."\n\n".
462 + gettext('Backup details').
463 + "\n$backupfile $size $time\n\n\n".
464 + gettext('Do you wish to restore from this file?'),
465 + );
466 goto INITIATE_RESTORE unless ($rc == 0);
467 - my %args_hash = ( @args );
468 - $device = $args_hash{$choice};
469 + $size = $found{1}{size};
470 }
471 - system("/bin/mount", "$device", "/mnt/bootstrap-console-backup");
472 - sleep(1);
473 -
474 - unless (-f "/mnt/bootstrap-console-backup/smeserver.tgz")
475 + else # Multiple backups found so display a choice
476 {
477 - system("/bin/umount", "$device");
478 - ($rc, $choice) = $console->message_page
479 - (
480 - title => gettext("Backup file not found"),
481 - right => "Try again",
482 - text =>
483 - gettext("No backup file found"),
484 - );
485 - goto INITIATE_RESTORE;
486 - }
487 - use File::stat;
488 - my $st = stat("/mnt/bootstrap-console-backup/smeserver.tgz");
489 - my $size = $st->size;
490 -
491 - ($rc, $choice) = $console->yesno_page
492 - (
493 - title => gettext("Start restore from backup"),
494 - text =>
495 - gettext("Backup file found:") . " smeserver.tgz ($device) " .
496 - gettext("size") . " $size " . gettext("bytes") .
497 - "\n\n" .
498 - gettext("Do you wish to restore from this file?"),
499 - );
500 - unless ($rc == 0) {
501 - system("/bin/umount", "$device");
502 - goto INITIATE_RESTORE;
503 + $text = gettext ('Backups found on these devices')."\n";
504 + foreach my $backupfound (sort keys %found)
505 + {
506 + $backupdrive = $found{$backupfound}{device};
507 + if (($backupfound == 1) || ($found{$backupfound}{device} ne $found{$backupfound-1}{device}))
508 + {
509 + $text.= "$backupdrive ".$devices->desc($backupdrive)."\n";
510 + }
511 + }
512 + my @args = map { $_ => "$found{$_}{device} $found{$_}{path} $found{$_}{sizeH} $found{$_}{time}" } sort keys %found;
513 + ($rc, $choice) = $console->menu_page
514 + (
515 + title => gettext('Start restore from backup'),
516 + text =>
517 + "$text\n".
518 + gettext ('Please select the backup that you wish to restore from.'),
519 + argsref => \@args,
520 + left => gettext('Cancel'),
521 + right => gettext('OK'),
522 + );
523 + goto INITIATE_RESTORE unless ($rc == 0);
524 + untaint $choice;
525 + $backupdrive = $found{$choice}{device};
526 + $size = $found{$choice}{size};
527 }
528 +
529 + $devices->mount ($backupdrive); # mount the chosen filesystem
530 + sleep(1); # Some mounts take time to become active
531 +
532 + ###ToDo This section has no error checking
533 + ###ToDo 'Restoring data is not localized
534 + # Execute the restore
535 system("/sbin/e-smith/signal-event", "pre-restore");
536 - system("(cd / ; cat /mnt/bootstrap-console-backup/smeserver.tgz |
537 + system("(cd / ; cat $mountpoint/smeserver.tgz |
538 pv -n -s $size |
539 gunzip |
540 tar xf - > /dev/null ) 2>&1 |
541 dialog --backtitle 'Restoring data' --guage 'Progress' 7 70");
542 - system("/bin/umount", "$device");
543 - system("/etc/init.d/haldaemon", "stop");
544 - system("/etc/init.d/messagebus", "stop");
545 - rmdir("/mnt/bootstrap-console-backup");
546 - system("/sbin/e-smith/signal-event", "post-upgrade");
547 -
548 +
549 + # Restore complete, now clean-up
550 + $devices->destroy;
551 + system("/sbin/e-smith/signal-event", "post-upgrade");
552 unless ( $self->{bootstrap} )
553 {
554 - $db->set_prop("bootstrap-console", "Run", "yes");
555 + $db->set_prop("bootstrap-console", "Run", "yes");
556 $db->set_prop("bootstrap-console", "ForceSave", "yes");
557 $db->set_prop("bootstrap-console", "Restore", "disabled");
558 -
559 - system("/usr/bin/tput", "clear");
560 - system("/sbin/e-smith/signal-event", "reboot");
561 -
562 - # A bit of a hack to avoid the console restarting before the
563 - # reboot takes effect.
564 -
565 +
566 + system("/usr/bin/tput", "clear");
567 + system("/sbin/e-smith/signal-event", "reboot");
568 +
569 + # A bit of a hack to avoid the console restarting before the
570 + # reboot takes effect.
571 +
572 sleep(600);
573 }
574 return;
575 --- e-smith-backup-2.6.0/root/usr/share/perl5/vendor_perl/esmith/BlockDevices.pm.devdetection 2017-02-24 14:39:00.743982759 -0500
576 +++ e-smith-backup-2.6.0/root/usr/share/perl5/vendor_perl/esmith/BlockDevices.pm 2017-02-24 14:47:46.334675319 -0500
577 @@ -0,0 +1,503 @@
578 +#----------------------------------------------------------------------
579 +# Copyright 2015 Ian Wells
580 +# This program is free software; you can redistribute it and/or
581 +# modify it under the same terms as Perl itself.
582 +#----------------------------------------------------------------------
583 +
584 +package esmith::BlockDevices;
585 +
586 +use strict;
587 +use warnings;
588 +use English '-no_match_vars';
589 +use Carp;
590 +use File::Path qw(make_path remove_tree);
591 +use POSIX qw(:sys_wait_h strftime);
592 +use Locale::gettext;
593 +use File::stat;
594 +use v5.10.1;
595 +use Taint::Util;
596 +use Readonly;
597 +use File::Find;
598 +
599 +use vars qw($VERSION @ISA @EXPORT_OK);
600 +
601 +@ISA = qw(Exporter);
602 +
603 +=head1 NAME
604 +
605 +esmith::BlockDevices - Module to handle block devices
606 +
607 +=head1 SYNOPSIS
608 +
609 + use esmith::BlockDevices;
610 + my $devices = BlockDevices->new ();
611 +
612 +=head1 DESCRIPTION
613 +
614 +This module provides an abstracted interface to the
615 +block devices used for backup/restore
616 +
617 +=cut
618 +
619 +my $EMPTY = q{};
620 +
621 +sub new
622 +{
623 + my $class = shift;
624 + my $self = {
625 + _blox => lsblk(),
626 + mount => findValidFS(),
627 + _fstype => $EMPTY,
628 + allowmount => $EMPTY,
629 + @_,
630 + };
631 + bless $self, $class;
632 + return $self;
633 +}
634 +
635 +sub lsblk
636 +{
637 +#ToDo add some comments
638 + my %blox; # a hash to hold the device information
639 +
640 + my $short = qx(/bin/lsblk -sdn -o KNAME);
641 + my @long = qx(/bin/lsblk -P -b -o KNAME,MAJ:MIN,RM,RO,TYPE,MOUNTPOINT,FSTYPE,LABEL,UUID,MODEL,SIZE,STATE,MODE,OWNER,GROUP);
642 + # Not all of this information may be needed currently, but it does not affect the processing time
643 + untaint ($short);
644 + untaint (@long);
645 +
646 + my $devicemodel= $EMPTY;
647 +
648 + for (@long)
649 + {
650 + my @line = split /\"\s/s;
651 + my $name;
652 + if ($line[0] =~ /KNAME=\"(.*)/s)
653 + {
654 + $name = $1;
655 + }
656 + else {carp 'Could not match KNAME'; last;} # should never occur.
657 +
658 + $blox{$name}{tip} = ($short =~ m/^$name$/sm) ? 1 : 0;
659 +
660 + for (@line)
661 + {
662 + my ($key,$value) = split /=/s;
663 + $value =~ s/\"//sg;
664 + $blox{$name}{$key} = trim($value);
665 + }
666 + if ($blox{$name}{TYPE} =~ /rom|disk/s)
667 + {
668 + $devicemodel = $blox{$name}{MODEL};
669 + }
670 + else
671 + {
672 + $blox{$name}{MODEL} = trim($devicemodel);
673 + }
674 + $blox{$name}{SIZEH} = scaleIt($blox{$name}{SIZE});
675 + }
676 + return \%blox;
677 +}
678 +
679 +sub findValidFS
680 +{
681 +# Find all filesystem types that are supported
682 + my %fs; # a hash to hold the supported filesystem type information
683 +
684 + my @cmd = `cat /proc/filesystems`;
685 + foreach (@cmd)
686 + {
687 + if (/.*\t(.*?)$/s){$fs {$1}=$1;}
688 + }
689 + @cmd = `ls -1 /lib/modules/\$(uname -r)/kernel/fs/*/*ko`;
690 + foreach (@cmd)
691 + {
692 + if (/.*\/(.*?)\.ko/s){$fs {$1}=$1;}
693 + }
694 + return \%fs;
695 +}
696 +
697 +sub scanBlocks
698 +{
699 + # Scan all the block devices
700 + # This takes some seconds on systems with many filesystems
701 + my ($self) = @_;
702 + $self->{_blox} = lsblk;
703 + $self->{_fstype} = findValidFS;
704 + return;
705 +}
706 +
707 +sub list
708 +{
709 + my ($self) = @_;
710 + my @dirs=();
711 + my $hashref = $self->{_blox};
712 +
713 + foreach my $drive (keys %{$hashref})
714 + {
715 + push @dirs, $drive;
716 + }
717 +
718 + return @dirs;
719 +}
720 +
721 +sub checkBackupDriveSize
722 +{
723 + my ($self,$drive, $size) = @_;
724 + my $hashref = $self->{_blox};
725 + my $sz = $EMPTY;
726 + my $mntdir = $self->{mount};
727 + Readonly my $VFAT_LIMIT => 2147483648;
728 + Readonly my $KBYTE => 1024;
729 +
730 + # size > drive size
731 + if ($size > $hashref->{$drive}{SIZE})
732 + {
733 + return 1; # filesystem too small
734 + }
735 +
736 + # FAT32 drive and size > 2G
737 + if (($size > $VFAT_LIMIT) && ($hashref->{$drive}{FSTYPE} eq 'vfat'))
738 + {
739 + return 2; # filesystem vfat limit
740 + }
741 +
742 +#ToDo add a check here to see if mounting is allowed by db value
743 +
744 + # check mount and find actual size
745 + if ($self->mountable ($drive)) # Only check filesystems that appear mountable
746 + {
747 + $self->mount ($drive);
748 + my $filesize = -s "$mntdir/smeserver.tgz";
749 +
750 + # Check free disk space
751 + my $df = qx(/usr/bin/df -P \"$mntdir\");
752 + if ($df =~ /(\S+)\s+(\S+)\s+(\S+)\s+(\d*%)/s)
753 + {
754 + my $dsize = ($3 * $KBYTE) + ($filesize //= 0);
755 + if ($size > $dsize) # not enough space
756 + {
757 + $sz = 3; # filesystem has too little free space
758 + }
759 + }
760 + else # fail (never seen in testing)
761 + {
762 + $sz = 4; # Failed to get disk size
763 + }
764 + $self->unmount;
765 + }
766 + return $sz;
767 +}
768 +
769 +# Check each block device
770 +# Return two arrays, valid drives, invalid drives
771 +sub checkBackupDrives
772 +{
773 + my ($self,$bsize) = @_;
774 + my @valid = ();
775 + my @invalid = ();
776 + $self->scanBlocks; # scan all block devices
777 + my $hashref = $self->{_blox};
778 + my $allowmount = $self->{'allowmount'}; # Are mounted drives allowed in $checks.
779 + my $checks = 'UU RO FS'; # These checks are always valid
780 + $checks .= ' MO' if ($allowmount eq 'enabled');
781 + $checks .= ' SZ' if ($bsize); # Only run the size check when a valid size is given
782 +
783 + foreach my $drive (keys %{$hashref})
784 + {
785 + $hashref->{$drive}{REASON} = $EMPTY; # Reason for a filesystem being (in)valid
786 + next unless $hashref->{$drive}{tip}; #Ignore drives that have child filesystems
787 +
788 + # drives mounted on /, /boot, or [SWAP] are never valid for backups
789 + next if ($hashref->{$drive}{MOUNTPOINT} =~ /^\/boot$|^\[SWAP\]$|^\/$/s );
790 +
791 + # validate each filesystem against the checks
792 + foreach my $check (split / /s, $checks)
793 + {
794 + for ($check)
795 + {
796 + if (/^UU/si) # No UUID
797 + {
798 + $hashref->{$drive}{REASON} .='UU ' unless $self->uuid ($drive); last;
799 + }
800 + if (/^RO/si) # Read Only
801 + {
802 + $hashref->{$drive}{REASON} .='RO ' if $self->readonly ($drive); last;
803 + }
804 + if (/^FS/si) # Invalid filesystem
805 + {
806 + $hashref->{$drive}{REASON} .='FS ' unless $self->validFS ($drive); last;
807 + }
808 + if (/^MO/si) # Mounted
809 + {
810 + $hashref->{$drive}{REASON} .='MO ' if $self->mountpoint ($drive); last;
811 + }
812 + if (/^SZ/si) # filesystem size, this includes mounting to check free space
813 + {
814 + $hashref->{$drive}{REASON} .='SZ ' if $self->checkBackupDriveSize ($drive, $bsize);
815 + #ToDo the return value contains the reason why there is insufficient space, but this is not used yet.
816 + last;
817 + }
818 + { carp "not supported yet in checkBackupDrives: $check"; } # Should never be seen
819 + }
820 + }
821 + if ($hashref->{$drive}{REASON})
822 + {
823 + push @invalid, $drive;
824 + }
825 + else
826 + {
827 + push @valid, $drive;
828 + }
829 + }
830 + return (\@valid, \@invalid);
831 +}
832 +
833 +sub findBackup
834 +{
835 + my ($self, $kname, $foundref, $maxDepth, $count) = @_;
836 + my $hashref = $self->{_blox};
837 + my $mountpoint = $self->{'mount'};
838 + my $file = 'smeserver.tgz';
839 +
840 + $self->mount ($kname);
841 + sleep 1;
842 +
843 + # start with the absolute path
844 + my $findRoot = Cwd::realpath($mountpoint);
845 +
846 + # determine the depth of our beginning directory
847 + my $begDepth = 1 + grep { length } File::Spec->splitdir($findRoot);
848 +
849 + find (
850 + {
851 + preprocess => sub
852 + { @_ if (scalar File::Spec->splitdir($File::Find::dir) - $begDepth) <= $maxDepth },
853 + wanted => sub
854 + {
855 + if (($_ =~ m/^$file/s) && ($File::Find::name =~ qr|^([-+@\w\s./:\\]+)$| )) # if matching the backup name
856 + {
857 + $$count++;
858 + my $sb = stat $1;
859 + ${$foundref}{$$count}{count}=$$count;
860 + ${$foundref}{$$count}{device}=$kname;
861 + ${$foundref}{$$count}{path} = $1;
862 + ${$foundref}{$$count}{path} =~ s/$mountpoint//; #strip off the mountpoint
863 + ${$foundref}{$$count}{path} =~ s/$file//; #strip off the filename
864 + ${$foundref}{$$count}{size}=$sb->size; # size in bytes
865 + ${$foundref}{$$count}{sizeH}=scaleIt($sb->size); # human readable size
866 + ${$foundref}{$$count}{time}=strftime '%d %b %g %H:%M', localtime $sb->mtime;
867 + }
868 + },
869 + untaint => 1,
870 + untaint_pattern => qr|^([-+@\w\s./:\\]+)$|,
871 + untaint_skip =>1,
872 + },
873 + $findRoot
874 + );
875 +
876 + $self->unmount;
877 + return;
878 +}
879 +
880 +sub desc # brief description of a filesystem
881 +{
882 + my ($self,$kname) = @_;
883 + my $hashref = $self->{_blox};
884 +
885 + my $model = $hashref->{$kname}{MODEL};
886 + my $label = $hashref->{$kname}{LABEL} || gettext('no label');
887 + my $size = $hashref->{$kname}{SIZEH};
888 +
889 + return "$label $model $size";
890 +}
891 +
892 +
893 +# Given the KNAME check if the filesystem.could be mountable
894 +# Check that there are no children, i.e. a tip
895 +# Check that it has a UUID, Filesystem,
896 +sub mountable
897 +{
898 + my ($self,$kname) = @_;
899 + my $hashref = $self->{_blox};
900 + return ($hashref->{$kname}{tip} && $hashref->{$kname}{UUID} && _isFS ($hashref->{$kname}{FSTYPE})) ? 1 : $EMPTY;
901 +}
902 +
903 +# Given the KNAME check if the filesystem.is read-only
904 +# returns 1 for Read-Only and $EMPTY for R-W
905 +sub readonly
906 +{
907 + my ($self,$kname) = @_;
908 + my $hashref = $self->{_blox};
909 + return ($hashref->{$kname}{RO}) ? 1 : $EMPTY;
910 +}
911 +
912 +sub mountpoint
913 +{
914 + my ($self,$kname) = @_;
915 + my $hashref = $self->{_blox};
916 + return ($hashref->{$kname}{MOUNTPOINT});
917 +}
918 +
919 +sub uuid
920 +{
921 + my ($self,$kname) = @_;
922 + my $hashref = $self->{_blox};
923 + return ($hashref->{$kname}{UUID});
924 +}
925 +
926 +sub model
927 +{
928 + my ($self,$kname) = @_;
929 + my $hashref = $self->{_blox};
930 + return ($hashref->{$kname}{MODEL});
931 +}
932 +
933 +# Given the KNAME return the label
934 +# returns 'no label' if none found
935 +sub label
936 +{
937 + my ($self,$kname) = @_;
938 + my $hashref = $self->{_blox};
939 + return ($hashref->{$kname}{LABEL}) || gettext('no label');
940 +}
941 +
942 +sub size
943 +{
944 + my ($self,$kname) = @_;
945 + my $hashref = $self->{_blox};
946 + return ($hashref->{$kname}{SIZE});
947 +}
948 +
949 +# Given a filesystem.(eg sr0) check if it's filesystem type is allowed
950 +sub validFS
951 +{
952 + my ($self,$kname) = @_;
953 + my $hashref = $self->{_blox};
954 + my $fsref = $self->{_fstype};
955 + return ($fsref->{$hashref->{$kname}{FSTYPE}}) || $EMPTY;
956 +}
957 +
958 +# Given a filesystem.type (eg vfat) check if it is allowed
959 +sub _isFS
960 +{
961 + my ($filesystem) = @_;
962 + return $EMPTY unless $filesystem;
963 +
964 + my $fsref = findValidFS;
965 + return ($fsref->{$filesystem}) || $EMPTY;
966 +}
967 +
968 +# Return the reason string which indicates why a drive is (in)valid
969 +sub reason
970 +{
971 + my ($self,$kname) = @_;
972 + my $hashref = $self->{_blox};
973 + return ($hashref->{$kname}{REASON});
974 +}
975 +
976 +# Given the KNAME mount the filesystem, example
977 +# system ('/bin/mount', '-t', 'vfat', '-U', '9891-4C8A', '/tmp/mnt');
978 +sub mount
979 +{
980 + my ($self, $kname) = @_;
981 + my $hashref = $self->{_blox};
982 +
983 + $self->createMountpoint;
984 +
985 + system ('/bin/mount', '-t', $hashref->{$kname}{FSTYPE}, '-U', $hashref->{$kname}{UUID}, $self->{mount}) == 0
986 + or croak (gettext('Failed to mount')." $self->{mount},$hashref->{$kname}{FSTYPE},$hashref->{$kname}{UUID}: $?");
987 + return;
988 +}
989 +
990 +# Unmount the block device
991 +sub unmount
992 +{
993 + my $self = shift;
994 + system('/bin/umount', $self->{mount}) == 0
995 + or croak (gettext('Failed to unmount')." $self->{mount}: $?");
996 + return;
997 +}
998 +
999 +# Create the mountpoint directory
1000 +# Error if already mounted
1001 +sub createMountpoint
1002 +{
1003 + my $self = shift;
1004 + my $mount = $self->{mount};
1005 +
1006 + # Check if the mountpoint is in use
1007 + if (!checkMount ($mount))
1008 + {
1009 + # Try to unmount, will die if fails
1010 + $self->unmount;
1011 + }
1012 +
1013 + if ($mount && ! -d $mount)
1014 + {
1015 + eval {make_path($mount)};
1016 + croak (gettext('Error while creating')." $mount $EVAL_ERROR".gettext('Maybe insufficient permissions.')) if $EVAL_ERROR;
1017 + }
1018 + return;
1019 +}
1020 +
1021 +sub destroy
1022 +{
1023 +# cleanup, unmount and remove mountpoint
1024 +
1025 + my $self = shift;
1026 + my $mount = $self->{mount};
1027 +
1028 +
1029 + # Check if the mountpoint is in use
1030 + if (!checkMount ($mount))
1031 + {
1032 + $self->unmount;
1033 + }
1034 +
1035 + if ($mount && -d $mount)
1036 + {
1037 + eval {remove_tree($mount)};
1038 + croak (gettext('Error while deleting')." $mount $EVAL_ERROR") if $EVAL_ERROR;
1039 + }
1040 + return;
1041 +}
1042 +
1043 +
1044 +### The following subroutines are not specific to block devices
1045 +sub scaleIt {
1046 + Readonly my $KBYTE => 1024;
1047 + my( $size, $n ) =( shift, 0 );
1048 + ++$n and $size /= $KBYTE until $size < $KBYTE;
1049 + if ($size >= 1000){++$n ; $size /= $KBYTE;}
1050 + return sprintf "%.3g %s",
1051 + $size, ( qw[ bytes KB MB GB TB] )[ $n ];
1052 +}
1053 +
1054 +sub checkMount
1055 +{
1056 + # check if $mountdir is mounted
1057 + my $mountdir = shift;
1058 + $|=1; # Auto-flush
1059 +
1060 + # copy STDOUT to another filehandle
1061 + open (my $STDOLD, '>&', STDOUT);
1062 +
1063 + open(STDOUT, ">/dev/null");
1064 + if ( open(MOUNTDIR, "|-", "/bin/findmnt", $mountdir)){;}
1065 +
1066 + # restore STDOUT
1067 + open (STDOUT, '>&', $STDOLD);
1068 +
1069 + return (!close(MOUNTDIR));
1070 +}
1071 +
1072 +# remove leading and trailing spaces from a string
1073 +# this should be moved to a util library.
1074 +sub trim
1075 +{
1076 + my ($string) = @_;
1077 + $string =~ s/^\s+|\s+$//g;
1078 + return $string;
1079 +}
1080 +1;

admin@koozali.org
ViewVC Help
Powered by ViewVC 1.2.1 RSS 2.0 feed