bin/pvesh

   1 #!/usr/bin/perl
   2
   3 # TODO:
   4 # implement persistent history ?
   5
   6 use strict;
   7 use warnings;
   8 use Term::ReadLine;
   9 use File::Basename;
  10 use Getopt::Long;
  11 use HTTP::Status qw(:constants :is status_message);
  12 use Text::ParseWords;
  13 use PVE::JSONSchema;
  14 use PVE::SafeSyslog;
  15 use PVE::Cluster;
  16 use PVE::INotify;
  17 use PVE::RPCEnvironment;
  18 use PVE::API2;
  19 use JSON;
  20
  21 PVE::INotify::inotify_init();
  22
  23 my $rpcenv = PVE::RPCEnvironment->init('cli');
  24
  25 $rpcenv->set_language($ENV{LANG});
  26 $rpcenv->set_user('root@pam');
  27
  28 my $logid = $ENV{PVE_LOG_ID} || 'pvesh';
  29 initlog($logid);
  30
  31 my $basedir = '/api2/json';
  32
  33 my $cdir = '';
  34
  35 sub print_usage {
  36     my $msg = shift;
  37
  38     print STDERR "ERROR: $msg\n" if $msg;
  39     print STDERR "USAGE: pvesh [verifyapi]\n";
  40     print STDERR "       pvesh CMD [OPTIONS]\n";
  41
  42 }
  43
  44 my $disable_proxy = 0;
  45 my $opt_nooutput = 0;
  46
  47 my $cmd = shift;
  48
  49 my $optmatch;
  50 do {
  51     $optmatch = 0;
  52     if ($cmd) {
  53         if ($cmd eq '--noproxy') {
  54             $cmd = shift;
  55             $disable_proxy = 1;
  56             $optmatch = 1;
  57         } elsif ($cmd eq '--nooutput') {
  58             # we use this when starting task in CLI (suppress printing upid)
  59             # for example 'pvesh --nooutput create /nodes/localhost/stopall'
  60             $cmd = shift;
  61             $opt_nooutput = 1;
  62             $optmatch = 1;
  63         }
  64     }
  65 } while ($optmatch);
  66
  67 if ($cmd) {
  68     if ($cmd eq 'verifyapi') {
  69         PVE::RESTHandler::validate_method_schemas();
  70         exit 0;
  71     } elsif ($cmd eq 'ls' || $cmd eq 'get' || $cmd eq 'create' ||
  72              $cmd eq 'set' || $cmd eq 'delete' ||$cmd eq 'help' ) {
  73         pve_command([ $cmd, @ARGV],  $opt_nooutput);
  74         exit(0);
  75     } else {
  76         print_usage ("unknown command '$cmd'");
  77         exit (-1);
  78     }
  79 }
  80
  81 if (scalar (@ARGV) != 0) {
  82     print_usage ();
  83     exit (-1);
  84 }
  85
  86 print "entering PVE shell - type 'help' for help\n";
  87
  88 my $term = new Term::ReadLine ('pvesh');
  89 my $attribs = $term->Attribs;
  90
  91 sub complete_path {
  92     my($text) = @_;
  93
  94     my ($dir, undef, $rest) = $text =~ m|^(.*/)?(([^/]*))?$|;
  95     my $path = abs_path($cdir, $dir);
  96
  97     my @res = ();
  98
  99     my $di = dir_info($path);
 100     if (my $children = $di->{children}) {
 101         foreach my $c (@$children) {
 102             if ($c =~ /^\Q$rest/) {
 103                 my $new =  $dir ? "$dir$c" : $c;
 104                 push @res, $new;
 105             }
 106         }
 107     }
 108
 109     if (scalar(@res) == 0) {
 110         return undef;
 111     } elsif (scalar(@res) == 1) {
 112         return ($res[0], $res[0], "$res[0]/");
 113     }
 114
 115     # lcd : lowest common denominator
 116     my $lcd = '';
 117     my $tmp = $res[0];
 118     for (my $i = 1; $i <= length($tmp); $i++) {
 119         my $found = 1;
 120         foreach my $p (@res) {
 121             if (substr($tmp, 0, $i) ne substr($p, 0, $i)) {
 122                 $found = 0;
 123                 last;
 124             }
 125         }
 126         if ($found) {
 127             $lcd = substr($tmp, 0, $i);
 128         } else {
 129             last;
 130         }
 131     }
 132
 133     return ($lcd, @res);
 134 };
 135
 136 # just to avoid an endless loop (called by attempted_completion_function)
 137 $attribs->{completion_entry_function} = sub {
 138     my($text, $state) = @_;
 139     return undef;
 140 };
 141
 142 $attribs->{attempted_completion_function} = sub {
 143     my ($text, $line, $start) = @_;
 144
 145     my $prefix = substr($line, 0, $start);
 146     if ($prefix =~ /^\s*$/) { # first word (command completeion)
 147         $attribs->{completion_word} = [qw(help ls cd get set create delete quit)];
 148         return $term->completion_matches($text, $attribs->{list_completion_function});
 149     }
 150
 151     if ($prefix =~ /^\s*\S+\s+$/) { # second word (path completion)
 152         return complete_path($text);
 153     }
 154
 155     return ();
 156 };
 157
 158 sub abs_path {
 159     my ($current, $path) = @_;
 160
 161     my $ret = $current;
 162
 163     return $current if !defined($path);
 164
 165     $ret = '' if $path =~ m|^\/|;
 166
 167     foreach my $d (split (/\/+/ , $path)) {
 168         if ($d eq '.') {
 169             next;
 170         } elsif ($d eq '..') {
 171             $ret = dirname($ret);
 172             $ret = '' if $ret eq '.';
 173         } else {
 174             $ret = "$ret/$d";
 175         }
 176     }
 177
 178     $ret =~ s|\/+|\/|g;
 179     $ret =~ s|^\/||;
 180     $ret =~ s|\/$||;
 181
 182     return $ret;
 183 }
 184
 185 my $read_password = sub {
 186     my $attribs = $term->Attribs;
 187     my $old = $attribs->{redisplay_function};
 188     $attribs->{redisplay_function} = $attribs->{shadow_redisplay};
 189     my $input = $term->readline('password: ');
 190     my $conf = $term->readline('Retype new password: ');
 191     $attribs->{redisplay_function} = $old;
 192
 193     # remove password from history
 194     if ($term->Features->{autohistory}) {
 195         my $historyPosition = $term->where_history();
 196         $term->remove_history($historyPosition);
 197         $term->remove_history($historyPosition - 1);
 198     }
 199
 200     die "Passwords do not match.\n" if ($input ne $conf);
 201     return $input;
 202 };
 203
 204 sub reverse_map_cmd {
 205     my $method = shift;
 206
 207     my $mmap = {
 208         GET => 'get',
 209         PUT => 'set',
 210         POST => 'create',
 211         DELETE => 'delete',
 212     };
 213
 214     my $cmd = $mmap->{$method};
 215
 216     die "got strange value for method ('$method') - internal error" if !$cmd;
 217
 218     return $cmd;
 219 }
 220
 221 sub map_cmd {
 222     my $cmd = shift;
 223
 224     my $mmap = {
 225         create => 'POST',
 226         set => 'PUT',
 227         get => 'GET',
 228         ls => 'GET',
 229         delete => 'DELETE',
 230     };
 231
 232     my $method = $mmap->{$cmd};
 233
 234     die "unable to map method" if !$method;
 235
 236     return $method;
 237 }
 238
 239 sub check_proxyto {
 240     my ($info, $uri_param) = @_;
 241
 242     if ($info->{proxyto}) {
 243         my $pn = $info->{proxyto};
 244         my $node = $uri_param->{$pn};
 245         die "proxy parameter '$pn' does not exists" if !$node;
 246
 247         if ($node ne 'localhost' && ($node ne PVE::INotify::nodename())) {
 248             die "proxy loop detected - aborting\n" if $disable_proxy;
 249             my $remip = PVE::Cluster::remote_node_ip($node);
 250             return ($node, $remip);
 251         }
 252     }
 253
 254     return undef;
 255 }
 256
 257 sub proxy_handler {
 258     my ($node, $remip, $dir, $cmd, $args) = @_;
 259
 260     my $remcmd = ['ssh', '-o', 'BatchMode=yes', "root\@$remip",
 261                'pvesh', '--noproxy', $cmd, $dir, @$args];
 262
 263     system(@$remcmd) == 0 || die "proxy handler failed\n";
 264 }
 265
 266 sub call_method {
 267     my ($dir, $cmd, $args, $nooutput) = @_;
 268
 269     my $method = map_cmd($cmd);
 270
 271     my $uri_param = {};
 272     my ($handler, $info) = PVE::API2->find_handler($method, $dir, $uri_param);
 273     if (!$handler || !$info) {
 274         die "no '$cmd' handler for '$dir'\n";
 275     }
 276
 277     my ($node, $remip) = check_proxyto($info, $uri_param);
 278     return proxy_handler($node, $remip, $dir, $cmd, $args) if $node;
 279
 280     my $data = $handler->cli_handler("$cmd $dir", $info->{name}, $args, [], $uri_param, $read_password);
 281
 282     return if $nooutput;
 283
 284     warn "200 OK\n"; # always print OK status if successful
 285
 286     if ($info && $info->{returns} && $info->{returns}->{type}) {
 287         my $rtype = $info->{returns}->{type};
 288
 289         return if $rtype eq 'null';
 290
 291         if ($rtype eq 'string') {
 292             print $data if $data;
 293             return;
 294         }
 295     }
 296
 297     print to_json($data, {utf8 => 1, allow_nonref => 1, canonical => 1, pretty => 1 });
 298
 299     return;
 300 }
 301
 302 sub find_resource_methods {
 303     my ($path, $ihash) = @_;
 304
 305     for my $method (qw(GET POST PUT DELETE)) {
 306         my $uri_param = {};
 307         my $path_match;
 308         my ($handler, $info) = PVE::API2->find_handler($method, $path, $uri_param, \$path_match);
 309         if ($handler && $info && !$ihash->{$info}) {
 310             $ihash->{$info} = {
 311                 path => $path_match,
 312                 handler => $handler,
 313                 info => $info,
 314                 uri_param => $uri_param,
 315             };
 316         }
 317     }
 318 }
 319
 320 sub print_help {
 321     my ($path, $opts) = @_;
 322
 323     my $ihash = {};
 324
 325     find_resource_methods($path, $ihash);
 326
 327     if (!scalar(keys(%$ihash))) {
 328         die "no such resource\n";
 329     }
 330
 331     my $di = dir_info($path);
 332     if (my $children = $di->{children}) {
 333         foreach my $c (@$children) {
 334             my $cp = abs_path($path, $c);
 335             find_resource_methods($cp, $ihash);
 336         }
 337     }
 338
 339     foreach my $mi (sort { $a->{path} cmp $b->{path} } values %$ihash) {
 340         my $method = $mi->{info}->{method};
 341
 342         # we skip index methods for now.
 343         next if ($method eq 'GET') && PVE::JSONSchema::method_get_child_link($mi->{info});
 344
 345         my $path = $mi->{path};
 346         $path =~ s|/+$||; # remove trailing slash
 347
 348         my $cmd = reverse_map_cmd($method);
 349
 350         print $mi->{handler}->usage_str($mi->{info}->{name}, "$cmd $path", [], $mi->{uri_param},
 351                                         $opts->{verbose} ? 'full' : 'short', 1);
 352         print "\n\n" if $opts->{verbose};
 353     }
 354
 355 };
 356
 357 sub resource_cap {
 358     my ($path) = @_;
 359
 360     my $res = '';
 361
 362     my ($handler, $info) = PVE::API2->find_handler('GET', $path);
 363     if (!($handler && $info)) {
 364         $res .= '--';
 365     } else {
 366         if (PVE::JSONSchema::method_get_child_link($info)) {
 367             $res .= 'Dr';
 368         } else {
 369             $res .= '-r';
 370         }
 371     }
 372
 373     ($handler, $info) = PVE::API2->find_handler('PUT', $path);
 374     if (!($handler && $info)) {
 375         $res .= '-';
 376     } else {
 377         $res .= 'w';
 378     }
 379
 380     ($handler, $info) = PVE::API2->find_handler('POST', $path);
 381     if (!($handler && $info)) {
 382         $res .= '-';
 383     } else {
 384         $res .= 'c';
 385     }
 386
 387     ($handler, $info) = PVE::API2->find_handler('DELETE', $path);
 388     if (!($handler && $info)) {
 389         $res .= '-';
 390     } else {
 391         $res .= 'd';
 392     }
 393
 394     return $res;
 395 }
 396
 397 sub extract_children {
 398     my ($lnk, $data) = @_;
 399
 400     my $res = [];
 401
 402     return $res if !($lnk && $data);
 403
 404     my $href = $lnk->{href};
 405     if ($href =~ m/^\{(\S+)\}$/) {
 406         my $prop = $1;
 407
 408         foreach my $elem (sort {$a->{$prop} cmp $b->{$prop}} @$data) {
 409             next if !ref($elem);
 410             my $value = $elem->{$prop};
 411             push @$res, $value;
 412         }
 413     }
 414
 415     return $res;
 416 }
 417
 418 sub dir_info {
 419     my ($path) = @_;
 420
 421     my $res = { path => $path };
 422     my $uri_param = {};
 423     my ($handler, $info, $pm) = PVE::API2->find_handler('GET', $path, $uri_param);
 424     if ($handler && $info) {
 425         eval {
 426             my $data = $handler->handle($info, $uri_param);
 427             my $lnk = PVE::JSONSchema::method_get_child_link($info);
 428             $res->{children} = extract_children($lnk, $data);
 429         }; # ignore errors ?
 430     }
 431     return $res;
 432 }
 433
 434 sub list_dir {
 435     my ($dir, $args) = @_;
 436
 437     my $uri_param = {};
 438     my ($handler, $info) = PVE::API2->find_handler('GET', $dir, $uri_param);
 439     if (!$handler || !$info) {
 440         die "no such resource\n";
 441     }
 442
 443     if (!PVE::JSONSchema::method_get_child_link($info)) {
 444         die "resource does not define child links\n";
 445     }
 446
 447     my ($node, $remip) = check_proxyto($info, $uri_param);
 448     return proxy_handler($node, $remip, $dir, 'ls', $args) if $node;
 449
 450
 451     my $data = $handler->cli_handler("ls $dir", $info->{name}, $args, [], $uri_param, $read_password);
 452     my $lnk = PVE::JSONSchema::method_get_child_link($info);
 453     my $children = extract_children($lnk, $data);
 454
 455     foreach my $c (@$children) {
 456         my $cap = resource_cap(abs_path($dir, $c));
 457         print "$cap $c\n";
 458     }
 459 }
 460
 461
 462 sub pve_command {
 463     my ($args, $nooutput) = @_;
 464
 465     PVE::Cluster::cfs_update();
 466
 467     $rpcenv->init_request();
 468
 469     my $cmd = shift @$args;
 470
 471     if ($cmd eq 'cd') {
 472
 473         my $path =  shift @$args;
 474
 475         die "usage: cd [dir]\n" if scalar(@$args);
 476
 477         if (!defined($path)) {
 478             $cdir = '';
 479             return;
 480         } else {
 481             my $new_dir = abs_path($cdir, $path);
 482             my ($handler, $info) = PVE::API2->find_handler('GET', $new_dir);
 483             die "no such resource\n" if !$handler;
 484             $cdir = $new_dir;
 485         }
 486
 487     } elsif ($cmd eq 'help') {
 488
 489         my $help_usage_error = sub {
 490             die "usage: help [path] [--verbose]\n";
 491         };
 492
 493         my $opts = {};
 494
 495         &$help_usage_error() if !Getopt::Long::GetOptionsFromArray($args, $opts, 'verbose');
 496
 497         my $path;
 498         if (scalar(@$args) && $args->[0] !~ m/^\-/)  {
 499             $path = shift @$args;
 500         }
 501
 502         &$help_usage_error() if scalar(@$args);
 503
 504         print "help [path] [--verbose]\n";
 505         print "cd [path]\n";
 506         print "ls [path]\n\n";
 507
 508         print_help(abs_path($cdir, $path), $opts);
 509
 510     } elsif ($cmd eq 'ls') {
 511         my $path;
 512         if (scalar(@$args) && $args->[0] !~ m/^\-/)  {
 513             $path = shift @$args;
 514         }
 515
 516         list_dir(abs_path($cdir, $path), $args);
 517
 518     } elsif ($cmd =~ m/^get|delete|set$/) {
 519
 520         my $path;
 521         if (scalar(@$args) && $args->[0] !~ m/^\-/)  {
 522             $path = shift @$args;
 523         }
 524
 525         call_method(abs_path($cdir, $path), $cmd, $args);
 526
 527     } elsif ($cmd eq 'create') {
 528
 529         my $path;
 530         if (scalar(@$args) && $args->[0] !~ m/^\-/)  {
 531             $path = shift @$args;
 532         }
 533
 534         call_method(abs_path($cdir, $path), $cmd, $args, $nooutput);
 535
 536     } else {
 537         die "unknown command '$cmd'\n";
 538     }
 539
 540 }
 541
 542 my $input;
 543 while (defined ($input = $term->readline("pve:/$cdir> "))) {
 544     chomp $input;
 545
 546     next if $input =~ m/^\s*$/;
 547
 548     if ($input =~ m/^\s*q(uit)?\s*$/) {
 549         exit (0);
 550     }
 551
 552     # add input to history if it gets not
 553     # automatically added
 554     if (!$term->Features->{autohistory}) {
 555         $term->addhistory($input);
 556     }
 557
 558     eval {
 559         my $args = [ shellwords($input) ];
 560         pve_command($args);
 561     };
 562     warn $@ if $@;
 563 }
 564
 565 __END__
 566
 567 =head1 NAME
 568
 569 pvesh - shell interface to the Promox VE API
 570
 571 =head1 SYNOPSIS
 572
 573 pvesh [get|set|create|delete|help] [REST API path] [--verbose]
 574
 575 =head1 DESCRIPTION
 576
 577 pvesh provides a shell-like interface to the Proxmox VE REST API, in two different modes:
 578
 579 =over
 580
 581 =item interactive
 582
 583 when called without parameters, pvesh starts an interactive client, where you can navigate
 584 in the different parts of the API
 585
 586 =item command line
 587
 588 when started with parameters pvesh will send a command to the corresponding REST url, and will
 589 return the JSON formatted output
 590
 591 =back
 592
 593 =head1 EXAMPLES
 594
 595 get the list of nodes in my cluster
 596
 597 pvesh get /nodes
 598
 599 get a list of available options for the datacenter
 600
 601 pvesh help cluster/options -v
 602
 603 set the HTMl5 NoVNC console as the default console for the datacenter
 604
 605 pvesh set cluster/options -console html5
 606
 607 =head1 SEE ALSO
 608
 609 qm(1), pct(1)