X-Git-Url: https://git.proxmox.com/?p=pve-client.git;a=blobdiff_plain;f=PVE%2FAPIClient%2FHelpers.pm;h=ec932ec5f261bc2a55d23946cfcfdb7372293fb9;hp=e7f221656b7814ba2e41c0c8980e6b2b6cb11ea4;hb=5eb200482a2d7d7127933186e51839ecdff8895c;hpb=a04fd959f6ea5b1b8842782ba0ab514b84a21d59

diff --git a/PVE/APIClient/Helpers.pm b/PVE/APIClient/Helpers.pm
index e7f2216..ec932ec 100644
--- a/PVE/APIClient/Helpers.pm
+++ b/PVE/APIClient/Helpers.pm
@@ -3,67 +3,353 @@ package PVE::APIClient::Helpers;
 use strict;
 use warnings;
 
-use Data::Dumper;
+use Storable;
 use JSON;
+use File::Path qw(make_path);
+
 use PVE::APIClient::Exception qw(raise);
 use Encode::Locale;
 use Encode;
 use HTTP::Status qw(:constants);
 
 my $pve_api_definition;
-my $pve_api_path_hash;
 
-my $pve_api_definition_fn = "/usr/share/pve-client/pve-api-definition.js";
+my $pve_api_definition_fn = "/usr/share/pve-client/pve-api-definition.dat";
 
