PVE/API2/Qemu.pm

   1 package PVE::API2::Qemu;
   2
   3 use strict;
   4 use warnings;
   5 use Cwd 'abs_path';
   6
   7 use PVE::Cluster;
   8 use PVE::SafeSyslog;
   9 use PVE::Tools qw(extract_param);
  10 use PVE::Exception qw(raise raise_param_exc);
  11 use PVE::Storage;
  12 use PVE::JSONSchema qw(get_standard_option);
  13 use PVE::RESTHandler;
  14 use PVE::QemuServer;
  15 use PVE::QemuMigrate;
  16 use PVE::RPCEnvironment;
  17 use PVE::AccessControl;
  18 use PVE::INotify;
  19
  20 use Data::Dumper; # fixme: remove
  21
  22 use base qw(PVE::RESTHandler);
  23
  24 my $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.";
  25
  26 my $resolve_cdrom_alias = sub {
  27     my $param = shift;
  28
  29     if (my $value = $param->{cdrom}) {
  30         $value .= ",media=cdrom" if $value !~ m/media=/;
  31         $param->{ide2} = $value;
  32         delete $param->{cdrom};
  33     }
  34 };
  35
  36 __PACKAGE__->register_method({
  37     name => 'vmlist',
  38     path => '',
  39     method => 'GET',
  40     description => "Virtual machine index (per node).",
  41     proxyto => 'node',
  42     protected => 1, # qemu pid files are only readable by root
  43     parameters => {
  44         additionalProperties => 0,
  45         properties => {
  46             node => get_standard_option('pve-node'),
  47         },
  48     },
  49     returns => {
  50         type => 'array',
  51         items => {
  52             type => "object",
  53             properties => {},
  54         },
  55         links => [ { rel => 'child', href => "{vmid}" } ],
  56     },
  57     code => sub {
  58         my ($param) = @_;
  59
  60         my $vmstatus = PVE::QemuServer::vmstatus();
  61
  62         return PVE::RESTHandler::hash_to_array($vmstatus, 'vmid');
  63
  64     }});
  65
  66 __PACKAGE__->register_method({
  67     name => 'create_vm',
  68     path => '',
  69     method => 'POST',
  70     description => "Create or restore a virtual machine.",
  71     protected => 1,
  72     proxyto => 'node',
  73     parameters => {
  74         additionalProperties => 0,
  75         properties => PVE::QemuServer::json_config_properties(
  76             {
  77                 node => get_standard_option('pve-node'),
  78                 vmid => get_standard_option('pve-vmid'),
  79                 archive => {
  80                     description => "The backup file.",
  81                     type => 'string',
  82                     optional => 1,
  83                     maxLength => 255,
  84                 },
  85                 storage => get_standard_option('pve-storage-id', {
  86                     description => "Default storage.",
  87                     optional => 1,
  88                 }),
  89                 force => {
  90                     optional => 1,
  91                     type => 'boolean',
  92                     description => "Allow to overwrite existing VM.",
  93                     requires => 'archive',
  94                 },
  95                 unique => {
  96                     optional => 1,
  97                     type => 'boolean',
  98                     description => "Assign a unique random ethernet address.",
  99                     requires => 'archive',
 100                 },
 101             }),
 102     },
 103     returns => {
 104         type => 'string',
 105     },
 106     code => sub {
 107         my ($param) = @_;
 108
 109         my $rpcenv = PVE::RPCEnvironment::get();
 110
 111         my $user = $rpcenv->get_user();
 112
 113         my $node = extract_param($param, 'node');
 114
 115         my $vmid = extract_param($param, 'vmid');
 116
 117         my $archive = extract_param($param, 'archive');
 118
 119         my $storage = extract_param($param, 'storage');
 120
 121         my $force = extract_param($param, 'force');
 122
 123         my $unique = extract_param($param, 'unique');
 124
 125         my $filename = PVE::QemuServer::config_file($vmid);
 126
 127         my $storecfg = PVE::Storage::config();
 128
 129         PVE::Cluster::check_cfs_quorum();
 130
 131         if (!$archive) {
 132             &$resolve_cdrom_alias($param);
 133
 134             foreach my $opt (keys %$param) {
 135                 if (PVE::QemuServer::valid_drivename($opt)) {
 136                     my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
 137                     raise_param_exc({ $opt => "unable to parse drive options" }) if !$drive;
 138
 139                     PVE::QemuServer::cleanup_drive_path($opt, $storecfg, $drive);
 140                     $param->{$opt} = PVE::QemuServer::print_drive($vmid, $drive);
 141                 }
 142             }
 143
 144             PVE::QemuServer::add_random_macs($param);
 145         } else {
 146             my $keystr = join(' ', keys %$param);
 147             raise_param_exc({ archive => "option conflicts with other options ($keystr)"}) if $keystr;
 148
 149             if ($archive eq '-') {
 150                 die "pipe requires cli environment\n"
 151                     && $rpcenv->{type} ne 'cli';
 152             } else {
 153                 my $path;
 154                 if (PVE::Storage::parse_volume_id($archive, 1)) {
 155                     $path = PVE::Storage::path($storecfg, $archive);
 156                 } else {
 157                     raise_param_exc({ archive => "Only root can pass arbitrary paths." })
 158                         if $user ne 'root@pam';
 159
 160                     $path = abs_path($archive);
 161                 }
 162                 die "can't find archive file '$archive'\n" if !($path && -f $path);
 163                 $archive = $path;
 164             }
 165         }
 166
 167         my $restorefn = sub {
 168
 169             if (-f $filename) {
 170                 die "unable to restore vm $vmid: config file already exists\n"
 171                     if !$force;
 172
 173                 die "unable to restore vm $vmid: vm is running\n"
 174                     if PVE::QemuServer::check_running($vmid);
 175
 176                 # destroy existing data - keep empty config
 177                 PVE::QemuServer::destroy_vm($storecfg, $vmid, 1);
 178             }
 179
 180             my $realcmd = sub {
 181                 PVE::QemuServer::restore_archive($archive, $vmid, {
 182                     storage => $storage,
 183                     unique => $unique });
 184             };
 185
 186             return $rpcenv->fork_worker('qmrestore', $vmid, $user, $realcmd);
 187         };
 188
 189         my $createfn = sub {
 190
 191             # second test (after locking test is accurate)
 192             die "unable to create vm $vmid: config file already exists\n"
 193                 if -f $filename;
 194
 195             my $realcmd = sub {
 196
 197                 my $vollist = [];
 198
 199                 eval {
 200                     $vollist = PVE::QemuServer::create_disks($storecfg, $vmid, $param, $storage);
 201
 202                     # try to be smart about bootdisk
 203                     my @disks = PVE::QemuServer::disknames();
 204                     my $firstdisk;
 205                     foreach my $ds (reverse @disks) {
 206                         next if !$param->{$ds};
 207                         my $disk = PVE::QemuServer::parse_drive($ds, $param->{$ds});
 208                         next if PVE::QemuServer::drive_is_cdrom($disk);
 209                         $firstdisk = $ds;
 210                     }
 211
 212                     if (!$param->{bootdisk} && $firstdisk) {
 213                         $param->{bootdisk} = $firstdisk;
 214                     }
 215
 216                     PVE::QemuServer::create_conf_nolock($vmid, $param);
 217                 };
 218                 my $err = $@;
 219
 220                 if ($err) {
 221                     foreach my $volid (@$vollist) {
 222                         eval { PVE::Storage::vdisk_free($storecfg, $volid); };
 223                         warn $@ if $@;
 224                     }
 225                     die "create failed - $err";
 226                 }
 227             };
 228
 229             return $rpcenv->fork_worker('qmcreate', $vmid, $user, $realcmd);
 230         };
 231
 232         return PVE::QemuServer::lock_config($vmid, $archive ? $restorefn : $createfn);
 233     }});
 234
 235 __PACKAGE__->register_method({
 236     name => 'vmdiridx',
 237     path => '{vmid}',
 238     method => 'GET',
 239     proxyto => 'node',
 240     description => "Directory index",
 241     parameters => {
 242         additionalProperties => 0,
 243         properties => {
 244             node => get_standard_option('pve-node'),
 245             vmid => get_standard_option('pve-vmid'),
 246         },
 247     },
 248     returns => {
 249         type => 'array',
 250         items => {
 251             type => "object",
 252             properties => {
 253                 subdir => { type => 'string' },
 254             },
 255         },
 256         links => [ { rel => 'child', href => "{subdir}" } ],
 257     },
 258     code => sub {
 259         my ($param) = @_;
 260
 261         my $res = [
 262             { subdir => 'config' },
 263             { subdir => 'status' },
 264             { subdir => 'unlink' },
 265             { subdir => 'vncproxy' },
 266             { subdir => 'migrate' },
 267             { subdir => 'rrd' },
 268             { subdir => 'rrddata' },
 269             { subdir => 'monitor' },
 270             ];
 271
 272         return $res;
 273     }});
 274
 275 __PACKAGE__->register_method({
 276     name => 'rrd',
 277     path => '{vmid}/rrd',
 278     method => 'GET',
 279     protected => 1, # fixme: can we avoid that?
 280     permissions => {
 281         check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
 282     },
 283     description => "Read VM RRD statistics (returns PNG)",
 284     parameters => {
 285         additionalProperties => 0,
 286         properties => {
 287             node => get_standard_option('pve-node'),
 288             vmid => get_standard_option('pve-vmid'),
 289             timeframe => {
 290                 description => "Specify the time frame you are interested in.",
 291                 type => 'string',
 292                 enum => [ 'hour', 'day', 'week', 'month', 'year' ],
 293             },
 294             ds => {
 295                 description => "The list of datasources you want to display.",
 296                 type => 'string', format => 'pve-configid-list',
 297             },
 298             cf => {
 299                 description => "The RRD consolidation function",
 300                 type => 'string',
 301                 enum => [ 'AVERAGE', 'MAX' ],
 302                 optional => 1,
 303             },
 304         },
 305     },
 306     returns => {
 307         type => "object",
 308         properties => {
 309             filename => { type => 'string' },
 310         },
 311     },
 312     code => sub {
 313         my ($param) = @_;
 314
 315         return PVE::Cluster::create_rrd_graph(
 316             "pve2-vm/$param->{vmid}", $param->{timeframe},
 317             $param->{ds}, $param->{cf});
 318
 319     }});
 320
 321 __PACKAGE__->register_method({
 322     name => 'rrddata',
 323     path => '{vmid}/rrddata',
 324     method => 'GET',
 325     protected => 1, # fixme: can we avoid that?
 326     permissions => {
 327         check => ['perm', '/vms/{vmid}', [ 'VM.Audit' ]],
 328     },
 329     description => "Read VM RRD statistics",
 330     parameters => {
 331         additionalProperties => 0,
 332         properties => {
 333             node => get_standard_option('pve-node'),
 334             vmid => get_standard_option('pve-vmid'),
 335             timeframe => {
 336                 description => "Specify the time frame you are interested in.",
 337                 type => 'string',
 338                 enum => [ 'hour', 'day', 'week', 'month', 'year' ],
 339             },
 340             cf => {
 341                 description => "The RRD consolidation function",
 342                 type => 'string',
 343                 enum => [ 'AVERAGE', 'MAX' ],
 344                 optional => 1,
 345             },
 346         },
 347     },
 348     returns => {
 349         type => "array",
 350         items => {
 351             type => "object",
 352             properties => {},
 353         },
 354     },
 355     code => sub {
 356         my ($param) = @_;
 357
 358         return PVE::Cluster::create_rrd_data(
 359             "pve2-vm/$param->{vmid}", $param->{timeframe}, $param->{cf});
 360     }});
 361
 362
 363 __PACKAGE__->register_method({
 364     name => 'vm_config',
 365     path => '{vmid}/config',
 366     method => 'GET',
 367     proxyto => 'node',
 368     description => "Get virtual machine configuration.",
 369     parameters => {
 370         additionalProperties => 0,
 371         properties => {
 372             node => get_standard_option('pve-node'),
 373             vmid => get_standard_option('pve-vmid'),
 374         },
 375     },
 376     returns => {
 377         type => "object",
 378         properties => {
 379             digest => {
 380                 type => 'string',
 381                 description => 'SHA1 digest of configuration file. This can be used to prevent concurrent modifications.',
 382             }
 383         },
 384     },
 385     code => sub {
 386         my ($param) = @_;
 387
 388         my $conf = PVE::QemuServer::load_config($param->{vmid});
 389
 390         return $conf;
 391     }});
 392
 393 __PACKAGE__->register_method({
 394     name => 'update_vm',
 395     path => '{vmid}/config',
 396     method => 'PUT',
 397     protected => 1,
 398     proxyto => 'node',
 399     description => "Set virtual machine options.",
 400     parameters => {
 401         additionalProperties => 0,
 402         properties => PVE::QemuServer::json_config_properties(
 403             {
 404                 node => get_standard_option('pve-node'),
 405                 vmid => get_standard_option('pve-vmid'),
 406                 skiplock => get_standard_option('skiplock'),
 407                 delete => {
 408                     type => 'string', format => 'pve-configid-list',
 409                     description => "A list of settings you want to delete.",
 410                     optional => 1,
 411                 },
 412                 force => {
 413                     type => 'boolean',
 414                     description => $opt_force_description,
 415                     optional => 1,
 416                     requires => 'delete',
 417                 },
 418                 digest => {
 419                     type => 'string',
 420                     description => 'Prevent changes if current configuration file has different SHA1 digest. This can be used to prevent concurrent modifications.',
 421                     maxLength => 40,
 422                     optional => 1,
 423                 }
 424             }),
 425     },
 426     returns => { type => 'null'},
 427     code => sub {
 428         my ($param) = @_;
 429
 430         my $rpcenv = PVE::RPCEnvironment::get();
 431
 432         my $user = $rpcenv->get_user();
 433
 434         my $node = extract_param($param, 'node');
 435
 436         my $vmid = extract_param($param, 'vmid');
 437
 438         my $digest = extract_param($param, 'digest');
 439
 440         my @paramarr = (); # used for log message
 441         foreach my $key (keys %$param) {
 442             push @paramarr, "-$key", $param->{$key};
 443         }
 444
 445         my $skiplock = extract_param($param, 'skiplock');
 446         raise_param_exc({ skiplock => "Only root may use this option." })
 447             if $skiplock && $user ne 'root@pam';
 448
 449         my $delete = extract_param($param, 'delete');
 450         my $force = extract_param($param, 'force');
 451
 452         die "no options specified\n" if !$delete && !scalar(keys %$param);
 453
 454         my $storecfg = PVE::Storage::config();
 455
 456         &$resolve_cdrom_alias($param);
 457
 458         my $updatefn =  sub {
 459
 460             my $conf = PVE::QemuServer::load_config($vmid);
 461
 462             die "checksum missmatch (file change by other user?)\n"
 463                 if $digest && $digest ne $conf->{digest};
 464
 465             PVE::QemuServer::check_lock($conf) if !$skiplock;
 466
 467             PVE::Cluster::log_msg('info', $user, "update VM $vmid: " . join (' ', @paramarr));
 468
 469             #delete
 470             foreach my $opt (PVE::Tools::split_list($delete)) {
 471
 472                 $opt = 'ide2' if $opt eq 'cdrom';
 473                 die "you can't use '-$opt' and '-delete $opt' at the same time\n"
 474                     if defined($param->{$opt});
 475
 476                 if (!PVE::QemuServer::option_exists($opt)) {
 477                     raise_param_exc({ delete => "unknown option '$opt'" });
 478                 }
 479
 480                 next if !defined($conf->{$opt});
 481
 482                 die "error hot-unplug $opt" if !PVE::QemuServer::vm_deviceunplug($vmid, $conf, $opt);
 483
 484                 #drive
 485                 if (PVE::QemuServer::valid_drivename($opt)) {
 486                     my $drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt});
 487                     #hdd
 488                     if (!PVE::QemuServer::drive_is_cdrom($drive)) {
 489                         my $volid = $drive->{file};
 490
 491                         if ($volid !~  m|^/|) {
 492                             my ($path, $owner);
 493                             eval { ($path, $owner) = PVE::Storage::path($storecfg, $volid); };
 494                             if ($owner && ($owner == $vmid)) {
 495                                 if ($force) {
 496                                     eval { PVE::Storage::vdisk_free($storecfg, $volid); };
 497                                     # fixme: log ?
 498                                     warn $@ if $@;
 499                                 } else {
 500                                     PVE::QemuServer::add_unused_volume($conf, $volid, $vmid);
 501                                 }
 502                             }
 503                         }
 504                     }
 505                 } elsif ($opt =~ m/^unused/) {
 506                     my $drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt});
 507                     my $volid = $drive->{file};
 508                     eval { PVE::Storage::vdisk_free($storecfg, $volid); };
 509                     # fixme: log ?
 510                     warn $@ if $@;
 511                 }
 512
 513                 PVE::QemuServer::change_config_nolock($vmid, {}, { $opt => 1 }, 1);
 514             }
 515
 516             #add
 517             foreach my $opt (keys %$param) {
 518
 519                 #drives
 520                 if (PVE::QemuServer::valid_drivename($opt)) {
 521                     my $drive = PVE::QemuServer::parse_drive($opt, $param->{$opt});
 522                     raise_param_exc({ $opt => "unable to parse drive options" }) if !$drive;
 523
 524                     PVE::QemuServer::cleanup_drive_path($opt, $storecfg, $drive);
 525                     $param->{$opt} = PVE::QemuServer::print_drive($vmid, $drive);
 526
 527                     #cdrom
 528                     if (PVE::QemuServer::drive_is_cdrom($drive) && PVE::QemuServer::check_running($vmid)) {
 529                         if ($drive->{file} eq 'none') {
 530                             PVE::QemuServer::vm_monitor_command($vmid, "eject -f drive-$opt", 0);
 531                             #delete $param->{$opt};
 532                         }
 533                         else {
 534                             my $path = PVE::QemuServer::get_iso_path($storecfg, $vmid, $drive->{file});
 535                             PVE::QemuServer::vm_monitor_command($vmid, "eject -f drive-$opt", 0); #force eject if locked
 536                             PVE::QemuServer::vm_monitor_command($vmid, "change drive-$opt \"$path\"", 0) if $path;
 537                         }
 538                     }
 539                     #hdd
 540                     else {
 541                         #swap drive
 542                         if ($conf->{$opt}){
 543                             my $old_drive = PVE::QemuServer::parse_drive($opt, $conf->{$opt});
 544                             if ($drive->{file} ne $old_drive->{file} && !PVE::QemuServer::drive_is_cdrom($old_drive)) {
 545
 546                                 my ($path, $owner);
 547                                 eval { ($path, $owner) = PVE::Storage::path($storecfg, $old_drive->{file}); };
 548                                 if ($owner && ($owner == $vmid)) {
 549                                     die "error hot-unplug $opt" if !PVE::QemuServer::vm_deviceunplug($vmid, $conf, $opt);
 550                                     PVE::QemuServer::add_unused_volume($conf, $old_drive->{file}, $vmid);
 551                                 }
 552                             }
 553                         }
 554                         my $settings = { $opt => $param->{$opt} };
 555                         PVE::QemuServer::create_disks($storecfg, $vmid, $settings, $conf);
 556                         $param->{$opt} = $settings->{$opt};
 557                         #hotplug disks
 558                         if(!PVE::QemuServer::vm_deviceplug($storecfg, $conf, $vmid, $opt, $drive)) {
 559                             PVE::QemuServer::add_unused_volume($conf,$drive->{file},$vmid);
 560                             PVE::QemuServer::change_config_nolock($vmid, {}, { $opt => 1 }, 1);
 561                             die "error hotplug $opt - put disk in unused";
 562                         }
 563                     }
 564                 }
 565                 #nics
 566                 my $net = undef;
 567                 if ($opt =~ m/^net(\d+)$/) {
 568                     $net = PVE::QemuServer::parse_net($param->{$opt});
 569                     $param->{$opt} = PVE::QemuServer::print_net($net);
 570                     #if online update, then unplug first
 571                     die "error hot-unplug $opt for update" if $conf->{$opt} && !PVE::QemuServer::vm_deviceunplug($vmid, $conf, $opt);
 572                 }
 573
 574                 PVE::QemuServer::change_config_nolock($vmid, { $opt => $param->{$opt} }, {}, 1);
 575
 576                 #nic hotplug after config write as we need it for pve-bridge script
 577                 if (defined ($net)) {
 578                     if(!PVE::QemuServer::vm_deviceplug($storecfg, $conf, $vmid, $opt, $net)) {
 579                     #rewrite conf to remove nic if hotplug fail
 580                     PVE::QemuServer::change_config_nolock($vmid, {}, { $opt => 1 }, 1);
 581                     die "error hotplug $opt";
 582                     }
 583                 }
 584             }
 585         };
 586
 587         PVE::QemuServer::lock_config($vmid, $updatefn);
 588
 589         return undef;
 590     }});
 591
 592
 593 __PACKAGE__->register_method({
 594     name => 'destroy_vm',
 595     path => '{vmid}',
 596     method => 'DELETE',
 597     protected => 1,
 598     proxyto => 'node',
 599     description => "Destroy the vm (also delete all used/owned volumes).",
 600     parameters => {
 601         additionalProperties => 0,
 602         properties => {
 603             node => get_standard_option('pve-node'),
 604             vmid => get_standard_option('pve-vmid'),
 605             skiplock => get_standard_option('skiplock'),
 606         },
 607     },
 608     returns => {
 609         type => 'string',
 610     },
 611     code => sub {
 612         my ($param) = @_;
 613
 614         my $rpcenv = PVE::RPCEnvironment::get();
 615
 616         my $user = $rpcenv->get_user();
 617
 618         my $vmid = $param->{vmid};
 619
 620         my $skiplock = $param->{skiplock};
 621         raise_param_exc({ skiplock => "Only root may use this option." })
 622             if $skiplock && $user ne 'root@pam';
 623
 624         # test if VM exists
 625         my $conf = PVE::QemuServer::load_config($vmid);
 626
 627         my $storecfg = PVE::Storage::config();
 628
 629         my $realcmd = sub {
 630             my $upid = shift;
 631
 632             syslog('info', "destroy VM $vmid: $upid\n");
 633
 634             PVE::QemuServer::vm_destroy($storecfg, $vmid, $skiplock);
 635         };
 636
 637         return $rpcenv->fork_worker('qmdestroy', $vmid, $user, $realcmd);
 638     }});
 639
 640 __PACKAGE__->register_method({
 641     name => 'unlink',
 642     path => '{vmid}/unlink',
 643     method => 'PUT',
 644     protected => 1,
 645     proxyto => 'node',
 646     description => "Unlink/delete disk images.",
 647     parameters => {
 648         additionalProperties => 0,
 649         properties => {
 650             node => get_standard_option('pve-node'),
 651             vmid => get_standard_option('pve-vmid'),
 652             idlist => {
 653                 type => 'string', format => 'pve-configid-list',
 654                 description => "A list of disk IDs you want to delete.",
 655             },
 656             force => {
 657                 type => 'boolean',
 658                 description => $opt_force_description,
 659                 optional => 1,
 660             },
 661         },
 662     },
 663     returns => { type => 'null'},
 664     code => sub {
 665         my ($param) = @_;
 666
 667         $param->{delete} = extract_param($param, 'idlist');
 668
 669         __PACKAGE__->update_vm($param);
 670
 671         return undef;
 672     }});
 673
 674 my $sslcert;
 675
 676 __PACKAGE__->register_method({
 677     name => 'vncproxy',
 678     path => '{vmid}/vncproxy',
 679     method => 'POST',
 680     protected => 1,
 681     permissions => {
 682         check => ['perm', '/vms/{vmid}', [ 'VM.Console' ]],
 683     },
 684     description => "Creates a TCP VNC proxy connections.",
 685     parameters => {
 686         additionalProperties => 0,
 687         properties => {
 688             node => get_standard_option('pve-node'),
 689             vmid => get_standard_option('pve-vmid'),
 690         },
 691     },
 692     returns => {
 693         additionalProperties => 0,
 694         properties => {
 695             user => { type => 'string' },
 696             ticket => { type => 'string' },
 697             cert => { type => 'string' },
 698             port => { type => 'integer' },
 699             upid => { type => 'string' },
 700         },
 701     },
 702     code => sub {
 703         my ($param) = @_;
 704
 705         my $rpcenv = PVE::RPCEnvironment::get();
 706
 707         my $user = $rpcenv->get_user();
 708
 709         my $vmid = $param->{vmid};
 710         my $node = $param->{node};
 711
 712         my $authpath = "/vms/$vmid";
 713
 714         my $ticket = PVE::AccessControl::assemble_vnc_ticket($user, $authpath);
 715
 716         $sslcert = PVE::Tools::file_get_contents("/etc/pve/pve-root-ca.pem", 8192)
 717             if !$sslcert;
 718
 719         my $port = PVE::Tools::next_vnc_port();
 720
 721         my $remip;
 722
 723         if ($node ne 'localhost' && $node ne PVE::INotify::nodename()) {
 724             $remip = PVE::Cluster::remote_node_ip($node);
 725         }
 726
 727         # NOTE: kvm VNC traffic is already TLS encrypted,
 728         # so we select the fastest chipher here (or 'none'?)
 729         my $remcmd = $remip ? ['/usr/bin/ssh', '-T', '-o', 'BatchMode=yes',
 730                                '-c', 'blowfish-cbc', $remip] : [];
 731
 732         my $timeout = 10;
 733
 734         my $realcmd = sub {
 735             my $upid = shift;
 736
 737             syslog('info', "starting vnc proxy $upid\n");
 738
 739             my $qmcmd = [@$remcmd, "/usr/sbin/qm", 'vncproxy', $vmid];
 740
 741             my $qmstr = join(' ', @$qmcmd);
 742
 743             # also redirect stderr (else we get RFB protocol errors)
 744             my $cmd = ['/bin/nc', '-l', '-p', $port, '-w', $timeout, '-c', "$qmstr 2>/dev/null"];
 745
 746             PVE::Tools::run_command($cmd);
 747
 748             return;
 749         };
 750
 751         my $upid = $rpcenv->fork_worker('vncproxy', $vmid, $user, $realcmd);
 752
 753         return {
 754             user => $user,
 755             ticket => $ticket,
 756             port => $port,
 757             upid => $upid,
 758             cert => $sslcert,
 759         };
 760     }});
 761
 762 __PACKAGE__->register_method({
 763     name => 'vmcmdidx',
 764     path => '{vmid}/status',
 765     method => 'GET',
 766     proxyto => 'node',
 767     description => "Directory index",
 768     parameters => {
 769         additionalProperties => 0,
 770         properties => {
 771             node => get_standard_option('pve-node'),
 772             vmid => get_standard_option('pve-vmid'),
 773         },
 774     },
 775     returns => {
 776         type => 'array',
 777         items => {
 778             type => "object",
 779             properties => {
 780                 subdir => { type => 'string' },
 781             },
 782         },
 783         links => [ { rel => 'child', href => "{subdir}" } ],
 784     },
 785     code => sub {
 786         my ($param) = @_;
 787
 788         # test if VM exists
 789         my $conf = PVE::QemuServer::load_config($param->{vmid});
 790
 791         my $res = [
 792             { subdir => 'current' },
 793             { subdir => 'start' },
 794             { subdir => 'stop' },
 795             ];
 796
 797         return $res;
 798     }});
 799
 800 __PACKAGE__->register_method({
 801     name => 'vm_status',
 802     path => '{vmid}/status/current',
 803     method => 'GET',
 804     proxyto => 'node',
 805     protected => 1, # qemu pid files are only readable by root
 806     description => "Get virtual machine status.",
 807     parameters => {
 808         additionalProperties => 0,
 809         properties => {
 810             node => get_standard_option('pve-node'),
 811             vmid => get_standard_option('pve-vmid'),
 812         },
 813     },
 814     returns => { type => 'object' },
 815     code => sub {
 816         my ($param) = @_;
 817
 818         # test if VM exists
 819         my $conf = PVE::QemuServer::load_config($param->{vmid});
 820
 821         my $vmstatus = PVE::QemuServer::vmstatus($param->{vmid});
 822         my $status = $vmstatus->{$param->{vmid}};
 823
 824         my $cc = PVE::Cluster::cfs_read_file('cluster.conf');
 825         if (PVE::Cluster::cluster_conf_lookup_pvevm($cc, 0, $param->{vmid}, 1)) {
 826             $status->{ha} = 1;
 827         } else {
 828             $status->{ha} = 0;
 829         }
 830
 831         return $status;
 832     }});
 833
 834 __PACKAGE__->register_method({
 835     name => 'vm_start',
 836     path => '{vmid}/status/start',
 837     method => 'POST',
 838     protected => 1,
 839     proxyto => 'node',
 840     description => "Start virtual machine.",
 841     parameters => {
 842         additionalProperties => 0,
 843         properties => {
 844             node => get_standard_option('pve-node'),
 845             vmid => get_standard_option('pve-vmid'),
 846             skiplock => get_standard_option('skiplock'),
 847             stateuri => get_standard_option('pve-qm-stateuri'),
 848         },
 849     },
 850     returns => {
 851         type => 'string',
 852     },
 853     code => sub {
 854         my ($param) = @_;
 855
 856         my $rpcenv = PVE::RPCEnvironment::get();
 857
 858         my $user = $rpcenv->get_user();
 859
 860         my $node = extract_param($param, 'node');
 861
 862         my $vmid = extract_param($param, 'vmid');
 863
 864         my $stateuri = extract_param($param, 'stateuri');
 865         raise_param_exc({ stateuri => "Only root may use this option." })
 866             if $stateuri && $user ne 'root@pam';
 867
 868         my $skiplock = extract_param($param, 'skiplock');
 869         raise_param_exc({ skiplock => "Only root may use this option." })
 870             if $skiplock && $user ne 'root@pam';
 871
 872         my $storecfg = PVE::Storage::config();
 873
 874         my $realcmd = sub {
 875             my $upid = shift;
 876
 877             syslog('info', "start VM $vmid: $upid\n");
 878
 879             PVE::QemuServer::vm_start($storecfg, $vmid, $stateuri, $skiplock);
 880
 881             return;
 882         };
 883
 884         return $rpcenv->fork_worker('qmstart', $vmid, $user, $realcmd);
 885     }});
 886
 887 __PACKAGE__->register_method({
 888     name => 'vm_stop',
 889     path => '{vmid}/status/stop',
 890     method => 'POST',
 891     protected => 1,
 892     proxyto => 'node',
 893     description => "Stop virtual machine.",
 894     parameters => {
 895         additionalProperties => 0,
 896         properties => {
 897             node => get_standard_option('pve-node'),
 898             vmid => get_standard_option('pve-vmid'),
 899             skiplock => get_standard_option('skiplock'),
 900             timeout => {
 901                 description => "Wait maximal timeout seconds.",
 902                 type => 'integer',
 903                 minimum => 0,
 904                 optional => 1,
 905             },
 906             keepActive => {
 907                 description => "Do not decativate storage volumes.",
 908                 type => 'boolean',
 909                 optional => 1,
 910                 default => 0,
 911             }
 912         },
 913     },
 914     returns => {
 915         type => 'string',
 916     },
 917     code => sub {
 918         my ($param) = @_;
 919
 920         my $rpcenv = PVE::RPCEnvironment::get();
 921
 922         my $user = $rpcenv->get_user();
 923
 924         my $node = extract_param($param, 'node');
 925
 926         my $vmid = extract_param($param, 'vmid');
 927
 928         my $skiplock = extract_param($param, 'skiplock');
 929         raise_param_exc({ skiplock => "Only root may use this option." })
 930             if $skiplock && $user ne 'root@pam';
 931
 932         my $keepActive = extract_param($param, 'keepActive');
 933         raise_param_exc({ keepActive => "Only root may use this option." })
 934             if $keepActive && $user ne 'root@pam';
 935
 936         my $storecfg = PVE::Storage::config();
 937
 938         my $realcmd = sub {
 939             my $upid = shift;
 940
 941             syslog('info', "stop VM $vmid: $upid\n");
 942
 943             PVE::QemuServer::vm_stop($storecfg, $vmid, $skiplock, 0,
 944                                      $param->{timeout}, 0, 1, $keepActive);
 945
 946             return;
 947         };
 948
 949         return $rpcenv->fork_worker('qmstop', $vmid, $user, $realcmd);
 950     }});
 951
 952 __PACKAGE__->register_method({
 953     name => 'vm_reset',
 954     path => '{vmid}/status/reset',
 955     method => 'POST',
 956     protected => 1,
 957     proxyto => 'node',
 958     description => "Reset virtual machine.",
 959     parameters => {
 960         additionalProperties => 0,
 961         properties => {
 962             node => get_standard_option('pve-node'),
 963             vmid => get_standard_option('pve-vmid'),
 964             skiplock => get_standard_option('skiplock'),
 965         },
 966     },
 967     returns => {
 968         type => 'string',
 969     },
 970     code => sub {
 971         my ($param) = @_;
 972
 973         my $rpcenv = PVE::RPCEnvironment::get();
 974
 975         my $user = $rpcenv->get_user();
 976
 977         my $node = extract_param($param, 'node');
 978
 979         my $vmid = extract_param($param, 'vmid');
 980
 981         my $skiplock = extract_param($param, 'skiplock');
 982         raise_param_exc({ skiplock => "Only root may use this option." })
 983             if $skiplock && $user ne 'root@pam';
 984
 985         die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid);
 986
 987         my $realcmd = sub {
 988             my $upid = shift;
 989
 990             PVE::QemuServer::vm_reset($vmid, $skiplock);
 991
 992             return;
 993         };
 994
 995         return $rpcenv->fork_worker('qmreset', $vmid, $user, $realcmd);
 996     }});
 997
 998 __PACKAGE__->register_method({
 999     name => 'vm_shutdown',
1000     path => '{vmid}/status/shutdown',
1001     method => 'POST',
1002     protected => 1,
1003     proxyto => 'node',
1004     description => "Shutdown virtual machine.",
1005     parameters => {
1006         additionalProperties => 0,
1007         properties => {
1008             node => get_standard_option('pve-node'),
1009             vmid => get_standard_option('pve-vmid'),
1010             skiplock => get_standard_option('skiplock'),
1011             timeout => {
1012                 description => "Wait maximal timeout seconds.",
1013                 type => 'integer',
1014                 minimum => 0,
1015                 optional => 1,
1016             },
1017             forceStop => {
1018                 description => "Make sure the VM stops.",
1019                 type => 'boolean',
1020                 optional => 1,
1021                 default => 0,
1022             },
1023             keepActive => {
1024                 description => "Do not decativate storage volumes.",
1025                 type => 'boolean',
1026                 optional => 1,
1027                 default => 0,
1028             }
1029         },
1030     },
1031     returns => {
1032         type => 'string',
1033     },
1034     code => sub {
1035         my ($param) = @_;
1036
1037         my $rpcenv = PVE::RPCEnvironment::get();
1038
1039         my $user = $rpcenv->get_user();
1040
1041         my $node = extract_param($param, 'node');
1042
1043         my $vmid = extract_param($param, 'vmid');
1044
1045         my $skiplock = extract_param($param, 'skiplock');
1046         raise_param_exc({ skiplock => "Only root may use this option." })
1047             if $skiplock && $user ne 'root@pam';
1048
1049         my $keepActive = extract_param($param, 'keepActive');
1050         raise_param_exc({ keepActive => "Only root may use this option." })
1051             if $keepActive && $user ne 'root@pam';
1052
1053         my $storecfg = PVE::Storage::config();
1054
1055         my $realcmd = sub {
1056             my $upid = shift;
1057
1058             syslog('info', "shutdown VM $vmid: $upid\n");
1059
1060             PVE::QemuServer::vm_stop($storecfg, $vmid, $skiplock, 0, $param->{timeout},
1061                                      1, $param->{forceStop}, $keepActive);
1062
1063             return;
1064         };
1065
1066         return $rpcenv->fork_worker('qmshutdown', $vmid, $user, $realcmd);
1067     }});
1068
1069 __PACKAGE__->register_method({
1070     name => 'vm_suspend',
1071     path => '{vmid}/status/suspend',
1072     method => 'POST',
1073     protected => 1,
1074     proxyto => 'node',
1075     description => "Suspend virtual machine.",
1076     parameters => {
1077         additionalProperties => 0,
1078         properties => {
1079             node => get_standard_option('pve-node'),
1080             vmid => get_standard_option('pve-vmid'),
1081             skiplock => get_standard_option('skiplock'),
1082         },
1083     },
1084     returns => {
1085         type => 'string',
1086     },
1087     code => sub {
1088         my ($param) = @_;
1089
1090         my $rpcenv = PVE::RPCEnvironment::get();
1091
1092         my $user = $rpcenv->get_user();
1093
1094         my $node = extract_param($param, 'node');
1095
1096         my $vmid = extract_param($param, 'vmid');
1097
1098         my $skiplock = extract_param($param, 'skiplock');
1099         raise_param_exc({ skiplock => "Only root may use this option." })
1100             if $skiplock && $user ne 'root@pam';
1101
1102         die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid);
1103
1104         my $realcmd = sub {
1105             my $upid = shift;
1106
1107             syslog('info', "suspend VM $vmid: $upid\n");
1108
1109             PVE::QemuServer::vm_suspend($vmid, $skiplock);
1110
1111             return;
1112         };
1113
1114         return $rpcenv->fork_worker('qmsuspend', $vmid, $user, $realcmd);
1115     }});
1116
1117 __PACKAGE__->register_method({
1118     name => 'vm_resume',
1119     path => '{vmid}/status/resume',
1120     method => 'POST',
1121     protected => 1,
1122     proxyto => 'node',
1123     description => "Resume virtual machine.",
1124     parameters => {
1125         additionalProperties => 0,
1126         properties => {
1127             node => get_standard_option('pve-node'),
1128             vmid => get_standard_option('pve-vmid'),
1129             skiplock => get_standard_option('skiplock'),
1130         },
1131     },
1132     returns => {
1133         type => 'string',
1134     },
1135     code => sub {
1136         my ($param) = @_;
1137
1138         my $rpcenv = PVE::RPCEnvironment::get();
1139
1140         my $user = $rpcenv->get_user();
1141
1142         my $node = extract_param($param, 'node');
1143
1144         my $vmid = extract_param($param, 'vmid');
1145
1146         my $skiplock = extract_param($param, 'skiplock');
1147         raise_param_exc({ skiplock => "Only root may use this option." })
1148             if $skiplock && $user ne 'root@pam';
1149
1150         die "VM $vmid not running\n" if !PVE::QemuServer::check_running($vmid);
1151
1152         my $realcmd = sub {
1153             my $upid = shift;
1154
1155             syslog('info', "resume VM $vmid: $upid\n");
1156
1157             PVE::QemuServer::vm_resume($vmid, $skiplock);
1158
1159             return;
1160         };
1161
1162         return $rpcenv->fork_worker('qmresume', $vmid, $user, $realcmd);
1163     }});
1164
1165 __PACKAGE__->register_method({
1166     name => 'vm_sendkey',
1167     path => '{vmid}/sendkey',
1168     method => 'PUT',
1169     protected => 1,
1170     proxyto => 'node',
1171     description => "Send key event to virtual machine.",
1172     parameters => {
1173         additionalProperties => 0,
1174         properties => {
1175             node => get_standard_option('pve-node'),
1176             vmid => get_standard_option('pve-vmid'),
1177             skiplock => get_standard_option('skiplock'),
1178             key => {
1179                 description => "The key (qemu monitor encoding).",
1180                 type => 'string'
1181             }
1182         },
1183     },
1184     returns => { type => 'null'},
1185     code => sub {
1186         my ($param) = @_;
1187
1188         my $rpcenv = PVE::RPCEnvironment::get();
1189
1190         my $user = $rpcenv->get_user();
1191
1192         my $node = extract_param($param, 'node');
1193
1194         my $vmid = extract_param($param, 'vmid');
1195
1196         my $skiplock = extract_param($param, 'skiplock');
1197         raise_param_exc({ skiplock => "Only root may use this option." })
1198             if $skiplock && $user ne 'root@pam';
1199
1200         PVE::QemuServer::vm_sendkey($vmid, $skiplock, $param->{key});
1201
1202         return;
1203     }});
1204
1205 __PACKAGE__->register_method({
1206     name => 'migrate_vm',
1207     path => '{vmid}/migrate',
1208     method => 'POST',
1209     protected => 1,
1210     proxyto => 'node',
1211     description => "Migrate virtual machine. Creates a new migration task.",
1212     parameters => {
1213         additionalProperties => 0,
1214         properties => {
1215             node => get_standard_option('pve-node'),
1216             vmid => get_standard_option('pve-vmid'),
1217             target => get_standard_option('pve-node', { description => "Target node." }),
1218             online => {
1219                 type => 'boolean',
1220                 description => "Use online/live migration.",
1221                 optional => 1,
1222             },
1223             force => {
1224                 type => 'boolean',
1225                 description => "Allow to migrate VMs which use local devices. Only root may use this option.",
1226                 optional => 1,
1227             },
1228         },
1229     },
1230     returns => {
1231         type => 'string',
1232         description => "the task ID.",
1233     },
1234     code => sub {
1235         my ($param) = @_;
1236
1237         my $rpcenv = PVE::RPCEnvironment::get();
1238
1239         my $user = $rpcenv->get_user();
1240
1241         my $target = extract_param($param, 'target');
1242
1243         my $localnode = PVE::INotify::nodename();
1244         raise_param_exc({ target => "target is local node."}) if $target eq $localnode;
1245
1246         PVE::Cluster::check_cfs_quorum();
1247
1248         PVE::Cluster::check_node_exists($target);
1249
1250         my $targetip = PVE::Cluster::remote_node_ip($target);
1251
1252         my $vmid = extract_param($param, 'vmid');
1253
1254         raise_param_exc({ force => "Only root may use this option." })
1255             if $param->{force} && $user ne 'root@pam';
1256
1257         # test if VM exists
1258         my $conf = PVE::QemuServer::load_config($vmid);
1259
1260         # try to detect errors early
1261
1262         PVE::QemuServer::check_lock($conf);
1263
1264         if (PVE::QemuServer::check_running($vmid)) {
1265             die "cant migrate running VM without --online\n"
1266                 if !$param->{online};
1267         }
1268
1269         my $realcmd = sub {
1270             my $upid = shift;
1271
1272             PVE::QemuMigrate->migrate($target, $targetip, $vmid, $param);
1273         };
1274
1275         my $upid = $rpcenv->fork_worker('qmigrate', $vmid, $user, $realcmd);
1276
1277         return $upid;
1278     }});
1279
1280 __PACKAGE__->register_method({
1281     name => 'monitor',
1282     path => '{vmid}/monitor',
1283     method => 'POST',
1284     protected => 1,
1285     proxyto => 'node',
1286     description => "Execute Qemu monitor commands.",
1287     parameters => {
1288         additionalProperties => 0,
1289         properties => {
1290             node => get_standard_option('pve-node'),
1291             vmid => get_standard_option('pve-vmid'),
1292             command => {
1293                 type => 'string',
1294                 description => "The monitor command.",
1295             }
1296         },
1297     },
1298     returns => { type => 'string'},
1299     code => sub {
1300         my ($param) = @_;
1301
1302         my $vmid = $param->{vmid};
1303
1304         my $conf = PVE::QemuServer::load_config ($vmid); # check if VM exists
1305
1306         my $res = '';
1307         eval {
1308             $res = PVE::QemuServer::vm_monitor_command($vmid, $param->{command});
1309         };
1310         $res = "ERROR: $@" if $@;
1311
1312         return $res;
1313     }});
1314
1315 1;