JSONSchema: use validator in print_property_string too

[pve-common.git] / src / PVE / JSONSchema.pm

diff --git a/src/PVE/JSONSchema.pm b/src/PVE/JSONSchema.pm
index 1d28f36510bab45b0ba58c4fb22478a3c870f4fe..c5002d83036209592562bd947fea10418c76fdb0 100644 (file)
--- a/src/PVE/JSONSchema.pm
+++ b/src/PVE/JSONSchema.pm
@@ -16,8 +16,9 @@ use Data::Dumper;
 use base 'Exporter';
 
 our @EXPORT_OK = qw(
-register_standard_option
 get_standard_option
+parse_property_string
+register_standard_option
 );
 
 # Note: This class implements something similar to JSON schema, but it is not 100% complete.
@@ -120,19 +121,26 @@ register_standard_option('pve-snapshot-name', {
 });
 
 my $format_list = {};
+my $format_validators = {};
 
 sub register_format {
-    my ($format, $code) = @_;
+    my ($name, $format, $validator) = @_;
 
-    die "JSON schema format '$format' already registered\n"
-       if $format_list->{$format};
+    die "JSON schema format '$name' already registered\n"
+       if $format_list->{$name};
 
-    $format_list->{$format} = $code;
+    if ($validator) {
+       die "A \$validator function can only be specified for hash-based formats\n"
+           if ref($format) ne 'HASH';
+       $format_validators->{$name} = $validator;
+    }
+
+    $format_list->{$name} = $format;
 }
 
 sub get_format {
-    my ($format) = @_;
-    return $format_list->{$format};
+    my ($name) = @_;
+    return $format_list->{$name};
 }
 
 my $renderer_hash = {};
@@ -481,6 +489,25 @@ sub pve_verify_dns_name {
     return $name;
 }
 
+register_format('timezone', \&pve_verify_timezone);
+sub pve_verify_timezone {
+    my ($timezone, $noerr) = @_;
+
+    return $timezone if $timezone eq 'UTC';
+
+    open(my $fh, "<",  "/usr/share/zoneinfo/zone.tab");
+    while (my $line = <$fh>) {
+       next if $line =~ /^\s*#/;
+       chomp $line;
+       my $zone = (split /\t/, $line)[2];
+       return $timezone if $timezone eq $zone; # found
+    }
+    close $fh;
+
+    return undef if $noerr;
+    die "invalid time zone '$timezone'\n";
+}
+
 # network interface name
 register_format('pve-iface', \&pve_verify_iface);
 sub pve_verify_iface {
@@ -646,39 +673,47 @@ sub pve_verify_tfa_secret {
 sub check_format {
     my ($format, $value, $path) = @_;
 
-    return parse_property_string($format, $value, $path) if ref($format) eq 'HASH';
-    return if $format eq 'regex';
+    if (ref($format) eq 'HASH') {
+       # hash ref cannot have validator/list/opt handling attached
+       return parse_property_string($format, $value, $path);
+    }
 
-    if ($format =~ m/^(.*)-a?list$/) {
+    if (ref($format) eq 'CODE') {
+       # we are the (sole, old-style) validator
+       return $format->($value);
+    }
 
-       my $code = $format_list->{$1};
+    return if $format eq 'regex';
 
-       die "undefined format '$format'\n" if !$code;
+    my $parsed;
+    $format =~ m/^(.*?)(?:-a?(list|opt))?$/;
+    my ($format_name, $format_type) = ($1, $2 // 'none');
+    my $registered = get_format($format_name);
+    die "undefined format '$format'\n" if !$registered;
 
+    die "'-$format_type' format must have code ref, not hash\n"
+       if $format_type ne 'none' && ref($registered) ne 'CODE';
+
+    if ($format_type eq 'list') {
        # Note: we allow empty lists
        foreach my $v (split_list($value)) {
-           &$code($v);
+           $parsed = $registered->($v);
        }
-
-    } elsif ($format =~ m/^(.*)-opt$/) {
-
-       my $code = $format_list->{$1};
-
-       die "undefined format '$format'\n" if !$code;
-
-       return if !$value; # allow empty string
-
-       &$code($value);
-
+    } elsif ($format_type eq 'opt') {
+       $parsed = $registered->($value) if $value;
    } else {
-
-       my $code = $format_list->{$format};
-
-       die "undefined format '$format'\n" if !$code;
-
-       return parse_property_string($code, $value, $path) if ref($code) eq 'HASH';
-       &$code($value);
+       if (ref($registered) eq 'HASH') {
+           # Note: this is the only case where a validator function could be
+           # attached, hence it's safe to handle that in parse_property_string.
+           # We do however have to call it with $format_name instead of
+           # $registered, so it knows about the name (and thus any validators).
+           $parsed = parse_property_string($format, $value, $path);
+       } else {
+           $parsed = $registered->($value);
+       }
     }
+
+    return $parsed;
 }
 
 sub parse_size {
@@ -734,9 +769,16 @@ sub parse_property_string {
     $additional_properties = 0 if !defined($additional_properties);
 
     # Support named formats here, too:
+    my $validator;
     if (!ref($format)) {
-       if (my $desc = $format_list->{$format}) {
-           $format = $desc;
+       if (my $reg = get_format($format)) {
+           die "parse_property_string only accepts hash based named formats\n"
+               if ref($reg) ne 'HASH';
+
+           # named formats can have validators attached
+           $validator = $format_validators->{$format};
+
+           $format = $reg;
        } else {
            die "unknown format: $format\n";
        }
@@ -792,6 +834,7 @@ sub parse_property_string {
        raise "format error\n", errors => $errors;
     }
 
+    return $validator->($res) if $validator;
     return $res;
 }
 
@@ -1854,9 +1897,12 @@ sub generate_typetext {
 sub print_property_string {
     my ($data, $format, $skip, $path) = @_;
 
+    my $validator;
     if (ref($format) ne 'HASH') {
        my $schema = get_format($format);
        die "not a valid format: $format\n" if !$schema;
+       # named formats can have validators attached
+       $validator = $format_validators->{$format};
        $format = $schema;
     }
 
@@ -1866,6 +1912,8 @@ sub print_property_string {
        raise "format error", errors => $errors;
     }
 
+    $data = $validator->($data) if $validator;
+
     my ($default_key, $keyAliasProps) = &$find_schema_default_key($format);
 
     my $res = '';