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);
my $pd = $d->{$p};
if ($p =~ m/^([a-z]+)(\d+)$/) {
my ($name, $idx) = ($1, $2);
- if ($idx == 0) {
+ 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
}
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 {
# $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', 'arg' or 'fixed'
+# $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, $mapdef) = @_;
my $res = '';
chomp $descr;
- my $type = PVE::JSONSchema::schema_get_type_text($phash);
-
- if ($hidepw && $name eq 'password') {
- $type = '';
- }
+ my $type_text = PVE::JSONSchema::schema_get_type_text($phash, $style);
- if ($fileparams && $type eq 'string') {
- foreach my $elem (@$fileparams) {
- if ($name eq $elem) {
- $type = 'filepath';
- last;
- }
- }
+ if ($mapdef && $phash->{type} eq 'string') {
+ $type_text = $mapdef->{desc};
}
if ($format eq 'asciidoc') {
} elsif ($style eq 'config-sub') {
$res .= "`$name`=";
} elsif ($style eq 'arg') {
- $res .= "`-$name` ";
+ $res .= "`--$name` ";
} elsif ($style eq 'fixed') {
- $res .= "`<$name>` ";
+ $res .= "`<$name>`: ";
} else {
die "unknown style '$style'";
}
- $res .= "`$type` " if $type;
+ $res .= "`$type_text` " if $type_text;
if (defined(my $dv = $phash->{default})) {
- $res .= "(default=`$dv`)";
+ $res .= "('default =' `$dv`)";
}
if ($style eq 'config-sub') {
die "unknown style '$style'";
}
- my $tmp = sprintf " %-10s %s$defaulttxt\n", $display_name, "$type";
+ my $tmp = sprintf " %-10s %s$defaulttxt\n", $display_name, "$type_text";
my $indend = " ";
$res .= Text::Wrap::wrap('', $indend, ($tmp));
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
# '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)
-# $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, $param_mapping_func) = @_;
$format = 'long' if !$format;
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_property_description($k, 'fixed', $prop->{$k}, $format, 0);
+ $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_mapping_hash = {};
- next if $hidepw && ($k eq 'password') && !$prop->{$k}->{optional};
+ if (defined($param_mapping_func)) {
+ my $mapping = $param_mapping_func->($name);
+ $param_mapping_hash = $compute_param_mapping_hash->($mapping);
+ next if $k eq 'password' && $param_mapping_hash->{$k} && !$prop->{$k}->{optional};
+ }
my $base = $k;
if ($k =~ m/^([a-z]+)(\d+)$/) {
my ($name, $idx) = ($1, $2);
next if $idx_param->{$name};
- if ($idx == 0) {
+ if ($idx == 0 && defined($prop->{"${name}1"})) {
$idx_param->{$name} = 1;
$base = "${name}[n]";
}
}
- my $mapping = defined($stringfilemap) ? &$stringfilemap($name) : undef;
- $opts .= &$get_property_description($base, 'arg', $prop->{$k}, $format,
- $hidepw, $mapping);
+
+ $opts .= $get_property_description->($base, 'arg', $prop->{$k}, $format,
+ $param_mapping_hash->{$k});
if (!$prop->{$k}->{optional}) {
$args .= " " if $args;
- $args .= "-$base <$type>"
+ $args .= "--$base <$type_text>"
}
}
if ($k =~ m/^([a-z]+)(\d+)$/) {
my ($name, $idx) = ($1, $2);
next if $idx_param->{$name};
- if ($idx == 0) {
+ if ($idx == 0 && defined($prop->{"${name}1"})) {
$idx_param->{$name} = 1;
$base = "${name}[n]";
}
}
- $raw .= &$get_property_description($base, $style, $phash, $format, 0);
+ $raw .= $get_property_description->($base, $style, $phash, $format);
next if $style ne 'config';
}
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, $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 = {};
+ $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, $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', $param_mapping_func);
die $err;
}
projects / pve-common.git / blobdiff