use PVE::SafeSyslog;
use PVE::Exception qw(raise raise_param_exc);
use PVE::JSONSchema;
+use PVE::Tools;
use HTTP::Status qw(:constants :is status_message);
use Text::Wrap;
use Clone qw(clone);
}
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;
};
# $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, $hidepw, $fileparams) = @_;
+ my ($name, $style, $phash, $format, $hidepw, $mapdef) = @_;
my $res = '';
$type_text = '';
}
- if ($fileparams && $phash->{type} eq 'string') {
- foreach my $elem (@$fileparams) {
- if ($name eq $elem) {
- $type_text = '<filepath>';
- last;
- }
- }
+ if ($mapdef && $phash->{type} eq 'string') {
+ $type_text = $mapdef->{desc};
}
if ($format eq 'asciidoc') {
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;
+ } 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
# '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)
-# $stringfilemap ... mapping for string parameters to file path parameters
+# $param_mapping_func ... mapping for string parameters to file path parameters
sub usage_str {
- my ($self, $name, $prefix, $arg_param, $fixed_param, $format, $hidepw, $stringfilemap) = @_;
+ my ($self, $name, $prefix, $arg_param, $fixed_param, $format, $hidepw, $param_mapping_func) = @_;
$format = 'long' if !$format;
}
}
- my $mapping = defined($stringfilemap) ? &$stringfilemap($name) : undef;
+ my $param_mapping_hash = $compute_param_mapping_hash->(&$param_mapping_func($name))
+ if $param_mapping_func;
+
$opts .= &$get_property_description($base, 'arg', $prop->{$k}, $format,
- $hidepw, $mapping);
+ $hidepw, $param_mapping_hash->{$k});
if (!$prop->{$k}->{optional}) {
$args .= " " if $args;
}
my $replace_file_names_with_contents = sub {
- my ($param, $mapping) = @_;
+ my ($param, $param_mapping_hash) = @_;
- if ($mapping) {
- foreach my $elem ( @$mapping ) {
- $param->{$elem} = PVE::Tools::file_get_contents($param->{$elem})
- if defined($param->{$elem});
- }
+ while (my ($k, $d) = each %$param_mapping_hash) {
+ next if $d->{interactive}; # handled by the JSONSchema's get_options code
+ $param->{$k} = $d->{func}->($param->{$k})
+ if defined($param->{$k});
}
return $param;
};
sub cli_handler {
- my ($self, $prefix, $name, $args, $arg_param, $fixed_param, $pwcallback, $stringfilemap) = @_;
+ my ($self, $prefix, $name, $args, $arg_param, $fixed_param, $read_password_func, $param_mapping_func) = @_;
my $info = $self->map_method_by_name($name);
my $res;
eval {
- my $param = PVE::JSONSchema::get_options($info->{parameters}, $args, $arg_param, $fixed_param, $pwcallback);
- &$replace_file_names_with_contents($param, &$stringfilemap($name))
- if defined($stringfilemap);
+ my $param_mapping_hash = $compute_param_mapping_hash->($param_mapping_func->($name)) if $param_mapping_func;
+ my $param = PVE::JSONSchema::get_options($info->{parameters}, $args, $arg_param, $fixed_param, $read_password_func, $param_mapping_hash);
+
+ if (defined($param_mapping_hash)) {
+ &$replace_file_names_with_contents($param, $param_mapping_hash);
+ }
+
$res = $self->handle($info, $param);
};
if (my $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, $stringfilemap);
+ $err->{usage} = $self->usage_str($name, $prefix, $arg_param, $fixed_param, 'short', $read_password_func, $param_mapping_func);
die $err;
}