PVE/API2/VZDump.pm

   1 package PVE::API2::VZDump;
   2
   3 use strict;
   4 use warnings;
   5 use PVE::Exception qw(raise_param_exc);
   6 use PVE::Tools qw(extract_param);
   7 use PVE::Cluster qw(cfs_register_file cfs_read_file);
   8 use PVE::INotify;
   9 use PVE::RPCEnvironment;
  10 use PVE::AccessControl;
  11 use PVE::JSONSchema qw(get_standard_option);
  12 use PVE::Storage;
  13 use PVE::VZDump;
  14
  15 use Data::Dumper; # fixme: remove
  16
  17
  18 use base qw(PVE::RESTHandler);
  19
  20 __PACKAGE__->register_method ({
  21     name => 'vzdump',
  22     path => '',
  23     method => 'POST',
  24     description => "Create backup.",
  25     permissions => {
  26         description => "The user needs 'VM.Backup' permissions on any VM, and 'Datastore.AllocateSpace' on the backup storage.",
  27         user => 'all',
  28     },
  29     protected => 1,
  30     proxyto => 'node',
  31     parameters => {
  32         additionalProperties => 0,
  33         properties => PVE::VZDump::json_config_properties({
  34             stdout => {
  35                 type => 'boolean',
  36                 description => "Write tar to stdout, not to a file.",
  37                 optional => 1,
  38             },
  39         }),
  40     },
  41     returns => { type => 'string' },
  42     code => sub {
  43         my ($param) = @_;
  44
  45         my $rpcenv = PVE::RPCEnvironment::get();
  46
  47         my $user = $rpcenv->get_user();
  48
  49         my $nodename = PVE::INotify::nodename();
  50
  51         if ($rpcenv->{type} ne 'cli') {
  52             raise_param_exc({ node => "option is only allowed on the command line interface."})
  53                 if $param->{node} && $param->{node} ne $nodename;
  54
  55             raise_param_exc({ stdout => "option is only allowed on the command line interface."})
  56                 if $param->{stdout};
  57         }
  58
  59         # by default we set --rsyncable for gzip
  60         local $ENV{GZIP} = "--rsyncable" if !$ENV{GZIP};
  61
  62         PVE::VZDump::verify_vzdump_parameters($param, 1);
  63
  64         # silent exit if we run on wrong node
  65         return 'OK' if $param->{node} && $param->{node} ne $nodename;
  66
  67         my $cmdline = PVE::VZDump::command_line($param);
  68
  69         # convert string lists to arrays
  70         my @vmids = PVE::Tools::split_list(extract_param($param, 'vmid'));
  71
  72         if($param->{stop}){
  73             PVE::VZDump::stop_running_backups();
  74             return 'OK' if !scalar(@vmids);
  75         }
  76
  77         my $skiplist = [];
  78         if (!$param->{all}) {
  79             if (!$param->{node}) {
  80                 my $vmlist = PVE::Cluster::get_vmlist();
  81                 my @localvmids = ();
  82                 foreach my $vmid (@vmids) {
  83                     my $d = $vmlist->{ids}->{$vmid};
  84                     if ($d && ($d->{node} ne $nodename)) {
  85                         push @$skiplist, $vmid;
  86                     } else {
  87                         push @localvmids, $vmid;
  88                     }
  89                 }
  90                 @vmids = @localvmids;
  91                 # silent exit if specified VMs run on other nodes
  92                 return "OK" if !scalar(@vmids);
  93             }
  94
  95             $param->{vmids} = PVE::VZDump::check_vmids(@vmids)
  96         }
  97
  98         my @exclude = PVE::Tools::split_list(extract_param($param, 'exclude'));
  99         $param->{exclude} = PVE::VZDump::check_vmids(@exclude);
 100
 101         # exclude-path list need to be 0 separated
 102         if (defined($param->{'exclude-path'})) {
 103             my @expaths = split(/\0/, $param->{'exclude-path'} || '');
 104             $param->{'exclude-path'} = [ @expaths ];
 105         }
 106
 107         if (defined($param->{mailto})) {
 108             my @mailto = PVE::Tools::split_list(extract_param($param, 'mailto'));
 109             $param->{mailto} = [ @mailto ];
 110         }
 111
 112         die "you can only backup a single VM with option --stdout\n"
 113             if $param->{stdout} && scalar(@vmids) != 1;
 114
 115         foreach my $key (qw(maxfiles tmpdir dumpdir script bwlimit ionice)) {
 116             raise_param_exc({ $key => "Only root may set this option."})
 117                 if defined($param->{$key}) && ($user ne 'root@pam');
 118         }
 119
 120         $rpcenv->check($user, "/storage/$param->{storage}", [ 'Datastore.AllocateSpace' ])
 121             if $param->{storage};
 122
 123         my $vzdump = PVE::VZDump->new($cmdline, $param, $skiplist);
 124
 125         my $worker = sub {
 126             my $upid = shift;
 127
 128             $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = $SIG{PIPE} = sub {
 129                 die "interrupted by signal\n";
 130             };
 131
 132             eval {
 133                 $vzdump->getlock($upid); # only one process allowed
 134             };
 135             if (my $err = $@) {
 136                 $vzdump->sendmail([], 0, $err);
 137                 exit(-1);
 138             }
 139
 140             if (defined($param->{ionice})) {
 141                 if ($param->{ionice} > 7) {
 142                     PVE::VZDump::run_command(undef, "ionice -c3 -p $$");
 143                 } else {
 144                     PVE::VZDump::run_command(undef, "ionice -c2 -n$param->{ionice} -p $$");
 145                 }
 146             }
 147             $vzdump->exec_backup($rpcenv, $user);
 148         };
 149
 150         open STDOUT, '>/dev/null' if $param->{quiet} && !$param->{stdout};
 151         open STDERR, '>/dev/null' if $param->{quiet};
 152
 153         if ($rpcenv->{type} eq 'cli') {
 154             if ($param->{stdout}) {
 155
 156                 open my $saved_stdout, ">&STDOUT"
 157                     || die "can't dup STDOUT: $!\n";
 158
 159                 open STDOUT, '>&STDERR' ||
 160                     die "unable to redirect STDOUT: $!\n";
 161
 162                 $param->{stdout} = $saved_stdout;
 163             }
 164         }
 165
 166         return $rpcenv->fork_worker('vzdump', undef, $user, $worker);
 167    }});
 168
 169 __PACKAGE__->register_method ({
 170     name => 'extractconfig',
 171     path => 'extractconfig',
 172     method => 'GET',
 173     description => "Extract configuration from vzdump backup archive.",
 174     permissions => {
 175         description => "The user needs 'VM.Backup' permissions on the backed up guest ID, and 'Datastore.AllocateSpace' on the backup storage.",
 176         user => 'all',
 177     },
 178     protected => 1,
 179     proxyto => 'node',
 180     parameters => {
 181         additionalProperties => 0,
 182         properties => {
 183             node => get_standard_option('pve-node'),
 184             volume => {
 185                 description => "Volume identifier",
 186                 type => 'string',
 187                 completion => \&PVE::Storage::complete_volume,
 188             },
 189         },
 190     },
 191     returns => { type => 'string' },
 192     code => sub {
 193         my ($param) = @_;
 194
 195         my $volume = extract_param($param, 'volume');
 196
 197         my $rpcenv = PVE::RPCEnvironment::get();
 198         my $authuser = $rpcenv->get_user();
 199
 200         my $storage_cfg = PVE::Storage::config();
 201         $rpcenv->check_volume_access($authuser, $storage_cfg, undef, $volume);
 202
 203         return PVE::Storage::extract_vzdump_config($storage_cfg, $volume);
 204     }});
 205
 206 1;