use strict;
use warnings;
+use JSON;
+use Scalar::Util qw(weaken);
+
use PVE::SafeSyslog;
use PVE::Exception qw(raise raise_param_exc);
+use PVE::JSONSchema;
use PVE::RESTHandler;
+use PVE::PTY;
use PVE::INotify;
+use PVE::CLIFormatter;
use base qw(PVE::RESTHandler);
# A real command is always an array consisting of its class, name, array of
# position fixed (required) parameters and hash of predefined parameters when
# mapping a CLI command t o an API call. Optionally an output method can be
-# passed at the end, e.g., for formatting or transformation purpose.
+# passed at the end, e.g., for formatting or transformation purpose, and
+# a schema of additional properties/arguments which are added to
+# the method schema and gets passed to the formatter.
#
# [class, name, fixed_params, API_pre-set params, output_sub ]
#
my $exename;
my $cli_handler_class;
+my $standard_mappings = {
+ 'pve-password' => {
+ name => 'password',
+ desc => '<password>',
+ interactive => 1,
+ func => sub {
+ my ($value) = @_;
+ return $value if $value;
+ return PVE::PTY::get_confirmed_password();
+ },
+ },
+};
+sub get_standard_mapping {
+ my ($name, $base) = @_;
+
+ my $std = $standard_mappings->{$name};
+ die "no such standard mapping '$name'\n" if !$std;
+
+ my $res = $base || {};
+
+ foreach my $opt (keys %$std) {
+ next if defined($res->{$opt});
+ $res->{$opt} = $std->{$opt};
+ }
+
+ return $res;
+}
+
+my $gen_param_mapping_func = sub {
+ my ($cli_handler_class) = @_;
+
+ my $param_mapping = $cli_handler_class->can('param_mapping');
+
+ if (!$param_mapping) {
+ my $read_password = $cli_handler_class->can('read_password');
+ my $string_param_mapping = $cli_handler_class->can('string_param_file_mapping');
+
+ return $string_param_mapping if !$read_password;
+
+ $param_mapping = sub {
+ my ($name) = @_;
+
+ my $password_map = get_standard_mapping('pve-password', {
+ func => $read_password
+ });
+ my $map = $string_param_mapping ? $string_param_mapping->($name) : [];
+ return [@$map, $password_map];
+ };
+ }
+
+ return $param_mapping;
+};
+
my $assert_initialized = sub {
my @caller = caller;
die "$caller[0]:$caller[2] - not initialized\n"
};
my $expand_command_name = sub {
- my ($def, $cmd) = @_;
+ my ($def, $cmd, $enforce_exact) = @_;
return $cmd if exists $def->{$cmd}; # command is already complete
my $is_alias = sub { ref($_[0]) eq 'HASH' && exists($_[0]->{alias}) };
my @expanded = grep { /^\Q$cmd\E/ && !$is_alias->($def->{$_}) } keys %$def;
+ return @expanded if !$enforce_exact;
+
return $expanded[0] if scalar(@expanded) == 1; # enforce exact match
return undef;
my $complete_command_names = sub { $get_commands->($cmddef) };
-my $standard_mappings = { };
-
-sub get_standard_mapping {
- my ($name, $base) = @_;
-
- my $std = $standard_mappings->{$name};
- die "no such standard mapping '$name'\n" if !$std;
-
- my $res = $base || {};
-
- foreach my $opt (keys %$std) {
- next if defined($res->{$opt});
- $res->{$opt} = $std->{$opt};
- }
-
- return $res;
-}
-
# traverses the command definition using the $argv array, resolving one level
# of aliases.
# Returns the matching (sub) command and its definition, and argument array for
my $last_arg_id = scalar(@$argv) - 1;
for my $i (0..$last_arg_id) {
- $cmd = $expand_command_name->($def, $argv->[$i]);
+ $cmd = $expand_command_name->($def, $argv->[$i], 1);
if (defined($cmd)) {
# If the argument was expanded (or was already complete) and it
# is the final argument, tell our caller about it:
$expanded_last_arg = $cmd if $i == $last_arg_id;
} else {
# Otherwise continue with the unexpanded version of it.
- $cmd = $argv->[$i];
+ $cmd = $argv->[$i];
}
$cmdstr .= " $cmd";
+ if (!defined($def->{$cmd})) {
+ # $cmd still could be a valid prefix for bash_completion
+ # in that case keep $def as it is, else set it to undef
+ $def = undef if !$expand_command_name->($def, $cmd);
+ last;
+ }
$def = $def->{$cmd};
- last if !defined($def);
if (ref($def) eq 'ARRAY') {
# could expand to a real command, rest of $argv are its arguments
$separator //= '';
$indent //= '';
- my $read_password_func = $cli_handler_class->can('read_password');
- my $param_mapping_func = $cli_handler_class->can('param_mapping') ||
- $cli_handler_class->can('string_param_file_mapping');
+ my $param_cb = $gen_param_mapping_func->($cli_handler_class);
my ($subcmd, $def, undef, undef, $cmdstr) = resolve_cmd($cmd);
- $abort->("unknown command '$cmdstr'") if !defined($def) && ref($cmd) eq 'ARRAY';
- my $generate;
- $generate = sub {
+ my $generate_weak;
+ $generate_weak = sub {
my ($indent, $separator, $def, $prefix) = @_;
my $str = '';
foreach my $cmd (&$sortfunc($def)) {
if (ref($def->{$cmd}) eq 'ARRAY') {
- my ($class, $name, $arg_param, $fixed_param) = @{$def->{$cmd}};
+ my ($class, $name, $arg_param, $fixed_param, undef, $formatter_properties) = @{$def->{$cmd}};
$str .= $separator if $oldclass && $oldclass ne $class;
$str .= $indent;
$str .= $class->usage_str($name, "$prefix $cmd", $arg_param,
- $fixed_param, $format,
- $read_password_func, $param_mapping_func);
+ $fixed_param, $format, $param_cb, $formatter_properties);
$oldclass = $class;
} elsif (defined($def->{$cmd}->{alias}) && ($format eq 'asciidoc')) {
} else {
next if $def->{$cmd}->{alias};
- my $substr = $generate->($indent, $separator, $def->{$cmd}, "$prefix $cmd");
+ my $substr = $generate_weak->($indent, '', $def->{$cmd}, "$prefix $cmd");
if ($substr) {
$substr .= $separator if $substr !~ /\Q$separator\E{2}/;
$str .= $substr;
}
} else {
- my ($class, $name, $arg_param, $fixed_param) = @$def;
- $abort->("unknown command '$cmd'") if !$class;
+ $abort->("unknown command '$cmd->[0]'") if !$def;
+ my ($class, $name, $arg_param, $fixed_param, undef, $formatter_properties) = @$def;
$str .= $indent;
- $str .= $class->usage_str($name, $prefix, $arg_param, $fixed_param, $format,
- $read_password_func, $param_mapping_func);
+ $str .= $class->usage_str($name, $prefix, $arg_param, $fixed_param, $format, $param_cb, $formatter_properties);
}
return $str;
};
+ my $generate = $generate_weak;
+ weaken($generate_weak);
return $generate->($indent, $separator, $def, $cmdstr);
}
$assert_initialized->();
print $fd "ERROR: $msg\n" if $msg;
- print $fd "USAGE: $exename <COMMAND> [ARGS] [OPTIONS]\n";
+ print $fd "USAGE: $exename <COMMAND> [ARGS] [OPTIONS]\n\n";
- print {$fd} generate_usage_str('short', $cmd, ' ' x 7, "\n", sub {
+ print {$fd} generate_usage_str('short', $cmd, ' ' x 7, $cmd ? '' : "\n", sub {
my ($h) = @_;
return sort {
if (ref($h->{$a}) eq 'ARRAY' && ref($h->{$b}) eq 'ARRAY') {
my $skip_param = {};
- my ($class, $name, $arg_param, $uri_param) = @$def;
+ my ($class, $name, $arg_param, $uri_param, undef, $formatter_properties) = @$def;
$arg_param //= [];
$uri_param //= {};
my $info = $class->map_method_by_name($name);
- my $prop = $info->{parameters}->{properties};
+ my $prop = { %{$info->{parameters}->{properties}} }; # copy
+ $prop = { %$prop, %$formatter_properties } if $formatter_properties;
my $print_parameter_completion = sub {
my ($pname) = @_;
&$print_result(@option_list);
};
-# prints a formatted table with a title row.
-# $formatopts is an array of hashes, with the following keys:
-# 'key' - key of $data element to print
-# 'title' - column title, defaults to 'key' - won't get cutoff
-# 'cutoff' - maximal (print) length of this column values, if set
-# the last column will never be cutoff
-# 'default' - optional default value for the column
-# formatopts element order defines column order (left to right)
-sub print_text_table {
- my ($formatopts, $data) = @_;
-
- my ($formatstring, @keys, @titles, %cutoffs, %defaults);
- my $last_col = $formatopts->[$#{$formatopts}];
-
- foreach my $col ( @$formatopts ) {
- my ($key, $title, $cutoff, $default) = @$col{qw(key title cutoff default)};
- $title //= $key;
-
- push @keys, $key;
- push @titles, $title;
- $defaults{$key} = $default;
-
- # calculate maximal print width and cutoff
- my $titlelen = length($title);
-
- my $longest = $titlelen;
- foreach my $entry (@$data) {
- my $len = length($entry->{$key}) // 0;
- $longest = $len if $len > $longest;
- }
-
- $cutoff = (defined($cutoff) && $cutoff < $longest) ? $cutoff : $longest;
- $cutoffs{$key} = $cutoff;
-
- my $printalign = $cutoff > $titlelen ? '-' : '';
- if ($col == $last_col) {
- $formatstring .= "%${printalign}${titlelen}s\n";
- } else {
- $formatstring .= "%${printalign}${cutoff}s ";
- }
- }
-
- printf $formatstring, @titles;
-
- foreach my $entry (sort { $a->{$keys[0]} cmp $b->{$keys[0]} } @$data) {
- printf $formatstring, map { substr(($entry->{$_} // $defaults{$_}), 0 , $cutoffs{$_}) } @keys;
- }
-}
-
-sub print_entry {
- my $entry = shift;
-
- #TODO: handle objects/hashes as well
- foreach my $item (sort keys %$entry) {
- if (ref($entry->{$item}) eq 'ARRAY') {
- printf "%s: [ %s ]\n", $item, join(", ", @{$entry->{$item}});
- } else {
- printf "%s: %s\n", $item, $entry->{$item};
- }
- }
-}
-
-# prints the result of an API GET call returning an array
-# and to have the results key of the API call defined.
-sub print_api_list {
- my ($props_to_print, $data, $returninfo) = @_;
-
- die "can only print array result" if $returninfo->{type} ne 'array';
-
- my $returnprops = $returninfo->{items}->{properties};
-
- my $formatopts = [];
- foreach my $prop ( @$props_to_print ) {
- my $propinfo = $returnprops->{$prop};
- my $colopts = {
- key => $prop,
- title => $propinfo->{title},
- default => $propinfo->{default},
- cutoff => $propinfo->{print_width} // $propinfo->{maxLength},
- };
- push @$formatopts, $colopts;
- }
-
- print_text_table($formatopts, $data);
-}
-
sub verify_api {
my ($class) = @_;
__EOD__
}
+sub generate_zsh_completions {
+ my ($class) = @_;
+
+ # generate zsh completion config
+
+ $exename = &$get_exe_name($class);
+
+ print <<__EOD__;
+#compdef _$exename $exename
+
+function _$exename() {
+ local cwords line point cmd curr prev
+ cwords=\${#words[@]}
+ line=\$words
+ point=\${#line}
+ cmd=\${words[1]}
+ curr=\${words[cwords]}
+ prev=\${words[cwords-1]}
+ compadd -- \$(COMP_CWORD="\$cwords" COMP_LINE="\$line" COMP_POINT="\$point" \\
+ $exename bashcomplete "\$cmd" "\$curr" "\$prev")
+}
+__EOD__
+}
+
sub generate_asciidoc_synopsys {
my ($class) = @_;
$class->generate_asciidoc_synopsis();
}
my $handle_cmd = sub {
- my ($args, $read_password_func, $preparefunc, $param_mapping_func) = @_;
+ my ($args, $preparefunc, $param_cb) = @_;
$cmddef->{help} = [ __PACKAGE__, 'help', ['extra-args'] ];
&$preparefunc() if $preparefunc;
- my ($class, $name, $arg_param, $uri_param, $outsub) = @{$def || []};
+ my ($class, $name, $arg_param, $uri_param, $outsub, $formatter_properties) = @{$def || []};
$abort->("unknown command '$cmd_str'") if !$class;
- my $res = $class->cli_handler($cmd_str, $name, $cmd_args, $arg_param, $uri_param, $read_password_func, $param_mapping_func);
+ my ($res, $formatter_params) = $class->cli_handler(
+ $cmd_str, $name, $cmd_args, $arg_param, $uri_param, $param_cb, $formatter_properties);
if (defined $outsub) {
- my $returninfo = $class->map_method_by_name($name)->{returns};
- $outsub->($res, $returninfo);
+ my $result_schema = $class->map_method_by_name($name)->{returns};
+ $outsub->($res, $result_schema, $formatter_params);
}
};
my $handle_simple_cmd = sub {
- my ($args, $read_password_func, $preparefunc, $param_mapping_func) = @_;
+ my ($args, $preparefunc, $param_cb) = @_;
- my ($class, $name, $arg_param, $uri_param, $outsub) = @{$cmddef};
+ my ($class, $name, $arg_param, $uri_param, $outsub, $formatter_properties) = @{$cmddef};
die "no class specified" if !$class;
if (scalar(@$args) >= 1) {
&$preparefunc() if $preparefunc;
- my $res = $class->cli_handler($name, $name, \@ARGV, $arg_param, $uri_param, $read_password_func, $param_mapping_func);
+ my ($res, $formatter_params) = $class->cli_handler(
+ $name, $name, \@ARGV, $arg_param, $uri_param, $param_cb, $formatter_properties);
if (defined $outsub) {
- my $returninfo = $class->map_method_by_name($name)->{returns};
- $outsub->($res, $returninfo);
+ my $result_schema = $class->map_method_by_name($name)->{returns};
+ $outsub->($res, $result_schema, $formatter_params);
}
};
my $preparefunc = $params{prepare};
- my $read_password_func = $class->can('read_password');
- my $param_mapping_func = $cli_handler_class->can('param_mapping') ||
- $class->can('string_param_file_mapping');
+ my $param_cb = $gen_param_mapping_func->($cli_handler_class);
$exename = &$get_exe_name($class);
- initlog($exename);
+ my $logid = $ENV{PVE_LOG_ID} || $exename;
+ initlog($logid);
no strict 'refs';
$cmddef = ${"${class}::cmddef"};
if (ref($cmddef) eq 'ARRAY') {
- &$handle_simple_cmd(\@ARGV, $read_password_func, $preparefunc, $param_mapping_func);
+ $handle_simple_cmd->(\@ARGV, $preparefunc, $param_cb);
} else {
- &$handle_cmd(\@ARGV, $read_password_func, $preparefunc, $param_mapping_func);
+ $handle_cmd->(\@ARGV, $preparefunc, $param_cb);
}
exit 0;
projects / pve-common.git / blobdiff