use File::Path;
use Cwd 'abs_path';
use Socket;
+use Time::Local qw(timelocal);
use PVE::Tools qw(run_command file_read_firstline dir_glob_foreach $IPV6RE);
use PVE::Cluster qw(cfs_read_file cfs_write_file cfs_lock_file);
-use PVE::Exception qw(raise_param_exc);
+use PVE::DataCenterConfig;
+use PVE::Exception qw(raise_param_exc raise);
use PVE::JSONSchema;
use PVE::INotify;
use PVE::RPCEnvironment;
+use PVE::SSHInfo;
use PVE::Storage::Plugin;
use PVE::Storage::DirPlugin;
use PVE::Storage::ZFSPoolPlugin;
use PVE::Storage::ZFSPlugin;
use PVE::Storage::DRBDPlugin;
+use PVE::Storage::PBSPlugin;
# Storage API version. Icrement it on changes in storage API interface.
-use constant APIVER => 3;
+use constant APIVER => 6;
# Age is the number of versions we're backward compatible with.
# This is like having 'current=APIVER' and age='APIAGE' in libtool,
# see https://www.gnu.org/software/libtool/manual/html_node/Libtool-versioning.html
-use constant APIAGE => 2;
+use constant APIAGE => 5;
# load standard plugins
PVE::Storage::DirPlugin->register();
PVE::Storage::ZFSPoolPlugin->register();
PVE::Storage::ZFSPlugin->register();
PVE::Storage::DRBDPlugin->register();
+PVE::Storage::PBSPlugin->register();
# load third-party plugins
if ( -d '/usr/share/perl5/PVE/Storage/Custom' ) {
my $UDEVADM = '/sbin/udevadm';
+our $iso_extension_re = qr/\.(?:iso|img)/i;
+
# PVE::Storage utility functions
sub config {
my $scfg = $cfg->{ids}->{$storeid};
- die "storage '$storeid' does not exists\n" if (!$noerr && !$scfg);
+ die "storage '$storeid' does not exist\n" if (!$noerr && !$scfg);
return $scfg;
}
sub volume_resize {
my ($cfg, $volid, $size, $running) = @_;
+ my $padding = (1024 - $size % 1024) % 1024;
+ $size = $size + $padding;
+
my ($storeid, $volname) = parse_volume_id($volid, 1);
if ($storeid) {
my $scfg = storage_config($cfg, $storeid);
}
}
+# check if a volume or snapshot supports a given feature
+# $feature - one of:
+# clone - linked clone is possible
+# copy - full clone is possible
+# replicate - replication is possible
+# snapshot - taking a snapshot is possible
+# sparseinit - volume is sparsely initialized
+# template - conversion to base image is possible
+# $snap - check if the feature is supported for a given snapshot
+# $running - if the guest owning the volume is running
+# $opts - hash with further options:
+# valid_target_formats - list of formats for the target of a copy/clone
+# operation that the caller could work with. The
+# format of $volid is always considered valid and if
+# no list is specified, all formats are considered valid.
sub volume_has_feature {
- my ($cfg, $feature, $volid, $snap, $running) = @_;
+ my ($cfg, $feature, $volid, $snap, $running, $opts) = @_;
my ($storeid, $volname) = parse_volume_id($volid, 1);
if ($storeid) {
my $scfg = storage_config($cfg, $storeid);
my $plugin = PVE::Storage::Plugin->lookup($scfg->{type});
- return $plugin->volume_has_feature($scfg, $feature, $storeid, $volname, $snap, $running);
+ return $plugin->volume_has_feature($scfg, $feature, $storeid, $volname, $snap, $running, $opts);
} elsif ($volid =~ m|^(/.+)$| && -e $volid) {
return undef;
} else {
my $tmpldir = $plugin->get_subdir($scfg, 'vztmpl');
my $backupdir = $plugin->get_subdir($scfg, 'backup');
my $privatedir = $plugin->get_subdir($scfg, 'rootdir');
+ my $snippetsdir = $plugin->get_subdir($scfg, 'snippets');
if ($path =~ m!^$imagedir/(\d+)/([^/\s]+)$!) {
my $vmid = $1;
return ('images', $info->{volid});
}
}
- } elsif ($path =~ m!^$isodir/([^/]+\.[Ii][Ss][Oo])$!) {
+ } elsif ($path =~ m!^$isodir/([^/]+$iso_extension_re)$!) {
my $name = $1;
return ('iso', "$sid:iso/$name");
} elsif ($path =~ m!^$tmpldir/([^/]+\.tar\.gz)$!) {
} elsif ($path =~ m!^$privatedir/(\d+)$!) {
my $vmid = $1;
return ('rootdir', "$sid:rootdir/$vmid");
- } elsif ($path =~ m!^$backupdir/([^/]+\.(tar|tar\.gz|tar\.lzo|tgz|vma|vma\.gz|vma\.lzo))$!) {
+ } elsif ($path =~ m!^$backupdir/([^/]+\.(?:tgz|(?:(?:tar|vma)(?:\.(?:${\PVE::Storage::Plugin::COMPRESSOR_RE}))?)))$!) {
my $name = $1;
- return ('iso', "$sid:backup/$name");
+ return ('backup', "$sid:backup/$name");
+ } elsif ($path =~ m!^$snippetsdir/([^/]+)$!) {
+ my $name = $1;
+ return ('snippets', "$sid:snippets/$name");
}
}
my ($cfg, $volid) = @_;
my $path;
- if (PVE::Storage::parse_volume_id ($volid, 1)) {
- PVE::Storage::activate_volumes($cfg, [ $volid ]);
+ if (parse_volume_id ($volid, 1)) {
+ activate_volumes($cfg, [ $volid ]);
$path = PVE::Storage::path($cfg, $volid);
} else {
if (-f $volid) {
return $path;
}
+my $volname_for_storage = sub {
+ my ($cfg, $volid, $target_storeid) = @_;
+
+ my (undef, $name, $vmid, undef, undef, undef, $format) = parse_volname($cfg, $volid);
+ my $target_scfg = storage_config($cfg, $target_storeid);
+
+ my (undef, $valid_formats) = PVE::Storage::Plugin::default_format($target_scfg);
+ my $format_is_valid = grep { $_ eq $format } @$valid_formats;
+ die "unsupported format '$format' for storage type $target_scfg->{type}\n" if !$format_is_valid;
+
+ (my $name_without_extension = $name) =~ s/\.$format$//;
+
+ if ($target_scfg->{path}) {
+ return "$vmid/$name_without_extension.$format";
+ } else {
+ return "$name_without_extension";
+ }
+};
+
sub storage_migrate {
- my ($cfg, $volid, $target_sshinfo, $target_storeid, $target_volname, $base_snapshot, $snapshot, $ratelimit_bps, $insecure, $with_snapshots, $logfunc) = @_;
+ my ($cfg, $volid, $target_sshinfo, $target_storeid, $opts, $logfunc) = @_;
+
+ my $base_snapshot = $opts->{base_snapshot};
+ my $snapshot = $opts->{snapshot};
+ my $ratelimit_bps = $opts->{ratelimit_bps};
+ my $insecure = $opts->{insecure};
+ my $with_snapshots = $opts->{with_snapshots} ? 1 : 0;
+ my $allow_rename = $opts->{allow_rename} ? 1 : 0;
my ($storeid, $volname) = parse_volume_id($volid);
- $target_volname = $volname if !$target_volname;
my $scfg = storage_config($cfg, $storeid);
# no need to migrate shared content
- return if $storeid eq $target_storeid && $scfg->{shared};
+ return $volid if $storeid eq $target_storeid && $scfg->{shared};
my $tcfg = storage_config($cfg, $target_storeid);
+ my $target_volname;
+ if ($opts->{target_volname}) {
+ $target_volname = $opts->{target_volname};
+ } elsif ($scfg->{type} eq $tcfg->{type}) {
+ $target_volname = $volname;
+ } else {
+ $target_volname = $volname_for_storage->($cfg, $volid, $target_storeid);
+ }
+
my $target_volid = "${target_storeid}:${target_volname}";
my $target_ip = $target_sshinfo->{ip};
- my $errstr = "unable to migrate '$volid' to '${target_volid}' on host '$target_sshinfo->{name}'";
- my $ssh = PVE::Cluster::ssh_info_to_command($target_sshinfo);
- my $ssh_base = PVE::Cluster::ssh_info_to_command_base($target_sshinfo);
+ my $ssh = PVE::SSHInfo::ssh_info_to_command($target_sshinfo);
+ my $ssh_base = PVE::SSHInfo::ssh_info_to_command_base($target_sshinfo);
local $ENV{RSYNC_RSH} = PVE::Tools::cmd2string($ssh_base);
my @cstream = ([ '/usr/bin/cstream', '-t', $ratelimit_bps ])
}
}
- my @formats = volume_transfer_formats($cfg, $volid, $volid, $snapshot, $base_snapshot, $with_snapshots);
+ my @formats = volume_transfer_formats($cfg, $volid, $target_volid, $snapshot, $base_snapshot, $with_snapshots);
die "cannot migrate from storage type '$scfg->{type}' to '$tcfg->{type}'\n" if !@formats;
my $format = $formats[0];
$import_fn = "tcp://$net";
}
- $with_snapshots = $with_snapshots ? 1 : 0; # sanitize for passing as cli parameter
+ my $target_apiver = 1; # if there is no apiinfo call, assume 1
+ my $get_api_version = [@$ssh, 'pvesm', 'apiinfo'];
+ my $match_api_version = sub { $target_apiver = $1 if $_[0] =~ m!^APIVER (\d+)$!; };
+ eval { run_command($get_api_version, logfunc => $match_api_version); };
+
my $send = ['pvesm', 'export', $volid, $format, '-', '-with-snapshots', $with_snapshots];
- my $recv = [@$ssh, '--', 'pvesm', 'import', $volid, $format, $import_fn, '-with-snapshots', $with_snapshots];
+ my $recv = [@$ssh, '--', 'pvesm', 'import', $target_volid, $format, $import_fn, '-with-snapshots', $with_snapshots];
if (defined($snapshot)) {
push @$send, '-snapshot', $snapshot
}
if ($migration_snapshot) {
push @$recv, '-delete-snapshot', $snapshot;
}
+ push @$recv, '-allow-rename', $allow_rename if $target_apiver >= 5;
if (defined($base_snapshot)) {
# Check if the snapshot exists on the remote side:
push @$recv, '-base', $base_snapshot;
}
+ my $new_volid;
+ my $pattern = volume_imported_message(undef, 1);
+ my $match_volid_and_log = sub {
+ my $line = shift;
+
+ $new_volid = $1 if ($line =~ $pattern);
+
+ if ($logfunc) {
+ chomp($line);
+ $logfunc->($line);
+ }
+ };
+
volume_snapshot($cfg, $volid, $snapshot) if $migration_snapshot;
eval {
if ($insecure) {
or die "failed to connect to tunnel at $ip:$port\n";
# we won't be reading from the socket
shutdown($socket, 0);
- run_command([$send, @cstream], output => '>&'.fileno($socket));
+ run_command([$send, @cstream], output => '>&'.fileno($socket), errfunc => $logfunc);
# don't close the connection entirely otherwise the receiving end
# might not get all buffered data (and fails with 'connection reset by peer')
shutdown($socket, 1);
- 1 while <$info>; # wait for the remote process to finish
+
+ # wait for the remote process to finish
+ while (my $line = <$info>) {
+ $match_volid_and_log->("[$target_sshinfo->{name}] $line");
+ }
+
# now close the socket
close($socket);
if (!close($info)) { # does waitpid()
die "import failed: exit code ".($?>>8)."\n";
}
} else {
- run_command([$send, @cstream, $recv], logfunc => $logfunc);
+ run_command([$send, @cstream, $recv], logfunc => $match_volid_and_log);
}
+
+ die "unable to get ID of the migrated volume\n"
+ if !defined($new_volid) && $target_apiver >= 5;
};
my $err = $@;
warn "send/receive failed, cleaning up snapshot(s)..\n" if $err;
warn "could not remove source snapshot: $@\n" if $@;
}
die $err if $err;
+
+ return $new_volid // $target_volid;
}
sub vdisk_clone {
foreach my $sid (keys %$ids) {
next if $storeid && $storeid ne $sid;
next if !storage_check_enabled($cfg, $sid, undef, 1);
+ my $content = $ids->{$sid}->{content};
+ next if !($content->{rootdir} || $content->{images});
push @$storage_list, $sid;
}
}
sub scan_cifs {
my ($server_in, $user, $password, $domain) = @_;
- my $server;
- if (!($server = resolv_server ($server_in))) {
- die "unable to resolve address for server '${server_in}'\n";
- }
+ my $server = resolv_server($server_in);
+ die "unable to resolve address for server '${server_in}'\n" if !$server;
- # we support only Windows grater than 2012 cifsscan so use smb3
+ # we only support Windows 2012 and newer, so just use smb3
my $cmd = ['/usr/bin/smbclient', '-m', 'smb3', '-d', '0', '-L', $server];
- if (defined($user)) {
- die "password is required" if !defined($password);
- push @$cmd, '-U', "$user\%$password";
- push @$cmd, '-W', $domain if defined($domain);
- } else {
- push @$cmd, '-N';
- }
+ push @$cmd, '-W', $domain if defined($domain);
+
+ push @$cmd, '-N' if !defined($password);
+ local $ENV{USER} = $user if defined($user);
+ local $ENV{PASSWD} = $password if defined($password);
my $res = {};
+ my $err = '';
run_command($cmd,
- outfunc => sub {
- my $line = shift;
- if ($line =~ m/(\S+)\s*Disk\s*(\S*)/) {
- $res->{$1} = $2;
- } elsif ($line =~ m/(NT_STATUS_(\S*))/) {
- $res->{$1} = '';
- }
- },
- errfunc => sub {},
- noerr => 1
+ noerr => 1,
+ errfunc => sub {
+ $err .= "$_[0]\n"
+ },
+ outfunc => sub {
+ my $line = shift;
+ if ($line =~ m/(\S+)\s*Disk\s*(\S*)/) {
+ $res->{$1} = $2;
+ } elsif ($line =~ m/(NT_STATUS_(\S+))/) {
+ my $status = $1;
+ $err .= "unexpected status: $1\n" if uc($1) ne 'SUCCESS';
+ }
+ },
);
+ # only die if we got no share, else it's just some followup check error
+ # (like workgroup querying)
+ raise($err) if $err && !%$res;
return $res;
}
sub scan_zfs {
- my $cmd = ['zfs', 'list', '-t', 'filesystem', '-H', '-o', 'name,avail,used'];
+ my $cmd = ['zfs', 'list', '-t', 'filesystem', '-Hp', '-o', 'name,avail,used'];
my $res = [];
run_command($cmd, outfunc => sub {
if ($line =~m/^(\S+)\s+(\S+)\s+(\S+)$/) {
my ($pool, $size_str, $used_str) = ($1, $2, $3);
- my $size = PVE::Storage::ZFSPoolPlugin::zfs_parse_size($size_str);
- my $used = PVE::Storage::ZFSPoolPlugin::zfs_parse_size($used_str);
+ my $size = $size_str + 0;
+ my $used = $used_str + 0;
# ignore subvolumes generated by our ZFSPoolPlugin
return if $pool =~ m!/subvol-\d+-[^/]+$!;
return if $pool =~ m!/basevol-\d+-[^/]+$!;
}
}
+sub decompressor_info {
+ my ($format, $comp) = @_;
+
+ if ($format eq 'tgz' && !defined($comp)) {
+ ($format, $comp) = ('tar', 'gz');
+ }
+
+ my $decompressor = {
+ tar => {
+ gz => ['tar', '-z'],
+ lzo => ['tar', '--lzop'],
+ zst => ['tar', '--zstd'],
+ },
+ vma => {
+ gz => ['zcat'],
+ lzo => ['lzop', '-d', '-c'],
+ zst => ['zstd', '-q', '-d', '-c'],
+ },
+ };
+
+ die "ERROR: archive format not defined\n"
+ if !defined($decompressor->{$format});
+
+ my $decomp = $decompressor->{$format}->{$comp} if $comp;
+
+ my $info = {
+ format => $format,
+ compression => $comp,
+ decompressor => $decomp,
+ };
+
+ return $info;
+}
+
+sub archive_info {
+ my ($archive) = shift;
+ my $info;
+
+ my $volid = basename($archive);
+ if ($volid =~ /^(vzdump-(lxc|openvz|qemu)-.+\.(tgz$|tar|vma)(?:\.(${\PVE::Storage::Plugin::COMPRESSOR_RE}))?)$/) {
+ my $filename = "$1"; # untaint
+ my ($type, $format, $comp) = ($2, $3, $4);
+ my $format_re = defined($comp) ? "$format.$comp" : "$format";
+ $info = decompressor_info($format, $comp);
+ $info->{filename} = $filename;
+ $info->{type} = $type;
+
+ if ($volid =~ /^(vzdump-${type}-([1-9][0-9]{2,8})-(\d{4})_(\d{2})_(\d{2})-(\d{2})_(\d{2})_(\d{2}))\.${format_re}$/) {
+ $info->{logfilename} = "$1.log";
+ $info->{vmid} = int($2);
+ $info->{ctime} = timelocal($8, $7, $6, $5, $4 - 1, $3);
+ $info->{is_std_name} = 1;
+ } else {
+ $info->{is_std_name} = 0;
+ }
+ } else {
+ die "ERROR: couldn't determine archive info from '$archive'\n";
+ }
+
+ return $info;
+}
+
+sub archive_remove {
+ my ($archive_path) = @_;
+
+ my $dirname = dirname($archive_path);
+ my $archive_info = eval { archive_info($archive_path) } // {};
+ my $logfn = $archive_info->{logfilename};
+
+ unlink $archive_path or die "removing archive $archive_path failed: $!\n";
+
+ if (defined($logfn)) {
+ my $logpath = "$dirname/$logfn";
+ if (-e $logpath) {
+ unlink $logpath or warn "removing log file $logpath failed: $!\n";
+ }
+ }
+}
+
sub extract_vzdump_config_tar {
my ($archive, $conf_re) = @_;
$raw .= "$output\n";
};
- PVE::Tools::run_command(['tar', '-xpOf', $archive, $file, '--occurrence'], outfunc => $out);
+ run_command(['tar', '-xpOf', $archive, $file, '--occurrence'], outfunc => $out);
return wantarray ? ($raw, $file) : $raw;
}
sub extract_vzdump_config_vma {
my ($archive, $comp) = @_;
- my $cmd;
my $raw = '';
- my $out = sub {
- my $output = shift;
- $raw .= "$output\n";
- };
+ my $out = sub { $raw .= "$_[0]\n"; };
+ my $info = archive_info($archive);
+ $comp //= $info->{compression};
+ my $decompressor = $info->{decompressor};
if ($comp) {
- my $uncomp;
- if ($comp eq 'gz') {
- $uncomp = ["zcat", $archive];
- } elsif ($comp eq 'lzo') {
- $uncomp = ["lzop", "-d", "-c", $archive];
- } else {
- die "unknown compression method '$comp'\n";
- }
- $cmd = [$uncomp, ["vma", "config", "-"]];
+ my $cmd = [ [@$decompressor, $archive], ["vma", "config", "-"] ];
- # in some cases, lzop/zcat exits with 1 when its stdout pipe is
- # closed early by vma, detect this and ignore the exit code later
+ # lzop/zcat exits with 1 when the pipe is closed early by vma, detect this and ignore the exit code later
my $broken_pipe;
my $errstring;
my $err = sub {
my $output = shift;
- if ($output =~ m/lzop: Broken pipe: <stdout>/ || $output =~ m/gzip: stdout: Broken pipe/) {
+ if ($output =~ m/lzop: Broken pipe: <stdout>/ || $output =~ m/gzip: stdout: Broken pipe/ || $output =~ m/zstd: error 70 : Write error : Broken pipe/) {
$broken_pipe = 1;
} elsif (!defined ($errstring) && $output !~ m/^\s*$/) {
$errstring = "Failed to extract config from VMA archive: $output\n";
}
};
- # in other cases, the pipeline will exit with exit code 141
- # because of the broken pipe, handle / ignore this as well
- my $rc;
- eval {
- $rc = PVE::Tools::run_command($cmd, outfunc => $out, errfunc => $err, noerr => 1);
- };
+ my $rc = eval { run_command($cmd, outfunc => $out, errfunc => $err, noerr => 1) };
my $rerr = $@;
- # use exit code if no stderr output and not just broken pipe
- if (!$errstring && !$broken_pipe && $rc != 0 && $rc != 141) {
+ $broken_pipe ||= $rc == 141; # broken pipe from vma POV
+
+ if (!$errstring && !$broken_pipe && $rc != 0) {
die "$rerr\n" if $rerr;
die "config extraction failed with exit code $rc\n";
}
die "$errstring\n" if $errstring;
} else {
- # simple case without compression and weird piping behaviour
- PVE::Tools::run_command(["vma", "config", $archive], outfunc => $out);
+ run_command(["vma", "config", $archive], outfunc => $out);
}
return wantarray ? ($raw, undef) : $raw;
sub extract_vzdump_config {
my ($cfg, $volid) = @_;
+ my ($storeid, $volname) = parse_volume_id($volid);
+ if (defined($storeid)) {
+ my $scfg = storage_config($cfg, $storeid);
+ if ($scfg->{type} eq 'pbs') {
+ storage_check_enabled($cfg, $storeid);
+ return PVE::Storage::PBSPlugin->extract_vzdump_config($scfg, $volname, $storeid);
+ }
+ }
+
my $archive = abs_filesystem_path($cfg, $volid);
+ my $info = archive_info($archive);
+ my $format = $info->{format};
+ my $comp = $info->{compression};
+ my $type = $info->{type};
- if ($volid =~ /vzdump-(lxc|openvz)-\d+-(\d{4})_(\d{2})_(\d{2})-(\d{2})_(\d{2})_(\d{2})\.(tgz|(tar(\.(gz|lzo))?))$/) {
+ if ($type eq 'lxc' || $type eq 'openvz') {
return extract_vzdump_config_tar($archive, qr!^(\./etc/vzdump/(pct|vps)\.conf)$!);
- } elsif ($volid =~ /vzdump-qemu-\d+-(\d{4})_(\d{2})_(\d{2})-(\d{2})_(\d{2})_(\d{2})\.(tgz|((tar|vma)(\.(gz|lzo))?))$/) {
- my $format;
- my $comp;
- if ($7 eq 'tgz') {
- $format = 'tar';
- $comp = 'gz';
- } else {
- $format = $9;
- $comp = $11 if defined($11);
- }
-
+ } elsif ($type eq 'qemu') {
if ($format eq 'tar') {
return extract_vzdump_config_tar($archive, qr!\(\./qemu-server\.conf\)!);
} else {
}
}
+sub prune_backups {
+ my ($cfg, $storeid, $keep, $vmid, $type, $dryrun, $logfunc) = @_;
+
+ my $scfg = storage_config($cfg, $storeid);
+ die "storage '$storeid' does not support backups\n" if !$scfg->{content}->{backup};
+
+ if (!defined($keep)) {
+ die "no prune-backups options configured for storage '$storeid'\n"
+ if !defined($scfg->{'prune-backups'});
+ $keep = PVE::JSONSchema::parse_property_string('prune-backups', $scfg->{'prune-backups'});
+ }
+
+ my $plugin = PVE::Storage::Plugin->lookup($scfg->{type});
+ return $plugin->prune_backups($scfg, $storeid, $keep, $vmid, $type, $dryrun, $logfunc);
+}
+
+my $prune_mark = sub {
+ my ($prune_entries, $keep_count, $id_func) = @_;
+
+ return if !$keep_count;
+
+ my $already_included = {};
+ my $newly_included = {};
+
+ foreach my $prune_entry (@{$prune_entries}) {
+ my $mark = $prune_entry->{mark};
+ my $id = $id_func->($prune_entry->{ctime});
+
+ next if $already_included->{$id};
+
+ if (defined($mark)) {
+ $already_included->{$id} = 1 if $mark eq 'keep';
+ next;
+ }
+
+ if (!$newly_included->{$id}) {
+ last if scalar(keys %{$newly_included}) >= $keep_count;
+ $newly_included->{$id} = 1;
+ $prune_entry->{mark} = 'keep';
+ } else {
+ $prune_entry->{mark} = 'remove';
+ }
+ }
+};
+
+sub prune_mark_backup_group {
+ my ($backup_group, $keep) = @_;
+
+ my $prune_list = [ sort { $b->{ctime} <=> $a->{ctime} } @{$backup_group} ];
+
+ $prune_mark->($prune_list, $keep->{'keep-last'}, sub {
+ my ($ctime) = @_;
+ return $ctime;
+ });
+ $prune_mark->($prune_list, $keep->{'keep-hourly'}, sub {
+ my ($ctime) = @_;
+ my (undef, undef, $hour, $day, $month, $year) = localtime($ctime);
+ return "$hour/$day/$month/$year";
+ });
+ $prune_mark->($prune_list, $keep->{'keep-daily'}, sub {
+ my ($ctime) = @_;
+ my (undef, undef, undef, $day, $month, $year) = localtime($ctime);
+ return "$day/$month/$year";
+ });
+ $prune_mark->($prune_list, $keep->{'keep-weekly'}, sub {
+ my ($ctime) = @_;
+ my ($sec, $min, $hour, $day, $month, $year) = localtime($ctime);
+ my $iso_week = int(strftime("%V", $sec, $min, $hour, $day, $month - 1, $year - 1900));
+ my $iso_week_year = int(strftime("%G", $sec, $min, $hour, $day, $month - 1, $year - 1900));
+ return "$iso_week/$iso_week_year";
+ });
+ $prune_mark->($prune_list, $keep->{'keep-monthly'}, sub {
+ my ($ctime) = @_;
+ my (undef, undef, undef, undef, $month, $year) = localtime($ctime);
+ return "$month/$year";
+ });
+ $prune_mark->($prune_list, $keep->{'keep-yearly'}, sub {
+ my ($ctime) = @_;
+ my $year = (localtime($ctime))[5];
+ return "$year";
+ });
+
+ foreach my $prune_entry (@{$prune_list}) {
+ $prune_entry->{mark} //= 'remove';
+ }
+}
+
sub volume_export {
my ($cfg, $fh, $volid, $format, $snapshot, $base_snapshot, $with_snapshots) = @_;
}
sub volume_import {
- my ($cfg, $fh, $volid, $format, $base_snapshot, $with_snapshots) = @_;
+ my ($cfg, $fh, $volid, $format, $base_snapshot, $with_snapshots, $allow_rename) = @_;
my ($storeid, $volname) = parse_volume_id($volid, 1);
die "cannot import into volume '$volid'\n" if !$storeid;
my $scfg = storage_config($cfg, $storeid);
my $plugin = PVE::Storage::Plugin->lookup($scfg->{type});
return $plugin->volume_import($scfg, $storeid, $fh, $volname, $format,
- $base_snapshot, $with_snapshots);
+ $base_snapshot, $with_snapshots, $allow_rename) // $volid;
}
sub volume_export_formats {
return @common;
}
+sub volume_imported_message {
+ my ($volid, $want_pattern) = @_;
+
+ if ($want_pattern) {
+ return qr/successfully imported '([^']*)'$/;
+ } else {
+ return "successfully imported '$volid'\n";
+ }
+}
+
# bash completion helper
sub complete_storage {
projects / pve-storage.git / blobdiff