src/PVE/CLIHandler.pm

   1 package PVE::CLIHandler;
   2
   3 use strict;
   4 use warnings;
   5 use Data::Dumper;
   6
   7 use PVE::SafeSyslog;
   8 use PVE::Exception qw(raise raise_param_exc);
   9 use PVE::RESTHandler;
  10 use PVE::INotify;
  11
  12 use base qw(PVE::RESTHandler);
  13
  14 my $cmddef;
  15 my $exename;
  16 my $cli_handler_class;
  17
  18 my $expand_command_name = sub {
  19     my ($def, $cmd) = @_;
  20
  21     if (!$def->{$cmd}) {
  22         my $expanded;
  23         for my $k (keys(%$def)) {
  24             if ($k =~ m/^$cmd/) {
  25                 if ($expanded) {
  26                     $expanded = undef; # more than one match
  27                     last;
  28                 } else {
  29                     $expanded = $k;
  30                 }
  31             }
  32         }
  33         $cmd = $expanded if $expanded;
  34     }
  35     return $cmd;
  36 };
  37
  38 my $complete_command_names = sub {
  39     my $res = [];
  40
  41     return if ref($cmddef) ne 'HASH';
  42
  43     foreach my $cmd (keys %$cmddef) {
  44         next if $cmd eq 'help';
  45         push @$res, $cmd;
  46     }
  47
  48     return $res;
  49 };
  50
  51 __PACKAGE__->register_method ({
  52     name => 'help',
  53     path => 'help',
  54     method => 'GET',
  55     description => "Get help about specified command.",
  56     parameters => {
  57         additionalProperties => 0,
  58         properties => {
  59             cmd => {
  60                 description => "Command name",
  61                 type => 'string',
  62                 optional => 1,
  63                 completion => $complete_command_names,
  64             },
  65             verbose => {
  66                 description => "Verbose output format.",
  67                 type => 'boolean',
  68                 optional => 1,
  69             },
  70         },
  71     },
  72     returns => { type => 'null' },
  73
  74     code => sub {
  75         my ($param) = @_;
  76
  77         die "not initialized" if !($cmddef && $exename && $cli_handler_class);
  78
  79         my $cmd = $param->{cmd};
  80
  81         my $verbose = defined($cmd) && $cmd;
  82         $verbose = $param->{verbose} if defined($param->{verbose});
  83
  84         if (!$cmd) {
  85             if ($verbose) {
  86                 print_usage_verbose();
  87             } else {
  88                 print_usage_short(\*STDOUT);
  89             }
  90             return undef;
  91         }
  92
  93         $cmd = &$expand_command_name($cmddef, $cmd);
  94
  95         my ($class, $name, $arg_param, $uri_param) = @{$cmddef->{$cmd} || []};
  96
  97         raise_param_exc({ cmd => "no such command '$cmd'"}) if !$class;
  98
  99         my $pwcallback = $cli_handler_class->can('read_password');
 100         my $stringfilemap = $cli_handler_class->can('string_param_file_mapping');
 101
 102         my $str = $class->usage_str($name, "$exename $cmd", $arg_param, $uri_param,
 103                                     $verbose ? 'full' : 'short', $pwcallback,
 104                                     $stringfilemap);
 105         if ($verbose) {
 106             print "$str\n";
 107         } else {
 108             print "USAGE: $str\n";
 109         }
 110
 111         return undef;
 112
 113     }});
 114
 115 sub print_simple_asciidoc_synopsys {
 116     my ($class, $name, $arg_param, $uri_param) = @_;
 117
 118     die "not initialized" if !$cli_handler_class;
 119
 120     my $pwcallback = $cli_handler_class->can('read_password');
 121     my $stringfilemap = $cli_handler_class->can('string_param_file_mapping');
 122
 123     my $synopsis = "*${name}* `help`\n\n";
 124
 125     $synopsis .= $class->usage_str($name, $name, $arg_param, $uri_param,
 126                                    'asciidoc', $pwcallback, $stringfilemap);
 127
 128     return $synopsis;
 129 }
 130
 131 sub print_asciidoc_synopsys {
 132
 133     die "not initialized" if !($cmddef && $exename && $cli_handler_class);
 134
 135     my $pwcallback = $cli_handler_class->can('read_password');
 136     my $stringfilemap = $cli_handler_class->can('string_param_file_mapping');
 137
 138     my $synopsis = "";
 139
 140     $synopsis .= "*${exename}* `<COMMAND> [ARGS] [OPTIONS]`\n\n";
 141
 142     my $oldclass;
 143     foreach my $cmd (sort keys %$cmddef) {
 144         my ($class, $name, $arg_param, $uri_param) = @{$cmddef->{$cmd}};
 145         my $str = $class->usage_str($name, "$exename $cmd", $arg_param,
 146                                     $uri_param, 'asciidoc', $pwcallback,
 147                                     $stringfilemap);
 148         $synopsis .= "\n" if $oldclass && $oldclass ne $class;
 149
 150         $synopsis .= "$str\n\n";
 151         $oldclass = $class;
 152     }
 153
 154     $synopsis .= "\n";
 155
 156     return $synopsis;
 157 }
 158
 159 sub print_usage_verbose {
 160
 161     die "not initialized" if !($cmddef && $exename && $cli_handler_class);
 162
 163     my $pwcallback = $cli_handler_class->can('read_password');
 164     my $stringfilemap = $cli_handler_class->can('string_param_file_mapping');
 165
 166     print "USAGE: $exename <COMMAND> [ARGS] [OPTIONS]\n\n";
 167
 168     foreach my $cmd (sort keys %$cmddef) {
 169         my ($class, $name, $arg_param, $uri_param) = @{$cmddef->{$cmd}};
 170         my $str = $class->usage_str($name, "$exename $cmd", $arg_param, $uri_param,
 171                                     'full', $pwcallback, $stringfilemap);
 172         print "$str\n\n";
 173     }
 174 }
 175
 176 sub sorted_commands {
 177     return sort { ($cmddef->{$a}->[0] cmp $cmddef->{$b}->[0]) || ($a cmp $b)} keys %$cmddef;
 178 }
 179
 180 sub print_usage_short {
 181     my ($fd, $msg) = @_;
 182
 183     die "not initialized" if !($cmddef && $exename && $cli_handler_class);
 184
 185     my $pwcallback = $cli_handler_class->can('read_password');
 186     my $stringfilemap = $cli_handler_class->can('string_param_file_mapping');
 187
 188     print $fd "ERROR: $msg\n" if $msg;
 189     print $fd "USAGE: $exename <COMMAND> [ARGS] [OPTIONS]\n";
 190
 191     my $oldclass;
 192     foreach my $cmd (sorted_commands()) {
 193         my ($class, $name, $arg_param, $uri_param) = @{$cmddef->{$cmd}};
 194         my $str = $class->usage_str($name, "$exename $cmd", $arg_param, $uri_param, 'short', $pwcallback, $stringfilemap);
 195         print $fd "\n" if $oldclass && $oldclass ne $class;
 196         print $fd "       $str";
 197         $oldclass = $class;
 198     }
 199 }
 200
 201 my $print_bash_completion = sub {
 202     my ($cmddef, $simple_cmd, $bash_command, $cur, $prev) = @_;
 203
 204     my $debug = 0;
 205
 206     return if !(defined($cur) && defined($prev) && defined($bash_command));
 207     return if !defined($ENV{COMP_LINE});
 208     return if !defined($ENV{COMP_POINT});
 209
 210     my $cmdline = substr($ENV{COMP_LINE}, 0, $ENV{COMP_POINT});
 211     print STDERR "\nCMDLINE: $ENV{COMP_LINE}\n" if $debug;
 212
 213     my $args = PVE::Tools::split_args($cmdline);
 214     my $pos = scalar(@$args) - 2;
 215     $pos += 1 if $cmdline =~ m/\s+$/;
 216
 217     print STDERR "CMDLINE:$pos:$cmdline\n" if $debug;
 218
 219     return if $pos < 0;
 220
 221     my $print_result = sub {
 222         foreach my $p (@_) {
 223             print "$p\n" if $p =~ m/^$cur/;
 224         }
 225     };
 226
 227     my $cmd;
 228     if ($simple_cmd) {
 229         $cmd = $simple_cmd;
 230     } else {
 231         if ($pos == 0) {
 232             &$print_result(keys %$cmddef);
 233             return;
 234         }
 235         $cmd = $args->[1];
 236     }
 237
 238     my $def = $cmddef->{$cmd};
 239     return if !$def;
 240
 241     print STDERR "CMDLINE1:$pos:$cmdline\n" if $debug;
 242
 243     my $skip_param = {};
 244
 245     my ($class, $name, $arg_param, $uri_param) = @$def;
 246     $arg_param //= [];
 247     $uri_param //= {};
 248
 249     $arg_param = [ $arg_param ] if !ref($arg_param);
 250
 251     map { $skip_param->{$_} = 1; } @$arg_param;
 252     map { $skip_param->{$_} = 1; } keys %$uri_param;
 253
 254     my $fpcount = scalar(@$arg_param);
 255
 256     my $info = $class->map_method_by_name($name);
 257
 258     my $schema = $info->{parameters};
 259     my $prop = $schema->{properties};
 260
 261     my $print_parameter_completion = sub {
 262         my ($pname) = @_;
 263         my $d = $prop->{$pname};
 264         if ($d->{completion}) {
 265             my $vt = ref($d->{completion});
 266             if ($vt eq 'CODE') {
 267                 my $res = $d->{completion}->($cmd, $pname, $cur, $args);
 268                 &$print_result(@$res);
 269             }
 270         } elsif ($d->{type} eq 'boolean') {
 271             &$print_result('0', '1');
 272         } elsif ($d->{enum}) {
 273             &$print_result(@{$d->{enum}});
 274         }
 275     };
 276
 277     # positional arguments
 278     $pos += 1 if $simple_cmd;
 279     if ($fpcount && $pos <= $fpcount) {
 280         my $pname = $arg_param->[$pos -1];
 281         &$print_parameter_completion($pname);
 282         return;
 283     }
 284
 285     my @option_list = ();
 286     foreach my $key (keys %$prop) {
 287         next if $skip_param->{$key};
 288         push @option_list, "--$key";
 289     }
 290
 291     if ($cur =~ m/^-/) {
 292         &$print_result(@option_list);
 293         return;
 294     }
 295
 296     if ($prev =~ m/^--?(.+)$/ && $prop->{$1}) {
 297         my $pname = $1;
 298         &$print_parameter_completion($pname);
 299         return;
 300     }
 301
 302     &$print_result(@option_list);
 303 };
 304
 305 sub verify_api {
 306     my ($class) = @_;
 307
 308     # simply verify all registered methods
 309     PVE::RESTHandler::validate_method_schemas();
 310 }
 311
 312 my $get_exe_name = sub {
 313     my ($class) = @_;
 314
 315     my $name = $class;
 316     $name =~ s/^.*:://;
 317     $name =~ s/_/-/g;
 318
 319     return $name;
 320 };
 321
 322 sub generate_bash_completions {
 323     my ($class) = @_;
 324
 325     # generate bash completion config
 326
 327     $exename = &$get_exe_name($class);
 328
 329     print <<__EOD__;
 330 # $exename bash completion
 331
 332 # see http://tiswww.case.edu/php/chet/bash/FAQ
 333 # and __ltrim_colon_completions() in /usr/share/bash-completion/bash_completion
 334 # this modifies global var, but I found no better way
 335 COMP_WORDBREAKS=\${COMP_WORDBREAKS//:}
 336
 337 complete -o default -C '$exename bashcomplete' $exename
 338 __EOD__
 339 }
 340
 341 sub find_cli_class_source {
 342     my ($name) = @_;
 343
 344     my $filename;
 345
 346     $name =~ s/-/_/g;
 347
 348     my $cpath = "PVE/CLI/${name}.pm";
 349     my $spath = "PVE/Service/${name}.pm";
 350     foreach my $p (@INC) {
 351         foreach my $s (($cpath, $spath)) {
 352             my $testfn = "$p/$s";
 353             if (-f $testfn) {
 354                 $filename = $testfn;
 355                 last;
 356             }
 357         }
 358         last if defined($filename);
 359     }
 360
 361     return $filename;
 362 }
 363
 364 sub generate_asciidoc_synopsys {
 365     my ($class) = @_;
 366
 367     $cli_handler_class = $class;
 368
 369     $exename = &$get_exe_name($class);
 370
 371     no strict 'refs';
 372     my $def = ${"${class}::cmddef"};
 373
 374     if (ref($def) eq 'ARRAY') {
 375         print_simple_asciidoc_synopsys(@$def);
 376     } else {
 377         $cmddef = $def;
 378
 379         $cmddef->{help} = [ __PACKAGE__, 'help', ['cmd'] ];
 380
 381         print_asciidoc_synopsys();
 382     }
 383 }
 384
 385 my $handle_cmd  = sub {
 386     my ($def, $cmdname, $cmd, $args, $pwcallback, $preparefunc, $stringfilemap) = @_;
 387
 388     $cmddef = $def;
 389     $exename = $cmdname;
 390
 391     $cmddef->{help} = [ __PACKAGE__, 'help', ['cmd'] ];
 392
 393     if (!$cmd) {
 394         print_usage_short (\*STDERR, "no command specified");
 395         exit (-1);
 396     } elsif ($cmd eq 'verifyapi') {
 397         PVE::RESTHandler::validate_method_schemas();
 398         return;
 399     } elsif ($cmd eq 'bashcomplete') {
 400         &$print_bash_completion($cmddef, 0, @$args);
 401         return;
 402     }
 403
 404     &$preparefunc() if $preparefunc;
 405
 406     $cmd = &$expand_command_name($cmddef, $cmd);
 407
 408     my ($class, $name, $arg_param, $uri_param, $outsub) = @{$cmddef->{$cmd} || []};
 409
 410     if (!$class) {
 411         print_usage_short (\*STDERR, "unknown command '$cmd'");
 412         exit (-1);
 413     }
 414
 415     my $prefix = "$exename $cmd";
 416     my $res = $class->cli_handler($prefix, $name, \@ARGV, $arg_param, $uri_param, $pwcallback, $stringfilemap);
 417
 418     &$outsub($res) if $outsub;
 419 };
 420
 421 my $handle_simple_cmd = sub {
 422     my ($def, $args, $pwcallback, $preparefunc, $stringfilemap) = @_;
 423
 424     my ($class, $name, $arg_param, $uri_param, $outsub) = @{$def};
 425     die "no class specified" if !$class;
 426
 427     if (scalar(@$args) >= 1) {
 428         if ($args->[0] eq 'help') {
 429             my $str = "USAGE: $name help\n";
 430             $str .= $class->usage_str($name, $name, $arg_param, $uri_param, 'long', $pwcallback, $stringfilemap);
 431             print STDERR "$str\n\n";
 432             return;
 433         } elsif ($args->[0] eq 'bashcomplete') {
 434             shift @$args;
 435             &$print_bash_completion({ $name => $def }, $name, @$args);
 436             return;
 437         } elsif ($args->[0] eq 'verifyapi') {
 438             PVE::RESTHandler::validate_method_schemas();
 439             return;
 440         }
 441     }
 442
 443     &$preparefunc() if $preparefunc;
 444
 445     my $res = $class->cli_handler($name, $name, \@ARGV, $arg_param, $uri_param, $pwcallback, $stringfilemap);
 446
 447     &$outsub($res) if $outsub;
 448 };
 449
 450 sub run_cli {
 451     my ($class, $pwcallback, $podfn, $preparefunc) = @_;
 452
 453     # Note: "depreciated function run_cli - use run_cli_handler instead";
 454     # silently ignore $podfn , which is no longer supported.
 455
 456     die "password callback is no longer supported" if $pwcallback;
 457
 458     run_cli_handler($class, prepare => $preparefunc);
 459 }
 460
 461 sub run_cli_handler {
 462     my ($class, %params) = @_;
 463
 464     $cli_handler_class = $class;
 465
 466     $ENV{'PATH'} = '/sbin:/bin:/usr/sbin:/usr/bin';
 467
 468     foreach my $key (keys %params) {
 469         next if $key eq 'prepare';
 470         next if $key eq 'no_init'; # used by lxc hooks
 471         next if $key eq 'no_rpcenv';
 472         die "unknown parameter '$key'";
 473     }
 474
 475     my $preparefunc = $params{prepare};
 476     my $no_init = $params{no_init};
 477     my $no_rpcenv = $params{no_rpcenv};
 478
 479     my $pwcallback = $class->can('read_password');
 480     my $stringfilemap = $class->can('string_param_file_mapping');
 481
 482     $exename = &$get_exe_name($class);
 483
 484     initlog($exename);
 485
 486     if ($class !~ m/^PVE::Service::/) {
 487         die "please run as root\n" if $> != 0;
 488
 489         PVE::INotify::inotify_init() if !$no_init;
 490
 491         if (!$no_rpcenv) {
 492         my $rpcenv = PVE::RPCEnvironment->init('cli');
 493             $rpcenv->init_request() if !$no_init;
 494             $rpcenv->set_language($ENV{LANG});
 495             $rpcenv->set_user('root@pam');
 496         }
 497     }
 498
 499     no strict 'refs';
 500     my $def = ${"${class}::cmddef"};
 501
 502     if (ref($def) eq 'ARRAY') {
 503         &$handle_simple_cmd($def, \@ARGV, $pwcallback, $preparefunc, $stringfilemap);
 504     } else {
 505         $cmddef = $def;
 506         my $cmd = shift @ARGV;
 507         &$handle_cmd($cmddef, $exename, $cmd, \@ARGV, $pwcallback, $preparefunc, $stringfilemap);
 508     }
 509
 510     exit 0;
 511 }
 512
 513 1;