]> git.proxmox.com Git - qemu-server.git/blame - PVE/API2/Qemu.pm
projects / qemu-server.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
white space cleanups
[qemu-server.git] / PVE / API2 / Qemu.pm
CommitLineData
1e3baf05
DM		 1package PVE::API2::Qemu;
2
3use strict;
4use warnings;
5b9d692a 5use Cwd 'abs_path';
451b2b81 6use Net::SSLeay;
1e3baf05 7
502d18a2 8use PVE::Cluster qw (cfs_read_file cfs_write_file);;
1e3baf05
DM		 9use PVE::SafeSyslog;
10use PVE::Tools qw(extract_param);
f9bfceef 11use PVE::Exception qw(raise raise_param_exc raise_perm_exc);
1e3baf05
DM		 12use PVE::Storage;
13use PVE::JSONSchema qw(get_standard_option);
14use PVE::RESTHandler;
15use PVE::QemuServer;
3ea94c60 16use PVE::QemuMigrate;
1e3baf05
DM		 17use PVE::RPCEnvironment;
18use PVE::AccessControl;
19use PVE::INotify;
de8f60b2 20use PVE::Network;
1e3baf05
DM		 21
22use Data::Dumper; # fixme: remove
23
24use base qw(PVE::RESTHandler);
25
26my $opt_force_description = "Force physical removal. Without this, we simple remove the disk from the config file and create an additional configuration entry called 'unused[n]', which contains the volume ID. Unlink of unused[n] always cause physical removal.";
27
28my $resolve_cdrom_alias = sub {
29 my $param = shift;
30
31 if (my $value = $param->{cdrom}) {
32 $value .= ",media=cdrom" if $value !~ m/media=/;
33 $param->{ide2} = $value;
34 delete $param->{cdrom};
35 }
36};
37
a0d1b1a2 38
ae57f6b3 39my $check_storage_access = sub {
fcbb753e 40 my ($rpcenv, $authuser, $storecfg, $vmid, $settings, $default_storage) = @_;
a0d1b1a2 41
ae57f6b3
DM		 42 PVE::QemuServer::foreach_drive($settings, sub {
43 my ($ds, $drive) = @_;
a0d1b1a2 44
ae57f6b3 45 my $isCDROM = PVE::QemuServer::drive_is_cdrom($drive);
a0d1b1a2 46
ae57f6b3 47 my $volid = $drive->{file};
a0d1b1a2 48
09d0ee64
DM		 49 if (!$volid || $volid eq 'none') {
50 # nothing to check
f5782fd0
DM		 51 } elsif ($isCDROM && ($volid eq 'cdrom')) {
52 $rpcenv->check($authuser, "/", ['Sys.Console']);
09d0ee64 53 } elsif (!$isCDROM && ($volid =~ m/^(([^:\s]+):)?(\d+(\.\d+)?)$/)) {
a0d1b1a2
DM		 54 my ($storeid, $size) = ($2 || $default_storage, $3);
55 die "no storage ID specified (and no default storage)\n" if !$storeid;
fcbb753e 56 $rpcenv->check($authuser, "/storage/$storeid", ['Datastore.AllocateSpace']);
a0d1b1a2 57 } else {
8b192abf 58 $rpcenv->check_volume_access($authuser, $storecfg, $vmid, $volid);
a0d1b1a2
DM		 59 }
60 });
ae57f6b3 61};
a0d1b1a2 62
9418baad 63my $check_storage_access_clone = sub {
81f043eb 64 my ($rpcenv, $authuser, $storecfg, $conf, $storage) = @_;
6116f729 65
55173c6b
DM		 66 my $sharedvm = 1;
67
6116f729
DM		 68 PVE::QemuServer::foreach_drive($conf, sub {
69 my ($ds, $drive) = @_;
70
71 my $isCDROM = PVE::QemuServer::drive_is_cdrom($drive);
72
73 my $volid = $drive->{file};
74
75 return if !$volid || $volid eq 'none';
76
77 if ($isCDROM) {
78 if ($volid eq 'cdrom') {
79 $rpcenv->check($authuser, "/", ['Sys.Console']);
80 } else {
75466c4f 81 # we simply allow access
55173c6b
DM		 82 my ($sid, $volname) = PVE::Storage::parse_volume_id($volid);
83 my $scfg = PVE::Storage::storage_config($storecfg, $sid);
84 $sharedvm = 0 if !$scfg->{shared};
85
6116f729
DM		 86 }
87 } else {
55173c6b
DM		 88 my ($sid, $volname) = PVE::Storage::parse_volume_id($volid);
89 my $scfg = PVE::Storage::storage_config($storecfg, $sid);
90 $sharedvm = 0 if !$scfg->{shared};
91
81f043eb 92 $sid = $storage if $storage;
6116f729
DM		 93 $rpcenv->check($authuser, "/storage/$sid", ['Datastore.AllocateSpace']);
94 }
95 });
55173c6b
DM		 96
97 return $sharedvm;
6116f729
DM		 98};
99
ae57f6b3
DM		 100# Note: $pool is only needed when creating a VM, because pool permissions
101# are automatically inherited if VM already exists inside a pool.
102my $create_disks = sub {
103 my ($rpcenv, $authuser, $conf, $storecfg, $vmid, $pool, $settings, $default_storage) = @_;
a0d1b1a2
DM		 104
105 my $vollist = [];
a0d1b1a2 106
ae57f6b3
DM		 107 my $res = {};
108 PVE::QemuServer::foreach_drive($settings, sub {
109 my ($ds, $disk) = @_;
110
111 my $volid = $disk->{file};
112
f5782fd0 113 if (!$volid || $volid eq 'none' || $volid eq 'cdrom') {
628e9a2b
AD		 114 delete $disk->{size};
115 $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk);
09d0ee64 116 } elsif ($volid =~ m/^(([^:\s]+):)?(\d+(\.\d+)?)$/) {
ae57f6b3
DM		 117 my ($storeid, $size) = ($2 || $default_storage, $3);
118 die "no storage ID specified (and no default storage)\n" if !$storeid;
119 my $defformat = PVE::Storage::storage_default_format($storecfg, $storeid);
120 my $fmt = $disk->{format} || $defformat;
a0d1b1a2
DM		 121 my $volid = PVE::Storage::vdisk_alloc($storecfg, $storeid, $vmid,
122 $fmt, undef, $size*1024*1024);
a0d1b1a2 123 $disk->{file} = $volid;
24afaca0 124 $disk->{size} = $size*1024*1024*1024;
a0d1b1a2 125 push @$vollist, $volid;
ae57f6b3
DM		 126 delete $disk->{format}; # no longer needed
127 $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk);
128 } else {
eabe0da0 129
c9928b3d 130 $rpcenv->check_volume_access($authuser, $storecfg, $vmid, $volid);
75466c4f 131
7043d946 132 my $volid_is_new = 1;
35cb731c 133
7043d946
DM		 134 if ($conf->{$ds}) {
135 my $olddrive = PVE::QemuServer::parse_drive($ds, $conf->{$ds});
136 $volid_is_new = undef if $olddrive->{file} && $olddrive->{file} eq $volid;
eabe0da0 137 }
75466c4f 138
d52b8b77 139 if ($volid_is_new) {
09a89895 140
7043d946
DM		 141 my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid, 1);
142
09a89895 143 PVE::Storage::activate_volumes($storecfg, [ $volid ]) if $storeid;
d52b8b77
DM		 144
145 my $size = PVE::Storage::volume_size_info($storecfg, $volid);
146
147 die "volume $volid does not exists\n" if !$size;
148
149 $disk->{size} = $size;
09a89895 150 }
24afaca0 151
24afaca0 152 $res->{$ds} = PVE::QemuServer::print_drive($vmid, $disk);
a0d1b1a2 153 }
ae57f6b3 154 });
a0d1b1a2
DM		 155
156 # free allocated images on error
157 if (my $err = $@) {
158 syslog('err', "VM $vmid creating disks failed");
159 foreach my $volid (@$vollist) {
160 eval { PVE::Storage::vdisk_free($storecfg, $volid); };
161 warn $@ if $@;
162 }
163 die $err;
164 }
165
166 # modify vm config if everything went well
ae57f6b3
DM		 167 foreach my $ds (keys %$res) {
168 $conf->{$ds} = $res->{$ds};
a0d1b1a2
DM		 169 }
170
171 return $vollist;
172};
173
174my $check_vm_modify_config_perm = sub {
ae57f6b3 175 my ($rpcenv, $authuser, $vmid, $pool, $key_list) = @_;
a0d1b1a2 176
6e5c4da7 177 return 1 if $authuser eq 'root@pam';
a0d1b1a2 178
ae57f6b3 179 foreach my $opt (@$key_list) {
a0d1b1a2
DM		 180 # disk checks need to be done somewhere else
181 next if PVE::QemuServer::valid_drivename($opt);
182
183 if ($opt eq 'sockets' || $opt eq 'cores' ||
75466c4f 184 $opt eq 'cpu' || $opt eq 'smp' ||
ab6b35df 185 $opt eq 'cpulimit' || $opt eq 'cpuunits') {
a0d1b1a2
DM		 186 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.CPU']);
187 } elsif ($opt eq 'boot' || $opt eq 'bootdisk') {
188 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Disk']);
ccd5438f 189 } elsif ($opt eq 'memory' || $opt eq 'balloon' || $opt eq 'shares') {
a0d1b1a2
DM		 190 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Memory']);
191 } elsif ($opt eq 'args' || $opt eq 'lock') {
192 die "only root can set '$opt' config\n";
6dbe8b45 193 } elsif ($opt eq 'cpu' || $opt eq 'kvm' || $opt eq 'acpi' || $opt eq 'machine' ||
a0d1b1a2
DM		 194 $opt eq 'vga' || $opt eq 'watchdog' || $opt eq 'tablet') {
195 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.HWType']);
196 } elsif ($opt =~ m/^net\d+$/) {
197 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Network']);
198 } else {
199 $rpcenv->check_vm_perm($authuser, $vmid, $pool, ['VM.Config.Options']);
200 }
201 }
202
203 return 1;
204};
205
1e3baf05 206__PACKAGE__->register_method({
afdb31d5
DM		 207 name => 'vmlist',
208 path => '',
1e3baf05
DM		 209 method => 'GET',
210 description => "Virtual machine index (per node).",
a0d1b1a2
DM		 211 permissions => {
212 description => "Only list VMs where you have VM.Audit permissons on /vms/<vmid>.",
213 user => 'all',
214 },
1e3baf05
DM		 215 proxyto => 'node',
216 protected => 1, # qemu pid files are only readable by root
217 parameters => {
218 additionalProperties => 0,
219 properties => {
220 node => get_standard_option('pve-node'),
221 },
222 },
223 returns => {
224 type => 'array',
225 items => {
226 type => "object",
227 properties => {},
228 },
229 links => [ { rel => 'child', href => "{vmid}" } ],
230 },
231 code => sub {
232 my ($param) = @_;
233
a0d1b1a2
DM		 234 my $rpcenv = PVE::RPCEnvironment::get();
235 my $authuser = $rpcenv->get_user();
236
1e3baf05
DM		 237 my $vmstatus = PVE::QemuServer::vmstatus();
238
a0d1b1a2
DM		 239 my $res = [];
240 foreach my $vmid (keys %$vmstatus) {
241 next if !$rpcenv->check($authuser, "/vms/$vmid", [ 'VM.Audit' ], 1);
242
243 my $data = $vmstatus->{$vmid};
244 $data->{vmid} = $vmid;
245 push @$res, $data;
246 }
1e3baf05 247
a0d1b1a2 248 return $res;
1e3baf05
DM		 249 }});
250
d703d4c0 251
d703d4c0 252
1e3baf05 253__PACKAGE__->register_method({
afdb31d5
DM		 254 name => 'create_vm',
255 path => '',
1e3baf05 256 method => 'POST',
3e16d5fc 257 description => "Create or restore a virtual machine.",
a0d1b1a2 258 permissions => {
f9bfceef
DM		 259 description => "You need 'VM.Allocate' permissions on /vms/{vmid} or on the VM pool /pool/{pool}. " .
260 "For restore (option 'archive'), it is enough if the user has 'VM.Backup' permission and the VM already exists. " .
261 "If you create disks you need 'Datastore.AllocateSpace' on any used storage.",
262 user => 'all', # check inside
a0d1b1a2 263 },
1e3baf05
DM		 264 protected => 1,
265 proxyto => 'node',
266 parameters => {
267 additionalProperties => 0,
268 properties => PVE::QemuServer::json_config_properties(
269 {
270 node => get_standard_option('pve-node'),
271 vmid => get_standard_option('pve-vmid'),
3e16d5fc
DM		 272 archive => {
273 description => "The backup file.",
274 type => 'string',
275 optional => 1,
276 maxLength => 255,
277 },
278 storage => get_standard_option('pve-storage-id', {
279 description => "Default storage.",
280 optional => 1,
281 }),
282 force => {
afdb31d5 283 optional => 1,
3e16d5fc
DM		 284 type => 'boolean',
285 description => "Allow to overwrite existing VM.",
51586c3a
DM		 286 requires => 'archive',
287 },
288 unique => {
afdb31d5 289 optional => 1,
51586c3a
DM		 290 type => 'boolean',
291 description => "Assign a unique random ethernet address.",
292 requires => 'archive',
3e16d5fc 293 },
75466c4f 294 pool => {
a0d1b1a2
DM		 295 optional => 1,
296 type => 'string', format => 'pve-poolid',
297 description => "Add the VM to the specified pool.",
298 },
1e3baf05
DM		 299 }),
300 },
afdb31d5 301 returns => {
5fdbe4f0
DM		 302 type => 'string',
303 },
1e3baf05
DM		 304 code => sub {
305 my ($param) = @_;
306
5fdbe4f0
DM		 307 my $rpcenv = PVE::RPCEnvironment::get();
308
a0d1b1a2 309 my $authuser = $rpcenv->get_user();
5fdbe4f0 310
1e3baf05
DM		 311 my $node = extract_param($param, 'node');
312
1e3baf05
DM		 313 my $vmid = extract_param($param, 'vmid');
314
3e16d5fc
DM		 315 my $archive = extract_param($param, 'archive');
316
317 my $storage = extract_param($param, 'storage');
318
51586c3a
DM		 319 my $force = extract_param($param, 'force');
320
321 my $unique = extract_param($param, 'unique');
75466c4f 322
a0d1b1a2 323 my $pool = extract_param($param, 'pool');
51586c3a 324
1e3baf05 325 my $filename = PVE::QemuServer::config_file($vmid);
afdb31d5
DM		 326
327 my $storecfg = PVE::Storage::config();
1e3baf05 328
3e16d5fc 329 PVE::Cluster::check_cfs_quorum();
1e3baf05 330
a0d1b1a2
DM		 331 if (defined($pool)) {
332 $rpcenv->check_pool_exist($pool);
75466c4f 333 }
a0d1b1a2 334
fcbb753e 335 $rpcenv->check($authuser, "/storage/$storage", ['Datastore.AllocateSpace'])
a0d1b1a2
DM		 336 if defined($storage);
337
f9bfceef
DM		 338 if ($rpcenv->check($authuser, "/vms/$vmid", ['VM.Allocate'], 1)) {
339 # OK
340 } elsif ($pool && $rpcenv->check($authuser, "/pool/$pool", ['VM.Allocate'], 1)) {
341 # OK
342 } elsif ($archive && $force && (-f $filename) &&
343 $rpcenv->check($authuser, "/vms/$vmid", ['VM.Backup'], 1)) {
344 # OK: user has VM.Backup permissions, and want to restore an existing VM
345 } else {
346 raise_perm_exc();
347 }
348
afdb31d5 349 if (!$archive) {
3e16d5fc 350 &$resolve_cdrom_alias($param);
1e3baf05 351
fcbb753e 352 &$check_storage_access($rpcenv, $authuser, $storecfg, $vmid, $param, $storage);
ae57f6b3
DM		 353
354 &$check_vm_modify_config_perm($rpcenv, $authuser, $vmid, $pool, [ keys %$param]);
355
3e16d5fc
DM		 356 foreach my $opt (keys %$param) {
357 if (PVE::QemuServer::valid_drivename($opt)) {
358 my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
359 raise_param_exc({ $opt => "unable to parse drive options" }) if !$drive;
afdb31d5 360
3e16d5fc
DM		 361 PVE::QemuServer::cleanup_drive_path($opt, $storecfg, $drive);
362 $param->{$opt} = PVE::QemuServer::print_drive($vmid, $drive);
363 }
1e3baf05 364 }
3e16d5fc
DM		 365
366 PVE::QemuServer::add_random_macs($param);
51586c3a
DM		 367 } else {
368 my $keystr = join(' ', keys %$param);
bc4dcb99
DM		 369 raise_param_exc({ archive => "option conflicts with other options ($keystr)"}) if $keystr;
370
5b9d692a 371 if ($archive eq '-') {
afdb31d5 372 die "pipe requires cli environment\n"
d7810bc1 373 if $rpcenv->{type} ne 'cli';
5b9d692a 374 } else {
c9928b3d
DM		 375 $rpcenv->check_volume_access($authuser, $storecfg, $vmid, $archive);
376 $archive = PVE::Storage::abs_filesystem_path($storecfg, $archive);
971f27c4 377 }
1e3baf05
DM		 378 }
379
3e16d5fc
DM		 380 my $restorefn = sub {
381
6116f729 382 # fixme: this test does not work if VM exists on other node!
3e16d5fc 383 if (-f $filename) {
afdb31d5 384 die "unable to restore vm $vmid: config file already exists\n"
51586c3a 385 if !$force;
3e16d5fc 386
afdb31d5 387 die "unable to restore vm $vmid: vm is running\n"
3e16d5fc
DM		 388 if PVE::QemuServer::check_running($vmid);
389 }
390
391 my $realcmd = sub {
a0d1b1a2 392 PVE::QemuServer::restore_archive($archive, $vmid, $authuser, {
51586c3a 393 storage => $storage,
a0d1b1a2 394 pool => $pool,
51586c3a 395 unique => $unique });
502d18a2 396
be517049 397 PVE::AccessControl::add_vm_to_pool($vmid, $pool) if $pool;
3e16d5fc
DM		 398 };
399
a0d1b1a2 400 return $rpcenv->fork_worker('qmrestore', $vmid, $authuser, $realcmd);
3e16d5fc 401 };
1e3baf05 402
1e3baf05
DM		 403 my $createfn = sub {
404
191435c6 405 # test after locking
afdb31d5 406 die "unable to create vm $vmid: config file already exists\n"
1e3baf05
DM		 407 if -f $filename;
408
5fdbe4f0 409 my $realcmd = sub {
1e3baf05 410
5fdbe4f0 411 my $vollist = [];
1e3baf05 412
1858638f
DM		 413 my $conf = $param;
414
5fdbe4f0 415 eval {
ae57f6b3 416
1858638f 417 $vollist = &$create_disks($rpcenv, $authuser, $conf, $storecfg, $vmid, $pool, $param, $storage);
1e3baf05 418
5fdbe4f0
DM		 419 # try to be smart about bootdisk
420 my @disks = PVE::QemuServer::disknames();
421 my $firstdisk;
422 foreach my $ds (reverse @disks) {
1858638f
DM		 423 next if !$conf->{$ds};
424 my $disk = PVE::QemuServer::parse_drive($ds, $conf->{$ds});
5fdbe4f0
DM		 425 next if PVE::QemuServer::drive_is_cdrom($disk);
426 $firstdisk = $ds;
427 }
1e3baf05 428
1858638f
DM		 429 if (!$conf->{bootdisk} && $firstdisk) {
430 $conf->{bootdisk} = $firstdisk;
5fdbe4f0 431 }
1e3baf05 432
ae9ca91d
DM		 433 PVE::QemuServer::update_config_nolock($vmid, $conf);
434
5fdbe4f0
DM		 435 };
436 my $err = $@;
1e3baf05 437
5fdbe4f0
DM		 438 if ($err) {
439 foreach my $volid (@$vollist) {
440 eval { PVE::Storage::vdisk_free($storecfg, $volid); };
441 warn $@ if $@;
442 }
443 die "create failed - $err";
444 }
502d18a2 445
be517049 446 PVE::AccessControl::add_vm_to_pool($vmid, $pool) if $pool;
5fdbe4f0
DM		 447 };
448
a0d1b1a2 449 return $rpcenv->fork_worker('qmcreate', $vmid, $authuser, $realcmd);
5fdbe4f0
DM		 450 };
451
191435c6 452 return PVE::QemuServer::lock_config_full($vmid, 1, $archive ? $restorefn : $createfn);
1e3baf05
DM		 453 }});
454
455__PACKAGE__->register_method({
456 name => 'vmdiridx',
afdb31d5 457 path => '{vmid}',
1e3baf05
DM		 458 method => 'GET',
459 proxyto => 'node',
460 description => "Directory index",
a0d1b1a2
DM		 461 permissions => {
462 user => 'all',
463 },
1e3baf05
DM		 464 parameters => {
465 additionalProperties => 0,
466 properties => {
467 node => get_standard_option('pve-node'),
468 vmid => get_standard_option('pve-vmid'),
469 },
470 },
471 returns => {
472 type => 'array',
473 items => {
474 type => "object",
475 properties => {
476 subdir => { type => 'string' },
477 },
478 },
479 links => [ { rel => 'child', href => "{subdir}" } ],
480 },
481 code => sub {
482 my ($param) = @_;
483
484 my $res = [
485 { subdir => 'config' },
486 { subdir => 'status' },
487 { subdir => 'unlink' },
488 { subdir => 'vncproxy' },
3ea94c60 489 { subdir => 'migrate' },
2f48a4f5 490 { subdir => 'resize' },
586bfa78 491 { subdir => 'move' },
1e3baf05
DM		 492 { subdir => 'rrd' },
493 { subdir => 'rrddata' },
91c94f0a 494 { subdir => 'monitor' },
7e7d7b61 495 { subdir => 'snapshot' },
288eeea8 496 { subdir => 'spiceproxy' },
7aa608d6 497 { subdir => 'sendkey' },
1e3baf05 498 ];
afdb31d5 499
1e3baf05
DM		 500 return $res;
501 }});
502
503__PACKAGE__->register_method({
afdb31d5
DM		 504 name => 'rrd',
505 path => '{vmid}/rrd',
1e3baf05
DM		 506 method => 'GET',
507 protected => 1, # fixme: can we avoid that?
508 permissions => {
378b359e 509 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
1e3baf05
DM		 510 },
511 description => "Read VM RRD statistics (returns PNG)",
512 parameters => {
513 additionalProperties => 0,
514 properties => {
515 node => get_standard_option('pve-node'),
516 vmid => get_standard_option('pve-vmid'),
517 timeframe => {
518 description => "Specify the time frame you are interested in.",
519 type => 'string',
520 enum => [ 'hour', 'day', 'week', 'month', 'year' ],
521 },
522 ds => {
523 description => "The list of datasources you want to display.",
524 type => 'string', format => 'pve-configid-list',
525 },
526 cf => {
527 description => "The RRD consolidation function",
528 type => 'string',
529 enum => [ 'AVERAGE', 'MAX' ],
530 optional => 1,
531 },
532 },
533 },
534 returns => {
535 type => "object",
536 properties => {
537 filename => { type => 'string' },
538 },
539 },
540 code => sub {
541 my ($param) = @_;
542
543 return PVE::Cluster::create_rrd_graph(
afdb31d5 544 "pve2-vm/$param->{vmid}", $param->{timeframe},
1e3baf05 545 $param->{ds}, $param->{cf});
afdb31d5 546
1e3baf05
DM		 547 }});
548
549__PACKAGE__->register_method({
afdb31d5
DM		 550 name => 'rrddata',
551 path => '{vmid}/rrddata',
1e3baf05
DM		 552 method => 'GET',
553 protected => 1, # fixme: can we avoid that?
554 permissions => {
378b359e 555 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
1e3baf05
DM		 556 },
557 description => "Read VM RRD statistics",
558 parameters => {
559 additionalProperties => 0,
560 properties => {
561 node => get_standard_option('pve-node'),
562 vmid => get_standard_option('pve-vmid'),
563 timeframe => {
564 description => "Specify the time frame you are interested in.",
565 type => 'string',
566 enum => [ 'hour', 'day', 'week', 'month', 'year' ],
567 },
568 cf => {
569 description => "The RRD consolidation function",
570 type => 'string',
571 enum => [ 'AVERAGE', 'MAX' ],
572 optional => 1,
573 },
574 },
575 },
576 returns => {
577 type => "array",
578 items => {
579 type => "object",
580 properties => {},
581 },
582 },
583 code => sub {
584 my ($param) = @_;
585
586 return PVE::Cluster::create_rrd_data(
587 "pve2-vm/$param->{vmid}", $param->{timeframe}, $param->{cf});
588 }});
589
590
591__PACKAGE__->register_method({
afdb31d5
DM		 592 name => 'vm_config',
593 path => '{vmid}/config',
1e3baf05
DM		 594 method => 'GET',
595 proxyto => 'node',
596 description => "Get virtual machine configuration.",
a0d1b1a2
DM		 597 permissions => {
598 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
599 },
1e3baf05
DM		 600 parameters => {
601 additionalProperties => 0,
602 properties => {
603 node => get_standard_option('pve-node'),
604 vmid => get_standard_option('pve-vmid'),
605 },
606 },
afdb31d5 607 returns => {
1e3baf05 608 type => "object",
554ac7e7
DM		 609 properties => {
610 digest => {
611 type => 'string',
612 description => 'SHA1 digest of configuration file. This can be used to prevent concurrent modifications.',
613 }
614 },
1e3baf05
DM		 615 },
616 code => sub {
617 my ($param) = @_;
618
619 my $conf = PVE::QemuServer::load_config($param->{vmid});
620
22c377f0
DM		 621 delete $conf->{snapshots};
622
1e3baf05
DM		 623 return $conf;
624 }});
625
ae57f6b3
DM		 626my $vm_is_volid_owner = sub {
627 my ($storecfg, $vmid, $volid) =@_;
628
629 if ($volid !~ m|^/|) {
630 my ($path, $owner);
631 eval { ($path, $owner) = PVE::Storage::path($storecfg, $volid); };
632 if ($owner && ($owner == $vmid)) {
633 return 1;
634 }
635 }
636
637 return undef;
638};
639
640my $test_deallocate_drive = sub {
641 my ($storecfg, $vmid, $key, $drive, $force) = @_;
642
643 if (!PVE::QemuServer::drive_is_cdrom($drive)) {
644 my $volid = $drive->{file};
645 if (&$vm_is_volid_owner($storecfg, $vmid, $volid)) {
646 if ($force || $key =~ m/^unused/) {
647 my $sid = PVE::Storage::parse_volume_id($volid);
648 return $sid;
649 }
650 }
651 }
652
653 return undef;
654};
655
5d7a6767 656my $delete_drive = sub {
1858638f 657 my ($conf, $storecfg, $vmid, $key, $drive, $force) = @_;
5d7a6767
DM		 658
659 if (!PVE::QemuServer::drive_is_cdrom($drive)) {
660 my $volid = $drive->{file};
a8e2f942 661
ae57f6b3 662 if (&$vm_is_volid_owner($storecfg, $vmid, $volid)) {
7043d946
DM		 663 if ($force || $key =~ m/^unused/) {
664 eval {
665 # check if the disk is really unused
a8e2f942 666 my $used_paths = PVE::QemuServer::get_used_paths($vmid, $storecfg, $conf, 1, $key);
7043d946 667 my $path = PVE::Storage::path($storecfg, $volid);
a8e2f942
DM		 668
669 die "unable to delete '$volid' - volume is still in use (snapshot?)\n"
670 if $used_paths->{$path};
671
7043d946 672 PVE::Storage::vdisk_free($storecfg, $volid);
a8e2f942 673 };
7e4e69a6 674 die $@ if $@;
ae57f6b3
DM		 675 } else {
676 PVE::QemuServer::add_unused_volume($conf, $volid, $vmid);
5d7a6767 677 }
ae57f6b3
DM		 678 }
679 }
49f9db93
DM		 680
681 delete $conf->{$key};
ae57f6b3
DM		 682};
683
684my $vmconfig_delete_option = sub {
685 my ($rpcenv, $authuser, $conf, $storecfg, $vmid, $opt, $force) = @_;
686
687 return if !defined($conf->{$opt});
688
689 my $isDisk = PVE::QemuServer::valid_drivename($opt)|| ($opt =~ m/^unused/);
690
691 if ($isDisk) {
692 $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.Disk']);
693
694 my $drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt});
75466c4f 695 if (my $sid = &$test_deallocate_drive($storecfg, $vmid, $opt, $drive, $force)) {
65753353 696 $rpcenv->check($authuser, "/storage/$sid", ['Datastore.AllocateSpace']);
5d7a6767 697 }
ae57f6b3 698 }
9a8d6b66
AD		 699
700 my $unplugwarning = "";
fa8ea931 701 if ($conf->{ostype} && $conf->{ostype} eq 'l26') {
9a8d6b66 702 $unplugwarning = "<br>verify that you have acpiphp && pci_hotplug modules loaded in your guest VM";
fa8ea931 703 } elsif ($conf->{ostype} && $conf->{ostype} eq 'l24') {
9a8d6b66 704 $unplugwarning = "<br>kernel 2.4 don't support hotplug, please disable hotplug in options";
fa8ea931 705 } elsif (!$conf->{ostype} || ($conf->{ostype} && $conf->{ostype} eq 'other')) {
9a8d6b66
AD		 706 $unplugwarning = "<br>verify that your guest support acpi hotplug";
707 }
708
fa8ea931 709 if ($opt eq 'tablet') {
e8a7e9b4 710 PVE::QemuServer::vm_deviceplug(undef, $conf, $vmid, $opt);
fa8ea931 711 } else {
e8a7e9b4
AD		 712 die "error hot-unplug $opt $unplugwarning" if !PVE::QemuServer::vm_deviceunplug($vmid, $conf, $opt);
713 }
cd6ecb89 714
ae57f6b3
DM		 715 if ($isDisk) {
716 my $drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt});
717 &$delete_drive($conf, $storecfg, $vmid, $opt, $drive, $force);
5d7a6767 718 } else {
ae57f6b3
DM		 719 delete $conf->{$opt};
720 }
721
722 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
723};
724
9bf371a6 725my $safe_num_ne = sub {
93ae06e1
DM		 726 my ($a, $b) = @_;
727
75466c4f
DM		 728 return 0 if !defined($a) && !defined($b);
729 return 1 if !defined($a);
730 return 1 if !defined($b);
93ae06e1
DM		 731
732 return $a != $b;
733};
734
ae57f6b3
DM		 735my $vmconfig_update_disk = sub {
736 my ($rpcenv, $authuser, $conf, $storecfg, $vmid, $opt, $value, $force) = @_;
5d7a6767 737
ae57f6b3
DM		 738 my $drive = PVE::QemuServer::parse_drive($opt, $value);
739
740 if (PVE::QemuServer::drive_is_cdrom($drive)) { #cdrom
741 $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.CDROM']);
742 } else {
743 $rpcenv->check_vm_perm($authuser, $vmid, undef, ['VM.Config.Disk']);
744 }
745
746 if ($conf->{$opt}) {
747
748 if (my $old_drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt})) {
749
750 my $media = $drive->{media} || 'disk';
751 my $oldmedia = $old_drive->{media} || 'disk';
752 die "unable to change media type\n" if $media ne $oldmedia;
753
754 if (!PVE::QemuServer::drive_is_cdrom($old_drive) &&
755 ($drive->{file} ne $old_drive->{file})) { # delete old disks
756
757 &$vmconfig_delete_option($rpcenv, $authuser, $conf, $storecfg, $vmid, $opt, $force);
758 $conf = PVE::QemuServer::load_config($vmid); # update/reload
759 }
0f56d571 760
9bf371a6
DM		 761 if(&$safe_num_ne($drive->{mbps}, $old_drive->{mbps}) ||
762 &$safe_num_ne($drive->{mbps_rd}, $old_drive->{mbps_rd}) ||
763 &$safe_num_ne($drive->{mbps_wr}, $old_drive->{mbps_wr}) ||
764 &$safe_num_ne($drive->{iops}, $old_drive->{iops}) ||
765 &$safe_num_ne($drive->{iops_rd}, $old_drive->{iops_rd}) ||
74edd76b
AD		 766 &$safe_num_ne($drive->{iops_wr}, $old_drive->{iops_wr}) ||
767 &$safe_num_ne($drive->{mbps_max}, $old_drive->{mbps_max}) ||
768 &$safe_num_ne($drive->{mbps_rd_max}, $old_drive->{mbps_rd_max}) ||
769 &$safe_num_ne($drive->{mbps_wr_max}, $old_drive->{mbps_wr_max}) ||
770 &$safe_num_ne($drive->{iops_max}, $old_drive->{iops_max}) ||
771 &$safe_num_ne($drive->{iops_rd_max}, $old_drive->{iops_rd_max}) ||
772 &$safe_num_ne($drive->{iops_wr_max}, $old_drive->{iops_wr_max})) {
fa8ea931 773 PVE::QemuServer::qemu_block_set_io_throttle($vmid,"drive-$opt",
9b2c0efb 774 ($drive->{mbps} || 0)*1024*1024,
fa8ea931 775 ($drive->{mbps_rd} || 0)*1024*1024,
9b2c0efb 776 ($drive->{mbps_wr} || 0)*1024*1024,
fa8ea931
DM		 777 $drive->{iops} || 0,
778 $drive->{iops_rd} || 0,
74edd76b
AD		 779 $drive->{iops_wr} || 0,
780 ($drive->{mbps_max} || 0)*1024*1024,
781 ($drive->{mbps_rd_max} || 0)*1024*1024,
782 ($drive->{mbps_wr_max} || 0)*1024*1024,
783 $drive->{iops_max} || 0,
784 $drive->{iops_rd_max} || 0,
785 $drive->{iops_wr_max} || 0)
9bf371a6 786 if !PVE::QemuServer::drive_is_cdrom($drive);
0f56d571 787 }
ae57f6b3
DM		 788 }
789 }
790
791 &$create_disks($rpcenv, $authuser, $conf, $storecfg, $vmid, undef, {$opt => $value});
792 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
793
794 $conf = PVE::QemuServer::load_config($vmid); # update/reload
795 $drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt});
796
797 if (PVE::QemuServer::drive_is_cdrom($drive)) { # cdrom
798
799 if (PVE::QemuServer::check_running($vmid)) {
800 if ($drive->{file} eq 'none') {
ce156282 801 PVE::QemuServer::vm_mon_cmd($vmid, "eject",force => JSON::true,device => "drive-$opt");
ae57f6b3
DM		 802 } else {
803 my $path = PVE::QemuServer::get_iso_path($storecfg, $vmid, $drive->{file});
ce156282
AD		 804 PVE::QemuServer::vm_mon_cmd($vmid, "eject",force => JSON::true,device => "drive-$opt"); #force eject if locked
805 PVE::QemuServer::vm_mon_cmd($vmid, "change",device => "drive-$opt",target => "$path") if $path;
ae57f6b3
DM		 806 }
807 }
808
809 } else { # hotplug new disks
810
811 die "error hotplug $opt" if !PVE::QemuServer::vm_deviceplug($storecfg, $conf, $vmid, $opt, $drive);
5d7a6767 812 }
5d7a6767
DM		 813};
814
ae57f6b3
DM		 815my $vmconfig_update_net = sub {
816 my ($rpcenv, $authuser, $conf, $storecfg, $vmid, $opt, $value) = @_;
817
de8f60b2
AD		 818 if ($conf->{$opt} && PVE::QemuServer::check_running($vmid)) {
819 my $oldnet = PVE::QemuServer::parse_net($conf->{$opt});
820 my $newnet = PVE::QemuServer::parse_net($value);
821
822 if($oldnet->{model} ne $newnet->{model}){
823 #if model change, we try to hot-unplug
824 die "error hot-unplug $opt for update" if !PVE::QemuServer::vm_deviceunplug($vmid, $conf, $opt);
825 }else{
75466c4f 826
de8f60b2
AD		 827 if($newnet->{bridge} && $oldnet->{bridge}){
828 my $iface = "tap".$vmid."i".$1 if $opt =~ m/net(\d+)/;
ae57f6b3 829
de8f60b2
AD		 830 if($newnet->{rate} ne $oldnet->{rate}){
831 PVE::Network::tap_rate_limit($iface, $newnet->{rate});
832 }
833
834 if(($newnet->{bridge} ne $oldnet->{bridge}) || ($newnet->{tag} ne $oldnet->{tag})){
835 eval{PVE::Network::tap_unplug($iface, $oldnet->{bridge}, $oldnet->{tag});};
836 PVE::Network::tap_plug($iface, $newnet->{bridge}, $newnet->{tag});
837 }
838
839 }else{
840 #if bridge/nat mode change, we try to hot-unplug
841 die "error hot-unplug $opt for update" if !PVE::QemuServer::vm_deviceunplug($vmid, $conf, $opt);
842 }
843 }
75466c4f 844
de8f60b2 845 }
ae57f6b3
DM		 846 $conf->{$opt} = $value;
847 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
848 $conf = PVE::QemuServer::load_config($vmid); # update/reload
849
850 my $net = PVE::QemuServer::parse_net($conf->{$opt});
851
852 die "error hotplug $opt" if !PVE::QemuServer::vm_deviceplug($storecfg, $conf, $vmid, $opt, $net);
853};
854
5555edea
DM		 855# POST/PUT {vmid}/config implementation
856#
857# The original API used PUT (idempotent) an we assumed that all operations
858# are fast. But it turned out that almost any configuration change can
859# involve hot-plug actions, or disk alloc/free. Such actions can take long
860# time to complete and have side effects (not idempotent).
861#
7043d946 862# The new implementation uses POST and forks a worker process. We added
5555edea 863# a new option 'background_delay'. If specified we wait up to
7043d946 864# 'background_delay' second for the worker task to complete. It returns null
5555edea 865# if the task is finished within that time, else we return the UPID.
7043d946 866
5555edea
DM		 867my $update_vm_api = sub {
868 my ($param, $sync) = @_;
a0d1b1a2 869
5555edea 870 my $rpcenv = PVE::RPCEnvironment::get();
1e3baf05 871
5555edea 872 my $authuser = $rpcenv->get_user();
1e3baf05 873
5555edea 874 my $node = extract_param($param, 'node');
1e3baf05 875
5555edea 876 my $vmid = extract_param($param, 'vmid');
1e3baf05 877
5555edea 878 my $digest = extract_param($param, 'digest');
1e3baf05 879
5555edea 880 my $background_delay = extract_param($param, 'background_delay');
1e3baf05 881
5555edea
DM		 882 my @paramarr = (); # used for log message
883 foreach my $key (keys %$param) {
884 push @paramarr, "-$key", $param->{$key};
885 }
0532bc63 886
5555edea
DM		 887 my $skiplock = extract_param($param, 'skiplock');
888 raise_param_exc({ skiplock => "Only root may use this option." })
889 if $skiplock && $authuser ne 'root@pam';
1e3baf05 890
5555edea 891 my $delete_str = extract_param($param, 'delete');
0532bc63 892
5555edea 893 my $force = extract_param($param, 'force');
1e68cb19 894
5555edea 895 die "no options specified\n" if !$delete_str && !scalar(keys %$param);
7bfdeb5f 896
5555edea 897 my $storecfg = PVE::Storage::config();
1e68cb19 898
5555edea 899 my $defaults = PVE::QemuServer::load_defaults();
1e68cb19 900
5555edea 901 &$resolve_cdrom_alias($param);
0532bc63 902
5555edea 903 # now try to verify all parameters
ae57f6b3 904
5555edea
DM		 905 my @delete = ();
906 foreach my $opt (PVE::Tools::split_list($delete_str)) {
907 $opt = 'ide2' if $opt eq 'cdrom';
908 raise_param_exc({ delete => "you can't use '-$opt' and " .
909 "-delete $opt' at the same time" })
910 if defined($param->{$opt});
7043d946 911
5555edea
DM		 912 if (!PVE::QemuServer::option_exists($opt)) {
913 raise_param_exc({ delete => "unknown option '$opt'" });
0532bc63 914 }
1e3baf05 915
5555edea
DM		 916 push @delete, $opt;
917 }
918
919 foreach my $opt (keys %$param) {
920 if (PVE::QemuServer::valid_drivename($opt)) {
921 # cleanup drive path
922 my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
923 PVE::QemuServer::cleanup_drive_path($opt, $storecfg, $drive);
924 $param->{$opt} = PVE::QemuServer::print_drive($vmid, $drive);
925 } elsif ($opt =~ m/^net(\d+)$/) {
926 # add macaddr
927 my $net = PVE::QemuServer::parse_net($param->{$opt});
928 $param->{$opt} = PVE::QemuServer::print_net($net);
1e68cb19 929 }
5555edea 930 }
1e3baf05 931
5555edea 932 &$check_vm_modify_config_perm($rpcenv, $authuser, $vmid, undef, [@delete]);
ae57f6b3 933
5555edea 934 &$check_vm_modify_config_perm($rpcenv, $authuser, $vmid, undef, [keys %$param]);
ae57f6b3 935
5555edea 936 &$check_storage_access($rpcenv, $authuser, $storecfg, $vmid, $param);
1e3baf05 937
5555edea 938 my $updatefn = sub {
1e3baf05 939
5555edea 940 my $conf = PVE::QemuServer::load_config($vmid);
1e3baf05 941
5555edea
DM		 942 die "checksum missmatch (file change by other user?)\n"
943 if $digest && $digest ne $conf->{digest};
944
945 PVE::QemuServer::check_lock($conf) if !$skiplock;
7043d946 946
5555edea
DM		 947 if ($param->{memory} || defined($param->{balloon})) {
948 my $maxmem = $param->{memory} || $conf->{memory} || $defaults->{memory};
949 my $balloon = defined($param->{balloon}) ? $param->{balloon} : $conf->{balloon};
7043d946 950
5555edea
DM		 951 die "balloon value too large (must be smaller than assigned memory)\n"
952 if $balloon && $balloon > $maxmem;
953 }
1e3baf05 954
5555edea 955 PVE::Cluster::log_msg('info', $authuser, "update VM $vmid: " . join (' ', @paramarr));
1e3baf05 956
5555edea 957 my $worker = sub {
7bfdeb5f 958
5555edea 959 print "update VM $vmid: " . join (' ', @paramarr) . "\n";
c2a64aa7 960
5d7a6767 961 foreach my $opt (@delete) { # delete
1e68cb19 962 $conf = PVE::QemuServer::load_config($vmid); # update/reload
ae57f6b3 963 &$vmconfig_delete_option($rpcenv, $authuser, $conf, $storecfg, $vmid, $opt, $force);
5d39a182 964 }
1e3baf05 965
7bfdeb5f 966 my $running = PVE::QemuServer::check_running($vmid);
7043d946 967
5d7a6767 968 foreach my $opt (keys %$param) { # add/change
7043d946 969
1e68cb19 970 $conf = PVE::QemuServer::load_config($vmid); # update/reload
7043d946 971
5d7a6767
DM		 972 next if $conf->{$opt} && ($param->{$opt} eq $conf->{$opt}); # skip if nothing changed
973
ae57f6b3 974 if (PVE::QemuServer::valid_drivename($opt)) {
5d7a6767 975
75466c4f 976 &$vmconfig_update_disk($rpcenv, $authuser, $conf, $storecfg, $vmid,
ae57f6b3 977 $opt, $param->{$opt}, $force);
75466c4f 978
ae57f6b3 979 } elsif ($opt =~ m/^net(\d+)$/) { #nics
1858638f 980
75466c4f 981 &$vmconfig_update_net($rpcenv, $authuser, $conf, $storecfg, $vmid,
ae57f6b3 982 $opt, $param->{$opt});
1e68cb19
DM		 983
984 } else {
985
cd6ecb89
AD		 986 if($opt eq 'tablet' && $param->{$opt} == 1){
987 PVE::QemuServer::vm_deviceplug(undef, $conf, $vmid, $opt);
5555edea 988 } elsif($opt eq 'tablet' && $param->{$opt} == 0){
cd6ecb89
AD		 989 PVE::QemuServer::vm_deviceunplug($vmid, $conf, $opt);
990 }
838776ab
AD		 991
992 if($opt eq 'cores' && $conf->{maxcpus}){
993 PVE::QemuServer::qemu_cpu_hotplug($vmid, $conf, $param->{$opt});
994 }
cd6ecb89 995
1858638f
DM		 996 $conf->{$opt} = $param->{$opt};
997 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
3a1e36bb 998 }
5d39a182 999 }
7bfdeb5f
DM		 1000
1001 # allow manual ballooning if shares is set to zero
75466c4f 1002 if ($running && defined($param->{balloon}) &&
7bfdeb5f
DM		 1003 defined($conf->{shares}) && ($conf->{shares} == 0)) {
1004 my $balloon = $param->{'balloon'} || $conf->{memory} || $defaults->{memory};
1005 PVE::QemuServer::vm_mon_cmd($vmid, "balloon", value => $balloon*1024*1024);
1006 }
5d39a182
DM		 1007 };
1008
5555edea
DM		 1009 if ($sync) {
1010 &$worker();
1011 return undef;
1012 } else {
1013 my $upid = $rpcenv->fork_worker('qmconfig', $vmid, $authuser, $worker);
fcdb0117 1014
5555edea
DM		 1015 if ($background_delay) {
1016
1017 # Note: It would be better to do that in the Event based HTTPServer
7043d946 1018 # to avoid blocking call to sleep.
5555edea
DM		 1019
1020 my $end_time = time() + $background_delay;
1021
1022 my $task = PVE::Tools::upid_decode($upid);
1023
1024 my $running = 1;
1025 while (time() < $end_time) {
1026 $running = PVE::ProcFSTools::check_process_running($task->{pid}, $task->{pstart});
1027 last if !$running;
1028 sleep(1); # this gets interrupted when child process ends
1029 }
1030
1031 if (!$running) {
1032 my $status = PVE::Tools::upid_read_status($upid);
1033 return undef if $status eq 'OK';
1034 die $status;
1035 }
7043d946 1036 }
5555edea
DM		 1037
1038 return $upid;
1039 }
1040 };
1041
1042 return PVE::QemuServer::lock_config($vmid, $updatefn);
1043};
1044
1045my $vm_config_perm_list = [
1046 'VM.Config.Disk',
1047 'VM.Config.CDROM',
1048 'VM.Config.CPU',
1049 'VM.Config.Memory',
1050 'VM.Config.Network',
1051 'VM.Config.HWType',
1052 'VM.Config.Options',
1053 ];
1054
1055__PACKAGE__->register_method({
1056 name => 'update_vm_async',
1057 path => '{vmid}/config',
1058 method => 'POST',
1059 protected => 1,
1060 proxyto => 'node',
1061 description => "Set virtual machine options (asynchrounous API).",
1062 permissions => {
1063 check => ['perm', '/vms/{vmid}', $vm_config_perm_list, any => 1],
1064 },
1065 parameters => {
1066 additionalProperties => 0,
1067 properties => PVE::QemuServer::json_config_properties(
1068 {
1069 node => get_standard_option('pve-node'),
1070 vmid => get_standard_option('pve-vmid'),
1071 skiplock => get_standard_option('skiplock'),
1072 delete => {
1073 type => 'string', format => 'pve-configid-list',
1074 description => "A list of settings you want to delete.",
1075 optional => 1,
1076 },
1077 force => {
1078 type => 'boolean',
1079 description => $opt_force_description,
1080 optional => 1,
1081 requires => 'delete',
1082 },
1083 digest => {
1084 type => 'string',
1085 description => 'Prevent changes if current configuration file has different SHA1 digest. This can be used to prevent concurrent modifications.',
1086 maxLength => 40,
1087 optional => 1,
1088 },
1089 background_delay => {
1090 type => 'integer',
1091 description => "Time to wait for the task to finish. We return 'null' if the task finish within that time.",
1092 minimum => 1,
1093 maximum => 30,
1094 optional => 1,
1095 },
1096 }),
1097 },
1098 returns => {
1099 type => 'string',
1100 optional => 1,
1101 },
1102 code => $update_vm_api,
1103});
1104
1105__PACKAGE__->register_method({
1106 name => 'update_vm',
1107 path => '{vmid}/config',
1108 method => 'PUT',
1109 protected => 1,
1110 proxyto => 'node',
1111 description => "Set virtual machine options (synchrounous API) - You should consider using the POST method instead for any actions involving hotplug or storage allocation.",
1112 permissions => {
1113 check => ['perm', '/vms/{vmid}', $vm_config_perm_list, any => 1],
1114 },
1115 parameters => {
1116 additionalProperties => 0,
1117 properties => PVE::QemuServer::json_config_properties(
1118 {
1119 node => get_standard_option('pve-node'),
1120 vmid => get_standard_option('pve-vmid'),
1121 skiplock => get_standard_option('skiplock'),
1122 delete => {
1123 type => 'string', format => 'pve-configid-list',
1124 description => "A list of settings you want to delete.",
1125 optional => 1,
1126 },
1127 force => {
1128 type => 'boolean',
1129 description => $opt_force_description,
1130 optional => 1,
1131 requires => 'delete',
1132 },
1133 digest => {
1134 type => 'string',
1135 description => 'Prevent changes if current configuration file has different SHA1 digest. This can be used to prevent concurrent modifications.',
1136 maxLength => 40,
1137 optional => 1,
1138 },
1139 }),
1140 },
1141 returns => { type => 'null' },
1142 code => sub {
1143 my ($param) = @_;
1144 &$update_vm_api($param, 1);
1e3baf05 1145 return undef;
5555edea
DM		 1146 }
1147});
1e3baf05
DM		 1148
1149
1150__PACKAGE__->register_method({
afdb31d5
DM		 1151 name => 'destroy_vm',
1152 path => '{vmid}',
1e3baf05
DM		 1153 method => 'DELETE',
1154 protected => 1,
1155 proxyto => 'node',
1156 description => "Destroy the vm (also delete all used/owned volumes).",
a0d1b1a2
DM		 1157 permissions => {
1158 check => [ 'perm', '/vms/{vmid}', ['VM.Allocate']],
1159 },
1e3baf05
DM		 1160 parameters => {
1161 additionalProperties => 0,
1162 properties => {
1163 node => get_standard_option('pve-node'),
1164 vmid => get_standard_option('pve-vmid'),
3ea94c60 1165 skiplock => get_standard_option('skiplock'),
1e3baf05
DM		 1166 },
1167 },
afdb31d5 1168 returns => {
5fdbe4f0
DM		 1169 type => 'string',
1170 },
1e3baf05
DM		 1171 code => sub {
1172 my ($param) = @_;
1173
1174 my $rpcenv = PVE::RPCEnvironment::get();
1175
a0d1b1a2 1176 my $authuser = $rpcenv->get_user();
1e3baf05
DM		 1177
1178 my $vmid = $param->{vmid};
1179
1180 my $skiplock = $param->{skiplock};
afdb31d5 1181 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1182 if $skiplock && $authuser ne 'root@pam';
1e3baf05 1183
5fdbe4f0
DM		 1184 # test if VM exists
1185 my $conf = PVE::QemuServer::load_config($vmid);
1186
afdb31d5 1187 my $storecfg = PVE::Storage::config();
1e3baf05 1188
75466c4f 1189 my $delVMfromPoolFn = sub {
502d18a2 1190 my $usercfg = cfs_read_file("user.cfg");
5d0094ea
DM		 1191 if (my $pool = $usercfg->{vms}->{$vmid}) {
1192 if (my $data = $usercfg->{pools}->{$pool}) {
1193 delete $data->{vms}->{$vmid};
1194 delete $usercfg->{vms}->{$vmid};
1195 cfs_write_file("user.cfg", $usercfg);
1196 }
502d18a2
DM		 1197 }
1198 };
1199
5fdbe4f0 1200 my $realcmd = sub {
ff1a2432
DM		 1201 my $upid = shift;
1202
1203 syslog('info', "destroy VM $vmid: $upid\n");
1204
5fdbe4f0 1205 PVE::QemuServer::vm_destroy($storecfg, $vmid, $skiplock);
502d18a2 1206
be517049 1207 PVE::AccessControl::remove_vm_from_pool($vmid);
5fdbe4f0 1208 };
1e3baf05 1209
a0d1b1a2 1210 return $rpcenv->fork_worker('qmdestroy', $vmid, $authuser, $realcmd);
1e3baf05
DM		 1211 }});
1212
1213__PACKAGE__->register_method({
afdb31d5
DM		 1214 name => 'unlink',
1215 path => '{vmid}/unlink',
1e3baf05
DM		 1216 method => 'PUT',
1217 protected => 1,
1218 proxyto => 'node',
1219 description => "Unlink/delete disk images.",
a0d1b1a2
DM		 1220 permissions => {
1221 check => [ 'perm', '/vms/{vmid}', ['VM.Config.Disk']],
1222 },
1e3baf05
DM		 1223 parameters => {
1224 additionalProperties => 0,
1225 properties => {
1226 node => get_standard_option('pve-node'),
1227 vmid => get_standard_option('pve-vmid'),
1228 idlist => {
1229 type => 'string', format => 'pve-configid-list',
1230 description => "A list of disk IDs you want to delete.",
1231 },
1232 force => {
1233 type => 'boolean',
1234 description => $opt_force_description,
1235 optional => 1,
1236 },
1237 },
1238 },
1239 returns => { type => 'null'},
1240 code => sub {
1241 my ($param) = @_;
1242
1243 $param->{delete} = extract_param($param, 'idlist');
1244
1245 __PACKAGE__->update_vm($param);
1246
1247 return undef;
1248 }});
1249
1250my $sslcert;
1251
1252__PACKAGE__->register_method({
afdb31d5
DM		 1253 name => 'vncproxy',
1254 path => '{vmid}/vncproxy',
1e3baf05
DM		 1255 method => 'POST',
1256 protected => 1,
1257 permissions => {
378b359e 1258 check => ['perm', '/vms/{vmid}', [ 'VM.Console' ]],
1e3baf05
DM		 1259 },
1260 description => "Creates a TCP VNC proxy connections.",
1261 parameters => {
1262 additionalProperties => 0,
1263 properties => {
1264 node => get_standard_option('pve-node'),
1265 vmid => get_standard_option('pve-vmid'),
1266 },
1267 },
afdb31d5 1268 returns => {
1e3baf05
DM		 1269 additionalProperties => 0,
1270 properties => {
1271 user => { type => 'string' },
1272 ticket => { type => 'string' },
1273 cert => { type => 'string' },
1274 port => { type => 'integer' },
1275 upid => { type => 'string' },
1276 },
1277 },
1278 code => sub {
1279 my ($param) = @_;
1280
1281 my $rpcenv = PVE::RPCEnvironment::get();
1282
a0d1b1a2 1283 my $authuser = $rpcenv->get_user();
1e3baf05
DM		 1284
1285 my $vmid = $param->{vmid};
1286 my $node = $param->{node};
1287
2dc9c148 1288 my $conf = PVE::QemuServer::load_config($vmid, $node); # check if VM exists
ef5e2be2 1289
b6f39da2
DM		 1290 my $authpath = "/vms/$vmid";
1291
a0d1b1a2 1292 my $ticket = PVE::AccessControl::assemble_vnc_ticket($authuser, $authpath);
b6f39da2 1293
1e3baf05
DM		 1294 $sslcert = PVE::Tools::file_get_contents("/etc/pve/pve-root-ca.pem", 8192)
1295 if !$sslcert;
1296
1297 my $port = PVE::Tools::next_vnc_port();
1298
1299 my $remip;
ef5e2be2 1300 my $remcmd = [];
afdb31d5 1301
4f1be36c 1302 if ($node ne 'localhost' && $node ne PVE::INotify::nodename()) {
1e3baf05 1303 $remip = PVE::Cluster::remote_node_ip($node);
ef5e2be2
DM		 1304 # NOTE: kvm VNC traffic is already TLS encrypted
1305 $remcmd = ['/usr/bin/ssh', '-T', '-o', 'BatchMode=yes', $remip];
1e3baf05
DM		 1306 }
1307
afdb31d5 1308 my $timeout = 10;
1e3baf05
DM		 1309
1310 my $realcmd = sub {
1311 my $upid = shift;
1312
1313 syslog('info', "starting vnc proxy $upid\n");
1314
ef5e2be2 1315 my $cmd;
1e3baf05 1316
2dc23d72 1317 if ($conf->{vga} && ($conf->{vga} =~ m/^serial\d+$/)) {
ef5e2be2
DM		 1318
1319 my $termcmd = [ '/usr/sbin/qm', 'terminal', $vmid, '-iface', $conf->{vga} ];
1320 #my $termcmd = "/usr/bin/qm terminal -iface $conf->{vga}";
1321 $cmd = ['/usr/bin/vncterm', '-rfbport', $port,
fa8ea931 1322 '-timeout', $timeout, '-authpath', $authpath,
ef5e2be2
DM		 1323 '-perm', 'Sys.Console', '-c', @$remcmd, @$termcmd];
1324 } else {
1e3baf05 1325
ef5e2be2
DM		 1326 my $qmcmd = [@$remcmd, "/usr/sbin/qm", 'vncproxy', $vmid];
1327
1328 my $qmstr = join(' ', @$qmcmd);
1329
1330 # also redirect stderr (else we get RFB protocol errors)
1331 $cmd = ['/bin/nc', '-l', '-p', $port, '-w', $timeout, '-c', "$qmstr 2>/dev/null"];
1332 }
1e3baf05 1333
be62c45c 1334 PVE::Tools::run_command($cmd);
1e3baf05
DM		 1335
1336 return;
1337 };
1338
a0d1b1a2 1339 my $upid = $rpcenv->fork_worker('vncproxy', $vmid, $authuser, $realcmd);
1e3baf05 1340
3da85107
DM		 1341 PVE::Tools::wait_for_vnc_port($port);
1342
1e3baf05 1343 return {
a0d1b1a2 1344 user => $authuser,
1e3baf05 1345 ticket => $ticket,
afdb31d5
DM		 1346 port => $port,
1347 upid => $upid,
1348 cert => $sslcert,
1e3baf05
DM		 1349 };
1350 }});
1351
288eeea8
DM		 1352__PACKAGE__->register_method({
1353 name => 'spiceproxy',
1354 path => '{vmid}/spiceproxy',
78252ce7 1355 method => 'POST',
288eeea8 1356 protected => 1,
78252ce7 1357 proxyto => 'node',
288eeea8
DM		 1358 permissions => {
1359 check => ['perm', '/vms/{vmid}', [ 'VM.Console' ]],
1360 },
1361 description => "Returns a SPICE configuration to connect to the VM.",
1362 parameters => {
1363 additionalProperties => 0,
1364 properties => {
1365 node => get_standard_option('pve-node'),
1366 vmid => get_standard_option('pve-vmid'),
dd25eecf 1367 proxy => get_standard_option('spice-proxy', { optional => 1 }),
288eeea8
DM		 1368 },
1369 },
dd25eecf 1370 returns => get_standard_option('remote-viewer-config'),
288eeea8
DM		 1371 code => sub {
1372 my ($param) = @_;
1373
1374 my $rpcenv = PVE::RPCEnvironment::get();
1375
1376 my $authuser = $rpcenv->get_user();
1377
1378 my $vmid = $param->{vmid};
1379 my $node = $param->{node};
fb6c7260 1380 my $proxy = $param->{proxy};
288eeea8 1381
dd25eecf 1382 my $title = "VM $vmid";
288eeea8 1383
943340a6 1384 my $port = PVE::QemuServer::spice_port($vmid);
dd25eecf
DM		 1385
1386 my ($ticket, undef, $remote_viewer_config) =
1387 PVE::AccessControl::remote_viewer_config($authuser, $vmid, $node, $proxy, $title, $port);
1388
288eeea8
DM		 1389 PVE::QemuServer::vm_mon_cmd($vmid, "set_password", protocol => 'spice', password => $ticket);
1390 PVE::QemuServer::vm_mon_cmd($vmid, "expire_password", protocol => 'spice', time => "+30");
dd25eecf
DM		 1391
1392 return $remote_viewer_config;
288eeea8
DM		 1393 }});
1394
5fdbe4f0
DM		 1395__PACKAGE__->register_method({
1396 name => 'vmcmdidx',
afdb31d5 1397 path => '{vmid}/status',
5fdbe4f0
DM		 1398 method => 'GET',
1399 proxyto => 'node',
1400 description => "Directory index",
a0d1b1a2
DM		 1401 permissions => {
1402 user => 'all',
1403 },
5fdbe4f0
DM		 1404 parameters => {
1405 additionalProperties => 0,
1406 properties => {
1407 node => get_standard_option('pve-node'),
1408 vmid => get_standard_option('pve-vmid'),
1409 },
1410 },
1411 returns => {
1412 type => 'array',
1413 items => {
1414 type => "object",
1415 properties => {
1416 subdir => { type => 'string' },
1417 },
1418 },
1419 links => [ { rel => 'child', href => "{subdir}" } ],
1420 },
1421 code => sub {
1422 my ($param) = @_;
1423
1424 # test if VM exists
1425 my $conf = PVE::QemuServer::load_config($param->{vmid});
1426
1427 my $res = [
1428 { subdir => 'current' },
1429 { subdir => 'start' },
1430 { subdir => 'stop' },
1431 ];
afdb31d5 1432
5fdbe4f0
DM		 1433 return $res;
1434 }});
1435
88fc87b4
DM		 1436my $vm_is_ha_managed = sub {
1437 my ($vmid) = @_;
1438
1439 my $cc = PVE::Cluster::cfs_read_file('cluster.conf');
1440 if (PVE::Cluster::cluster_conf_lookup_pvevm($cc, 0, $vmid, 1)) {
1441 return 1;
75466c4f 1442 }
88fc87b4
DM		 1443 return 0;
1444};
1445
1e3baf05 1446__PACKAGE__->register_method({
afdb31d5 1447 name => 'vm_status',
5fdbe4f0 1448 path => '{vmid}/status/current',
1e3baf05
DM		 1449 method => 'GET',
1450 proxyto => 'node',
1451 protected => 1, # qemu pid files are only readable by root
1452 description => "Get virtual machine status.",
a0d1b1a2
DM		 1453 permissions => {
1454 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
1455 },
1e3baf05
DM		 1456 parameters => {
1457 additionalProperties => 0,
1458 properties => {
1459 node => get_standard_option('pve-node'),
1460 vmid => get_standard_option('pve-vmid'),
1461 },
1462 },
1463 returns => { type => 'object' },
1464 code => sub {
1465 my ($param) = @_;
1466
1467 # test if VM exists
1468 my $conf = PVE::QemuServer::load_config($param->{vmid});
1469
03a33f30 1470 my $vmstatus = PVE::QemuServer::vmstatus($param->{vmid}, 1);
8610701a 1471 my $status = $vmstatus->{$param->{vmid}};
1e3baf05 1472
88fc87b4 1473 $status->{ha} = &$vm_is_ha_managed($param->{vmid});
8610701a 1474
86b8228b 1475 $status->{spice} = 1 if PVE::QemuServer::vga_conf_has_spice($conf->{vga});
46246f04 1476
8610701a 1477 return $status;
1e3baf05
DM		 1478 }});
1479
1480__PACKAGE__->register_method({
afdb31d5 1481 name => 'vm_start',
5fdbe4f0
DM		 1482 path => '{vmid}/status/start',
1483 method => 'POST',
1e3baf05
DM		 1484 protected => 1,
1485 proxyto => 'node',
5fdbe4f0 1486 description => "Start virtual machine.",
a0d1b1a2
DM		 1487 permissions => {
1488 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1489 },
1e3baf05
DM		 1490 parameters => {
1491 additionalProperties => 0,
1492 properties => {
1493 node => get_standard_option('pve-node'),
1494 vmid => get_standard_option('pve-vmid'),
3ea94c60
DM		 1495 skiplock => get_standard_option('skiplock'),
1496 stateuri => get_standard_option('pve-qm-stateuri'),
7e8dcf2c 1497 migratedfrom => get_standard_option('pve-node',{ optional => 1 }),
952958bc 1498 machine => get_standard_option('pve-qm-machine'),
1e3baf05
DM		 1499 },
1500 },
afdb31d5 1501 returns => {
5fdbe4f0
DM		 1502 type => 'string',
1503 },
1e3baf05
DM		 1504 code => sub {
1505 my ($param) = @_;
1506
1507 my $rpcenv = PVE::RPCEnvironment::get();
1508
a0d1b1a2 1509 my $authuser = $rpcenv->get_user();
1e3baf05
DM		 1510
1511 my $node = extract_param($param, 'node');
1512
1e3baf05
DM		 1513 my $vmid = extract_param($param, 'vmid');
1514
952958bc
DM		 1515 my $machine = extract_param($param, 'machine');
1516
3ea94c60 1517 my $stateuri = extract_param($param, 'stateuri');
afdb31d5 1518 raise_param_exc({ stateuri => "Only root may use this option." })
a0d1b1a2 1519 if $stateuri && $authuser ne 'root@pam';
3ea94c60 1520
1e3baf05 1521 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1522 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1523 if $skiplock && $authuser ne 'root@pam';
1e3baf05 1524
7e8dcf2c
AD		 1525 my $migratedfrom = extract_param($param, 'migratedfrom');
1526 raise_param_exc({ migratedfrom => "Only root may use this option." })
1527 if $migratedfrom && $authuser ne 'root@pam';
1528
7c14dcae
DM		 1529 # read spice ticket from STDIN
1530 my $spice_ticket;
1531 if ($stateuri && ($stateuri eq 'tcp') && $migratedfrom && ($rpcenv->{type} eq 'cli')) {
a64d6146 1532 if (defined(my $line = <>)) {
760fb3c8
DM		 1533 chomp $line;
1534 $spice_ticket = $line;
1535 }
7c14dcae
DM		 1536 }
1537
afdb31d5 1538 my $storecfg = PVE::Storage::config();
5fdbe4f0 1539
cce37749
DM		 1540 if (&$vm_is_ha_managed($vmid) && !$stateuri &&
1541 $rpcenv->{type} ne 'ha') {
5fdbe4f0 1542
88fc87b4
DM		 1543 my $hacmd = sub {
1544 my $upid = shift;
5fdbe4f0 1545
88fc87b4 1546 my $service = "pvevm:$vmid";
5fdbe4f0 1547
88fc87b4
DM		 1548 my $cmd = ['clusvcadm', '-e', $service, '-m', $node];
1549
1550 print "Executing HA start for VM $vmid\n";
1551
1552 PVE::Tools::run_command($cmd);
1553
1554 return;
1555 };
1556
1557 return $rpcenv->fork_worker('hastart', $vmid, $authuser, $hacmd);
1558
1559 } else {
1560
1561 my $realcmd = sub {
1562 my $upid = shift;
1563
1564 syslog('info', "start VM $vmid: $upid\n");
1565
fa8ea931 1566 PVE::QemuServer::vm_start($storecfg, $vmid, $stateuri, $skiplock, $migratedfrom, undef,
7c14dcae 1567 $machine, $spice_ticket);
88fc87b4
DM		 1568
1569 return;
1570 };
5fdbe4f0 1571
88fc87b4
DM		 1572 return $rpcenv->fork_worker('qmstart', $vmid, $authuser, $realcmd);
1573 }
5fdbe4f0
DM		 1574 }});
1575
1576__PACKAGE__->register_method({
afdb31d5 1577 name => 'vm_stop',
5fdbe4f0
DM		 1578 path => '{vmid}/status/stop',
1579 method => 'POST',
1580 protected => 1,
1581 proxyto => 'node',
1582 description => "Stop virtual machine.",
a0d1b1a2
DM		 1583 permissions => {
1584 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1585 },
5fdbe4f0
DM		 1586 parameters => {
1587 additionalProperties => 0,
1588 properties => {
1589 node => get_standard_option('pve-node'),
1590 vmid => get_standard_option('pve-vmid'),
1591 skiplock => get_standard_option('skiplock'),
af30308f 1592 migratedfrom => get_standard_option('pve-node',{ optional => 1 }),
c6bb9502
DM		 1593 timeout => {
1594 description => "Wait maximal timeout seconds.",
1595 type => 'integer',
1596 minimum => 0,
1597 optional => 1,
254575e9
DM		 1598 },
1599 keepActive => {
1600 description => "Do not decativate storage volumes.",
1601 type => 'boolean',
1602 optional => 1,
1603 default => 0,
c6bb9502 1604 }
5fdbe4f0
DM		 1605 },
1606 },
afdb31d5 1607 returns => {
5fdbe4f0
DM		 1608 type => 'string',
1609 },
1610 code => sub {
1611 my ($param) = @_;
1612
1613 my $rpcenv = PVE::RPCEnvironment::get();
1614
a0d1b1a2 1615 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1616
1617 my $node = extract_param($param, 'node');
1618
1619 my $vmid = extract_param($param, 'vmid');
1620
1621 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1622 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1623 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0 1624
254575e9 1625 my $keepActive = extract_param($param, 'keepActive');
afdb31d5 1626 raise_param_exc({ keepActive => "Only root may use this option." })
a0d1b1a2 1627 if $keepActive && $authuser ne 'root@pam';
254575e9 1628
af30308f
DM		 1629 my $migratedfrom = extract_param($param, 'migratedfrom');
1630 raise_param_exc({ migratedfrom => "Only root may use this option." })
1631 if $migratedfrom && $authuser ne 'root@pam';
1632
1633
ff1a2432
DM		 1634 my $storecfg = PVE::Storage::config();
1635
3be30d63 1636 if (&$vm_is_ha_managed($vmid) && $rpcenv->{type} ne 'ha') {
5fdbe4f0 1637
88fc87b4
DM		 1638 my $hacmd = sub {
1639 my $upid = shift;
5fdbe4f0 1640
88fc87b4 1641 my $service = "pvevm:$vmid";
c6bb9502 1642
88fc87b4
DM		 1643 my $cmd = ['clusvcadm', '-d', $service];
1644
1645 print "Executing HA stop for VM $vmid\n";
1646
1647 PVE::Tools::run_command($cmd);
5fdbe4f0 1648
88fc87b4
DM		 1649 return;
1650 };
1651
1652 return $rpcenv->fork_worker('hastop', $vmid, $authuser, $hacmd);
1653
1654 } else {
1655 my $realcmd = sub {
1656 my $upid = shift;
1657
1658 syslog('info', "stop VM $vmid: $upid\n");
1659
1660 PVE::QemuServer::vm_stop($storecfg, $vmid, $skiplock, 0,
af30308f 1661 $param->{timeout}, 0, 1, $keepActive, $migratedfrom);
88fc87b4
DM		 1662
1663 return;
1664 };
1665
1666 return $rpcenv->fork_worker('qmstop', $vmid, $authuser, $realcmd);
1667 }
5fdbe4f0
DM		 1668 }});
1669
1670__PACKAGE__->register_method({
afdb31d5 1671 name => 'vm_reset',
5fdbe4f0
DM		 1672 path => '{vmid}/status/reset',
1673 method => 'POST',
1674 protected => 1,
1675 proxyto => 'node',
1676 description => "Reset virtual machine.",
a0d1b1a2
DM		 1677 permissions => {
1678 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1679 },
5fdbe4f0
DM		 1680 parameters => {
1681 additionalProperties => 0,
1682 properties => {
1683 node => get_standard_option('pve-node'),
1684 vmid => get_standard_option('pve-vmid'),
1685 skiplock => get_standard_option('skiplock'),
1686 },
1687 },
afdb31d5 1688 returns => {
5fdbe4f0
DM		 1689 type => 'string',
1690 },
1691 code => sub {
1692 my ($param) = @_;
1693
1694 my $rpcenv = PVE::RPCEnvironment::get();
1695
a0d1b1a2 1696 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1697
1698 my $node = extract_param($param, 'node');
1699
1700 my $vmid = extract_param($param, 'vmid');
1701
1702 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1703 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1704 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0 1705
ff1a2432
DM		 1706 die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid);
1707
5fdbe4f0
DM		 1708 my $realcmd = sub {
1709 my $upid = shift;
1710
1e3baf05 1711 PVE::QemuServer::vm_reset($vmid, $skiplock);
5fdbe4f0
DM		 1712
1713 return;
1714 };
1715
a0d1b1a2 1716 return $rpcenv->fork_worker('qmreset', $vmid, $authuser, $realcmd);
5fdbe4f0
DM		 1717 }});
1718
1719__PACKAGE__->register_method({
afdb31d5 1720 name => 'vm_shutdown',
5fdbe4f0
DM		 1721 path => '{vmid}/status/shutdown',
1722 method => 'POST',
1723 protected => 1,
1724 proxyto => 'node',
1725 description => "Shutdown virtual machine.",
a0d1b1a2
DM		 1726 permissions => {
1727 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1728 },
5fdbe4f0
DM		 1729 parameters => {
1730 additionalProperties => 0,
1731 properties => {
1732 node => get_standard_option('pve-node'),
1733 vmid => get_standard_option('pve-vmid'),
1734 skiplock => get_standard_option('skiplock'),
c6bb9502
DM		 1735 timeout => {
1736 description => "Wait maximal timeout seconds.",
1737 type => 'integer',
1738 minimum => 0,
1739 optional => 1,
9269013a
DM		 1740 },
1741 forceStop => {
1742 description => "Make sure the VM stops.",
1743 type => 'boolean',
1744 optional => 1,
1745 default => 0,
254575e9
DM		 1746 },
1747 keepActive => {
1748 description => "Do not decativate storage volumes.",
1749 type => 'boolean',
1750 optional => 1,
1751 default => 0,
c6bb9502 1752 }
5fdbe4f0
DM		 1753 },
1754 },
afdb31d5 1755 returns => {
5fdbe4f0
DM		 1756 type => 'string',
1757 },
1758 code => sub {
1759 my ($param) = @_;
1760
1761 my $rpcenv = PVE::RPCEnvironment::get();
1762
a0d1b1a2 1763 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1764
1765 my $node = extract_param($param, 'node');
1766
1767 my $vmid = extract_param($param, 'vmid');
1768
1769 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1770 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1771 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0 1772
254575e9 1773 my $keepActive = extract_param($param, 'keepActive');
afdb31d5 1774 raise_param_exc({ keepActive => "Only root may use this option." })
a0d1b1a2 1775 if $keepActive && $authuser ne 'root@pam';
254575e9 1776
02d07cf5
DM		 1777 my $storecfg = PVE::Storage::config();
1778
5fdbe4f0
DM		 1779 my $realcmd = sub {
1780 my $upid = shift;
1781
1782 syslog('info', "shutdown VM $vmid: $upid\n");
1783
afdb31d5 1784 PVE::QemuServer::vm_stop($storecfg, $vmid, $skiplock, 0, $param->{timeout},
254575e9 1785 1, $param->{forceStop}, $keepActive);
c6bb9502 1786
5fdbe4f0
DM		 1787 return;
1788 };
1789
a0d1b1a2 1790 return $rpcenv->fork_worker('qmshutdown', $vmid, $authuser, $realcmd);
5fdbe4f0
DM		 1791 }});
1792
1793__PACKAGE__->register_method({
afdb31d5 1794 name => 'vm_suspend',
5fdbe4f0
DM		 1795 path => '{vmid}/status/suspend',
1796 method => 'POST',
1797 protected => 1,
1798 proxyto => 'node',
1799 description => "Suspend virtual machine.",
a0d1b1a2
DM		 1800 permissions => {
1801 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1802 },
5fdbe4f0
DM		 1803 parameters => {
1804 additionalProperties => 0,
1805 properties => {
1806 node => get_standard_option('pve-node'),
1807 vmid => get_standard_option('pve-vmid'),
1808 skiplock => get_standard_option('skiplock'),
1809 },
1810 },
afdb31d5 1811 returns => {
5fdbe4f0
DM		 1812 type => 'string',
1813 },
1814 code => sub {
1815 my ($param) = @_;
1816
1817 my $rpcenv = PVE::RPCEnvironment::get();
1818
a0d1b1a2 1819 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1820
1821 my $node = extract_param($param, 'node');
1822
1823 my $vmid = extract_param($param, 'vmid');
1824
1825 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1826 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1827 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0 1828
ff1a2432
DM		 1829 die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid);
1830
5fdbe4f0
DM		 1831 my $realcmd = sub {
1832 my $upid = shift;
1833
1834 syslog('info', "suspend VM $vmid: $upid\n");
1835
1e3baf05 1836 PVE::QemuServer::vm_suspend($vmid, $skiplock);
5fdbe4f0
DM		 1837
1838 return;
1839 };
1840
a0d1b1a2 1841 return $rpcenv->fork_worker('qmsuspend', $vmid, $authuser, $realcmd);
5fdbe4f0
DM		 1842 }});
1843
1844__PACKAGE__->register_method({
afdb31d5 1845 name => 'vm_resume',
5fdbe4f0
DM		 1846 path => '{vmid}/status/resume',
1847 method => 'POST',
1848 protected => 1,
1849 proxyto => 'node',
1850 description => "Resume virtual machine.",
a0d1b1a2
DM		 1851 permissions => {
1852 check => ['perm', '/vms/{vmid}', [ 'VM.PowerMgmt' ]],
1853 },
5fdbe4f0
DM		 1854 parameters => {
1855 additionalProperties => 0,
1856 properties => {
1857 node => get_standard_option('pve-node'),
1858 vmid => get_standard_option('pve-vmid'),
1859 skiplock => get_standard_option('skiplock'),
1860 },
1861 },
afdb31d5 1862 returns => {
5fdbe4f0
DM		 1863 type => 'string',
1864 },
1865 code => sub {
1866 my ($param) = @_;
1867
1868 my $rpcenv = PVE::RPCEnvironment::get();
1869
a0d1b1a2 1870 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1871
1872 my $node = extract_param($param, 'node');
1873
1874 my $vmid = extract_param($param, 'vmid');
1875
1876 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1877 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1878 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0 1879
b7eeab21 1880 die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid);
ff1a2432 1881
5fdbe4f0
DM		 1882 my $realcmd = sub {
1883 my $upid = shift;
1884
1885 syslog('info', "resume VM $vmid: $upid\n");
1886
1e3baf05 1887 PVE::QemuServer::vm_resume($vmid, $skiplock);
1e3baf05 1888
5fdbe4f0
DM		 1889 return;
1890 };
1891
a0d1b1a2 1892 return $rpcenv->fork_worker('qmresume', $vmid, $authuser, $realcmd);
5fdbe4f0
DM		 1893 }});
1894
1895__PACKAGE__->register_method({
afdb31d5 1896 name => 'vm_sendkey',
5fdbe4f0
DM		 1897 path => '{vmid}/sendkey',
1898 method => 'PUT',
1899 protected => 1,
1900 proxyto => 'node',
1901 description => "Send key event to virtual machine.",
a0d1b1a2
DM		 1902 permissions => {
1903 check => ['perm', '/vms/{vmid}', [ 'VM.Console' ]],
1904 },
5fdbe4f0
DM		 1905 parameters => {
1906 additionalProperties => 0,
1907 properties => {
1908 node => get_standard_option('pve-node'),
1909 vmid => get_standard_option('pve-vmid'),
1910 skiplock => get_standard_option('skiplock'),
1911 key => {
1912 description => "The key (qemu monitor encoding).",
1913 type => 'string'
1914 }
1915 },
1916 },
1917 returns => { type => 'null'},
1918 code => sub {
1919 my ($param) = @_;
1920
1921 my $rpcenv = PVE::RPCEnvironment::get();
1922
a0d1b1a2 1923 my $authuser = $rpcenv->get_user();
5fdbe4f0
DM		 1924
1925 my $node = extract_param($param, 'node');
1926
1927 my $vmid = extract_param($param, 'vmid');
1928
1929 my $skiplock = extract_param($param, 'skiplock');
afdb31d5 1930 raise_param_exc({ skiplock => "Only root may use this option." })
a0d1b1a2 1931 if $skiplock && $authuser ne 'root@pam';
5fdbe4f0
DM		 1932
1933 PVE::QemuServer::vm_sendkey($vmid, $skiplock, $param->{key});
1934
1935 return;
1e3baf05
DM		 1936 }});
1937
1ac0d2ee
AD		 1938__PACKAGE__->register_method({
1939 name => 'vm_feature',
1940 path => '{vmid}/feature',
1941 method => 'GET',
1942 proxyto => 'node',
75466c4f 1943 protected => 1,
1ac0d2ee
AD		 1944 description => "Check if feature for virtual machine is available.",
1945 permissions => {
1946 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
1947 },
1948 parameters => {
1949 additionalProperties => 0,
1950 properties => {
1951 node => get_standard_option('pve-node'),
1952 vmid => get_standard_option('pve-vmid'),
1953 feature => {
1954 description => "Feature to check.",
1955 type => 'string',
7758ce86 1956 enum => [ 'snapshot', 'clone', 'copy' ],
1ac0d2ee
AD		 1957 },
1958 snapname => get_standard_option('pve-snapshot-name', {
1959 optional => 1,
1960 }),
1961 },
1ac0d2ee
AD		 1962 },
1963 returns => {
719893a9
DM		 1964 type => "object",
1965 properties => {
1966 hasFeature => { type => 'boolean' },
7043d946 1967 nodes => {
719893a9
DM		 1968 type => 'array',
1969 items => { type => 'string' },
1970 }
1971 },
1ac0d2ee
AD		 1972 },
1973 code => sub {
1974 my ($param) = @_;
1975
1976 my $node = extract_param($param, 'node');
1977
1978 my $vmid = extract_param($param, 'vmid');
1979
1980 my $snapname = extract_param($param, 'snapname');
1981
1982 my $feature = extract_param($param, 'feature');
1983
1984 my $running = PVE::QemuServer::check_running($vmid);
1985
1986 my $conf = PVE::QemuServer::load_config($vmid);
1987
1988 if($snapname){
1989 my $snap = $conf->{snapshots}->{$snapname};
1990 die "snapshot '$snapname' does not exist\n" if !defined($snap);
1991 $conf = $snap;
1992 }
1993 my $storecfg = PVE::Storage::config();
1994
719893a9
DM		 1995 my $nodelist = PVE::QemuServer::shared_nodes($conf, $storecfg);
1996 my $hasFeature = PVE::QemuServer::has_feature($feature, $conf, $storecfg, $snapname, $running);
7043d946 1997
719893a9
DM		 1998 return {
1999 hasFeature => $hasFeature,
2000 nodes => [ keys %$nodelist ],
7043d946 2001 };
1ac0d2ee
AD		 2002 }});
2003
6116f729 2004__PACKAGE__->register_method({
9418baad
DM		 2005 name => 'clone_vm',
2006 path => '{vmid}/clone',
6116f729
DM		 2007 method => 'POST',
2008 protected => 1,
2009 proxyto => 'node',
37329185 2010 description => "Create a copy of virtual machine/template.",
6116f729 2011 permissions => {
9418baad 2012 description => "You need 'VM.Clone' permissions on /vms/{vmid}, and 'VM.Allocate' permissions " .
6116f729
DM		 2013 "on /vms/{newid} (or on the VM pool /pool/{pool}). You also need " .
2014 "'Datastore.AllocateSpace' on any used storage.",
75466c4f
DM		 2015 check =>
2016 [ 'and',
9418baad 2017 ['perm', '/vms/{vmid}', [ 'VM.Clone' ]],
75466c4f 2018 [ 'or',
6116f729
DM		 2019 [ 'perm', '/vms/{newid}', ['VM.Allocate']],
2020 [ 'perm', '/pool/{pool}', ['VM.Allocate'], require_param => 'pool'],
2021 ],
2022 ]
2023 },
2024 parameters => {
2025 additionalProperties => 0,
2026 properties => {
6116f729
DM		 2027 node => get_standard_option('pve-node'),
2028 vmid => get_standard_option('pve-vmid'),
9418baad 2029 newid => get_standard_option('pve-vmid', { description => 'VMID for the clone.' }),
a60ab1a6
DM		 2030 name => {
2031 optional => 1,
2032 type => 'string', format => 'dns-name',
2033 description => "Set a name for the new VM.",
2034 },
2035 description => {
2036 optional => 1,
2037 type => 'string',
2038 description => "Description for the new VM.",
2039 },
75466c4f 2040 pool => {
6116f729
DM		 2041 optional => 1,
2042 type => 'string', format => 'pve-poolid',
2043 description => "Add the new VM to the specified pool.",
2044 },
9076d880
DM		 2045 snapname => get_standard_option('pve-snapshot-name', {
2046 requires => 'full',
2047 optional => 1,
2048 }),
81f043eb 2049 storage => get_standard_option('pve-storage-id', {
9418baad 2050 description => "Target storage for full clone.",
4e4f83fe 2051 requires => 'full',
81f043eb
AD		 2052 optional => 1,
2053 }),
55173c6b 2054 'format' => {
42a19c87
AD		 2055 description => "Target format for file storage.",
2056 requires => 'full',
2057 type => 'string',
2058 optional => 1,
55173c6b 2059 enum => [ 'raw', 'qcow2', 'vmdk'],
42a19c87 2060 },
6116f729
DM		 2061 full => {
2062 optional => 1,
55173c6b
DM		 2063 type => 'boolean',
2064 description => "Create a full copy of all disk. This is always done when " .
9418baad 2065 "you clone a normal VM. For VM templates, we try to create a linked clone by default.",
6116f729
DM		 2066 default => 0,
2067 },
75466c4f 2068 target => get_standard_option('pve-node', {
55173c6b
DM		 2069 description => "Target node. Only allowed if the original VM is on shared storage.",
2070 optional => 1,
2071 }),
2072 },
6116f729
DM		 2073 },
2074 returns => {
2075 type => 'string',
2076 },
2077 code => sub {
2078 my ($param) = @_;
2079
2080 my $rpcenv = PVE::RPCEnvironment::get();
2081
55173c6b 2082 my $authuser = $rpcenv->get_user();
6116f729
DM		 2083
2084 my $node = extract_param($param, 'node');
2085
2086 my $vmid = extract_param($param, 'vmid');
2087
2088 my $newid = extract_param($param, 'newid');
2089
6116f729
DM		 2090 my $pool = extract_param($param, 'pool');
2091
2092 if (defined($pool)) {
2093 $rpcenv->check_pool_exist($pool);
2094 }
2095
55173c6b 2096 my $snapname = extract_param($param, 'snapname');
9076d880 2097
81f043eb
AD		 2098 my $storage = extract_param($param, 'storage');
2099
42a19c87
AD		 2100 my $format = extract_param($param, 'format');
2101
55173c6b
DM		 2102 my $target = extract_param($param, 'target');
2103
2104 my $localnode = PVE::INotify::nodename();
2105
751cc556 2106 undef $target if $target && ($target eq $localnode || $target eq 'localhost');
55173c6b
DM		 2107
2108 PVE::Cluster::check_node_exists($target) if $target;
2109
6116f729
DM		 2110 my $storecfg = PVE::Storage::config();
2111
4a5a2590
DM		 2112 if ($storage) {
2113 # check if storage is enabled on local node
2114 PVE::Storage::storage_check_enabled($storecfg, $storage);
2115 if ($target) {
2116 # check if storage is available on target node
2117 PVE::Storage::storage_check_node($storecfg, $storage, $target);
2118 # clone only works if target storage is shared
2119 my $scfg = PVE::Storage::storage_config($storecfg, $storage);
2120 die "can't clone to non-shared storage '$storage'\n" if !$scfg->{shared};
2121 }
2122 }
2123
55173c6b 2124 PVE::Cluster::check_cfs_quorum();
6116f729 2125
4e4f83fe
DM		 2126 my $running = PVE::QemuServer::check_running($vmid) || 0;
2127
4e4f83fe
DM		 2128 # exclusive lock if VM is running - else shared lock is enough;
2129 my $shared_lock = $running ? 0 : 1;
2130
9418baad 2131 my $clonefn = sub {
6116f729 2132
829967a9
DM		 2133 # do all tests after lock
2134 # we also try to do all tests before we fork the worker
2135
6116f729
DM		 2136 my $conf = PVE::QemuServer::load_config($vmid);
2137
2138 PVE::QemuServer::check_lock($conf);
2139
4e4f83fe 2140 my $verify_running = PVE::QemuServer::check_running($vmid) || 0;
6116f729 2141
4e4f83fe 2142 die "unexpected state change\n" if $verify_running != $running;
6116f729 2143
75466c4f
DM		 2144 die "snapshot '$snapname' does not exist\n"
2145 if $snapname && !defined( $conf->{snapshots}->{$snapname});
6116f729 2146
75466c4f 2147 my $oldconf = $snapname ? $conf->{snapshots}->{$snapname} : $conf;
9076d880 2148
9418baad 2149 my $sharedvm = &$check_storage_access_clone($rpcenv, $authuser, $storecfg, $oldconf, $storage);
6116f729 2150
9418baad 2151 die "can't clone VM to node '$target' (VM uses local storage)\n" if $target && !$sharedvm;
75466c4f 2152
6116f729
DM		 2153 my $conffile = PVE::QemuServer::config_file($newid);
2154
2155 die "unable to create VM $newid: config file already exists\n"
2156 if -f $conffile;
2157
9418baad 2158 my $newconf = { lock => 'clone' };
829967a9
DM		 2159 my $drives = {};
2160 my $vollist = [];
2161
2162 foreach my $opt (keys %$oldconf) {
2163 my $value = $oldconf->{$opt};
2164
2165 # do not copy snapshot related info
2166 next if $opt eq 'snapshots' || $opt eq 'parent' || $opt eq 'snaptime' ||
2167 $opt eq 'vmstate' || $opt eq 'snapstate';
2168
2169 # always change MAC! address
2170 if ($opt =~ m/^net(\d+)$/) {
2171 my $net = PVE::QemuServer::parse_net($value);
2172 $net->{macaddr} = PVE::Tools::random_ether_addr();
2173 $newconf->{$opt} = PVE::QemuServer::print_net($net);
1f1412d1
DM		 2174 } elsif (PVE::QemuServer::valid_drivename($opt)) {
2175 my $drive = PVE::QemuServer::parse_drive($opt, $value);
2176 die "unable to parse drive options for '$opt'\n" if !$drive;
829967a9
DM		 2177 if (PVE::QemuServer::drive_is_cdrom($drive)) {
2178 $newconf->{$opt} = $value; # simply copy configuration
2179 } else {
dba198b0 2180 if ($param->{full} || !PVE::Storage::volume_is_base($storecfg, $drive->{file})) {
2dd53043 2181 die "Full clone feature is not available"
dba198b0 2182 if !PVE::Storage::volume_has_feature($storecfg, 'copy', $drive->{file}, $snapname, $running);
2dd53043 2183 $drive->{full} = 1;
dba198b0 2184 }
829967a9
DM		 2185 $drives->{$opt} = $drive;
2186 push @$vollist, $drive->{file};
2187 }
2188 } else {
2189 # copy everything else
2190 $newconf->{$opt} = $value;
2191 }
2192 }
2193
2194 delete $newconf->{template};
2195
2196 if ($param->{name}) {
2197 $newconf->{name} = $param->{name};
2198 } else {
c55fee03
DM		 2199 if ($oldconf->{name}) {
2200 $newconf->{name} = "Copy-of-$oldconf->{name}";
2201 } else {
2202 $newconf->{name} = "Copy-of-VM-$vmid";
2203 }
829967a9 2204 }
2dd53043 2205
829967a9
DM		 2206 if ($param->{description}) {
2207 $newconf->{description} = $param->{description};
2208 }
2209
6116f729 2210 # create empty/temp config - this fails if VM already exists on other node
9418baad 2211 PVE::Tools::file_set_contents($conffile, "# qmclone temporary file\nlock: clone\n");
6116f729
DM		 2212
2213 my $realcmd = sub {
2214 my $upid = shift;
2215
b83e0181 2216 my $newvollist = [];
6116f729 2217
b83e0181 2218 eval {
829967a9 2219 local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = sub { die "interrupted by signal\n"; };
75466c4f 2220
6116f729
DM		 2221 PVE::Storage::activate_volumes($storecfg, $vollist);
2222
829967a9
DM		 2223 foreach my $opt (keys %$drives) {
2224 my $drive = $drives->{$opt};
2dd53043 2225
152fe752
DM		 2226 my $newdrive = PVE::QemuServer::clone_disk($storecfg, $vmid, $running, $opt, $drive, $snapname,
2227 $newid, $storage, $format, $drive->{full}, $newvollist);
00b095ca 2228
152fe752 2229 $newconf->{$opt} = PVE::QemuServer::print_drive($vmid, $newdrive);
2dd53043 2230
829967a9
DM		 2231 PVE::QemuServer::update_config_nolock($newid, $newconf, 1);
2232 }
b83e0181
DM		 2233
2234 delete $newconf->{lock};
2235 PVE::QemuServer::update_config_nolock($newid, $newconf, 1);
55173c6b
DM		 2236
2237 if ($target) {
baca276d
DM		 2238 # always deactivate volumes - avoid lvm LVs to be active on several nodes
2239 PVE::Storage::deactivate_volumes($storecfg, $vollist);
2240
55173c6b
DM		 2241 my $newconffile = PVE::QemuServer::config_file($newid, $target);
2242 die "Failed to move config to node '$target' - rename failed: $!\n"
2243 if !rename($conffile, $newconffile);
2244 }
d703d4c0 2245
be517049 2246 PVE::AccessControl::add_vm_to_pool($newid, $pool) if $pool;
6116f729 2247 };
75466c4f 2248 if (my $err = $@) {
6116f729
DM		 2249 unlink $conffile;
2250
b83e0181
DM		 2251 sleep 1; # some storage like rbd need to wait before release volume - really?
2252
2253 foreach my $volid (@$newvollist) {
2254 eval { PVE::Storage::vdisk_free($storecfg, $volid); };
2255 warn $@ if $@;
2256 }
9418baad 2257 die "clone failed: $err";
6116f729
DM		 2258 }
2259
2260 return;
2261 };
2262
9418baad 2263 return $rpcenv->fork_worker('qmclone', $vmid, $authuser, $realcmd);
6116f729
DM		 2264 };
2265
4e4f83fe 2266 return PVE::QemuServer::lock_config_mode($vmid, 1, $shared_lock, sub {
6116f729 2267 # Aquire exclusive lock lock for $newid
9418baad 2268 return PVE::QemuServer::lock_config_full($newid, 1, $clonefn);
6116f729
DM		 2269 });
2270
2271 }});
2272
586bfa78 2273__PACKAGE__->register_method({
43bc02a9
DM		 2274 name => 'move_vm_disk',
2275 path => '{vmid}/move_disk',
e2cd75fa 2276 method => 'POST',
586bfa78
AD		 2277 protected => 1,
2278 proxyto => 'node',
2279 description => "Move volume to different storage.",
2280 permissions => {
e2cd75fa
DM		 2281 description => "You need 'VM.Config.Disk' permissions on /vms/{vmid}, " .
2282 "and 'Datastore.AllocateSpace' permissions on the storage.",
7043d946 2283 check =>
e2cd75fa
DM		 2284 [ 'and',
2285 ['perm', '/vms/{vmid}', [ 'VM.Config.Disk' ]],
2286 ['perm', '/storage/{storage}', [ 'Datastore.AllocateSpace' ]],
2287 ],
586bfa78
AD		 2288 },
2289 parameters => {
2290 additionalProperties => 0,
2291 properties => {
2292 node => get_standard_option('pve-node'),
2293 vmid => get_standard_option('pve-vmid'),
586bfa78
AD		 2294 disk => {
2295 type => 'string',
2296 description => "The disk you want to move.",
e2cd75fa 2297 enum => [ PVE::QemuServer::disknames() ],
586bfa78 2298 },
e2cd75fa 2299 storage => get_standard_option('pve-storage-id', { description => "Target Storage." }),
635c3c44 2300 'format' => {
586bfa78
AD		 2301 type => 'string',
2302 description => "Target Format.",
2303 enum => [ 'raw', 'qcow2', 'vmdk' ],
2304 optional => 1,
2305 },
70d45e33
DM		 2306 delete => {
2307 type => 'boolean',
2308 description => "Delete the original disk after successful copy. By default the original disk is kept as unused disk.",
2309 optional => 1,
2310 default => 0,
2311 },
586bfa78
AD		 2312 digest => {
2313 type => 'string',
2314 description => 'Prevent changes if current configuration file has different SHA1 digest. This can be used to prevent concurrent modifications.',
2315 maxLength => 40,
2316 optional => 1,
2317 },
2318 },
2319 },
e2cd75fa
DM		 2320 returns => {
2321 type => 'string',
2322 description => "the task ID.",
2323 },
586bfa78
AD		 2324 code => sub {
2325 my ($param) = @_;
2326
2327 my $rpcenv = PVE::RPCEnvironment::get();
2328
2329 my $authuser = $rpcenv->get_user();
2330
2331 my $node = extract_param($param, 'node');
2332
2333 my $vmid = extract_param($param, 'vmid');
2334
2335 my $digest = extract_param($param, 'digest');
2336
2337 my $disk = extract_param($param, 'disk');
2338
2339 my $storeid = extract_param($param, 'storage');
2340
2341 my $format = extract_param($param, 'format');
2342
586bfa78
AD		 2343 my $storecfg = PVE::Storage::config();
2344
2345 my $updatefn = sub {
2346
2347 my $conf = PVE::QemuServer::load_config($vmid);
2348
2349 die "checksum missmatch (file change by other user?)\n"
2350 if $digest && $digest ne $conf->{digest};
586bfa78
AD		 2351
2352 die "disk '$disk' does not exist\n" if !$conf->{$disk};
2353
2354 my $drive = PVE::QemuServer::parse_drive($disk, $conf->{$disk});
2355
70d45e33 2356 my $old_volid = $drive->{file} || die "disk '$disk' has no associated volume\n";
586bfa78
AD		 2357
2358 die "you can't move a cdrom\n" if PVE::QemuServer::drive_is_cdrom($drive);
2359
e2cd75fa 2360 my $oldfmt;
70d45e33 2361 my ($oldstoreid, $oldvolname) = PVE::Storage::parse_volume_id($old_volid);
586bfa78
AD		 2362 if ($oldvolname =~ m/\.(raw|qcow2|vmdk)$/){
2363 $oldfmt = $1;
2364 }
2365
7043d946 2366 die "you can't move on the same storage with same format\n" if $oldstoreid eq $storeid &&
e2cd75fa 2367 (!$format || !$oldfmt || $oldfmt eq $format);
586bfa78
AD		 2368
2369 PVE::Cluster::log_msg('info', $authuser, "move disk VM $vmid: move --disk $disk --storage $storeid");
2370
2371 my $running = PVE::QemuServer::check_running($vmid);
e2cd75fa
DM		 2372
2373 PVE::Storage::activate_volumes($storecfg, [ $drive->{file} ]);
2374
586bfa78
AD		 2375 my $realcmd = sub {
2376
2377 my $newvollist = [];
2378
2379 eval {
2380 local $SIG{INT} = $SIG{TERM} = $SIG{QUIT} = $SIG{HUP} = sub { die "interrupted by signal\n"; };
2381
e2cd75fa
DM		 2382 my $newdrive = PVE::QemuServer::clone_disk($storecfg, $vmid, $running, $disk, $drive, undef,
2383 $vmid, $storeid, $format, 1, $newvollist);
2384
2385 $conf->{$disk} = PVE::QemuServer::print_drive($vmid, $newdrive);
2386
70d45e33 2387 PVE::QemuServer::add_unused_volume($conf, $old_volid) if !$param->{delete};
7043d946 2388
e2cd75fa 2389 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
586bfa78
AD		 2390 };
2391 if (my $err = $@) {
2392
2393 foreach my $volid (@$newvollist) {
2394 eval { PVE::Storage::vdisk_free($storecfg, $volid); };
2395 warn $@ if $@;
2396 }
2397 die "storage migration failed: $err";
2398 }
70d45e33
DM		 2399
2400 if ($param->{delete}) {
2401 eval { PVE::Storage::vdisk_free($storecfg, $old_volid); };
2402 warn $@ if $@;
2403 }
586bfa78
AD		 2404 };
2405
2406 return $rpcenv->fork_worker('qmmove', $vmid, $authuser, $realcmd);
2407 };
e2cd75fa
DM		 2408
2409 return PVE::QemuServer::lock_config($vmid, $updatefn);
586bfa78
AD		 2410 }});
2411
3ea94c60 2412__PACKAGE__->register_method({
afdb31d5 2413 name => 'migrate_vm',
3ea94c60
DM		 2414 path => '{vmid}/migrate',
2415 method => 'POST',
2416 protected => 1,
2417 proxyto => 'node',
2418 description => "Migrate virtual machine. Creates a new migration task.",
a0d1b1a2
DM		 2419 permissions => {
2420 check => ['perm', '/vms/{vmid}', [ 'VM.Migrate' ]],
2421 },
3ea94c60
DM		 2422 parameters => {
2423 additionalProperties => 0,
2424 properties => {
2425 node => get_standard_option('pve-node'),
2426 vmid => get_standard_option('pve-vmid'),
2427 target => get_standard_option('pve-node', { description => "Target node." }),
2428 online => {
2429 type => 'boolean',
2430 description => "Use online/live migration.",
2431 optional => 1,
2432 },
2433 force => {
2434 type => 'boolean',
2435 description => "Allow to migrate VMs which use local devices. Only root may use this option.",
2436 optional => 1,
2437 },
2438 },
2439 },
afdb31d5 2440 returns => {
3ea94c60
DM		 2441 type => 'string',
2442 description => "the task ID.",
2443 },
2444 code => sub {
2445 my ($param) = @_;
2446
2447 my $rpcenv = PVE::RPCEnvironment::get();
2448
a0d1b1a2 2449 my $authuser = $rpcenv->get_user();
3ea94c60
DM		 2450
2451 my $target = extract_param($param, 'target');
2452
2453 my $localnode = PVE::INotify::nodename();
2454 raise_param_exc({ target => "target is local node."}) if $target eq $localnode;
2455
2456 PVE::Cluster::check_cfs_quorum();
2457
2458 PVE::Cluster::check_node_exists($target);
2459
2460 my $targetip = PVE::Cluster::remote_node_ip($target);
2461
2462 my $vmid = extract_param($param, 'vmid');
2463
afdb31d5 2464 raise_param_exc({ force => "Only root may use this option." })
a0d1b1a2 2465 if $param->{force} && $authuser ne 'root@pam';
3ea94c60
DM		 2466
2467 # test if VM exists
a5ed42d3 2468 my $conf = PVE::QemuServer::load_config($vmid);
3ea94c60
DM		 2469
2470 # try to detect errors early
a5ed42d3
DM		 2471
2472 PVE::QemuServer::check_lock($conf);
2473
3ea94c60 2474 if (PVE::QemuServer::check_running($vmid)) {
afdb31d5 2475 die "cant migrate running VM without --online\n"
3ea94c60
DM		 2476 if !$param->{online};
2477 }
2478
47152e2e 2479 my $storecfg = PVE::Storage::config();
22d646a7 2480 PVE::QemuServer::check_storage_availability($storecfg, $conf, $target);
47152e2e 2481
3be30d63 2482 if (&$vm_is_ha_managed($vmid) && $rpcenv->{type} ne 'ha') {
3ea94c60 2483
88fc87b4
DM		 2484 my $hacmd = sub {
2485 my $upid = shift;
3ea94c60 2486
88fc87b4
DM		 2487 my $service = "pvevm:$vmid";
2488
2489 my $cmd = ['clusvcadm', '-M', $service, '-m', $target];
2490
2491 print "Executing HA migrate for VM $vmid to node $target\n";
2492
2493 PVE::Tools::run_command($cmd);
2494
2495 return;
2496 };
2497
2498 return $rpcenv->fork_worker('hamigrate', $vmid, $authuser, $hacmd);
2499
2500 } else {
2501
2502 my $realcmd = sub {
2503 my $upid = shift;
2504
2505 PVE::QemuMigrate->migrate($target, $targetip, $vmid, $param);
2506 };
2507
2508 return $rpcenv->fork_worker('qmigrate', $vmid, $authuser, $realcmd);
2509 }
3ea94c60 2510
3ea94c60 2511 }});
1e3baf05 2512
91c94f0a 2513__PACKAGE__->register_method({
afdb31d5
DM		 2514 name => 'monitor',
2515 path => '{vmid}/monitor',
91c94f0a
DM		 2516 method => 'POST',
2517 protected => 1,
2518 proxyto => 'node',
2519 description => "Execute Qemu monitor commands.",
a0d1b1a2
DM		 2520 permissions => {
2521 check => ['perm', '/vms/{vmid}', [ 'VM.Monitor' ]],
2522 },
91c94f0a
DM		 2523 parameters => {
2524 additionalProperties => 0,
2525 properties => {
2526 node => get_standard_option('pve-node'),
2527 vmid => get_standard_option('pve-vmid'),
2528 command => {
2529 type => 'string',
2530 description => "The monitor command.",
2531 }
2532 },
2533 },
2534 returns => { type => 'string'},
2535 code => sub {
2536 my ($param) = @_;
2537
2538 my $vmid = $param->{vmid};
2539
2540 my $conf = PVE::QemuServer::load_config ($vmid); # check if VM exists
2541
2542 my $res = '';
2543 eval {
7b7c6d1b 2544 $res = PVE::QemuServer::vm_human_monitor_command($vmid, $param->{command});
91c94f0a
DM		 2545 };
2546 $res = "ERROR: $@" if $@;
2547
2548 return $res;
2549 }});
2550
0d02881c
AD		 2551__PACKAGE__->register_method({
2552 name => 'resize_vm',
614e3941 2553 path => '{vmid}/resize',
0d02881c
AD		 2554 method => 'PUT',
2555 protected => 1,
2556 proxyto => 'node',
2f48a4f5 2557 description => "Extend volume size.",
0d02881c 2558 permissions => {
3b2773f6 2559 check => ['perm', '/vms/{vmid}', [ 'VM.Config.Disk' ]],
0d02881c
AD		 2560 },
2561 parameters => {
2562 additionalProperties => 0,
2f48a4f5
DM		 2563 properties => {
2564 node => get_standard_option('pve-node'),
2565 vmid => get_standard_option('pve-vmid'),
2566 skiplock => get_standard_option('skiplock'),
2567 disk => {
2568 type => 'string',
2569 description => "The disk you want to resize.",
2570 enum => [PVE::QemuServer::disknames()],
2571 },
2572 size => {
2573 type => 'string',
f91b2e45 2574 pattern => '\+?\d+(\.\d+)?[KMGT]?',
2f48a4f5
DM		 2575 description => "The new size. With the '+' sign the value is added to the actual size of the volume and without it, the value is taken as an absolute one. Shrinking disk size is not supported.",
2576 },
2577 digest => {
2578 type => 'string',
2579 description => 'Prevent changes if current configuration file has different SHA1 digest. This can be used to prevent concurrent modifications.',
2580 maxLength => 40,
2581 optional => 1,
2582 },
2583 },
0d02881c
AD		 2584 },
2585 returns => { type => 'null'},
2586 code => sub {
2587 my ($param) = @_;
2588
2589 my $rpcenv = PVE::RPCEnvironment::get();
2590
2591 my $authuser = $rpcenv->get_user();
2592
2593 my $node = extract_param($param, 'node');
2594
2595 my $vmid = extract_param($param, 'vmid');
2596
2597 my $digest = extract_param($param, 'digest');
2598
2f48a4f5 2599 my $disk = extract_param($param, 'disk');
75466c4f 2600
2f48a4f5 2601 my $sizestr = extract_param($param, 'size');
0d02881c 2602
f91b2e45 2603 my $skiplock = extract_param($param, 'skiplock');
0d02881c
AD		 2604 raise_param_exc({ skiplock => "Only root may use this option." })
2605 if $skiplock && $authuser ne 'root@pam';
2606
0d02881c
AD		 2607 my $storecfg = PVE::Storage::config();
2608
0d02881c
AD		 2609 my $updatefn = sub {
2610
2611 my $conf = PVE::QemuServer::load_config($vmid);
2612
2613 die "checksum missmatch (file change by other user?)\n"
2614 if $digest && $digest ne $conf->{digest};
2615 PVE::QemuServer::check_lock($conf) if !$skiplock;
2616
f91b2e45
DM		 2617 die "disk '$disk' does not exist\n" if !$conf->{$disk};
2618
2619 my $drive = PVE::QemuServer::parse_drive($disk, $conf->{$disk});
2620
2621 my $volid = $drive->{file};
2622
2623 die "disk '$disk' has no associated volume\n" if !$volid;
2624
2625 die "you can't resize a cdrom\n" if PVE::QemuServer::drive_is_cdrom($drive);
2626
75466c4f 2627 die "you can't online resize a virtio windows bootdisk\n"
f2965e67
AD		 2628 if PVE::QemuServer::check_running($vmid) && $conf->{bootdisk} eq $disk && $conf->{ostype} =~ m/^w/ && $disk =~ m/^virtio/;
2629
f91b2e45
DM		 2630 my ($storeid, $volname) = PVE::Storage::parse_volume_id($volid);
2631
2632 $rpcenv->check($authuser, "/storage/$storeid", ['Datastore.AllocateSpace']);
2633
2634 my $size = PVE::Storage::volume_size_info($storecfg, $volid, 5);
2635
2636 die "internal error" if $sizestr !~ m/^(\+)?(\d+(\.\d+)?)([KMGT])?$/;
2637 my ($ext, $newsize, $unit) = ($1, $2, $4);
2638 if ($unit) {
2639 if ($unit eq 'K') {
2640 $newsize = $newsize * 1024;
2641 } elsif ($unit eq 'M') {
2642 $newsize = $newsize * 1024 * 1024;
2643 } elsif ($unit eq 'G') {
2644 $newsize = $newsize * 1024 * 1024 * 1024;
2645 } elsif ($unit eq 'T') {
2646 $newsize = $newsize * 1024 * 1024 * 1024 * 1024;
2647 }
2648 }
2649 $newsize += $size if $ext;
2650 $newsize = int($newsize);
2651
2652 die "unable to skrink disk size\n" if $newsize < $size;
2653
2654 return if $size == $newsize;
2655
2f48a4f5 2656 PVE::Cluster::log_msg('info', $authuser, "update VM $vmid: resize --disk $disk --size $sizestr");
0d02881c 2657
f91b2e45 2658 PVE::QemuServer::qemu_block_resize($vmid, "drive-$disk", $storecfg, $volid, $newsize);
75466c4f 2659
f91b2e45
DM		 2660 $drive->{size} = $newsize;
2661 $conf->{$disk} = PVE::QemuServer::print_drive($vmid, $drive);
2662
2663 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
2664 };
0d02881c
AD		 2665
2666 PVE::QemuServer::lock_config($vmid, $updatefn);
2667 return undef;
2668 }});
2669
9dbd1ee4 2670__PACKAGE__->register_method({
7e7d7b61 2671 name => 'snapshot_list',
9dbd1ee4 2672 path => '{vmid}/snapshot',
7e7d7b61
DM		 2673 method => 'GET',
2674 description => "List all snapshots.",
2675 permissions => {
2676 check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
2677 },
2678 proxyto => 'node',
2679 protected => 1, # qemu pid files are only readable by root
2680 parameters => {
2681 additionalProperties => 0,
2682 properties => {
2683 vmid => get_standard_option('pve-vmid'),
2684 node => get_standard_option('pve-node'),
2685 },
2686 },
2687 returns => {
2688 type => 'array',
2689 items => {
2690 type => "object",
2691 properties => {},
2692 },
2693 links => [ { rel => 'child', href => "{name}" } ],
2694 },
2695 code => sub {
2696 my ($param) = @_;
2697
6aa4651b
DM		 2698 my $vmid = $param->{vmid};
2699
2700 my $conf = PVE::QemuServer::load_config($vmid);
7e7d7b61
DM		 2701 my $snaphash = $conf->{snapshots} || {};
2702
2703 my $res = [];
2704
2705 foreach my $name (keys %$snaphash) {
0ea6bc69 2706 my $d = $snaphash->{$name};
75466c4f
DM		 2707 my $item = {
2708 name => $name,
2709 snaptime => $d->{snaptime} || 0,
6aa4651b 2710 vmstate => $d->{vmstate} ? 1 : 0,
982c7f12
DM		 2711 description => $d->{description} || '',
2712 };
0ea6bc69 2713 $item->{parent} = $d->{parent} if $d->{parent};
3ee28e38 2714 $item->{snapstate} = $d->{snapstate} if $d->{snapstate};
0ea6bc69
DM		 2715 push @$res, $item;
2716 }
2717
6aa4651b
DM		 2718 my $running = PVE::QemuServer::check_running($vmid, 1) ? 1 : 0;
2719 my $current = { name => 'current', digest => $conf->{digest}, running => $running };
d1914468
DM		 2720 $current->{parent} = $conf->{parent} if $conf->{parent};
2721
2722 push @$res, $current;
7e7d7b61
DM		 2723
2724 return $res;
2725 }});
2726
2727__PACKAGE__->register_method({
2728 name => 'snapshot',
2729 path => '{vmid}/snapshot',
2730 method => 'POST',
9dbd1ee4
AD		 2731 protected => 1,
2732 proxyto => 'node',
2733 description => "Snapshot a VM.",
2734 permissions => {
f1baf1df 2735 check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
9dbd1ee4
AD		 2736 },
2737 parameters => {
2738 additionalProperties => 0,
2739 properties => {
2740 node => get_standard_option('pve-node'),
2741 vmid => get_standard_option('pve-vmid'),
8abd398b 2742 snapname => get_standard_option('pve-snapshot-name'),
9dbd1ee4
AD		 2743 vmstate => {
2744 optional => 1,
2745 type => 'boolean',
2746 description => "Save the vmstate",
2747 },
2748 freezefs => {
2749 optional => 1,
2750 type => 'boolean',
2751 description => "Freeze the filesystem",
2752 },
782f4f75
DM		 2753 description => {
2754 optional => 1,
2755 type => 'string',
2756 description => "A textual description or comment.",
2757 },
9dbd1ee4
AD		 2758 },
2759 },
7e7d7b61
DM		 2760 returns => {
2761 type => 'string',
2762 description => "the task ID.",
2763 },
9dbd1ee4
AD		 2764 code => sub {
2765 my ($param) = @_;
2766
2767 my $rpcenv = PVE::RPCEnvironment::get();
2768
2769 my $authuser = $rpcenv->get_user();
2770
2771 my $node = extract_param($param, 'node');
2772
2773 my $vmid = extract_param($param, 'vmid');
2774
9dbd1ee4
AD		 2775 my $snapname = extract_param($param, 'snapname');
2776
d1914468
DM		 2777 die "unable to use snapshot name 'current' (reserved name)\n"
2778 if $snapname eq 'current';
2779
7e7d7b61 2780 my $realcmd = sub {
22c377f0 2781 PVE::Cluster::log_msg('info', $authuser, "snapshot VM $vmid: $snapname");
75466c4f 2782 PVE::QemuServer::snapshot_create($vmid, $snapname, $param->{vmstate},
782f4f75 2783 $param->{freezefs}, $param->{description});
7e7d7b61
DM		 2784 };
2785
2786 return $rpcenv->fork_worker('qmsnapshot', $vmid, $authuser, $realcmd);
2787 }});
2788
154ccdcd
DM		 2789__PACKAGE__->register_method({
2790 name => 'snapshot_cmd_idx',
2791 path => '{vmid}/snapshot/{snapname}',
2792 description => '',
2793 method => 'GET',
2794 permissions => {
2795 user => 'all',
2796 },
2797 parameters => {
2798 additionalProperties => 0,
2799 properties => {
2800 vmid => get_standard_option('pve-vmid'),
2801 node => get_standard_option('pve-node'),
8abd398b 2802 snapname => get_standard_option('pve-snapshot-name'),
154ccdcd
DM		 2803 },
2804 },
2805 returns => {
2806 type => 'array',
2807 items => {
2808 type => "object",
2809 properties => {},
2810 },
2811 links => [ { rel => 'child', href => "{cmd}" } ],
2812 },
2813 code => sub {
2814 my ($param) = @_;
2815
2816 my $res = [];
2817
2818 push @$res, { cmd => 'rollback' };
d788cea6 2819 push @$res, { cmd => 'config' };
154ccdcd
DM		 2820
2821 return $res;
2822 }});
2823
d788cea6
DM		 2824__PACKAGE__->register_method({
2825 name => 'update_snapshot_config',
2826 path => '{vmid}/snapshot/{snapname}/config',
2827 method => 'PUT',
2828 protected => 1,
2829 proxyto => 'node',
2830 description => "Update snapshot metadata.",
2831 permissions => {
2832 check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
2833 },
2834 parameters => {
2835 additionalProperties => 0,
2836 properties => {
2837 node => get_standard_option('pve-node'),
2838 vmid => get_standard_option('pve-vmid'),
2839 snapname => get_standard_option('pve-snapshot-name'),
2840 description => {
2841 optional => 1,
2842 type => 'string',
2843 description => "A textual description or comment.",
2844 },
2845 },
2846 },
2847 returns => { type => 'null' },
2848 code => sub {
2849 my ($param) = @_;
2850
2851 my $rpcenv = PVE::RPCEnvironment::get();
2852
2853 my $authuser = $rpcenv->get_user();
2854
2855 my $vmid = extract_param($param, 'vmid');
2856
2857 my $snapname = extract_param($param, 'snapname');
2858
2859 return undef if !defined($param->{description});
2860
2861 my $updatefn = sub {
2862
2863 my $conf = PVE::QemuServer::load_config($vmid);
2864
2865 PVE::QemuServer::check_lock($conf);
2866
2867 my $snap = $conf->{snapshots}->{$snapname};
2868
75466c4f
DM		 2869 die "snapshot '$snapname' does not exist\n" if !defined($snap);
2870
d788cea6
DM		 2871 $snap->{description} = $param->{description} if defined($param->{description});
2872
2873 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
2874 };
2875
2876 PVE::QemuServer::lock_config($vmid, $updatefn);
2877
2878 return undef;
2879 }});
2880
2881__PACKAGE__->register_method({
2882 name => 'get_snapshot_config',
2883 path => '{vmid}/snapshot/{snapname}/config',
2884 method => 'GET',
2885 proxyto => 'node',
2886 description => "Get snapshot configuration",
2887 permissions => {
2888 check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
2889 },
2890 parameters => {
2891 additionalProperties => 0,
2892 properties => {
2893 node => get_standard_option('pve-node'),
2894 vmid => get_standard_option('pve-vmid'),
2895 snapname => get_standard_option('pve-snapshot-name'),
2896 },
2897 },
2898 returns => { type => "object" },
2899 code => sub {
2900 my ($param) = @_;
2901
2902 my $rpcenv = PVE::RPCEnvironment::get();
2903
2904 my $authuser = $rpcenv->get_user();
2905
2906 my $vmid = extract_param($param, 'vmid');
2907
2908 my $snapname = extract_param($param, 'snapname');
2909
2910 my $conf = PVE::QemuServer::load_config($vmid);
2911
2912 my $snap = $conf->{snapshots}->{$snapname};
2913
75466c4f
DM		 2914 die "snapshot '$snapname' does not exist\n" if !defined($snap);
2915
d788cea6
DM		 2916 return $snap;
2917 }});
2918
7e7d7b61
DM		 2919__PACKAGE__->register_method({
2920 name => 'rollback',
154ccdcd 2921 path => '{vmid}/snapshot/{snapname}/rollback',
7e7d7b61
DM		 2922 method => 'POST',
2923 protected => 1,
2924 proxyto => 'node',
2925 description => "Rollback VM state to specified snapshot.",
2926 permissions => {
f1baf1df 2927 check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
7e7d7b61
DM		 2928 },
2929 parameters => {
2930 additionalProperties => 0,
2931 properties => {
2932 node => get_standard_option('pve-node'),
2933 vmid => get_standard_option('pve-vmid'),
8abd398b 2934 snapname => get_standard_option('pve-snapshot-name'),
7e7d7b61
DM		 2935 },
2936 },
2937 returns => {
2938 type => 'string',
2939 description => "the task ID.",
2940 },
2941 code => sub {
2942 my ($param) = @_;
2943
2944 my $rpcenv = PVE::RPCEnvironment::get();
2945
2946 my $authuser = $rpcenv->get_user();
2947
2948 my $node = extract_param($param, 'node');
2949
2950 my $vmid = extract_param($param, 'vmid');
2951
2952 my $snapname = extract_param($param, 'snapname');
2953
7e7d7b61 2954 my $realcmd = sub {
22c377f0
DM		 2955 PVE::Cluster::log_msg('info', $authuser, "rollback snapshot VM $vmid: $snapname");
2956 PVE::QemuServer::snapshot_rollback($vmid, $snapname);
7e7d7b61
DM		 2957 };
2958
2959 return $rpcenv->fork_worker('qmrollback', $vmid, $authuser, $realcmd);
2960 }});
2961
2962__PACKAGE__->register_method({
2963 name => 'delsnapshot',
2964 path => '{vmid}/snapshot/{snapname}',
2965 method => 'DELETE',
2966 protected => 1,
2967 proxyto => 'node',
2968 description => "Delete a VM snapshot.",
2969 permissions => {
f1baf1df 2970 check => ['perm', '/vms/{vmid}', [ 'VM.Snapshot' ]],
7e7d7b61
DM		 2971 },
2972 parameters => {
2973 additionalProperties => 0,
2974 properties => {
2975 node => get_standard_option('pve-node'),
2976 vmid => get_standard_option('pve-vmid'),
8abd398b 2977 snapname => get_standard_option('pve-snapshot-name'),
3ee28e38
DM		 2978 force => {
2979 optional => 1,
2980 type => 'boolean',
2981 description => "For removal from config file, even if removing disk snapshots fails.",
2982 },
7e7d7b61
DM		 2983 },
2984 },
2985 returns => {
2986 type => 'string',
2987 description => "the task ID.",
2988 },
2989 code => sub {
2990 my ($param) = @_;
2991
2992 my $rpcenv = PVE::RPCEnvironment::get();
2993
2994 my $authuser = $rpcenv->get_user();
2995
2996 my $node = extract_param($param, 'node');
2997
2998 my $vmid = extract_param($param, 'vmid');
2999
3000 my $snapname = extract_param($param, 'snapname');
3001
7e7d7b61 3002 my $realcmd = sub {
22c377f0 3003 PVE::Cluster::log_msg('info', $authuser, "delete snapshot VM $vmid: $snapname");
3ee28e38 3004 PVE::QemuServer::snapshot_delete($vmid, $snapname, $param->{force});
7e7d7b61 3005 };
9dbd1ee4 3006
7b2257a8 3007 return $rpcenv->fork_worker('qmdelsnapshot', $vmid, $authuser, $realcmd);
9dbd1ee4
AD		 3008 }});
3009
04a69bb4
AD		 3010__PACKAGE__->register_method({
3011 name => 'template',
3012 path => '{vmid}/template',
3013 method => 'POST',
3014 protected => 1,
3015 proxyto => 'node',
3016 description => "Create a Template.",
b02691d8 3017 permissions => {
7af0a6c8
DM		 3018 description => "You need 'VM.Allocate' permissions on /vms/{vmid}",
3019 check => [ 'perm', '/vms/{vmid}', ['VM.Allocate']],
b02691d8 3020 },
04a69bb4
AD		 3021 parameters => {
3022 additionalProperties => 0,
3023 properties => {
3024 node => get_standard_option('pve-node'),
3025 vmid => get_standard_option('pve-vmid'),
3026 disk => {
3027 optional => 1,
3028 type => 'string',
3029 description => "If you want to convert only 1 disk to base image.",
3030 enum => [PVE::QemuServer::disknames()],
3031 },
3032
3033 },
3034 },
3035 returns => { type => 'null'},
3036 code => sub {
3037 my ($param) = @_;
3038
3039 my $rpcenv = PVE::RPCEnvironment::get();
3040
3041 my $authuser = $rpcenv->get_user();
3042
3043 my $node = extract_param($param, 'node');
3044
3045 my $vmid = extract_param($param, 'vmid');
3046
3047 my $disk = extract_param($param, 'disk');
3048
3049 my $updatefn = sub {
3050
3051 my $conf = PVE::QemuServer::load_config($vmid);
3052
3053 PVE::QemuServer::check_lock($conf);
3054
75466c4f 3055 die "unable to create template, because VM contains snapshots\n"
b91c2aae 3056 if $conf->{snapshots} && scalar(keys %{$conf->{snapshots}});
0402a80b 3057
75466c4f 3058 die "you can't convert a template to a template\n"
03c2d0ad 3059 if PVE::QemuServer::is_template($conf) && !$disk;
0402a80b 3060
75466c4f 3061 die "you can't convert a VM to template if VM is running\n"
218cab9a 3062 if PVE::QemuServer::check_running($vmid);
35c5fdef 3063
04a69bb4
AD		 3064 my $realcmd = sub {
3065 PVE::QemuServer::template_create($vmid, $conf, $disk);
3066 };
04a69bb4 3067
75e7e997 3068 $conf->{template} = 1;
04a69bb4 3069 PVE::QemuServer::update_config_nolock($vmid, $conf, 1);
75e7e997
DM		 3070
3071 return $rpcenv->fork_worker('qmtemplate', $vmid, $authuser, $realcmd);
04a69bb4
AD		 3072 };
3073
3074 PVE::QemuServer::lock_config($vmid, $updatefn);
3075 return undef;
3076 }});
3077
1e3baf05 30781;
Virtual Machine Manager