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;