106e497790512d65f068f92af1ba53d21b0f2ca9
[pve-client.git] / PVE / APIClient / Helpers.pm
1 package PVE::APIClient::Helpers;
2
3 use strict;
4 use warnings;
5
6 use Storable;
7 use JSON;
8 use File::Path qw(make_path);
9
10 use PVE::APIClient::JSONSchema;
11 use PVE::APIClient::Exception qw(raise);
12 use PVE::APIClient::CLIFormatter;
13 use PVE::APIClient::CLIHandler;
14 use PVE::APIClient::PTY;
15 use Encode::Locale;
16 use Encode;
17 use HTTP::Status qw(:constants);
18
19 my $pve_api_definition;
20
21 my $pve_api_definition_fn = "/usr/share/pve-client/pve-api-definition.dat";
22
23 our $method_map = {
24     create => 'POST',
25     set => 'PUT',
26     get => 'GET',
27     delete => 'DELETE',
28 };
29
30 my $__real_remove_formats; $__real_remove_formats = sub {
31     my ($properties) = @_;
32
33     foreach my $pname (keys %$properties) {
34         if (my $d = $properties->{$pname}) {
35             if (defined(my $format = $d->{format})) {
36                 if (ref($format)) {
37                     $__real_remove_formats->($format);
38                 } elsif (!PVE::APIClient::JSONSchema::get_format($format)) {
39                     # simply remove unknown format definitions
40                     delete $d->{format};
41                 }
42             }
43         }
44     }
45 };
46
47 my $remove_unknown_formats; $remove_unknown_formats = sub {
48     my ($tree) = @_;
49
50     my $class = ref($tree);
51     return if !$class;
52
53     if ($class eq 'ARRAY') {
54        foreach my $el (@$tree) {
55            $remove_unknown_formats->($el);
56        }
57     } elsif ($class eq 'HASH') {
58         if (my $info = $tree->{info}) {
59             for my $method (qw(GET PUT PUSH DELETE)) {
60                 next if !$info->{$method};
61                 my $properties = $info->{$method}->{parameters}->{properties};
62                 $__real_remove_formats->($properties) if $properties;
63             }
64         }
65         if ($tree->{children}) {
66             $remove_unknown_formats->($tree->{children});
67         }
68     }
69     return;
70 };
71
72 sub get_api_definition {
73
74     if (!defined($pve_api_definition)) {
75         open(my $fh, '<',  $pve_api_definition_fn) ||
76             die "unable to open '$pve_api_definition_fn' - $!\n";
77         $pve_api_definition = Storable::fd_retrieve($fh);
78
79         $remove_unknown_formats->($pve_api_definition);
80     }
81
82     return $pve_api_definition;
83 }
84
85 my $map_path_to_info = sub {
86     my ($child_list, $stack, $uri_param) = @_;
87
88     while (defined(my $comp = shift @$stack)) {
89         foreach my $child (@$child_list) {
90             my $text = $child->{text};
91
92             if ($text eq $comp) {
93                 # found
94             } elsif ($text =~ m/^\{(\S+)\}$/) {
95                 # found
96                 $uri_param->{$1} = $comp;
97             } else {
98                 next; # text next child
99             }
100             if ($child->{leaf} || !scalar(@$stack)) {
101                 return $child;
102             } else {
103                 $child_list = $child->{children};
104                 last; # test next path component
105             }
106         }
107     }
108     return undef;
109 };
110
111 sub find_method_info {
112     my ($path, $method, $uri_param, $noerr) = @_;
113
114     $uri_param //= {};
115
116     my $stack = [ grep { length($_) > 0 }  split('\/+' , $path)]; # skip empty fragments
117
118     my $api = get_api_definition();
119
120     my $child = scalar(@$stack) ? $map_path_to_info->($api->{children}, $stack, $uri_param) : $api;
121
122     if (!($child && $child->{info} && $child->{info}->{$method})) {
123         return undef if $noerr;
124         die "unable to find API method '$method' for path '$path'\n";
125     }
126
127     return $child->{info}->{$method};
128 }
129
130 sub complete_api_call_options {
131     my ($cmd, $prop, $prev, $cur, $args) = @_;
132
133     my $print_result = sub {
134         foreach my $p (@_) {
135             print "$p\n" if $p =~ m/^$cur/;
136         }
137     };
138
139     my $print_parameter_completion = sub {
140         my ($pname) = @_;
141         my $d = $prop->{$pname};
142         if ($d->{completion}) {
143             my $vt = ref($d->{completion});
144             if ($vt eq 'CODE') {
145                 my $res = $d->{completion}->($cmd, $pname, $cur, $args);
146                 &$print_result(@$res);
147             }
148         } elsif ($d->{type} eq 'boolean') {
149             &$print_result('0', '1');
150         } elsif ($d->{enum}) {
151             &$print_result(@{$d->{enum}});
152         }
153     };
154
155     my @option_list = ();
156     foreach my $key (keys %$prop) {
157         push @option_list, "--$key";
158     }
159
160     if ($cur =~ m/^-/) {
161         &$print_result(@option_list);
162         return;
163     }
164
165     if ($prev =~ m/^--?(.+)$/ && $prop->{$1}) {
166         my $pname = $1;
167         &$print_parameter_completion($pname);
168         return;
169     }
170
171     &$print_result(@option_list);
172 }
173
174 sub merge_api_definition_properties {
175     my ($path, $method, $properties) = @_;
176
177     my $info = PVE::APIClient::Helpers::find_method_info($path, $method);
178
179     return { %{$info->{parameters}->{properties}}, %$properties };
180 }
181
182 sub complete_api_path {
183     my ($text) = @_;
184
185     my $api = get_api_definition(); # make sure API data is loaded
186
187     $text =~ s!^/!!;
188
189     my ($dir, $rest) = $text =~ m|^(?:(.*)/)?(?:([^/]*))?$|;
190
191     my $info;
192     if (!defined($dir)) {
193         $dir = '';
194         $info = $api;
195     } else {
196         my $stack = [ grep { length($_) > 0 }  split('\/+' , $dir)]; # skip empty fragments
197         $info = $map_path_to_info->($api->{children}, $stack, {});
198     }
199
200     my $res = [];
201     if ($info) {
202         my $prefix = length($dir) ? "/$dir/" : '/';
203         if (my $children = $info->{children}) {
204             foreach my $c (@$children) {
205                 my $ctext = $c->{text};
206                 if ($ctext =~ m/^\{(\S+)\}$/) {
207                     push @$res, "$prefix$ctext";
208                     push @$res, "$prefix$ctext/";
209                     if (length($rest)) {
210                         push @$res, "$prefix$rest";
211                         push @$res, "$prefix$rest/";
212                     }
213                 } elsif ($ctext =~ m/^\Q$rest/) {
214                     push @$res, "$prefix$ctext";
215                     push @$res, "$prefix$ctext/" if $c->{children};
216                 }
217             }
218         }
219     }
220
221     return $res;
222 }
223
224 # test for command lines with api calls (or similar bash completion calls):
225 # example1: pveclient api get remote1 /cluster
226 sub extract_path_info {
227     my ($uri_param) = @_;
228
229     my $info;
230
231     my $test_path_properties = sub {
232         my ($args) = @_;
233
234         return if scalar(@$args) < 5;
235         return if $args->[1] ne 'api';
236
237         my $path = $args->[4];
238         if (my $method = $method_map->{$args->[2]}) {
239             $info = find_method_info($path, $method, $uri_param, 1);
240         }
241     };
242
243     if (defined(my $cmd = $ARGV[0])) {
244         if ($cmd eq 'api') {
245             $test_path_properties->([$0, @ARGV]);
246         } elsif ($cmd eq 'bashcomplete') {
247             my $cmdline = substr($ENV{COMP_LINE}, 0, $ENV{COMP_POINT});
248             my $args = PVE::APIClient::Tools::split_args($cmdline);
249             $test_path_properties->($args);
250         }
251     }
252
253     return $info;
254 }
255
256 sub get_vmid_resource {
257     my ($conn, $vmid) = @_;
258
259     my $resources = $conn->get('api2/json/cluster/resources', {type => 'vm'});
260
261     my $resource;
262     for my $tmp (@$resources) {
263         if ($tmp->{vmid} eq $vmid) {
264             $resource = $tmp;
265             last;
266         }
267     }
268
269     if (!defined($resource)) {
270         die "\"$vmid\" not found";
271     }
272
273     return $resource;
274 }
275
276 sub poll_task {
277     my ($conn, $node, $upid, $quiet) = @_;
278
279     my $path = "api2/json/nodes/$node/tasks/$upid/status";
280
281     my $task_status;
282     my $last_line = 0;
283     while(1) {
284         if (!$quiet) {
285             my $path = "api2/json/nodes/$node/tasks/$upid/log";
286             my $task_log = $conn->get($path, {start => $last_line});
287
288             my $printme = '';
289             for my $li (@$task_log) {
290                 if ($li->{t} eq 'no content') {
291                     next;
292                 }
293                 $printme .= $li->{t} . "\n";
294                 $last_line = $li->{n};
295             }
296
297             if ($printme ne '') {
298                 print $printme;
299             }
300         }
301
302         $task_status = $conn->get($path, {});
303
304         if ($task_status->{status} eq "stopped") {
305             last;
306         }
307
308         sleep(2);
309     }
310
311     if ($task_status->{exitstatus} ne "OK") {
312         die $task_status->{exitstatus};
313     }
314
315     return $task_status->{exitstatus};
316 }
317
318 sub configuration_directory {
319
320     my $home = $ENV{HOME} // '';
321     my $xdg = $ENV{XDG_CONFIG_HOME} // '';
322
323     my $subdir = "pveclient";
324
325     return "$xdg/$subdir" if length($xdg);
326
327     return "$home/.config/$subdir" if length($home);
328
329     die "neither XDG_CONFIG_HOME nor HOME environment variable set\n";
330 }
331
332 my $ticket_cache_filename = "/.tickets";
333
334 sub ticket_cache_lookup {
335     my ($remote) = @_;
336
337     my $dir = configuration_directory();
338     my $filename = "$dir/$ticket_cache_filename";
339
340     my $data = {};
341     eval { $data = from_json(PVE::APIClient::Tools::file_get_contents($filename)); };
342     # ignore errors
343
344     my $ticket = $data->{$remote};
345     return undef if !defined($ticket);
346
347     my $min_age = - 60;
348     my $max_age = 3600*2 - 60;
349
350     if ($ticket =~ m/:([a-fA-F0-9]{8})::/) {
351         my $ttime = hex($1);
352         my $ctime = time();
353         my $age = $ctime - $ttime;
354
355         return $ticket if ($age > $min_age) && ($age < $max_age);
356     }
357
358     return undef;
359 }
360
361 sub ticket_cache_update {
362     my ($remote, $ticket) = @_;
363
364     my $dir = configuration_directory();
365     my $filename = "$dir/$ticket_cache_filename";
366
367     my $code = sub {
368         make_path($dir);
369         my $data = {};
370         if (-f $filename) {
371             my $raw = PVE::APIClient::Tools::file_get_contents($filename);
372             eval { $data = from_json($raw); };
373             # ignore errors
374         }
375         $data->{$remote} = $ticket;
376
377         PVE::APIClient::Tools::file_set_contents($filename, to_json($data), 0600);
378     };
379
380     PVE::APIClient::Tools::lock_file($filename, undef, $code);
381     die $@ if $@;
382 }
383
384 sub extract_even_elements {
385     my ($list) = @_;
386
387     my $ind = 0;
388     return [ grep { ($ind++ % 2) == 0 } @$list ];
389 }
390
391 sub print_ordered_result {
392     my ($property_list, $data, $result_schema, $options) = @_;
393
394     my $param_order = extract_even_elements($property_list);
395
396     PVE::APIClient::CLIFormatter::print_api_result($data, $result_schema, $param_order, $options);
397 }
398
399 1;