X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=PVE%2FCLI%2Fqm.pm;h=b105830fa6f558e0efae0eb6efe66a764cc6b066;hb=HEAD;hp=6abf6dbc3db12de840729f2aa26348ede168a939;hpb=788a6a35da73e350fbc06d20ff889bb0bd76523b;p=qemu-server.git diff --git a/PVE/CLI/qm.pm b/PVE/CLI/qm.pm index 6abf6db..b105830 100755 --- a/PVE/CLI/qm.pm +++ b/PVE/CLI/qm.pm @@ -8,31 +8,50 @@ use Getopt::Long qw(:config no_getopt_compat); use Fcntl ':flock'; use File::Path; -use IO::Socket::UNIX; use IO::Select; +use IO::Socket::UNIX; +use JSON; +use POSIX qw(strftime); +use Term::ReadLine; +use URI::Escape; -use PVE::Tools qw(extract_param); +use PVE::APIClient::LWP; use PVE::Cluster; -use PVE::SafeSyslog; +use PVE::Exception qw(raise_param_exc); +use PVE::GuestHelpers; use PVE::INotify; +use PVE::JSONSchema qw(get_standard_option); +use PVE::Network; use PVE::RPCEnvironment; -use PVE::QemuServer; +use PVE::SafeSyslog; +use PVE::Tools qw(extract_param file_get_contents); + +use PVE::API2::Qemu::Agent; use PVE::API2::Qemu; -use JSON; -use PVE::JSONSchema qw(get_standard_option); -use Term::ReadLine; +use PVE::QemuConfig; +use PVE::QemuServer::Drive; +use PVE::QemuServer::Helpers; +use PVE::QemuServer::Agent qw(agent_available); +use PVE::QemuServer::ImportDisk; +use PVE::QemuServer::Monitor qw(mon_cmd); +use PVE::QemuServer::OVF; +use PVE::QemuServer; use PVE::CLIHandler; - use base qw(PVE::CLIHandler); my $upid_exit = sub { my $upid = shift; my $status = PVE::Tools::upid_read_status($upid); - exit($status eq 'OK' ? 0 : -1); + exit(PVE::Tools::upid_status_is_error($status) ? -1 : 0); }; my $nodename = PVE::INotify::nodename(); +my %node = (node => $nodename); + +sub setup_environment { + PVE::RPCEnvironment->setup_default_cli_env(); +} sub run_vnc_proxy { my ($path) = @_; @@ -44,7 +63,7 @@ sub run_vnc_proxy { die "unable to connect to socket '$path' - $!" if !$s; - my $select = new IO::Select; + my $select = IO::Select->new(); $select->add(\*STDIN); $select->add($s); @@ -83,17 +102,17 @@ sub print_recursive_hash { if (defined($key)) { print "$prefix$key:\n"; } - foreach my $itemkey (keys %$hash) { + for my $itemkey (sort keys %$hash) { print_recursive_hash("\t$prefix", $hash->{$itemkey}, $itemkey); } } elsif (ref($hash) eq 'ARRAY') { if (defined($key)) { print "$prefix$key:\n"; } - foreach my $item (@$hash) { + for my $item (@$hash) { print_recursive_hash("\t$prefix", $item); } - } elsif (!ref($hash) && defined($hash)) { + } elsif ((!ref($hash) && defined($hash)) || ref($hash) eq 'JSON::PP::Boolean') { if (defined($key)) { print "$prefix$key: $hash\n"; } else { @@ -111,6 +130,20 @@ __PACKAGE__->register_method ({ additionalProperties => 0, properties => { vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }), + pretty => { + description => "Puts each option on a new line to enhance human readability", + type => 'boolean', + optional => 1, + default => 0, + }, + snapshot => get_standard_option('pve-snapshot-name', { + description => "Fetch config values from given snapshot.", + optional => 1, + completion => sub { + my ($cmd, $pname, $cur, $args) = @_; + PVE::QemuConfig->snapshot_list($args->[0]); + } + }), }, }, returns => { type => 'null'}, @@ -118,9 +151,124 @@ __PACKAGE__->register_method ({ my ($param) = @_; my $storecfg = PVE::Storage::config(); - print PVE::QemuServer::vm_commandline($storecfg, $param->{vmid}) . "\n"; + my $cmdline = PVE::QemuServer::vm_commandline($storecfg, $param->{vmid}, $param->{snapshot}); + + $cmdline =~ s/ -/ \\\n -/g if $param->{pretty}; + + print "$cmdline\n"; + + return; + }}); + + +__PACKAGE__->register_method({ + name => 'remote_migrate_vm', + path => 'remote_migrate_vm', + method => 'POST', + description => "Migrate virtual machine to a remote cluster. Creates a new migration task. EXPERIMENTAL feature!", + permissions => { + check => ['perm', '/vms/{vmid}', [ 'VM.Migrate' ]], + }, + parameters => { + additionalProperties => 0, + properties => { + node => get_standard_option('pve-node'), + vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }), + 'target-vmid' => get_standard_option('pve-vmid', { optional => 1 }), + 'target-endpoint' => get_standard_option('proxmox-remote', { + description => "Remote target endpoint", + }), + online => { + type => 'boolean', + description => "Use online/live migration if VM is running. Ignored if VM is stopped.", + optional => 1, + }, + delete => { + type => 'boolean', + description => "Delete the original VM and related data after successful migration. By default the original VM is kept on the source cluster in a stopped state.", + optional => 1, + default => 0, + }, + 'target-storage' => get_standard_option('pve-targetstorage', { + completion => \&PVE::QemuServer::complete_migration_storage, + optional => 0, + }), + 'target-bridge' => { + type => 'string', + description => "Mapping from source to target bridges. Providing only a single bridge ID maps all source bridges to that bridge. Providing the special value '1' will map each source bridge to itself.", + format => 'bridge-pair-list', + }, + bwlimit => { + description => "Override I/O bandwidth limit (in KiB/s).", + optional => 1, + type => 'integer', + minimum => '0', + default => 'migrate limit from datacenter or storage config', + }, + }, + }, + returns => { + type => 'string', + description => "the task ID.", + }, + code => sub { + my ($param) = @_; + + my $rpcenv = PVE::RPCEnvironment::get(); + my $authuser = $rpcenv->get_user(); + + my $source_vmid = $param->{vmid}; + my $target_endpoint = $param->{'target-endpoint'}; + my $target_vmid = $param->{'target-vmid'} // $source_vmid; + + my $remote = PVE::JSONSchema::parse_property_string('proxmox-remote', $target_endpoint); + + # TODO: move this as helper somewhere appropriate? + my $conn_args = { + protocol => 'https', + host => $remote->{host}, + port => $remote->{port} // 8006, + apitoken => $remote->{apitoken}, + }; + + $conn_args->{cached_fingerprints} = { uc($remote->{fingerprint}) => 1 } + if defined($remote->{fingerprint}); + + my $api_client = PVE::APIClient::LWP->new(%$conn_args); + my $resources = $api_client->get("/cluster/resources", { type => 'vm' }); + if (grep { defined($_->{vmid}) && $_->{vmid} eq $target_vmid } @$resources) { + raise_param_exc({ target_vmid => "Guest with ID '$target_vmid' already exists on remote cluster" }); + } + + my $storages = $api_client->get("/nodes/localhost/storage", { enabled => 1 }); + + my $storecfg = PVE::Storage::config(); + my $target_storage = $param->{'target-storage'}; + my $storagemap = eval { PVE::JSONSchema::parse_idmap($target_storage, 'pve-storage-id') }; + raise_param_exc({ 'target-storage' => "failed to parse storage map: $@" }) + if $@; + + my $check_remote_storage = sub { + my ($storage) = @_; + my $found = [ grep { $_->{storage} eq $storage } @$storages ]; + die "remote: storage '$storage' does not exist (or missing permission)!\n" + if !@$found; + + $found = @$found[0]; + + my $content_types = [ PVE::Tools::split_list($found->{content}) ]; + die "remote: storage '$storage' cannot store images\n" + if !grep { $_ eq 'images' } @$content_types; + }; + + foreach my $target_sid (values %{$storagemap->{entries}}) { + $check_remote_storage->($target_sid); + } - return undef; + $check_remote_storage->($storagemap->{default}) + if $storagemap->{default}; + + return PVE::API2::Qemu->remote_migrate_vm($param); }}); __PACKAGE__->register_method ({ @@ -159,7 +307,7 @@ __PACKAGE__->register_method ({ print "status: $status\n"; } - return undef; + return; }}); __PACKAGE__->register_method ({ @@ -178,19 +326,19 @@ __PACKAGE__->register_method ({ my ($param) = @_; my $vmid = $param->{vmid}; - my $vnc_socket = PVE::QemuServer::vnc_socket($vmid); + PVE::QemuConfig::assert_config_exists_on_node($vmid); + my $vnc_socket = PVE::QemuServer::Helpers::vnc_socket($vmid); if (my $ticket = $ENV{LC_PVE_TICKET}) { # NOTE: ssh on debian only pass LC_* variables - PVE::QemuServer::vm_mon_cmd($vmid, "change", device => 'vnc', target => "unix:$vnc_socket,password"); - PVE::QemuServer::vm_mon_cmd($vmid, "set_password", protocol => 'vnc', password => $ticket); - PVE::QemuServer::vm_mon_cmd($vmid, "expire_password", protocol => 'vnc', time => "+30"); + mon_cmd($vmid, "set_password", protocol => 'vnc', password => $ticket); + mon_cmd($vmid, "expire_password", protocol => 'vnc', time => "+30"); } else { - PVE::QemuServer::vm_mon_cmd($vmid, "change", device => 'vnc', target => "unix:$vnc_socket,x509,password"); + die "LC_PVE_TICKET not set, VNC proxy without password is forbidden\n"; } run_vnc_proxy($vnc_socket); - return undef; + return; }}); __PACKAGE__->register_method ({ @@ -217,7 +365,30 @@ __PACKAGE__->register_method ({ PVE::QemuConfig->write_config($vmid, $conf); }); - return undef; + return; + }}); + +__PACKAGE__->register_method ({ + name => 'nbdstop', + path => 'nbdstop', + method => 'PUT', + description => "Stop embedded nbd server.", + parameters => { + additionalProperties => 0, + properties => { + vmid => get_standard_option('pve-vmid', { completion => \&PVE::QemuServer::complete_vmid }), + }, + }, + returns => { type => 'null'}, + code => sub { + my ($param) = @_; + + my $vmid = $param->{vmid}; + + eval { PVE::QemuServer::nbd_stop($vmid) }; + warn $@ if $@; + + return; }}); __PACKAGE__->register_method ({ @@ -235,18 +406,42 @@ __PACKAGE__->register_method ({ if (!PVE::Cluster::check_cfs_quorum(1)) { print "no quorum\n"; - return undef; + return; } - print "tunnel online\n"; - *STDOUT->flush(); + my $tunnel_write = sub { + my $text = shift; + chomp $text; + print "$text\n"; + *STDOUT->flush(); + }; + + $tunnel_write->("tunnel online"); + $tunnel_write->("ver 1"); - while (my $line = <>) { + while (my $line = ) { chomp $line; - last if $line =~ m/^quit$/; + if ($line =~ /^quit$/) { + $tunnel_write->("OK"); + last; + } elsif ($line =~ /^resume (\d+)$/) { + my $vmid = $1; + # check_running and vm_resume with nocheck, since local node + # might not have processed config move/rename yet + if (PVE::QemuServer::check_running($vmid, 1)) { + eval { PVE::QemuServer::vm_resume($vmid, 1, 1); }; + if ($@) { + $tunnel_write->("ERR: resume failed - $@"); + } else { + $tunnel_write->("OK"); + } + } else { + $tunnel_write->("ERR: resume failed - VM $vmid not running"); + } + } } - return undef; + return; }}); __PACKAGE__->register_method ({ @@ -286,14 +481,14 @@ __PACKAGE__->register_method ({ die "wait failed - got timeout\n" if PVE::QemuServer::check_running ($vmid); - return undef; + return; }}); __PACKAGE__->register_method ({ name => 'monitor', path => 'monitor', method => 'POST', - description => "Enter Qemu Monitor interface.", + description => "Enter QEMU Monitor interface.", parameters => { additionalProperties => 0, properties => { @@ -308,25 +503,20 @@ __PACKAGE__->register_method ({ my $conf = PVE::QemuConfig->load_config ($vmid); # check if VM exists - print "Entering Qemu Monitor for VM $vmid - type 'help' for help\n"; + print "Entering QEMU Monitor for VM $vmid - type 'help' for help\n"; - my $term = new Term::ReadLine ('qm'); + my $term = Term::ReadLine->new('qm'); - my $input; - while (defined ($input = $term->readline('qm> '))) { + while (defined(my $input = $term->readline('qm> '))) { chomp $input; - next if $input =~ m/^\s*$/; - last if $input =~ m/^\s*q(uit)?\s*$/; - eval { - print PVE::QemuServer::vm_human_monitor_command ($vmid, $input); - }; + eval { print PVE::QemuServer::Monitor::hmp_cmd($vmid, $input) }; print "ERROR: $@" if $@; } - return undef; + return; }}); @@ -342,15 +532,80 @@ __PACKAGE__->register_method ({ optional => 1, completion => \&PVE::QemuServer::complete_vmid, }), + dryrun => { + type => 'boolean', + optional => 1, + default => 0, + description => 'Do not actually write changes out to VM config(s).', + }, + }, + }, + returns => { type => 'null'}, + code => sub { + my ($param) = @_; + + my $dryrun = $param->{dryrun}; + + print "NOTE: running in dry-run mode, won't write changes out!\n" if $dryrun; + + PVE::QemuServer::rescan($param->{vmid}, 0, $dryrun); + + return; + }}); + +__PACKAGE__->register_method ({ + name => 'importdisk', + path => 'importdisk', + method => 'POST', + description => "Import an external disk image as an unused disk in a VM. The + image format has to be supported by qemu-img(1).", + parameters => { + additionalProperties => 0, + properties => { + vmid => get_standard_option('pve-vmid', {completion => \&PVE::QemuServer::complete_vmid}), + source => { + description => 'Path to the disk image to import', + type => 'string', + optional => 0, + }, + storage => get_standard_option('pve-storage-id', { + description => 'Target storage ID', + completion => \&PVE::QemuServer::complete_storage, + optional => 0, + }), + format => { + type => 'string', + description => 'Target format', + enum => [ 'raw', 'qcow2', 'vmdk' ], + optional => 1, + }, }, }, returns => { type => 'null'}, code => sub { my ($param) = @_; - PVE::QemuServer::rescan($param->{vmid}); + my $vmid = extract_param($param, 'vmid'); + my $source = extract_param($param, 'source'); + my $storeid = extract_param($param, 'storage'); + my $format = extract_param($param, 'format'); + + my $vm_conf = PVE::QemuConfig->load_config($vmid); + PVE::QemuConfig->check_lock($vm_conf); + die "$source: non-existent or non-regular file\n" if (! -f $source); + + my $storecfg = PVE::Storage::config(); + PVE::Storage::storage_check_enabled($storecfg, $storeid); + + my $target_storage_config = PVE::Storage::storage_config($storecfg, $storeid); + die "storage $storeid does not support vm images\n" + if !$target_storage_config->{content}->{images}; + + print "importing disk '$source' to VM $vmid ...\n"; + my ($drive_id, $volid) = PVE::QemuServer::ImportDisk::do_import($source, $vmid, $storeid, { format => $format }); + print "Successfully imported disk as '$drive_id:$volid'\n"; - return undef; + return; }}); __PACKAGE__->register_method ({ @@ -367,7 +622,13 @@ __PACKAGE__->register_method ({ type => 'string', optional => 1, enum => [qw(serial0 serial1 serial2 serial3)], - } + }, + escape => { + description => "Escape character.", + type => 'string', + optional => 1, + default => '^O', + }, }, }, returns => { type => 'null'}, @@ -376,6 +637,24 @@ __PACKAGE__->register_method ({ my $vmid = $param->{vmid}; + my $escape = $param->{escape} // '^O'; + if ($escape =~ /^\^([\x40-\x7a])$/) { + $escape = ord($1) & 0x1F; + } elsif ($escape =~ /^0x[0-9a-f]+$/i) { + $escape = hex($escape); + } elsif ($escape =~ /^[0-9]+$/) { + $escape = int($escape); + } else { + die "invalid escape character definition: $escape\n"; + } + my $escapemsg = ''; + if ($escape) { + $escapemsg = sprintf(' (press Ctrl+%c to exit)', $escape+0x40); + $escape = sprintf(',escape=0x%x', $escape); + } else { + $escape = ''; + } + my $conf = PVE::QemuConfig->load_config ($vmid); # check if VM exists my $iface = $param->{iface}; @@ -397,151 +676,480 @@ __PACKAGE__->register_method ({ my $socket = "/var/run/qemu-server/${vmid}.$iface"; - my $cmd = "socat UNIX-CONNECT:$socket STDIO,raw,echo=0,escape=0x0f"; + my $cmd = "socat UNIX-CONNECT:$socket STDIO,raw,echo=0$escape"; - print "starting serial terminal on interface $iface (press control-O to exit)\n"; + print "starting serial terminal on interface ${iface}${escapemsg}\n"; system($cmd); - return undef; + return; }}); +__PACKAGE__->register_method ({ + name => 'importovf', + path => 'importovf', + description => "Create a new VM using parameters read from an OVF manifest", + parameters => { + additionalProperties => 0, + properties => { + vmid => get_standard_option('pve-vmid', { completion => \&PVE::Cluster::complete_next_vmid }), + manifest => { + type => 'string', + description => 'path to the ovf file', + }, + storage => get_standard_option('pve-storage-id', { + description => 'Target storage ID', + completion => \&PVE::QemuServer::complete_storage, + optional => 0, + }), + format => { + type => 'string', + description => 'Target format', + enum => [ 'raw', 'qcow2', 'vmdk' ], + optional => 1, + }, + dryrun => { + type => 'boolean', + description => 'Print a parsed representation of the extracted OVF parameters, but do not create a VM', + optional => 1, + } + }, + }, + returns => { type => 'null' }, + code => sub { + my ($param) = @_; -my $print_agent_result = sub { - my ($data) = @_; + my $vmid = PVE::Tools::extract_param($param, 'vmid'); + my $ovf_file = PVE::Tools::extract_param($param, 'manifest'); + my $storeid = PVE::Tools::extract_param($param, 'storage'); + my $format = PVE::Tools::extract_param($param, 'format'); + my $dryrun = PVE::Tools::extract_param($param, 'dryrun'); - my $result = $data->{result}; - return if !defined($result); + die "$ovf_file: non-existent or non-regular file\n" if (! -f $ovf_file); + my $storecfg = PVE::Storage::config(); + PVE::Storage::storage_check_enabled($storecfg, $storeid); - my $class = ref($result); + my $parsed = PVE::QemuServer::OVF::parse_ovf($ovf_file); - if (!$class) { - chomp $result; - return if $result =~ m/^\s*$/; - print "$result\n"; - return; - } + if ($dryrun) { + print to_json($parsed, { pretty => 1, canonical => 1}); + return; + } + + eval { PVE::QemuConfig->create_and_lock_config($vmid) }; + die "Reserving empty config for OVF import to VM $vmid failed: $@" if $@; + + my $conf = PVE::QemuConfig->load_config($vmid); + die "Internal error: Expected 'create' lock in config of VM $vmid!" + if !PVE::QemuConfig->has_lock($conf, "create"); + + $conf->{name} = $parsed->{qm}->{name} if defined($parsed->{qm}->{name}); + $conf->{memory} = $parsed->{qm}->{memory} if defined($parsed->{qm}->{memory}); + $conf->{cores} = $parsed->{qm}->{cores} if defined($parsed->{qm}->{cores}); + + my $imported_disks = []; + eval { + # order matters, as do_import() will load_config() internally + $conf->{vmgenid} = PVE::QemuServer::generate_uuid(); + $conf->{smbios1} = PVE::QemuServer::generate_smbios1_uuid(); + PVE::QemuConfig->write_config($vmid, $conf); + + foreach my $disk (@{ $parsed->{disks} }) { + my ($file, $drive) = ($disk->{backing_file}, $disk->{disk_address}); + my ($name, $volid) = PVE::QemuServer::ImportDisk::do_import($file, $vmid, $storeid, { + drive_name => $drive, + format => $format, + skiplock => 1, + }); + # for cleanup on (later) error + push @$imported_disks, $volid; + } + + # reload after disks entries have been created + $conf = PVE::QemuConfig->load_config($vmid); + my $devs = PVE::QemuServer::get_default_bootdevices($conf); + $conf->{boot} = PVE::QemuServer::print_bootorder($devs); + PVE::QemuConfig->write_config($vmid, $conf); + }; + + if (my $err = $@) { + my $skiplock = 1; + warn "error during import, cleaning up created resources...\n"; + for my $volid (@$imported_disks) { + eval { PVE::Storage::vdisk_free($storecfg, $volid) }; + warn "cleanup of $volid failed: $@\n" if $@; + } + eval { PVE::QemuServer::destroy_vm($storecfg, $vmid, $skiplock) }; + warn "Could not destroy VM $vmid: $@" if "$@"; + die "import failed - $err"; + } + + PVE::QemuConfig->remove_lock($vmid, "create"); - if (($class eq 'HASH') && !scalar(keys %$result)) { # empty hash return; + } +}); - print to_json($result, { pretty => 1, canonical => 1}); -}; +__PACKAGE__->register_method({ + name => 'exec', + path => 'exec', + method => 'POST', + protected => 1, + description => "Executes the given command via the guest agent", + parameters => { + additionalProperties => 0, + properties => { + node => get_standard_option('pve-node'), + vmid => get_standard_option('pve-vmid', { + completion => \&PVE::QemuServer::complete_vmid_running }), + synchronous => { + type => 'boolean', + optional => 1, + default => 1, + description => "If set to off, returns the pid immediately instead of waiting for the commmand to finish or the timeout.", + }, + 'timeout' => { + type => 'integer', + description => "The maximum time to wait synchronously for the command to finish. If reached, the pid gets returned. Set to 0 to deactivate", + minimum => 0, + optional => 1, + default => 30, + }, + 'pass-stdin' => { + type => 'boolean', + description => "When set, read STDIN until EOF and forward to guest agent via 'input-data' (usually treated as STDIN to process launched by guest agent). Allows maximal 1 MiB.", + optional => 1, + default => 0, + }, + 'extra-args' => get_standard_option('extra-args'), + }, + }, + returns => { + type => 'object', + }, + code => sub { + my ($param) = @_; -our $cmddef = { - list => [ "PVE::API2::Qemu", 'vmlist', [], - { node => $nodename }, sub { - my $vmlist = shift; + my $vmid = $param->{vmid}; + my $sync = $param->{synchronous} // 1; + my $pass_stdin = $param->{'pass-stdin'}; + if (defined($param->{timeout}) && !$sync) { + raise_param_exc({ synchronous => "needs to be set for 'timeout'"}); + } - exit 0 if (!scalar(@$vmlist)); + my $input_data = undef; + if ($pass_stdin) { + $input_data = ''; + while (my $line = ) { + $input_data .= $line; + if (length($input_data) > 1024*1024) { + # not sure how QEMU handles large amounts of data being + # passed into the QMP socket, so limit to be safe + die "'input-data' (STDIN) is limited to 1 MiB, aborting\n"; + } + } + } - printf "%10s %-20s %-10s %-10s %12s %-10s\n", - qw(VMID NAME STATUS MEM(MB) BOOTDISK(GB) PID); + my $args = $param->{'extra-args'}; + $args = undef if !$args || !@$args; - foreach my $rec (sort { $a->{vmid} <=> $b->{vmid} } @$vmlist) { - printf "%10s %-20s %-10s %-10s %12.2f %-10s\n", $rec->{vmid}, $rec->{name}, - $rec->{qmpstatus} || $rec->{status}, - ($rec->{maxmem} || 0)/(1024*1024), - ($rec->{maxdisk} || 0)/(1024*1024*1024), - $rec->{pid}||0; - } + my $res = PVE::QemuServer::Agent::qemu_exec($vmid, $input_data, $args); + if ($sync) { + my $pid = $res->{pid}; + my $timeout = $param->{timeout} // 30; + my $starttime = time(); - } ], + while ($timeout == 0 || (time() - $starttime) < $timeout) { + my $out = PVE::QemuServer::Agent::qemu_exec_status($vmid, $pid); + if ($out->{exited}) { + $res = $out; + last; + } + sleep 1; + } - create => [ "PVE::API2::Qemu", 'create_vm', ['vmid'], { node => $nodename }, $upid_exit ], + if (!$res->{exited}) { + warn "timeout reached, returning pid\n"; + } + } - destroy => [ "PVE::API2::Qemu", 'destroy_vm', ['vmid'], { node => $nodename }, $upid_exit ], + return { result => $res }; + }}); - clone => [ "PVE::API2::Qemu", 'clone_vm', ['vmid', 'newid'], { node => $nodename }, $upid_exit ], +__PACKAGE__->register_method({ + name => 'cleanup', + path => 'cleanup', + method => 'POST', + protected => 1, + description => "Cleans up resources like tap devices, vgpus, etc. Called after a vm shuts down, crashes, etc.", + parameters => { + additionalProperties => 0, + properties => { + node => get_standard_option('pve-node'), + vmid => get_standard_option('pve-vmid', { + completion => \&PVE::QemuServer::complete_vmid_running }), + 'clean-shutdown' => { + type => 'boolean', + description => "Indicates if qemu shutdown cleanly.", + }, + 'guest-requested' => { + type => 'boolean', + description => "Indicates if the shutdown was requested by the guest or via qmp.", + }, + }, + }, + returns => { type => 'null', }, + code => sub { + my ($param) = @_; - migrate => [ "PVE::API2::Qemu", 'migrate_vm', ['vmid', 'target'], { node => $nodename }, $upid_exit ], + my $vmid = $param->{vmid}; + my $clean = $param->{'clean-shutdown'}; + my $guest = $param->{'guest-requested'}; + my $restart = 0; - set => [ "PVE::API2::Qemu", 'update_vm', ['vmid'], { node => $nodename } ], + # return if we do not have the config anymore + return if !-f PVE::QemuConfig->config_file($vmid); - resize => [ "PVE::API2::Qemu", 'resize_vm', ['vmid', 'disk', 'size'], { node => $nodename } ], + my $storecfg = PVE::Storage::config(); + warn "Starting cleanup for $vmid\n"; - move_disk => [ "PVE::API2::Qemu", 'move_vm_disk', ['vmid', 'disk', 'storage'], { node => $nodename }, $upid_exit ], + # mdev cleanup can take a while, so wait up to 60 seconds + PVE::QemuConfig->lock_config_full($vmid, 60, sub { + my $conf = PVE::QemuConfig->load_config ($vmid); + my $pid = PVE::QemuServer::check_running ($vmid); + die "vm still running\n" if $pid; - unlink => [ "PVE::API2::Qemu", 'unlink', ['vmid'], { node => $nodename } ], + if (!$clean) { + # we have to cleanup the tap devices after a crash - config => [ "PVE::API2::Qemu", 'vm_config', ['vmid'], - { node => $nodename }, sub { - my $config = shift; - foreach my $k (sort (keys %$config)) { - next if $k eq 'digest'; - my $v = $config->{$k}; - if ($k eq 'description') { - $v = PVE::Tools::encode_text($v); - } - print "$k: $v\n"; - } - }], - - pending => [ "PVE::API2::Qemu", 'vm_pending', ['vmid'], - { node => $nodename }, sub { - my $data = shift; - foreach my $item (sort { $a->{key} cmp $b->{key}} @$data) { - my $k = $item->{key}; - next if $k eq 'digest'; - my $v = $item->{value}; - my $p = $item->{pending}; - if ($k eq 'description') { - $v = PVE::Tools::encode_text($v) if defined($v); - $p = PVE::Tools::encode_text($p) if defined($p); - } - if (defined($v)) { - if ($item->{delete}) { - print "del $k: $v\n"; - } elsif (defined($p)) { - print "cur $k: $v\n"; - print "new $k: $p\n"; - } else { - print "cur $k: $v\n"; - } - } elsif (defined($p)) { - print "new $k: $p\n"; - } - } - }], + foreach my $opt (keys %$conf) { + next if $opt !~ m/^net(\d+)$/; + my $interface = $1; + PVE::Network::tap_unplug("tap${vmid}i${interface}"); + } + } - showcmd => [ __PACKAGE__, 'showcmd', ['vmid']], + if (!$clean || $guest) { + # vm was shutdown from inside the guest or crashed, doing api cleanup + PVE::QemuServer::vm_stop_cleanup($storecfg, $vmid, $conf, 0, 0); + } + PVE::GuestHelpers::exec_hookscript($conf, $vmid, 'post-stop'); - status => [ __PACKAGE__, 'status', ['vmid']], + $restart = eval { PVE::QemuServer::clear_reboot_request($vmid) }; + warn $@ if $@; + }); + + warn "Finished cleanup for $vmid\n"; + + if ($restart) { + warn "Restarting VM $vmid\n"; + PVE::API2::Qemu->vm_start({ + vmid => $vmid, + %node, + }); + } - snapshot => [ "PVE::API2::Qemu", 'snapshot', ['vmid', 'snapname'], { node => $nodename } , $upid_exit ], + return; + }}); + +__PACKAGE__->register_method({ + name => 'vm_import', + path => 'vm-import', + description => "Import a foreign virtual guest from a supported import source, such as an ESXi storage.", + parameters => { + additionalProperties => 0, + properties => PVE::QemuServer::json_config_properties({ + vmid => get_standard_option('pve-vmid', { completion => \&PVE::Cluster::complete_next_vmid }), + 'source' => { + type => 'string', + description => 'The import source volume id.', + }, + storage => get_standard_option('pve-storage-id', { + description => "Default storage.", + completion => \&PVE::QemuServer::complete_storage, + }), + 'live-import' => { + type => 'boolean', + optional => 1, + default => 0, + description => "Immediately start the VM and copy the data in the background.", + }, + 'dryrun' => { + type => 'boolean', + optional => 1, + default => 0, + description => "Show the create command and exit without doing anything.", + }, + delete => { + type => 'string', format => 'pve-configid-list', + description => "A list of settings you want to delete.", + optional => 1, + }, + format => { + type => 'string', + description => 'Target format', + enum => [ 'raw', 'qcow2', 'vmdk' ], + optional => 1, + }, + }), + }, + returns => { type => 'null' }, + code => sub { + my ($param) = @_; + + my ($vmid, $source, $storage, $format, $live_import, $dryrun, $delete) = + delete $param->@{qw(vmid source storage format live-import dryrun delete)}; + + if (defined($format)) { + $format = ",format=$format"; + } else { + $format = ''; + } + + my $storecfg = PVE::Storage::config(); + my $metadata = PVE::Storage::get_import_metadata($storecfg, $source); + + my $create_args = $metadata->{'create-args'}; + if (my $netdevs = $metadata->{net}) { + for my $net (keys $netdevs->%*) { + my $value = $netdevs->{$net}; + $create_args->{$net} = join(',', map { $_ . '=' . $value->{$_} } sort keys %$value); + } + } + if (my $disks = $metadata->{disks}) { + if (delete $disks->{efidisk0}) { + $create_args->{efidisk0} = "$storage:1$format,efitype=4m"; + } + for my $disk (keys $disks->%*) { + my $value = $disks->{$disk}->{volid}; + $create_args->{$disk} = "$storage:0${format},import-from=$value"; + } + } + + $create_args->{'live-restore'} = 1 if $live_import; + + $create_args->{$_} = $param->{$_} for keys $param->%*; + delete $create_args->{$_} for PVE::Tools::split_list($delete); + + if ($dryrun) { + print("# dry-run – the resulting create command for the import would be:\n"); + print("qm create $vmid \\\n "); + print(join(" \\\n ", map { "--$_ $create_args->{$_}" } sort keys $create_args->%*)); + print("\n"); + return; + } + + PVE::API2::Qemu->create_vm({ + %node, + vmid => $vmid, + %$create_args, + }); + return; + } +}); - delsnapshot => [ "PVE::API2::Qemu", 'delsnapshot', ['vmid', 'snapname'], { node => $nodename } , $upid_exit ], +my $print_agent_result = sub { + my ($data) = @_; - listsnapshot => [ "PVE::API2::Qemu", 'snapshot_list', ['vmid'], { node => $nodename }, - sub { - my $res = shift; - foreach my $e (@$res) { - my $headline = $e->{description} || 'no-description'; - $headline =~ s/\n.*//sg; - my $parent = $e->{parent} // 'no-parent'; - printf("%-20s %-20s %s\n", $e->{name}, $parent, $headline); - } - }], + my $result = $data->{result} // $data; + return if !defined($result); - rollback => [ "PVE::API2::Qemu", 'rollback', ['vmid', 'snapname'], { node => $nodename } , $upid_exit ], + my $class = ref($result); - template => [ "PVE::API2::Qemu", 'template', ['vmid'], { node => $nodename }], + if (!$class) { + chomp $result; + return if $result =~ m/^\s*$/; + print "$result\n"; + return; + } - start => [ "PVE::API2::Qemu", 'vm_start', ['vmid'], { node => $nodename } , $upid_exit ], + if (($class eq 'HASH') && !scalar(keys %$result)) { # empty hash + return; + } - stop => [ "PVE::API2::Qemu", 'vm_stop', ['vmid'], { node => $nodename }, $upid_exit ], + print to_json($result, { pretty => 1, canonical => 1, utf8 => 1}); +}; - reset => [ "PVE::API2::Qemu", 'vm_reset', ['vmid'], { node => $nodename }, $upid_exit ], +sub param_mapping { + my ($name) = @_; + + my $ssh_key_map = ['sshkeys', sub { + return URI::Escape::uri_escape(file_get_contents($_[0])); + }]; + my $cipassword_map = PVE::CLIHandler::get_standard_mapping('pve-password', { name => 'cipassword' }); + my $password_map = PVE::CLIHandler::get_standard_mapping('pve-password'); + my $mapping = { + 'update_vm' => [$ssh_key_map, $cipassword_map], + 'create_vm' => [$ssh_key_map, $cipassword_map], + 'set-user-password' => [$password_map], + }; + + return $mapping->{$name}; +} - shutdown => [ "PVE::API2::Qemu", 'vm_shutdown', ['vmid'], { node => $nodename }, $upid_exit ], +our $cmddef = { + list=> [ "PVE::API2::Qemu", 'vmlist', [], { %node }, sub { + my $vmlist = shift; + exit 0 if (!scalar(@$vmlist)); + + printf "%10s %-20s %-10s %-10s %12s %-10s\n", + qw(VMID NAME STATUS MEM(MB) BOOTDISK(GB) PID); + + foreach my $rec (sort { $a->{vmid} <=> $b->{vmid} } @$vmlist) { + printf "%10s %-20s %-10s %-10s %12.2f %-10s\n", $rec->{vmid}, $rec->{name}, + $rec->{qmpstatus} || $rec->{status}, + ($rec->{maxmem} || 0)/(1024*1024), + ($rec->{maxdisk} || 0)/(1024*1024*1024), + $rec->{pid} || 0; + } + }], - suspend => [ "PVE::API2::Qemu", 'vm_suspend', ['vmid'], { node => $nodename }, $upid_exit ], + create => [ "PVE::API2::Qemu", 'create_vm', ['vmid'], { %node }, $upid_exit ], + destroy => [ "PVE::API2::Qemu", 'destroy_vm', ['vmid'], { %node }, $upid_exit ], + clone => [ "PVE::API2::Qemu", 'clone_vm', ['vmid', 'newid'], { %node }, $upid_exit ], - resume => [ "PVE::API2::Qemu", 'vm_resume', ['vmid'], { node => $nodename }, $upid_exit ], + migrate => [ "PVE::API2::Qemu", 'migrate_vm', ['vmid', 'target'], { %node }, $upid_exit ], + 'remote-migrate' => [ __PACKAGE__, 'remote_migrate_vm', ['vmid', 'target-vmid', 'target-endpoint'], { %node }, $upid_exit ], - sendkey => [ "PVE::API2::Qemu", 'vm_sendkey', ['vmid', 'key'], { node => $nodename } ], + set => [ "PVE::API2::Qemu", 'update_vm', ['vmid'], { %node } ], + + config => [ "PVE::API2::Qemu", 'vm_config', ['vmid'], { %node }, sub { + my $config = shift; + foreach my $k (sort (keys %$config)) { + next if $k eq 'digest'; + my $v = $config->{$k}; + if ($k eq 'description') { + $v = PVE::Tools::encode_text($v); + } + print "$k: $v\n"; + } + }], + + pending => [ "PVE::API2::Qemu", 'vm_pending', ['vmid'], { %node }, \&PVE::GuestHelpers::format_pending ], + showcmd => [ __PACKAGE__, 'showcmd', ['vmid']], + + status => [ __PACKAGE__, 'status', ['vmid']], + + # FIXME: for 8.0 move to command group snapshot { create, list, destroy, rollback } + snapshot => [ "PVE::API2::Qemu", 'snapshot', ['vmid', 'snapname'], { %node } , $upid_exit ], + delsnapshot => [ "PVE::API2::Qemu", 'delsnapshot', ['vmid', 'snapname'], { %node } , $upid_exit ], + listsnapshot => [ "PVE::API2::Qemu", 'snapshot_list', ['vmid'], { %node }, \&PVE::GuestHelpers::print_snapshot_tree], + rollback => [ "PVE::API2::Qemu", 'rollback', ['vmid', 'snapname'], { %node } , $upid_exit ], + + template => [ "PVE::API2::Qemu", 'template', ['vmid'], { %node }], + + # FIXME: should be in a power command group? + start => [ "PVE::API2::Qemu", 'vm_start', ['vmid'], { %node } , $upid_exit ], + stop => [ "PVE::API2::Qemu", 'vm_stop', ['vmid'], { %node }, $upid_exit ], + reset => [ "PVE::API2::Qemu", 'vm_reset', ['vmid'], { %node }, $upid_exit ], + shutdown => [ "PVE::API2::Qemu", 'vm_shutdown', ['vmid'], { %node }, $upid_exit ], + reboot => [ "PVE::API2::Qemu", 'vm_reboot', ['vmid'], { %node }, $upid_exit ], + suspend => [ "PVE::API2::Qemu", 'vm_suspend', ['vmid'], { %node }, $upid_exit ], + resume => [ "PVE::API2::Qemu", 'vm_resume', ['vmid'], { %node }, $upid_exit ], + + sendkey => [ "PVE::API2::Qemu", 'vm_sendkey', ['vmid', 'key'], { %node } ], vncproxy => [ __PACKAGE__, 'vncproxy', ['vmid']], @@ -549,16 +1157,50 @@ our $cmddef = { unlock => [ __PACKAGE__, 'unlock', ['vmid']], - rescan => [ __PACKAGE__, 'rescan', []], + # TODO: evluate dropping below aliases for 8.0, if no usage is left + importdisk => { alias => 'disk import' }, + 'move-disk' => { alias => 'disk move' }, + move_disk => { alias => 'disk move' }, + rescan => { alias => 'disk rescan' }, + resize => { alias => 'disk resize' }, + unlink => { alias => 'disk unlink' }, + + disk => { + import => [ __PACKAGE__, 'importdisk', ['vmid', 'source', 'storage']], + 'move' => [ "PVE::API2::Qemu", 'move_vm_disk', ['vmid', 'disk', 'storage'], { %node }, $upid_exit ], + rescan => [ __PACKAGE__, 'rescan', []], + resize => [ "PVE::API2::Qemu", 'resize_vm', ['vmid', 'disk', 'size'], { %node } ], + unlink => [ "PVE::API2::Qemu", 'unlink', ['vmid'], { %node } ], + }, monitor => [ __PACKAGE__, 'monitor', ['vmid']], - agent => [ "PVE::API2::Qemu", 'agent', ['vmid'], - { node => $nodename }, $print_agent_result ], + agent => { alias => 'guest cmd' }, # FIXME: remove with PVE 8.0 + + guest => { + cmd => [ "PVE::API2::Qemu::Agent", 'agent', ['vmid', 'command'], { %node }, $print_agent_result ], + passwd => [ "PVE::API2::Qemu::Agent", 'set-user-password', [ 'vmid', 'username' ], { %node }], + exec => [ __PACKAGE__, 'exec', [ 'vmid', 'extra-args' ], { %node }, $print_agent_result], + 'exec-status' => [ "PVE::API2::Qemu::Agent", 'exec-status', [ 'vmid', 'pid' ], { %node }, $print_agent_result], + }, mtunnel => [ __PACKAGE__, 'mtunnel', []], + nbdstop => [ __PACKAGE__, 'nbdstop', ['vmid']], + terminal => [ __PACKAGE__, 'terminal', ['vmid']], + + importovf => [ __PACKAGE__, 'importovf', ['vmid', 'manifest', 'storage']], + + cleanup => [ __PACKAGE__, 'cleanup', ['vmid', 'clean-shutdown', 'guest-requested'], { %node }], + + cloudinit => { + dump => [ "PVE::API2::Qemu", 'cloudinit_generated_config_dump', ['vmid', 'type'], { %node }, sub { print "$_[0]\n"; }], + pending => [ "PVE::API2::Qemu", 'cloudinit_pending', ['vmid'], { %node }, \&PVE::GuestHelpers::format_pending ], + update => [ "PVE::API2::Qemu", 'cloudinit_update', ['vmid'], { node => $nodename }], + }, + + import => [ __PACKAGE__, 'vm_import', ['vmid', 'source']], }; 1;