X-Git-Url: https://git.proxmox.com/?p=pve-common.git;a=blobdiff_plain;f=src%2FPVE%2FCLIHandler.pm;h=9955d77e06395c85dd219dac7d9f322bc1824992;hp=8753e73b524f781aac6975bfc57274268e5c8c78;hb=87e31b23589e2747b819d7ac5f1fc45f6754b9c1;hpb=4842b6510546f76906b216cb05d98ec9768f9e8e diff --git a/src/PVE/CLIHandler.pm b/src/PVE/CLIHandler.pm index 8753e73..9955d77 100644 --- a/src/PVE/CLIHandler.pm +++ b/src/PVE/CLIHandler.pm @@ -2,13 +2,17 @@ package PVE::CLIHandler; 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); @@ -16,7 +20,9 @@ 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 ] # @@ -51,7 +57,6 @@ my $standard_mappings = { }, }, }; - sub get_standard_mapping { my ($name, $base) = @_; @@ -106,13 +111,15 @@ my $abort = sub { }; 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; @@ -141,18 +148,23 @@ sub resolve_cmd { 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 @@ -185,13 +197,12 @@ sub generate_usage_str { $separator //= ''; $indent //= ''; - my $param_mapping_func = $gen_param_mapping_func->($cli_handler_class); + 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 = ''; @@ -200,13 +211,12 @@ sub generate_usage_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, - $param_mapping_func); + $fixed_param, $format, $param_cb, $formatter_properties); $oldclass = $class; } elsif (defined($def->{$cmd}->{alias}) && ($format eq 'asciidoc')) { @@ -216,7 +226,7 @@ sub generate_usage_str { } 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; @@ -225,15 +235,16 @@ sub generate_usage_str { } } 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, - $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); } @@ -335,9 +346,9 @@ sub print_usage_short { $assert_initialized->(); print $fd "ERROR: $msg\n" if $msg; - print $fd "USAGE: $exename [ARGS] [OPTIONS]\n"; + print $fd "USAGE: $exename [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') { @@ -397,7 +408,7 @@ my $print_bash_completion = sub { 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 //= {}; @@ -408,7 +419,8 @@ my $print_bash_completion = sub { 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) = @_; @@ -453,150 +465,6 @@ my $print_bash_completion = sub { &$print_result(@option_list); }; -sub data_to_text { - my ($data) = @_; - - return '' if !defined($data); - - if (my $class = ref($data)) { - return to_json($data, { utf8 => 1, canonical => 1 }); - } else { - return "$data"; - } -} - -# prints a formatted table with a title row. -# $data - the data to print (array of objects) -# $returnprops -json schema property description -# $props_to_print - ordered list of properties to print -# $sort_key can be used to sort after a column, if it isn't set we sort -# after the leftmost column (with no undef value in $data) this can be -# turned off by passing 0 as $sort_key -sub print_text_table { - my ($data, $returnprops, $props_to_print, $sort_key) = @_; - - my $autosort = 1; - if (defined($sort_key) && $sort_key eq 0) { - $autosort = 0; - $sort_key = undef; - } - - my $colopts = {}; - my $formatstring = ''; - - my $column_count = scalar(@$props_to_print); - - for (my $i = 0; $i < $column_count; $i++) { - my $prop = $props_to_print->[$i]; - my $propinfo = $returnprops->{$prop} // {}; - - my $title = $propinfo->{title} // $prop; - my $cutoff = $propinfo->{print_width} // $propinfo->{maxLength}; - - # calculate maximal print width and cutoff - my $titlelen = length($title); - - my $longest = $titlelen; - my $sortable = $autosort; - foreach my $entry (@$data) { - my $len = length(data_to_text($entry->{$prop})) // 0; - $longest = $len if $len > $longest; - $sortable = 0 if !defined($entry->{$prop}); - } - $cutoff = $longest if !defined($cutoff) || $cutoff > $longest; - $sort_key //= $prop if $sortable; - - $colopts->{$prop} = { - title => $title, - default => $propinfo->{default} // '', - cutoff => $cutoff, - }; - - # skip alignment and cutoff on last column - $formatstring .= ($i == ($column_count - 1)) ? "%s\n" : "%-${cutoff}s "; - } - - printf $formatstring, map { $colopts->{$_}->{title} } @$props_to_print; - - if (defined($sort_key)) { - my $type = $returnprops->{$sort_key}->{type} // 'string'; - if ($type eq 'integer' || $type eq 'number') { - @$data = sort { $a->{$sort_key} <=> $b->{$sort_key} } @$data; - } else { - @$data = sort { $a->{$sort_key} cmp $b->{$sort_key} } @$data; - } - } - - foreach my $entry (@$data) { - printf $formatstring, map { - substr(data_to_text($entry->{$_}) // $colopts->{$_}->{default}, - 0, $colopts->{$_}->{cutoff}); - } @$props_to_print; - } -} - -# prints the result of an API GET call returning an array as a table. -# takes formatting information from the results property of the call -# if $props_to_print is provided, prints only those columns. otherwise -# takes all fields of the results property, with a fallback -# to all fields occuring in items of $data. -sub print_api_list { - my ($data, $result_schema, $props_to_print, $sort_key) = @_; - - die "can only print object lists\n" - if !($result_schema->{type} eq 'array' && $result_schema->{items}->{type} eq 'object'); - - my $returnprops = $result_schema->{items}->{properties}; - - if (!defined($props_to_print)) { - $props_to_print = [ sort keys %$returnprops ]; - if (!scalar(@$props_to_print)) { - my $all_props = {}; - foreach my $obj (@{$data}) { - foreach my $key (keys %{$obj}) { - $all_props->{ $key } = 1; - } - } - $props_to_print = [ sort keys %{$all_props} ]; - } - die "unable to detect list properties\n" if !scalar(@$props_to_print); - } - - print_text_table($data, $returnprops, $props_to_print, $sort_key); -} - -sub print_api_result { - my ($format, $data, $result_schema, $props_to_print, $sort_key) = @_; - - return if $result_schema->{type} eq 'null'; - - if ($format eq 'json') { - print to_json($data, {utf8 => 1, allow_nonref => 1, canonical => 1, pretty => 1 }); - } elsif ($format eq 'text') { - my $type = $result_schema->{type}; - if ($type eq 'object') { - $props_to_print = [ sort keys %$data ] if !defined($props_to_print); - foreach my $key (@$props_to_print) { - print $key . ": " . data_to_text($data->{$key}) . "\n"; - } - } elsif ($type eq 'array') { - return if !scalar(@$data); - my $item_type = $result_schema->{items}->{type}; - if ($item_type eq 'object') { - print_api_list($data, $result_schema, $props_to_print, $sort_key); - } else { - foreach my $entry (@$data) { - print data_to_text($entry) . "\n"; - } - } - } else { - print "$data\n"; - } - } else { - die "internal error: unknown output format"; # should not happen - } -} - sub verify_api { my ($class) = @_; @@ -633,6 +501,30 @@ complete -o default -C '$exename bashcomplete' $exename __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(); @@ -666,7 +558,7 @@ sub setup_environment { } my $handle_cmd = sub { - my ($args, $preparefunc, $param_mapping_func) = @_; + my ($args, $preparefunc, $param_cb) = @_; $cmddef->{help} = [ __PACKAGE__, 'help', ['extra-args'] ]; @@ -693,21 +585,22 @@ my $handle_cmd = sub { &$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, $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 $result_schema = $class->map_method_by_name($name)->{returns}; - $outsub->($res, $result_schema); + $outsub->($res, $result_schema, $formatter_params); } }; my $handle_simple_cmd = sub { - my ($args, $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) { @@ -734,11 +627,12 @@ my $handle_simple_cmd = sub { &$preparefunc() if $preparefunc; - my $res = $class->cli_handler($name, $name, \@ARGV, $arg_param, $uri_param, $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 $result_schema = $class->map_method_by_name($name)->{returns}; - $outsub->($res, $result_schema); + $outsub->($res, $result_schema, $formatter_params); } }; @@ -758,19 +652,20 @@ sub run_cli_handler { my $preparefunc = $params{prepare}; - my $param_mapping_func = $gen_param_mapping_func->($cli_handler_class); + 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, $preparefunc, $param_mapping_func); + $handle_simple_cmd->(\@ARGV, $preparefunc, $param_cb); } else { - $handle_cmd->(\@ARGV, $preparefunc, $param_mapping_func); + $handle_cmd->(\@ARGV, $preparefunc, $param_cb); } exit 0;