X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=PVE%2FCLI%2Fqm.pm;h=b105830fa6f558e0efae0eb6efe66a764cc6b066;hb=HEAD;hp=bc9e227a0b208afa4afacae7642b0b30fac3c750;hpb=90ec74eac142dde48d567976d791626e993d125b;p=qemu-server.git

diff --git a/PVE/CLI/qm.pm b/PVE/CLI/qm.pm
index bc9e227..b105830 100755
--- a/PVE/CLI/qm.pm
+++ b/PVE/CLI/qm.pm
@@ -8,40 +8,46 @@ use Getopt::Long qw(:config no_getopt_compat);
 
 use Fcntl ':flock';
 use File::Path;
-use IO::Socket::UNIX;
 use IO::Select;
-use URI::Escape;
+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::INotify;
-use PVE::RPCEnvironment;
 use PVE::Exception qw(raise_param_exc);
-use PVE::Network;
 use PVE::GuestHelpers;
-use PVE::QemuServer;
+use PVE::INotify;
+use PVE::JSONSchema qw(get_standard_option);
+use PVE::Network;
+use PVE::RPCEnvironment;
+use PVE::SafeSyslog;
+use PVE::Tools qw(extract_param file_get_contents);
+
+use PVE::API2::Qemu::Agent;
+use PVE::API2::Qemu;
+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::Agent qw(agent_available);
-use PVE::API2::Qemu;
-use PVE::API2::Qemu::Agent;
-use JSON;
-use PVE::JSONSchema qw(get_standard_option);
-use Term::ReadLine;
+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();
@@ -57,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);
@@ -96,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 {
@@ -151,7 +157,118 @@ __PACKAGE__->register_method ({
 
 	print "$cmdline\n";
 
-	return undef;
+	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);
+	}
+
+	$check_remote_storage->($storagemap->{default})
+	    if $storagemap->{default};
+
+	return PVE::API2::Qemu->remote_migrate_vm($param);
     }});
 
 __PACKAGE__->register_method ({
@@ -190,7 +307,7 @@ __PACKAGE__->register_method ({
 	    print "status: $status\n";
 	}
 
-	return undef;
+	return;
     }});
 
 __PACKAGE__->register_method ({
@@ -209,20 +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 {
-	    # FIXME: remove or allow to add tls-creds object, as x509 vnc param is removed with qemu 4??
-	    PVE::QemuServer::vm_mon_cmd($vmid, "change", device => 'vnc', target => "unix:$vnc_socket,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 ({
@@ -249,7 +365,7 @@ __PACKAGE__->register_method ({
 	    PVE::QemuConfig->write_config($vmid, $conf);
 	});
 
-	return undef;
+	return;
     }});
 
 __PACKAGE__->register_method ({
@@ -269,9 +385,10 @@ __PACKAGE__->register_method ({
 
 	my $vmid = $param->{vmid};
 
-	PVE::QemuServer::nbd_stop($vmid);
+	eval { PVE::QemuServer::nbd_stop($vmid) };
+	warn $@ if $@;
 
-	return undef;
+	return;
     }});
 
 __PACKAGE__->register_method ({
@@ -289,7 +406,7 @@ __PACKAGE__->register_method ({
 
 	if (!PVE::Cluster::check_cfs_quorum(1)) {
 	    print "no quorum\n";
-	    return undef;
+	    return;
 	}
 
 	my $tunnel_write = sub {
@@ -309,6 +426,8 @@ __PACKAGE__->register_method ({
 		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 ($@) {
@@ -322,7 +441,7 @@ __PACKAGE__->register_method ({
 	    }
 	}
 
-	return undef;
+	return;
     }});
 
 __PACKAGE__->register_method ({
@@ -362,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 => {
@@ -384,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;
 
     }});
 
@@ -436,7 +550,7 @@ __PACKAGE__->register_method ({
 
 	PVE::QemuServer::rescan($param->{vmid}, 0, $dryrun);
 
-	return undef;
+	return;
     }});
 
 __PACKAGE__->register_method ({
@@ -483,14 +597,15 @@ __PACKAGE__->register_method ({
 	my $storecfg = PVE::Storage::config();
 	PVE::Storage::storage_check_enabled($storecfg, $storeid);
 
-	my $target_storage_config =
-	    PVE::Storage::storage_config($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};
 
-	PVE::QemuServer::ImportDisk::do_import($source, $vmid, $storeid, { format => $format });
+	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 ({
@@ -567,7 +682,7 @@ __PACKAGE__->register_method ({
 
 	system($cmd);
 
-	return undef;
+	return;
     }});
 
 __PACKAGE__->register_method ({
@@ -621,48 +736,57 @@ __PACKAGE__->register_method ({
 	    return;
 	}
 
-	$param->{name} = $parsed->{qm}->{name} if defined($parsed->{qm}->{name});
-	$param->{memory} = $parsed->{qm}->{memory} if defined($parsed->{qm}->{memory});
-	$param->{cores} = $parsed->{qm}->{cores} if defined($parsed->{qm}->{cores});
+	eval { PVE::QemuConfig->create_and_lock_config($vmid) };
+	die "Reserving empty config for OVF import to VM $vmid failed: $@" if $@;
 
-	my $importfn = sub {
+	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");
 
-	    PVE::Cluster::check_vmid_unused($vmid);
+	$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 $conf = $param;
+	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);
 
-	    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;
+	    }
 
-		foreach my $disk (@{ $parsed->{disks} }) {
-		    my ($file, $drive) = ($disk->{backing_file}, $disk->{disk_address});
-		    PVE::QemuServer::ImportDisk::do_import($file, $vmid, $storeid,
-			{ drive_name => $drive, format => $format });
-		}
+	    # 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);
+	};
 
-		# reload after disks entries have been created
-		$conf = PVE::QemuConfig->load_config($vmid);
-		PVE::QemuConfig->check_lock($conf);
-		my $firstdisk = PVE::QemuServer::resolve_first_disk($conf);
-		$conf->{bootdisk} = $firstdisk if $firstdisk;
-		PVE::QemuConfig->write_config($vmid, $conf);
-	    };
-
-	    my $err = $@;
-	    if ($err) {
-		my $skiplock = 1;
-		eval { PVE::QemuServer::vm_destroy($storecfg, $vmid, $skiplock); };
-		die "import failed - $err";
+	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";
+	}
 
-	my $wait_for_lock = 1;
-	PVE::QemuConfig->lock_config_full($vmid, $wait_for_lock, $importfn);
+	PVE::QemuConfig->remove_lock($vmid, "create");
 
-	return undef;
+	return;
 
     }
 });
@@ -692,6 +816,12 @@ __PACKAGE__->register_method({
 		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'),
 	},
     },
@@ -703,14 +833,28 @@ __PACKAGE__->register_method({
 
 	my $vmid = $param->{vmid};
 	my $sync = $param->{synchronous} // 1;
-	if (!$param->{'extra-args'} || !@{$param->{'extra-args'}}) {
-	    raise_param_exc( { 'extra-args' => "No command given" });
-	}
+	my $pass_stdin = $param->{'pass-stdin'};
 	if (defined($param->{timeout}) && !$sync) {
 	    raise_param_exc({ synchronous => "needs to be set for 'timeout'"});
 	}
 
-	my $res = PVE::QemuServer::Agent::qemu_exec($vmid, $param->{'extra-args'});
+	my $input_data = undef;
+	if ($pass_stdin) {
+	    $input_data = '';
+	    while (my $line = <STDIN>) {
+		$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";
+		}
+	    }
+	}
+
+	my $args = $param->{'extra-args'};
+	$args = undef if !$args || !@$args;
+
+	my $res = PVE::QemuServer::Agent::qemu_exec($vmid, $input_data, $args);
 
 	if ($sync) {
 	    my $pid = $res->{pid};
@@ -771,7 +915,8 @@ __PACKAGE__->register_method({
 	my $storecfg = PVE::Storage::config();
 	warn "Starting cleanup for $vmid\n";
 
-	PVE::QemuConfig->lock_config($vmid, sub {
+	# 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;
@@ -780,7 +925,7 @@ __PACKAGE__->register_method({
 		# we have to cleanup the tap devices after a crash
 
 		foreach my $opt (keys %$conf) {
-		    next if $opt !~  m/^net(\d)+$/;
+		    next if $opt !~  m/^net(\d+)$/;
 		    my $interface = $1;
 		    PVE::Network::tap_unplug("tap${vmid}i${interface}");
 		}
@@ -802,13 +947,109 @@ __PACKAGE__->register_method({
 	    warn "Restarting VM $vmid\n";
 	    PVE::API2::Qemu->vm_start({
 		vmid => $vmid,
-		node => $nodename,
+		%node,
 	    });
 	}
 
-	return undef;
+	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;
+    }
+});
+
 my $print_agent_result = sub {
     my ($data) = @_;
 
@@ -828,14 +1069,14 @@ my $print_agent_result = sub {
 	return;
     }
 
-    print to_json($result, { pretty => 1, canonical => 1});
+    print to_json($result, { pretty => 1, canonical => 1, utf8 => 1});
 };
 
 sub param_mapping {
     my ($name) = @_;
 
     my $ssh_key_map = ['sshkeys', sub {
-	return URI::Escape::uri_escape(PVE::Tools::file_get_contents($_[0]));
+	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');
@@ -849,111 +1090,66 @@ sub param_mapping {
 }
 
 our $cmddef = {
-    list => [ "PVE::API2::Qemu", 'vmlist', [],
-	     { node => $nodename }, 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;
-		 }
-
-
-	      } ],
-
-    create => [ "PVE::API2::Qemu", 'create_vm', ['vmid'], { node => $nodename }, $upid_exit ],
-
-    destroy => [ "PVE::API2::Qemu", 'destroy_vm', ['vmid'], { node => $nodename }, $upid_exit ],
-
-    clone => [ "PVE::API2::Qemu", 'clone_vm', ['vmid', 'newid'], { node => $nodename }, $upid_exit ],
-
-    migrate => [ "PVE::API2::Qemu", 'migrate_vm', ['vmid', 'target'], { node => $nodename }, $upid_exit ],
-
-    set => [ "PVE::API2::Qemu", 'update_vm', ['vmid'], { node => $nodename } ],
+    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;
+	}
+    }],
 
-    resize => [ "PVE::API2::Qemu", 'resize_vm', ['vmid', 'disk', 'size'], { node => $nodename } ],
+    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 ],
 
-    move_disk => [ "PVE::API2::Qemu", 'move_vm_disk', ['vmid', 'disk', 'storage'], { 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 ],
 
-    unlink => [ "PVE::API2::Qemu", 'unlink', ['vmid'], { node => $nodename } ],
+    set => [ "PVE::API2::Qemu", 'update_vm', ['vmid'], { %node } ],
 
-    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";
-			}
-		    }
-		}],
+    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']],
 
-    snapshot => [ "PVE::API2::Qemu", 'snapshot', ['vmid', 'snapname'], { node => $nodename } , $upid_exit ],
+    # 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 ],
 
-    delsnapshot => [ "PVE::API2::Qemu", 'delsnapshot', ['vmid', 'snapname'], { node => $nodename } , $upid_exit ],
+    template => [ "PVE::API2::Qemu", 'template', ['vmid'], { %node }],
 
-    listsnapshot => [ "PVE::API2::Qemu", 'snapshot_list', ['vmid'], { node => $nodename }, \&PVE::GuestHelpers::print_snapshot_tree],
+    # 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 ],
 
-    rollback => [ "PVE::API2::Qemu", 'rollback', ['vmid', 'snapname'], { node => $nodename } , $upid_exit ],
-
-    template => [ "PVE::API2::Qemu", 'template', ['vmid'], { node => $nodename }],
-
-    start => [ "PVE::API2::Qemu", 'vm_start', ['vmid'], { node => $nodename } , $upid_exit ],
-
-    stop => [ "PVE::API2::Qemu", 'vm_stop', ['vmid'], { node => $nodename }, $upid_exit ],
-
-    reset => [ "PVE::API2::Qemu", 'vm_reset', ['vmid'], { node => $nodename }, $upid_exit ],
-
-    shutdown => [ "PVE::API2::Qemu", 'vm_shutdown', ['vmid'], { node => $nodename }, $upid_exit ],
-
-    reboot => [ "PVE::API2::Qemu", 'vm_reboot', ['vmid'], { node => $nodename }, $upid_exit ],
-
-    suspend => [ "PVE::API2::Qemu", 'vm_suspend', ['vmid'], { node => $nodename }, $upid_exit ],
-
-    resume => [ "PVE::API2::Qemu", 'vm_resume', ['vmid'], { node => $nodename }, $upid_exit ],
-
-    sendkey => [ "PVE::API2::Qemu", 'vm_sendkey', ['vmid', 'key'], { node => $nodename } ],
+    sendkey => [ "PVE::API2::Qemu", 'vm_sendkey', ['vmid', 'key'], { %node } ],
 
     vncproxy => [ __PACKAGE__, 'vncproxy', ['vmid']],
 
@@ -961,17 +1157,31 @@ 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  => { alias => 'guest cmd' },
+    agent  => { alias => 'guest cmd' }, # FIXME: remove with PVE 8.0
 
     guest => {
-	cmd  => [ "PVE::API2::Qemu::Agent", 'agent', ['vmid', 'command'], { node => $nodename }, $print_agent_result ],
-	passwd => [ "PVE::API2::Qemu::Agent", 'set-user-password', [ 'vmid', 'username' ], { node => $nodename }],
-	exec => [ __PACKAGE__, 'exec', [ 'vmid', 'extra-args' ], { node => $nodename }, $print_agent_result],
-	'exec-status' => [ "PVE::API2::Qemu::Agent", 'exec-status', [ 'vmid', 'pid' ], { node => $nodename }, $print_agent_result],
+	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', []],
@@ -980,19 +1190,17 @@ our $cmddef = {
 
     terminal => [ __PACKAGE__, 'terminal', ['vmid']],
 
-    importdisk => [ __PACKAGE__, 'importdisk', ['vmid', 'source', 'storage']],
-
     importovf => [ __PACKAGE__, 'importovf', ['vmid', 'manifest', 'storage']],
 
-    cleanup => [ __PACKAGE__, 'cleanup', ['vmid', 'clean-shutdown', 'guest-requested'], { node => $nodename }],
+    cleanup => [ __PACKAGE__, 'cleanup', ['vmid', 'clean-shutdown', 'guest-requested'], { %node }],
 
     cloudinit => {
-	dump => [ "PVE::API2::Qemu", 'cloudinit_generated_config_dump', ['vmid', 'type'], { node => $nodename }, sub {
-		my $data = shift;
-		print "$data\n";
-	    }],
+	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;