-my $build_pve_api_path_hash;
-$build_pve_api_path_hash = sub {
-    my ($tree) = @_;
+my $method_map = {
+    create => 'POST',
+    set => 'PUT',
+    get => 'GET',
+    delete => 'DELETE',
+};
 
-    my $class = ref($tree);
-    return $tree if !$class;
+my $default_output_format = 'text';
+my $client_output_format =  $default_output_format;
 
-    if ($class eq 'ARRAY') {
-	foreach my $el (@$tree) {
-	    $build_pve_api_path_hash->($el);
-	}
-    } elsif ($class eq 'HASH') {
-	if (defined($tree->{leaf}) && defined(my $path = $tree->{path})) {
-	    $pve_api_path_hash->{$path} = $tree;
-	}
-	foreach my $k (keys %$tree) {
-	    $build_pve_api_path_hash->($tree->{$k});
+sub set_output_format {
+    my ($format) = @_;
+
+    if (!defined($format)) {
+	$client_output_format =  $default_output_format;
+    } else {
+	$client_output_format =  $format;
+    }
+}
+
+sub get_output_format {
+    return $client_output_format;
+}
+
+sub print_result {
+    my ($data, $result_schema) = @_;
+
+    my $format = get_output_format();
+
+    return if $result_schema->{type} eq 'null';
+
+    # TODO: implement different output formats ($format)
+
+    if ($format eq 'json') {
+	print to_json($data, {utf8 => 1, allow_nonref => 1, canonical => 1, pretty => 1 });
+    } elsif ($format eq 'text') {
+	my $type = $result_schema->{type};
+	if ($type eq 'object') {
+	    die "implement me";
+	} elsif ($type eq 'array') {
+	    my $item_type = $result_schema->{items}->{type};
+	    if ($item_type eq 'object') {
+		die "implement me";
+	    } elsif ($item_type eq 'array') {
+		die "implement me";
+	    } else {
+		foreach my $el (@$data) {
+		    print "$el\n"
+		}
+	    }
+	} else {
+	    print "$data\n";
 	}
+    } else {
+	die "internal error: unknown output format"; # should not happen
     }
-};
+}
 
 sub get_api_definition {
 
     if (!defined($pve_api_definition)) {
-	local $/;
 	open(my $fh, '<',  $pve_api_definition_fn) ||
 	    die "unable to open '$pve_api_definition_fn' - $!\n";
-	my $json_text = <$fh>;
-	$pve_api_definition = decode_json($json_text);
+	$pve_api_definition = Storable::fd_retrieve($fh);
+    }
+
+    return $pve_api_definition;
+}
+
+my $map_path_to_info = sub {
+    my ($child_list, $stack, $uri_param) = @_;
 
-	$build_pve_api_path_hash->($pve_api_definition);
+    while (defined(my $comp = shift @$stack)) {
+	foreach my $child (@$child_list) {
+	    my $text = $child->{text};
+
+	    if ($text eq $comp) {
+		# found
+	    } elsif ($text =~ m/^\{(\S+)\}$/) {
+		# found
+		$uri_param->{$1} = $comp;
+	    } else {
+		next; # text next child
+	    }
+	    if ($child->{leaf} || !scalar(@$stack)) {
+		return $child;
+	    } else {
+		$child_list = $child->{children};
+		last; # test next path component
+	    }
+	}
     }
+    return undef;
+};
 
+sub find_method_info {
+    my ($path, $method, $uri_param, $noerr) = @_;
 
-    return $pve_api_definition;
+    $uri_param //= {};
+
+    my $stack = [ grep { length($_) > 0 }  split('\/+' , $path)]; # skip empty fragments
+
+    my $child = $map_path_to_info->(get_api_definition(), $stack, $uri_param);
+
+    if (!($child && $child->{info} && $child->{info}->{$method})) {
+	return undef if $noerr;
+	die "unable to find API method '$method' for path '$path'\n";
+    }
+
+    return $child->{info}->{$method};
+}
+
+sub complete_api_call_options {
+    my ($cmd, $prop, $prev, $cur, $args) = @_;
+
+    my $print_result = sub {
+	foreach my $p (@_) {
+	    print "$p\n" if $p =~ m/^$cur/;
+	}
+    };
+
+    my $print_parameter_completion = sub {
+	my ($pname) = @_;
+	my $d = $prop->{$pname};
+	if ($d->{completion}) {
+	    my $vt = ref($d->{completion});
+	    if ($vt eq 'CODE') {
+		my $res = $d->{completion}->($cmd, $pname, $cur, $args);
+		&$print_result(@$res);
+	    }
+	} elsif ($d->{type} eq 'boolean') {
+	    &$print_result('0', '1');
+	} elsif ($d->{enum}) {
+	    &$print_result(@{$d->{enum}});
+	}
+    };
+
+    my @option_list = ();
+    foreach my $key (keys %$prop) {
+	push @option_list, "--$key";
+    }
+
+    if ($cur =~ m/^-/) {
+	&$print_result(@option_list);
+	return;
+    }
+
+    if ($prev =~ m/^--?(.+)$/ && $prop->{$1}) {
+	my $pname = $1;
+	&$print_parameter_completion($pname);
+	return;
+    }
+
+    &$print_result(@option_list);
 }
 
-sub lookup_api_method {
-    my ($path, $method) = @_;
+sub complete_api_path {
+    my ($text) = @_;
 
     get_api_definition(); # make sure API data is loaded
 
-    my $info = $pve_api_path_hash->{$path} ||
-	die "unable to find API info for path '$path'\n";
+    $text =~ s!^/!!;
 
-    my $data = $info->{info}->{$method} ||
-	die "unable to find API method '$method' for path '$path'\n";
+    my ($dir, $rest) = $text =~ m|^(?:(.*)/)?(?:([^/]*))?$|;
+
+    my $info;
+    if (!defined($dir)) {
+	$dir = '';
+	$info = { children => $pve_api_definition };
+    } else {
+	my $stack = [ grep { length($_) > 0 }  split('\/+' , $dir)]; # skip empty fragments
+	$info = $map_path_to_info->($pve_api_definition, $stack, {});
+    }
 
-    return $data;
+    my $res = [];
+    if ($info) {
+	my $prefix = length($dir) ? "/$dir/" : '/';
+	if (my $children = $info->{children}) {
+	    foreach my $c (@$children) {
+		my $ctext = $c->{text};
+		if ($ctext =~ m/^\{(\S+)\}$/) {
+		    push @$res, "$prefix$ctext";
+		    push @$res, "$prefix$ctext/";
+		    if (length($rest)) {
+			push @$res, "$prefix$rest";
+			push @$res, "$prefix$rest/";
+		    }
+		} elsif ($ctext =~ m/^\Q$rest/) {
+		    push @$res, "$prefix$ctext";
+		    push @$res, "$prefix$ctext/" if $c->{children};
+		}
+	    }
+	}
+    }
+
+    return $res;
 }
 
+# test for command lines with api calls (or similar bash completion calls):
+# example1: pveclient api get remote1 /cluster
+sub extract_path_info {
+    my ($uri_param) = @_;
+
+    my $info;
+
+    my $test_path_properties = sub {
+	my ($args) = @_;
+
+	return if scalar(@$args) < 5;
+	return if $args->[1] ne 'api';
+
+	my $path = $args->[4];
+	if (my $method = $method_map->{$args->[2]}) {
+	    $info = find_method_info($path, $method, $uri_param, 1);
+	}
+    };
+
+    if (defined(my $cmd = $ARGV[0])) {
+	if ($cmd eq 'api') {
+	    $test_path_properties->([$0, @ARGV]);
+	} elsif ($cmd eq 'bashcomplete') {
+	    my $cmdline = substr($ENV{COMP_LINE}, 0, $ENV{COMP_POINT});
+	    my $args = PVE::APIClient::Tools::split_args($cmdline);
+	    $test_path_properties->($args);
+	}
+    }
+
+    return $info;
+}
+
+sub get_vmid_resource {
+    my ($conn, $vmid) = @_;
+
+    my $resources = $conn->get('api2/json/cluster/resources', {type => 'vm'});
+
+    my $resource;
+    for my $tmp (@$resources) {
+	if ($tmp->{vmid} eq $vmid) {
+	    $resource = $tmp;
+	    last;
+	}
+    }
+
+    if (!defined($resource)) {
+	die "\"$vmid\" not found";
+    }
+
+    return $resource;
+}
+
+sub poll_task {
+    my ($conn, $node, $upid) = @_;
+
+    my $path = "api2/json/nodes/$node/tasks/$upid/status";
+
+    my $task_status;
+    while(1) {
+	$task_status = $conn->get($path, {});
+
+	if ($task_status->{status} eq "stopped") {
+	    last;
+	}
+
+	sleep(10);
+    }
+
+    return $task_status->{exitstatus};
+}
+
+sub configuration_directory {
+
+    my $home = $ENV{HOME} // '';
+    my $xdg = $ENV{XDG_CONFIG_HOME} // '';
+
+    my $subdir = "pveclient";
+
+    return "$xdg/$subdir" if length($xdg);
+
+    return "$home/.config/$subdir" if length($home);
+
+    die "neither XDG_CONFIG_HOME nor HOME environment variable set\n";
+}
+
+my $ticket_cache_filename = "/.tickets";
+
+sub ticket_cache_lookup {
+    my ($remote) = @_;
+
+    my $dir = configuration_directory();
+    my $filename = "$dir/$ticket_cache_filename";
+
+    my $data = {};
+    eval { $data = from_json(PVE::APIClient::Tools::file_get_contents($filename)); };
+    # ignore errors
+
+    my $ticket = $data->{$remote};
+    return undef if !defined($ticket);
+
+    my $min_age = - 60;
+    my $max_age = 3600*2 - 60;
+
+    if ($ticket =~ m/:([a-fA-F0-9]{8})::/) {
+	my $ttime = hex($1);
+	my $ctime = time();
+	my $age = $ctime - $ttime;
+
+	return $ticket if ($age > $min_age) && ($age < $max_age);
+    }
+
+    return undef;
+}
+
+sub ticket_cache_update {
+    my ($remote, $ticket) = @_;
+
+    my $dir = configuration_directory();
+    my $filename = "$dir/$ticket_cache_filename";
+
+    my $code = sub {
+	make_path($dir);
+	my $data = {};
+	if (-f $filename) {
+	    my $raw = PVE::APIClient::Tools::file_get_contents($filename);
+	    eval { $data = from_json($raw); };
+	    # ignore errors
+	}
+	$data->{$remote} = $ticket;
+
+	PVE::APIClient::Tools::file_set_contents($filename, to_json($data), 0600);
+    };
+
+    PVE::APIClient::Tools::lock_file($filename, undef, $code);
+    die $@ if $@;
+}
+
+
 1;