use warnings;
use Storable; # for dclone
use Getopt::Long;
+use Encode::Locale;
+use Encode;
use Devel::Cycle -quiet; # todo: remove?
use PVE::Tools qw(split_list $IPV6RE $IPV4RE);
use PVE::Exception qw(raise);
use base 'Exporter';
our @EXPORT_OK = qw(
-register_standard_option
+register_standard_option
get_standard_option
);
-# Note: This class implements something similar to JSON schema, but it is not 100% complete.
+# Note: This class implements something similar to JSON schema, but it is not 100% complete.
# see: http://tools.ietf.org/html/draft-zyp-json-schema-02
# see: http://json-schema.org/
sub register_standard_option {
my ($name, $schema) = @_;
- die "standard option '$name' already registered\n"
+ die "standard option '$name' already registered\n"
if $standard_options->{$name};
$standard_options->{$name} = $schema;
register_standard_option('pve-storage-id', {
description => "The storage identifier.",
type => 'string', format => 'pve-storage-id',
-});
+});
register_standard_option('pve-config-digest', {
description => 'Prevent changes if current configuration file has different SHA1 digest. This can be used to prevent concurrent modifications.',
type => 'string',
optional => 1,
- maxLength => 40, # sha1 hex digest lenght is 40
+ maxLength => 40, # sha1 hex digest length is 40
+});
+
+register_standard_option('skiplock', {
+ description => "Ignore locks - only root is allowed to use this option.",
+ type => 'boolean',
+ optional => 1,
});
register_standard_option('extra-args', {
optional => 1
});
+register_standard_option('fingerprint-sha256', {
+ description => "Certificate SHA 256 fingerprint.",
+ type => 'string',
+ pattern => '([A-Fa-f0-9]{2}:){31}[A-Fa-f0-9]{2}',
+});
+
+register_standard_option('pve-output-format', {
+ type => 'string',
+ description => 'Output format.',
+ enum => [ 'text', 'json', 'json-pretty', 'yaml' ],
+ optional => 1,
+ default => 'text',
+});
+
+register_standard_option('pve-snapshot-name', {
+ description => "The name of the snapshot.",
+ type => 'string', format => 'pve-configid',
+ maxLength => 40,
+});
+
my $format_list = {};
sub register_format {
my ($format, $code) = @_;
- die "JSON schema format '$format' already registered\n"
+ die "JSON schema format '$format' already registered\n"
if $format_list->{$format};
$format_list->{$format} = $code;
return $format_list->{$format};
}
+my $renderer_hash = {};
+
+sub register_renderer {
+ my ($name, $code) = @_;
+
+ die "renderer '$name' already registered\n"
+ if $renderer_hash->{$name};
+
+ $renderer_hash->{$name} = $code;
+}
+
+sub get_renderer {
+ my ($name) = @_;
+ return $renderer_hash->{$name};
+}
+
# register some common type for pve
register_format('string', sub {}); # allow format => 'string-list'
register_format('pve-configid', \&pve_verify_configid);
sub pve_verify_configid {
my ($id, $noerr) = @_;
-
+
if ($id !~ m/^[a-z][a-z0-9_]+$/i) {
return undef if $noerr;
- die "invalid configuration ID '$id'\n";
+ die "invalid configuration ID '$id'\n";
}
return $id;
}
sub parse_storage_id {
my ($storeid, $noerr) = @_;
- if ($storeid !~ m/^[a-z][a-z0-9\-\_\.]*[a-z0-9]$/i) {
+ return parse_id($storeid, 'storage', $noerr);
+}
+
+sub parse_id {
+ my ($id, $type, $noerr) = @_;
+
+ if ($id !~ m/^[a-z][a-z0-9\-\_\.]*[a-z0-9]$/i) {
return undef if $noerr;
- die "storage ID '$storeid' contains illegal characters\n";
+ die "$type ID '$id' contains illegal characters\n";
}
- return $storeid;
+ return $id;
}
-
register_format('pve-vmid', \&pve_verify_vmid);
sub pve_verify_vmid {
my ($vmid, $noerr) = @_;
return $node;
}
+register_format('mac-addr', \&pve_verify_mac_addr);
+sub pve_verify_mac_addr {
+ my ($mac_addr, $noerr) = @_;
+
+ # don't allow I/G bit to be set, most of the time it breaks things, see:
+ # https://pve.proxmox.com/pipermail/pve-devel/2019-March/035998.html
+ if ($mac_addr !~ m/^[a-f0-9][02468ace](?::[a-f0-9]{2}){5}$/i) {
+ return undef if $noerr;
+ die "value does not look like a valid unicast MAC address\n";
+ }
+ return $mac_addr;
+
+}
+register_standard_option('mac-addr', {
+ type => 'string',
+ description => 'Unicast MAC address.',
+ verbose_description => 'A common MAC address with the I/G (Individual/Group) bit not set.',
+ format_description => "XX:XX:XX:XX:XX:XX",
+ optional => 1,
+ format => 'mac-addr',
+});
+
register_format('ipv4', \&pve_verify_ipv4);
sub pve_verify_ipv4 {
my ($ipv4, $noerr) = @_;
return $ip;
}
+PVE::JSONSchema::register_format('ldap-simple-attr', \&verify_ldap_simple_attr);
+sub verify_ldap_simple_attr {
+ my ($attr, $noerr) = @_;
+
+ if ($attr =~ m/^[a-zA-Z0-9]+$/) {
+ return $attr;
+ }
+
+ die "value '$attr' does not look like a simple ldap attribute name\n" if !$noerr;
+
+ return undef;
+}
+
my $ipv4_mask_hash = {
+ '0.0.0.0' => 0,
'128.0.0.0' => 1,
'192.0.0.0' => 2,
'224.0.0.0' => 3,
'255.255.255.255' => 32,
};
+sub get_netmask_bits {
+ my ($mask) = @_;
+ return $ipv4_mask_hash->{$mask};
+}
+
register_format('ipv4mask', \&pve_verify_ipv4mask);
sub pve_verify_ipv4mask {
my ($mask, $noerr) = @_;
sub pve_verify_cidrv6 {
my ($cidr, $noerr) = @_;
- if ($cidr =~ m!^(?:$IPV6RE)(?:/(\d+))$! && ($1 > 7) && ($1 <= 120)) {
+ if ($cidr =~ m!^(?:$IPV6RE)(?:/(\d+))$! && ($1 > 7) && ($1 <= 128)) {
return $cidr;
}
sub pve_verify_email {
my ($email, $noerr) = @_;
- # we use same regex as in Utils.js
- if ($email !~ /^(\w+)([\-+.][\w]+)*@(\w[\-\w]*\.){1,5}([A-Za-z]){2,63}$/) {
+ if ($email !~ /^[\w\+\-\~]+(\.[\w\+\-\~]+)*@[a-zA-Z0-9\-]+(\.[a-zA-Z0-9\-]+)*$/) {
return undef if $noerr;
die "value does not look like a valid email address\n";
}
register_format('pve-iface', \&pve_verify_iface);
sub pve_verify_iface {
my ($id, $noerr) = @_;
-
+
if ($id !~ m/^[a-z][a-z0-9_]{1,20}([:\.]\d+)?$/i) {
return undef if $noerr;
- die "invalid network interface name '$id'\n";
+ die "invalid network interface name '$id'\n";
}
return $id;
}
}
register_standard_option('spice-proxy', {
- description => "SPICE proxy server. This can be used by the client to specify the proxy server. All nodes in a cluster runs 'spiceproxy', so it is up to the client to choose one. By default, we return the node where the VM is currently running. As resonable setting is to use same node you use to connect to the API (This is window.location.hostname for the JS GUI).",
+ description => "SPICE proxy server. This can be used by the client to specify the proxy server. All nodes in a cluster runs 'spiceproxy', so it is up to the client to choose one. By default, we return the node where the VM is currently running. As reasonable setting is to use same node you use to connect to the API (This is window.location.hostname for the JS GUI).",
type => 'string', format => 'address',
-});
+});
register_standard_option('remote-viewer-config', {
description => "Returned values can be directly passed to the 'remote-viewer' application.",
die "unable to parse startup options\n";
}
+my %bwlimit_opt = (
+ optional => 1,
+ type => 'number', minimum => '0',
+ format_description => 'LIMIT',
+);
+
+my $bwlimit_format = {
+ default => {
+ %bwlimit_opt,
+ description => 'default bandwidth limit in KiB/s',
+ },
+ restore => {
+ %bwlimit_opt,
+ description => 'bandwidth limit in KiB/s for restoring guests from backups',
+ },
+ migration => {
+ %bwlimit_opt,
+ description => 'bandwidth limit in KiB/s for migrating guests (including moving local disks)',
+ },
+ clone => {
+ %bwlimit_opt,
+ description => 'bandwidth limit in KiB/s for cloning disks',
+ },
+ move => {
+ %bwlimit_opt,
+ description => 'bandwidth limit in KiB/s for moving disks',
+ },
+};
+register_format('bwlimit', $bwlimit_format);
+register_standard_option('bwlimit', {
+ description => "Set bandwidth/io limits various operations.",
+ optional => 1,
+ type => 'string',
+ format => $bwlimit_format,
+});
+
+# used for pve-tag-list in e.g., guest configs
+register_format('pve-tag', \&pve_verify_tag);
+sub pve_verify_tag {
+ my ($value, $noerr) = @_;
+
+ return $value if $value =~ m/^[a-z0-9_][a-z0-9_\-\+\.]*$/i;
+
+ return undef if $noerr;
+
+ die "invalid characters in tag\n";
+}
+
sub pve_parse_startup_order {
my ($value) = @_;
typetext => '[[order=]\d+] [,up=\d+] [,down=\d+] ',
});
+register_format('pve-tfa-secret', \&pve_verify_tfa_secret);
+sub pve_verify_tfa_secret {
+ my ($key, $noerr) = @_;
+
+ # The old format used 16 base32 chars or 40 hex digits. Since they have a common subset it's
+ # hard to distinguish them without the our previous length constraints, so add a 'v2' of the
+ # format to support arbitrary lengths properly:
+ if ($key =~ /^v2-0x[0-9a-fA-F]{16,128}$/ || # hex
+ $key =~ /^v2-[A-Z2-7=]{16,128}$/ || # base32
+ $key =~ /^(?:[A-Z2-7=]{16}|[A-Fa-f0-9]{40})$/) # and the old pattern copy&pasted
+ {
+ return $key;
+ }
+
+ return undef if $noerr;
+
+ die "unable to decode TFA secret\n";
+}
+
sub check_format {
my ($format, $value, $path) = @_;
return if $format eq 'regex';
if ($format =~ m/^(.*)-a?list$/) {
-
+
my $code = $format_list->{$1};
die "undefined format '$format'\n" if !$code;
return parse_property_string($code, $value, $path) if ref($code) eq 'HASH';
&$code($value);
}
-}
+}
sub parse_size {
my ($value) = @_;
return "${tb}T";
};
+sub parse_boolean {
+ my ($bool) = @_;
+ return 1 if $bool =~ m/^(1|on|yes|true)$/i;
+ return 0 if $bool =~ m/^(0|off|no|false)$/i;
+ return undef;
+}
+
sub parse_property_string {
my ($format, $data, $path, $additional_properties) = @_;
# In property strings we default to not allowing additional properties
$additional_properties = 0 if !defined($additional_properties);
+ # Support named formats here, too:
+ if (!ref($format)) {
+ if (my $desc = $format_list->{$format}) {
+ $format = $desc;
+ } else {
+ die "unknown format: $format\n";
+ }
+ } elsif (ref($format) ne 'HASH') {
+ die "unexpected format value of type ".ref($format)."\n";
+ }
+
my $default_key;
my $res = {};
die "invalid key in comma-separated list property: $k\n" if !$schema;
if ($schema->{type} && $schema->{type} eq 'boolean') {
- $v = 1 if $v =~ m/^(1|on|yes|true)$/i;
- $v = 0 if $v =~ m/^(0|off|no|false)$/i;
+ $v = parse_boolean($v) // $v;
}
$res->{$k} = $v;
} elsif ($part !~ /=/) {
my ($errors, $path, $msg) = @_;
$path = '_root' if !$path;
-
+
if ($errors->{$path}) {
$errors->{$path} = join ('\n', $errors->{$path}, $msg);
} else {
my $value = shift;
# see 'man perlretut'
- return $value =~ /^[+-]?(\d+\.\d+|\d+\.|\.\d+|\d+)([eE][+-]?\d+)?$/;
+ return $value =~ /^[+-]?(\d+\.\d+|\d+\.|\.\d+|\d+)([eE][+-]?\d+)?$/;
}
sub is_integer {
if (!defined($value)) {
return 1 if $type eq 'null';
- die "internal error"
+ die "internal error"
}
if (my $tt = ref($type)) {
foreach my $t (@$type) {
my $tmperr = {};
check_type($path, $t, $value, $tmperr);
- return 1 if !scalar(%$tmperr);
+ return 1 if !scalar(%$tmperr);
}
my $ttext = join ('|', @$type);
- add_error($errors, $path, "type check ('$ttext') failed");
+ add_error($errors, $path, "type check ('$ttext') failed");
return undef;
} elsif ($tt eq 'HASH') {
my $tmperr = {};
check_prop($value, $type, $path, $tmperr);
- return 1 if !scalar(%$tmperr);
- add_error($errors, $path, "type check failed");
+ return 1 if !scalar(%$tmperr);
+ add_error($errors, $path, "type check failed");
return undef;
} else {
die "internal error - got reference type '$tt'";
return 1;
#} elsif ($value =~ m/^(0|false|no|off)$/i) {
} elsif ($value eq '0') {
- return 0;
+ return 1; # return success (not value)
} else {
add_error($errors, $path, "type check ('$type') failed - got '$value'");
return undef;
}
}
}
- }
+ }
return undef;
}
#print "TEST: " . Dumper($value) . "\n", Dumper($requires) ;
check_prop($value, $requires, $path, $errors);
} elsif (!defined($value->{$requires})) {
- add_error($errors, $path ? "$path.$requires" : $requires,
- "missing property - '$newpath' requiers this property");
+ add_error($errors, $path ? "$path.$requires" : $requires,
+ "missing property - '$newpath' requires this property");
}
}
}
}
}
- return;
+ return;
} elsif ($schema->{properties} || $schema->{additionalProperties}) {
check_object($path, defined($schema->{properties}) ? $schema->{properties} : {},
$value, $schema->{additionalProperties}, $errors);
return;
}
}
-
+
if (is_number($value)) {
if (defined (my $max = $schema->{maximum})) {
- if ($value > $max) {
+ if ($value > $max) {
add_error($errors, $path, "value must have a maximum value of $max");
return;
}
}
if (defined (my $min = $schema->{minimum})) {
- if ($value < $min) {
+ if ($value < $min) {
add_error($errors, $path, "value must have a minimum value of $min");
return;
}
} elsif ($schema) {
check_prop($instance, $schema, '', $errors);
}
-
+
if (scalar(%$errors)) {
raise $errmsg, code => HTTP_BAD_REQUEST, errors => $errors;
}
optional => 1,
minimum => 0,
default => 0,
- },
+ },
maxLength => {
type => "integer",
description => "When the instance value is a string, this indicates maximum length of the string.",
optional => 1,
description => "This provides the title of the property",
},
+ renderer => {
+ type => "string",
+ optional => 1,
+ description => "This is used to provide rendering hints to format cli command output.",
+ },
requires => {
type => [ "string", "object" ],
optional => 1,
},
},
},
- }
+ print_width => {
+ type => "integer",
+ description => "For CLI context, this defines the maximal width to print before truncating",
+ optional => 1,
+ },
+ }
};
my $default_schema = Storable::dclone($default_schema_noref);
path => {},
parameters => {},
returns => {},
- }
+ }
},
},
method => {
},
protected => {
type => 'boolean',
- description => "Method needs special privileges - only pvedaemon can execute it",
+ description => "Method needs special privileges - only pvedaemon can execute it",
+ optional => 1,
+ },
+ allowtoken => {
+ type => 'boolean',
+ description => "Method is available for clients authenticated using an API token.",
+ optional => 1,
+ default => 1,
+ },
+ download => {
+ type => 'boolean',
+ description => "Method downloads the file content (filename is the return value of the method).",
optional => 1,
},
proxyto => {
description => "A parameter name. If specified, all calls to this method are proxied to the host contained in that parameter.",
optional => 1,
},
+ proxyto_callback => {
+ type => 'coderef',
+ description => "A function which is called to resolve the proxyto attribute. The default implementation returns the value of the 'proxyto' parameter.",
+ optional => 1,
+ },
permissions => {
type => 'object',
description => "Required access permissions. By default only 'root' is allowed to access this method.",
optional => 1,
},
user => {
- description => "A simply way to allow access for 'all' authenticated users. Value 'world' is used to allow access without credentials.",
- type => 'string',
+ description => "A simply way to allow access for 'all' authenticated users. Value 'world' is used to allow access without credentials.",
+ type => 'string',
enum => ['all', 'world'],
optional => 1,
},
check => {
description => "Array of permission checks (prefix notation).",
- type => 'array',
- optional => 1
+ type => 'array',
+ optional => 1
},
},
},
},
fragmentDelimiter => {
type => 'string',
- description => "A ways to override the default fragment delimiter '/'. This onyl works on a whole sub-class. You can set this to the empty string to match the whole rest of the URI.",
+ description => "A way to override the default fragment delimiter '/'. This only works on a whole sub-class. You can set this to the empty string to match the whole rest of the URI.",
optional => 1,
},
parameters => {
description => "JSON Schema for parameters.",
optional => 1,
},
- formatter => {
- type => 'object',
- description => "Used to store page formatter information (set by PVE::RESTHandler->register_page_formatter).",
- optional => 1,
- },
returns => {
type => 'object',
description => "JSON Schema for return value.",
},
code => {
type => 'coderef',
- description => "method implementaion (code reference)",
+ description => "method implementation (code reference)",
optional => 1,
},
subclass => {
match_name => {},
match_re => {},
fragmentDelimiter => { optional => 1 }
- }
+ }
},
- },
+ },
},
};
sub validate_schema {
- my ($schema) = @_;
+ my ($schema) = @_;
my $errmsg = "internal error - unable to verify schema\n";
validate($schema, $default_schema, $errmsg);
my $errmsg = "internal error - unable to verify method info\n";
validate($info, $method_schema, $errmsg);
-
+
validate_schema($info->{parameters}) if $info->{parameters};
validate_schema($info->{returns}) if $info->{returns};
}
# run a self test on load
-# make sure we can verify the default schema
+# make sure we can verify the default schema
validate_schema($default_schema_noref);
validate_schema($method_schema);
return $found;
}
-# a way to parse command line parameters, using a
+# a way to parse command line parameters, using a
# schema to configure Getopt::Long
sub get_options {
- my ($schema, $args, $arg_param, $fixed_param, $pwcallback) = @_;
+ my ($schema, $args, $arg_param, $fixed_param, $param_mapping_hash) = @_;
if (!$schema || !$schema->{properties}) {
raise("too many arguments\n", code => HTTP_BAD_REQUEST)
$list_param = $arg_param;
}
+ my @interactive = ();
my @getopt = ();
foreach my $prop (keys %{$schema->{properties}}) {
my $pd = $schema->{properties}->{$prop};
next if $list_param && $prop eq $list_param;
next if defined($fixed_param->{$prop});
- if ($prop eq 'password' && $pwcallback) {
- # we do not accept plain password on input line, instead
- # we turn this into a boolean option and ask for password below
- # using $pwcallback() (for security reasons).
- push @getopt, "$prop";
+ my $mapping = $param_mapping_hash->{$prop};
+ if ($mapping && $mapping->{interactive}) {
+ # interactive parameters such as passwords: make the argument
+ # optional and call the mapping function afterwards.
+ push @getopt, "$prop:s";
+ push @interactive, [$prop, $mapping->{func}];
} elsif ($pd->{type} eq 'boolean') {
push @getopt, "$prop:s";
} else {
raise("too many arguments\n", code => HTTP_BAD_REQUEST)
if scalar(@$args) != 0;
}
+ } else {
+ if (ref($arg_param)) {
+ foreach my $arg_name (@$arg_param) {
+ if ($arg_name eq 'extra-args') {
+ $opts->{'extra-args'} = [];
+ } else {
+ raise("not enough arguments\n", code => HTTP_BAD_REQUEST);
+ }
+ }
+ }
}
- if (my $pd = $schema->{properties}->{password}) {
- if ($pd->{type} ne 'boolean' && $pwcallback) {
- if ($opts->{password} || !$pd->{optional}) {
- $opts->{password} = &$pwcallback();
- }
+ foreach my $entry (@interactive) {
+ my ($opt, $func) = @$entry;
+ my $pd = $schema->{properties}->{$opt};
+ my $value = $opts->{$opt};
+ if (defined($value) || !$pd->{optional}) {
+ $opts->{$opt} = $func->($value);
}
}
- $opts = PVE::Tools::decode_utf8_parameters($opts);
+ # decode after Getopt as we are not sure how well it handles unicode
+ foreach my $p (keys %$opts) {
+ if (!ref($opts->{$p})) {
+ $opts->{$p} = decode('locale', $opts->{$p});
+ } elsif (ref($opts->{$p}) eq 'ARRAY') {
+ my $tmp = [];
+ foreach my $v (@{$opts->{$p}}) {
+ push @$tmp, decode('locale', $v);
+ }
+ $opts->{$p} = $tmp;
+ } elsif (ref($opts->{$p}) eq 'SCALAR') {
+ $opts->{$p} = decode('locale', $$opts->{$p});
+ } else {
+ raise("decoding options failed, unknown reference\n", code => HTTP_BAD_REQUEST);
+ }
+ }
foreach my $p (keys %$opts) {
if (my $pd = $schema->{properties}->{$p}) {
if ($pd->{type} eq 'boolean') {
if ($opts->{$p} eq '') {
$opts->{$p} = 1;
- } elsif ($opts->{$p} =~ m/^(1|true|yes|on)$/i) {
- $opts->{$p} = 1;
- } elsif ($opts->{$p} =~ m/^(0|false|no|off)$/i) {
- $opts->{$p} = 0;
+ } elsif (defined(my $bool = parse_boolean($opts->{$p}))) {
+ $opts->{$p} = $bool;
} else {
raise("unable to parse boolean option\n", code => HTTP_BAD_REQUEST);
}
}
}
}
- }
+ }
}
foreach my $p (keys %$fixed_param) {
my ($schema, $filename, $raw) = @_;
# do fast check (avoid validate_schema($schema))
- die "got strange schema" if !$schema->{type} ||
+ die "got strange schema" if !$schema->{type} ||
!$schema->{properties} || $schema->{type} ne 'object';
my $cfg = {};
if ($line =~ m/^(\S+?):\s*(.*)$/) {
my $key = $1;
my $value = $2;
- if ($schema->{properties}->{$key} &&
+ if ($schema->{properties}->{$key} &&
$schema->{properties}->{$key}->{type} eq 'boolean') {
- $value = 1 if $value =~ m/^(1|on|yes|true)$/i;
- $value = 0 if $value =~ m/^(0|off|no|false)$/i;
+ $value = parse_boolean($value) // $value;
}
$cfg->{$key} = $value;
} else {
foreach my $k (keys %$errors) {
warn "parse error in '$filename' - '$k': $errors->{$k}\n";
delete $cfg->{$k};
- }
+ }
return $cfg;
}
my ($schema, $filename, $cfg) = @_;
# do fast check (avoid validate_schema($schema))
- die "got strange schema" if !$schema->{type} ||
+ die "got strange schema" if !$schema->{type} ||
!$schema->{properties} || $schema->{type} ne 'object';
validate($cfg, $schema, "validation error in '$filename'\n");
my $data = '';
- foreach my $k (keys %$cfg) {
+ foreach my $k (sort keys %$cfg) {
$data .= "$k: $cfg->{$k}\n";
}
};
sub generate_typetext {
- my ($format) = @_;
+ my ($format, $list_enums) = @_;
my ($default_key, $keyAliasProps) = &$find_schema_default_key($format);
} elsif (my $text = $phash->{typetext}) {
$typetext .= $text;
} elsif (my $enum = $phash->{enum}) {
- $typetext .= '<' . join('|', @$enum) . '>';
+ if ($list_enums || (scalar(@$enum) <= 3)) {
+ $typetext .= '<' . join('|', @$enum) . '>';
+ } else {
+ $typetext .= '<enum>';
+ }
} elsif ($phash->{type} eq 'boolean') {
$typetext .= '<1|0>';
} elsif ($phash->{type} eq 'integer') {
}
sub schema_get_type_text {
- my ($phash) = @_;
+ my ($phash, $style) = @_;
my $type = $phash->{type} || 'string';
} elsif ($phash->{format_description}) {
return "<$phash->{format_description}>";
} elsif ($phash->{enum}) {
- return "(" . join(' | ', sort @{$phash->{enum}}) . ")";
+ return "<" . join(' | ', sort @{$phash->{enum}}) . ">";
} elsif ($phash->{pattern}) {
return $phash->{pattern};
} elsif ($type eq 'integer' || $type eq 'number') {
# NOTE: always access values as number (avoid converion to string)
if (defined($phash->{minimum}) && defined($phash->{maximum})) {
- return "$type (" . ($phash->{minimum} + 0) . " - " .
+ return "<$type> (" . ($phash->{minimum} + 0) . " - " .
($phash->{maximum} + 0) . ")";
} elsif (defined($phash->{minimum})) {
- return "$type (" . ($phash->{minimum} + 0) . " - N)";
+ return "<$type> (" . ($phash->{minimum} + 0) . " - N)";
} elsif (defined($phash->{maximum})) {
- return "$type (-N - " . ($phash->{maximum} + 0) . ")";
+ return "<$type> (-N - " . ($phash->{maximum} + 0) . ")";
}
} elsif ($type eq 'string') {
if (my $format = $phash->{format}) {
$format = get_format($format) if ref($format) ne 'HASH';
if (ref($format) eq 'HASH') {
- return generate_typetext($format);
+ my $list_enums = 0;
+ $list_enums = 1 if $style && $style eq 'config-sub';
+ return generate_typetext($format, $list_enums);
}
}
}
- return $type;
+ return "<$type>";
}
1;
projects / pve-common.git / blobdiff