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