use PVE::SafeSyslog;
use PVE::Exception qw(raise raise_param_exc);
use PVE::JSONSchema;
-use PVE::PodParser;
+use PVE::Tools;
use HTTP::Status qw(:constants :is status_message);
use Text::Wrap;
use Clone qw(clone);
foreach my $p (keys %$d) {
my $pd = $d->{$p};
if ($p =~ m/^([a-z]+)(\d+)$/) {
- if ($2 == 0) {
- $p = "$1\[n\]";
- } else {
- next;
+ my ($name, $idx) = ($1, $2);
+ if ($idx == 0 && defined($d->{"${name}1"})) {
+ $p = "${name}[n]";
+ } elsif (defined($d->{"${name}0"})) {
+ next; # only handle once for -xx0, but only if -xx0 exists
+ }
+ }
+ my $tmp = ref($pd) ? clone($pd) : $pd;
+ # NOTE: add typetext property for more complex types, to
+ # make the web api viewer code simpler
+ if (!(defined($tmp->{enum}) || defined($tmp->{pattern}))) {
+ my $typetext = PVE::JSONSchema::schema_get_type_text($tmp);
+ if ($tmp->{type} && ($tmp->{type} ne $typetext)) {
+ $tmp->{typetext} = $typetext;
}
}
- $res->{$k}->{$p} = ref($pd) ? clone($pd) : $pd;
+ $res->{$k}->{$p} = $tmp;
}
}
}
sub api_dump_full {
- my ($tree, $index, $class, $prefix) = @_;
+ my ($tree, $index, $class, $prefix, $raw_dump) = @_;
$prefix = '' if !$prefix;
$path =~ s/\/+$//;
if ($info->{subclass}) {
- api_dump_full($tree, $index, $info->{subclass}, $path);
+ api_dump_full($tree, $index, $info->{subclass}, $path, $raw_dump);
} else {
next if !$path;
$k eq "path";
my $d = $info->{$k};
-
- if ($k eq 'parameters') {
- $data->{$k} = api_clone_schema($d);
- } else {
- $data->{$k} = ref($d) ? clone($d) : $d;
+ if ($raw_dump) {
+ $data->{$k} = $d;
+ } else {
+ if ($k eq 'parameters') {
+ $data->{$k} = api_clone_schema($d);
+ } else {
+ $data->{$k} = ref($d) ? clone($d) : $d;
+ }
}
}
$res->{info}->{$info->{method}} = $data;
}
+# api_dump_remove_refs: prepare API tree for use with to_json($tree)
+sub api_dump_remove_refs {
+ my ($tree) = @_;
+
+ my $class = ref($tree);
+ return $tree if !$class;
+
+ if ($class eq 'ARRAY') {
+ my $res = [];
+ foreach my $el (@$tree) {
+ push @$res, api_dump_remove_refs($el);
+ }
+ return $res;
+ } elsif ($class eq 'HASH') {
+ my $res = {};
+ foreach my $k (keys %$tree) {
+ if (my $itemclass = ref($tree->{$k})) {
+ if ($itemclass eq 'CODE') {
+ next if $k eq 'completion';
+ }
+ $res->{$k} = api_dump_remove_refs($tree->{$k});
+ } else {
+ $res->{$k} = $tree->{$k};
+ }
+ }
+ return $res;
+ } elsif ($class eq 'Regexp') {
+ return "$tree"; # return string representation
+ } else {
+ die "unknown class '$class'\n";
+ }
+}
+
sub api_dump {
- my ($class, $prefix) = @_;
+ my ($class, $prefix, $raw_dump) = @_;
my $tree = [];
my $index = {};
- api_dump_full($tree, $index, $class);
+ api_dump_full($tree, $index, $class, $prefix, $raw_dump);
api_dump_cleanup_tree($tree);
return $tree;
};
push @{$method_registry->{$self}}, $info;
}
-sub register_page_formatter {
- my ($self, %config) = @_;
-
- my $format = $config{format} ||
- die "missing format";
-
- my $path = $config{path} ||
- die "missing path";
-
- my $method = $config{method} ||
- die "missing method";
-
- my $code = $config{code} ||
- die "missing formatter code";
-
- my $uri_param = {};
- my ($handler, $info) = $self->find_handler($method, $path, $uri_param);
- die "unabe to find handler for '$method: $path'" if !($handler && $info);
-
- die "duplicate formatter for '$method: $path'"
- if $info->{formatter} && $info->{formatter}->{$format};
-
- $info->{formatter}->{$format} = $code;
-}
-
sub DESTROY {}; # avoid problems with autoload
sub AUTOLOAD {
}
sub handle {
- my ($self, $info, $param) = @_;
+ my ($self, $info, $param, $output_options) = @_;
my $func = $info->{code};
$param->{'extra-args'} = [map { /^(.*)$/ } @$extra] if $extra;
}
- my $result = &$func($param);
+ $output_options //= {};
+ my $result = &$func($param, $output_options);
# todo: this is only to be safe - disable?
if (my $schema = $info->{returns}) {
return $result;
}
+# format option, display type and description
+# $name: option name
+# $display_name: for example "-$name" of "<$name>", pass undef to use "$name:"
+# $phash: json schema property hash
+# $format: 'asciidoc', 'short', 'long' or 'full'
+# $style: 'config', 'config-sub', 'arg' or 'fixed'
+# $mapdef: parameter mapping ({ desc => XXX, func => sub {...} })
+my $get_property_description = sub {
+ my ($name, $style, $phash, $format, $mapdef) = @_;
+
+ my $res = '';
+
+ $format = 'asciidoc' if !defined($format);
+
+ my $descr = $phash->{description} || "no description available";
+
+ if ($phash->{verbose_description} &&
+ ($style eq 'config' || $style eq 'config-sub')) {
+ $descr = $phash->{verbose_description};
+ }
+
+ chomp $descr;
+
+ my $type_text = PVE::JSONSchema::schema_get_type_text($phash, $style);
+
+ if ($mapdef && $phash->{type} eq 'string') {
+ $type_text = $mapdef->{desc};
+ }
+
+ if ($format eq 'asciidoc') {
+
+ if ($style eq 'config') {
+ $res .= "`$name`: ";
+ } elsif ($style eq 'config-sub') {
+ $res .= "`$name`=";
+ } elsif ($style eq 'arg') {
+ $res .= "`--$name` ";
+ } elsif ($style eq 'fixed') {
+ $res .= "`<$name>`: ";
+ } else {
+ die "unknown style '$style'";
+ }
+
+ $res .= "`$type_text` " if $type_text;
+
+ if (defined(my $dv = $phash->{default})) {
+ $res .= "('default =' `$dv`)";
+ }
+
+ if ($style eq 'config-sub') {
+ $res .= ";;\n\n";
+ } else {
+ $res .= "::\n\n";
+ }
+
+ my $wdescr = $descr;
+ chomp $wdescr;
+ $wdescr =~ s/^$/+/mg;
+
+ $res .= $wdescr . "\n";
+
+ if (my $req = $phash->{requires}) {
+ my $tmp .= ref($req) ? join(', ', @$req) : $req;
+ $res .= "+\nNOTE: Requires option(s): `$tmp`\n";
+ }
+ $res .= "\n";
+
+ } elsif ($format eq 'short' || $format eq 'long' || $format eq 'full') {
+
+ my $defaulttxt = '';
+ if (defined(my $dv = $phash->{default})) {
+ $defaulttxt = " (default=$dv)";
+ }
+
+ my $display_name;
+ if ($style eq 'config') {
+ $display_name = "$name:";
+ } elsif ($style eq 'arg') {
+ $display_name = "-$name";
+ } elsif ($style eq 'fixed') {
+ $display_name = "<$name>";
+ } else {
+ die "unknown style '$style'";
+ }
+
+ my $tmp = sprintf " %-10s %s$defaulttxt\n", $display_name, "$type_text";
+ my $indend = " ";
+
+ $res .= Text::Wrap::wrap('', $indend, ($tmp));
+ $res .= "\n",
+ $res .= Text::Wrap::wrap($indend, $indend, ($descr)) . "\n\n";
+
+ if (my $req = $phash->{requires}) {
+ my $tmp = "Requires option(s): ";
+ $tmp .= ref($req) ? join(', ', @$req) : $req;
+ $res .= Text::Wrap::wrap($indend, $indend, ($tmp)). "\n\n";
+ }
+
+ } else {
+ die "unknown format '$format'";
+ }
+
+ return $res;
+};
+
+# translate parameter mapping definition
+# $mapping_array is a array which can contain:
+# strings ... in that case we assume it is a parameter name, and
+# we want to load that parameter from a file
+# [ param_name, func, desc] ... allows you to specify a arbitrary
+# mapping func for any param
+#
+# Returns: a hash indexed by parameter_name,
+# i.e. { param_name => { func => .., desc => ... } }
+my $compute_param_mapping_hash = sub {
+ my ($mapping_array) = @_;
+
+ my $res = {};
+
+ return $res if !defined($mapping_array);
+
+ foreach my $item (@$mapping_array) {
+ my ($name, $func, $desc, $interactive);
+ if (ref($item) eq 'ARRAY') {
+ ($name, $func, $desc, $interactive) = @$item;
+ } elsif (ref($item) eq 'HASH') {
+ # just use the hash
+ $res->{$item->{name}} = $item;
+ next;
+ } else {
+ $name = $item;
+ $func = sub { return PVE::Tools::file_get_contents($_[0]) };
+ }
+ $desc //= '<filepath>';
+ $res->{$name} = { desc => $desc, func => $func, interactive => $interactive };
+ }
+
+ return $res;
+};
+
# generate usage information for command line tools
#
-# $name ... the name of the method
+# $info ... method info
# $prefix ... usually something like "$exename $cmd" ('pvesm add')
# $arg_param ... list of parameters we want to get as ordered arguments
# on the command line (or single parameter name for lists)
# $fixed_param ... do not generate and info about those parameters
# $format:
-# 'long' ... default (list all options)
-# 'short' ... command line only (one line)
-# 'full' ... also include description
+# 'long' ... default (text, list all options)
+# 'short' ... command line only (text, one line)
+# 'full' ... text, include description
# 'asciidoc' ... generate asciidoc for man pages (like 'full')
-# $hidepw ... hide password option (use this if you provide a read passwork callback)
-sub usage_str {
- my ($self, $name, $prefix, $arg_param, $fixed_param, $format, $hidepw) = @_;
+# $param_cb ... mapping for string parameters to file path parameters
+sub getopt_usage {
+ my ($info, $prefix, $arg_param, $fixed_param, $format, $param_cb) = @_;
$format = 'long' if !$format;
- my $info = $self->map_method_by_name($name);
my $schema = $info->{parameters};
+ my $name = $info->{name};
my $prop = $schema->{properties};
my $out = '';
}
}
- my $get_prop_descr = sub {
- my ($k, $display_name) = @_;
-
- my $phash = $prop->{$k};
-
- my $res = '';
-
- my $descr = $phash->{description} || "no description available";
- chomp $descr;
-
- my $type = PVE::PodParser::schema_get_type_text($phash);
-
- if ($hidepw && $k eq 'password') {
- $type = '';
- }
-
- if ($format eq 'asciidoc') {
- $res .= "`$display_name` `$type` ";
- if (defined(my $dv = $phash->{default})) {
- $res .= "(default=`$dv`)";
- }
- $res .= "::\n\n";
- $res .= Text::Wrap::wrap('', '', ($descr)) . "\n";
-
- if (my $req = $phash->{requires}) {
- my $tmp .= ref($req) ? join(', ', @$req) : $req;
- $res .= "+\nNOTE: Requires option(s): `$tmp`\n";
- }
- $res .= "\n";
- } else {
- my $defaulttxt = '';
- if (defined(my $dv = $phash->{default})) {
- $defaulttxt = " (default=$dv)";
- }
- my $tmp = sprintf " %-10s %s$defaulttxt\n", $display_name, "$type";
- my $indend = " ";
-
- $res .= Text::Wrap::wrap('', $indend, ($tmp));
- $res .= "\n",
- $res .= Text::Wrap::wrap($indend, $indend, ($descr)) . "\n\n";
-
- if (my $req = $phash->{requires}) {
- my $tmp = "Requires option(s): ";
- $tmp .= ref($req) ? join(', ', @$req) : $req;
- $res .= Text::Wrap::wrap($indend, $indend, ($tmp)). "\n\n";
- }
- }
-
- return $res;
- };
-
my $argdescr = '';
foreach my $k (@$arg_param) {
next if defined($fixed_param->{$k}); # just to be sure
next if !$prop->{$k}; # just to be sure
- $argdescr .= &$get_prop_descr($k, "<$k>");
+ $argdescr .= $get_property_description->($k, 'fixed', $prop->{$k}, $format);
}
my $idx_param = {}; # -vlan\d+ -scsi\d+
next if $arg_hash->{$k};
next if defined($fixed_param->{$k});
- my $type = $prop->{$k}->{type} || 'string';
+ my $type_text = $prop->{$k}->{type} || 'string';
+
+ my $param_map = {};
- next if $hidepw && ($k eq 'password') && !$prop->{$k}->{optional};
+ if (defined($param_cb)) {
+ my $mapping = $param_cb->($name);
+ $param_map = $compute_param_mapping_hash->($mapping);
+ next if $k eq 'password' && $param_map->{$k} && !$prop->{$k}->{optional};
+ }
my $base = $k;
if ($k =~ m/^([a-z]+)(\d+)$/) {
- my $name = $1;
+ my ($name, $idx) = ($1, $2);
next if $idx_param->{$name};
- $idx_param->{$name} = 1;
- $base = "${name}[n]";
+ if ($idx == 0 && defined($prop->{"${name}1"})) {
+ $idx_param->{$name} = 1;
+ $base = "${name}[n]";
+ }
}
- $opts .= &$get_prop_descr($k, "-$base");
+
+ $opts .= $get_property_description->($base, 'arg', $prop->{$k}, $format, $param_map->{$k});
if (!$prop->{$k}->{optional}) {
$args .= " " if $args;
- $args .= "-$base <$type>"
+ $args .= "--$base <$type_text>"
}
}
return $out;
}
+sub usage_str {
+ my ($self, $name, $prefix, $arg_param, $fixed_param, $format, $param_cb) = @_;
+
+ my $info = $self->map_method_by_name($name);
+
+ return getopt_usage($info, $prefix, $arg_param, $fixed_param, $format, $param_cb);
+}
+
+# generate docs from JSON schema properties
+sub dump_properties {
+ my ($prop, $format, $style, $filterFn) = @_;
+
+ my $raw = '';
+
+ $style //= 'config';
+
+ my $idx_param = {}; # -vlan\d+ -scsi\d+
+
+ foreach my $k (sort keys %$prop) {
+ my $phash = $prop->{$k};
+
+ next if defined($filterFn) && &$filterFn($k, $phash);
+ next if $phash->{alias};
+
+ my $base = $k;
+ if ($k =~ m/^([a-z]+)(\d+)$/) {
+ my ($name, $idx) = ($1, $2);
+ next if $idx_param->{$name};
+ if ($idx == 0 && defined($prop->{"${name}1"})) {
+ $idx_param->{$name} = 1;
+ $base = "${name}[n]";
+ }
+ }
+
+ $raw .= $get_property_description->($base, $style, $phash, $format);
+
+ next if $style ne 'config';
+
+ my $prop_fmt = $phash->{format};
+ next if !$prop_fmt;
+
+ if (ref($prop_fmt) ne 'HASH') {
+ $prop_fmt = PVE::JSONSchema::get_format($prop_fmt);
+ }
+
+ next if !(ref($prop_fmt) && (ref($prop_fmt) eq 'HASH'));
+
+ $raw .= dump_properties($prop_fmt, $format, 'config-sub')
+
+ }
+
+ return $raw;
+}
+
+my $replace_file_names_with_contents = sub {
+ my ($param, $param_map) = @_;
+
+ while (my ($k, $d) = each %$param_map) {
+ next if $d->{interactive}; # handled by the JSONSchema's get_options code
+ $param->{$k} = $d->{func}->($param->{$k})
+ if defined($param->{$k});
+ }
+
+ return $param;
+};
+
+our $standard_output_options = {
+ format => PVE::JSONSchema::get_standard_option('pve-output-format'),
+ noheader => {
+ description => "Do not show column headers (for 'text' format).",
+ type => 'boolean',
+ optional => 1,
+ default => 1,
+ },
+ noborder => {
+ description => "Do not draw borders (for 'text' format).",
+ type => 'boolean',
+ optional => 1,
+ default => 1,
+ },
+ quiet => {
+ description => "Suppress printing results.",
+ type => 'boolean',
+ optional => 1,
+ },
+ 'human-readable' => {
+ description => "Call output rendering functions to produce human readable text.",
+ type => 'boolean',
+ optional => 1,
+ default => 1,
+ }
+};
+
+sub add_standard_output_parameters {
+ my ($org_schema) = @_;
+
+ my $schema = { %$org_schema };
+ $schema->{properties} = { %{$schema->{properties}}, %$standard_output_options };
+
+ return $schema;
+};
+
sub cli_handler {
- my ($self, $prefix, $name, $args, $arg_param, $fixed_param, $pwcallback) = @_;
+ my ($self, $prefix, $name, $args, $arg_param, $fixed_param, $param_cb, $options) = @_;
my $info = $self->map_method_by_name($name);
+ $options //= {};
+
+ my $add_stdopts = $options->{'std-output-opts'};
my $res;
eval {
- my $param = PVE::JSONSchema::get_options($info->{parameters}, $args, $arg_param, $fixed_param, $pwcallback);
- $res = $self->handle($info, $param);
+ my $param_map = {};
+ $param_map = $compute_param_mapping_hash->($param_cb->($name)) if $param_cb;
+ my $schema = $add_stdopts ? add_standard_output_parameters($info->{parameters}) : $info->{properties} ;
+ my $param = PVE::JSONSchema::get_options($schema, $args, $arg_param, $fixed_param, $param_map);
+
+ if ($add_stdopts) {
+ foreach my $opt (keys %$standard_output_options) {
+ $options->{$opt} = delete $param->{$opt} if defined($param->{$opt});
+ }
+ }
+
+ if (defined($param_map)) {
+ $replace_file_names_with_contents->($param, $param_map);
+ }
+
+ $res = $self->handle($info, $param, $options);
};
if (my $err = $@) {
my $ec = ref($err);
die $err if !$ec || $ec ne "PVE::Exception" || !$err->is_param_exc();
- $err->{usage} = $self->usage_str($name, $prefix, $arg_param, $fixed_param, 'short', $pwcallback);
+ $err->{usage} = $self->usage_str($name, $prefix, $arg_param, $fixed_param, 'short', $param_cb);
die $err;
}