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

package PVE::SectionConfig;

use strict;
use warnings;

use Carp;
use Digest::SHA;

use PVE::Exception qw(raise_param_exc);
use PVE::JSONSchema qw(get_standard_option);

my $defaultData = {
    options => {},
    plugins => {},
    plugindata => {},
    propertyList => {},
};

sub private {
    die "overwrite me";
    return $defaultData;
}

sub register {
    my ($class) = @_;

    my $type = $class->type();
    my $pdata = $class->private();

    die "duplicate plugin registration (type = $type)"
	if defined($pdata->{plugins}->{$type});

    my $plugindata = $class->plugindata();
    $pdata->{plugindata}->{$type} = $plugindata;
    $pdata->{plugins}->{$type} = $class;
}

sub type {
    die "overwrite me";
}

sub properties {
    return {};
}

sub options {
    return {};
}

sub plugindata {
    return {};
}

sub createSchema {
    my ($class, $skip_type) = @_;

    my $pdata = $class->private();
    my $propertyList = $pdata->{propertyList};
    my $plugins = $pdata->{plugins};

    my $props = {};

    my $copy_property = sub {
	my ($src) = @_;

	my $res = {};
	foreach my $k (keys %$src) {
	    $res->{$k} = $src->{$k};
	}

	return $res;
    };

    foreach my $p (keys %$propertyList) {
	next if $skip_type && $p eq 'type';

	if (!$propertyList->{$p}->{optional}) {
	    $props->{$p} = $propertyList->{$p};
	    next;
	}

	my $required = 1;

	my $copts = $class->options();
	$required = 0 if defined($copts->{$p}) && $copts->{$p}->{optional};

	foreach my $t (keys %$plugins) {
	    my $opts = $pdata->{options}->{$t} || {};
	    $required = 0 if !defined($opts->{$p}) || $opts->{$p}->{optional};
	}

	if ($required) {
	    # make a copy, because we modify the optional property
	    my $res = &$copy_property($propertyList->{$p});
	    $res->{optional} = 0;
	    $props->{$p} = $res;
	} else {
	    $props->{$p} = $propertyList->{$p};
	}
    }

    return {
	type => "object",
	additionalProperties => 0,
	properties => $props,
    };
}

sub updateSchema {
    my ($class, $single_class) = @_;

    my $pdata = $class->private();
    my $propertyList = $pdata->{propertyList};
    my $plugins = $pdata->{plugins};

    my $props = {};

    my $filter_type = $class->type() if $single_class;

    foreach my $p (keys %$propertyList) {
	next if $p eq 'type';

	my $copts = $class->options();

	next if defined($filter_type) && !defined($copts->{$p});

	if (!$propertyList->{$p}->{optional}) {
	    $props->{$p} = $propertyList->{$p};
	    next;
	}

	my $modifyable = 0;

	$modifyable = 1 if defined($copts->{$p}) && !$copts->{$p}->{fixed};

	foreach my $t (keys %$plugins) {
	    my $opts = $pdata->{options}->{$t} || {};
	    next if !defined($opts->{$p});
	    $modifyable = 1 if !$opts->{$p}->{fixed};
	}
	next if !$modifyable;

	$props->{$p} = $propertyList->{$p};
    }

    $props->{digest} = get_standard_option('pve-config-digest');

    $props->{delete} = {
	type => 'string', format => 'pve-configid-list',
	description => "A list of settings you want to delete.",
	maxLength => 4096,
	optional => 1,
    };

    return {
	type => "object",
	additionalProperties => 0,
	properties => $props,
    };
}

sub init {
    my ($class) = @_;

    my $pdata = $class->private();

    foreach my $k (qw(options plugins plugindata propertyList)) {
	$pdata->{$k} = {} if !$pdata->{$k};
    }

    my $plugins = $pdata->{plugins};
    my $propertyList = $pdata->{propertyList};

    foreach my $type (keys %$plugins) {
	my $props = $plugins->{$type}->properties();
	foreach my $p (keys %$props) {
	    die "duplicate property '$p'" if defined($propertyList->{$p});
	    my $res = $propertyList->{$p} = {};
	    my $data = $props->{$p};
	    for my $a (keys %$data) {
		$res->{$a} = $data->{$a};
	    }
	    $res->{optional} = 1;
	}
    }

    foreach my $type (keys %$plugins) {
	my $opts = $plugins->{$type}->options();
	foreach my $p (keys %$opts) {
	    die "undefined property '$p'" if !$propertyList->{$p};
	}
	$pdata->{options}->{$type} = $opts;
    }

    $propertyList->{type}->{type} = 'string';
    $propertyList->{type}->{enum} = [sort keys %$plugins];
}

sub lookup {
    my ($class, $type) = @_;

    croak "cannot lookup undefined type!" if !defined($type);

    my $pdata = $class->private();
    my $plugin = $pdata->{plugins}->{$type};

    die "unknown section type '$type'\n" if !$plugin;

    return $plugin;
}

sub lookup_types {
    my ($class) = @_;

    my $pdata = $class->private();

    return [ sort keys %{$pdata->{plugins}} ];
}

sub decode_value {
    my ($class, $type, $key, $value) = @_;

    return $value;
}

sub encode_value {
    my ($class, $type, $key, $value) = @_;

    return $value;
}

sub check_value {
    my ($class, $type, $key, $value, $storeid, $skipSchemaCheck) = @_;

    my $pdata = $class->private();

    return $value if $key eq 'type' && $type eq $value;

    my $opts = $pdata->{options}->{$type};
    die "unknown section type '$type'\n" if !$opts;

    die "unexpected property '$key'\n" if !defined($opts->{$key});

    my $schema = $pdata->{propertyList}->{$key};
    die "unknown property type\n" if !$schema;

    my $ct = $schema->{type};

    $value = 1 if $ct eq 'boolean' && !defined($value);

    die "got undefined value\n" if !defined($value);

    die "property contains a line feed\n" if $value =~ m/[\n\r]/;

    if (!$skipSchemaCheck) {
	my $errors = {};
	PVE::JSONSchema::check_prop($value, $schema, '', $errors);
	if (scalar(keys %$errors)) {
	    die "$errors->{$key}\n" if $errors->{$key};
	    die "$errors->{_root}\n" if $errors->{_root};
	    die "unknown error\n";
	}
    }

    if ($ct eq 'boolean' || $ct eq 'integer' || $ct eq 'number') {
	return $value + 0; # convert to number
    }

    return $value;
}

sub parse_section_header {
    my ($class, $line) = @_;

    if ($line =~ m/^(\S+):\s*(\S+)\s*$/) {
	my ($type, $sectionId) = ($1, $2);
	my $errmsg = undef; # set if you want to skip whole section
	my $config = {}; # to return additional attributes
	return ($type, $sectionId, $errmsg, $config);
    }
    return undef;
}

sub format_section_header {
    my ($class, $type, $sectionId, $scfg, $done_hash) = @_;

    return "$type: $sectionId\n";
}


sub parse_config {
    my ($class, $filename, $raw, $allow_unknown) = @_;

    my $pdata = $class->private();

    my $ids = {};
    my $order = {};

    $raw = '' if !defined($raw);

    my $digest = Digest::SHA::sha1_hex($raw);

    my $pri = 1;

    my $lineno = 0;
    my @lines = split(/\n/, $raw);
    my $nextline = sub {
	while (defined(my $line = shift @lines)) {
	    $lineno++;
	    return $line if ($line !~ /^\s*#/);
	}
    };

    my $errors = [];
    while (@lines) {
	my $line = $nextline->();
	next if !$line;

	my $errprefix = "file $filename line $lineno";

	my ($type, $sectionId, $errmsg, $config) = $class->parse_section_header($line);
	if ($config) {
	    my $skip = 0;
	    my $unknown = 0;

	    my $plugin;

	    if ($errmsg) {
		$skip = 1;
		chomp $errmsg;
		warn "$errprefix (skip section '$sectionId'): $errmsg\n";
	    } elsif (!$type) {
		$skip = 1;
		warn "$errprefix (skip section '$sectionId'): missing type - internal error\n";
	    } else {
		if (!($plugin = $pdata->{plugins}->{$type})) {
		    if ($allow_unknown) {
			$unknown = 1;
		    } else {
			$skip = 1;
			warn "$errprefix (skip section '$sectionId'): unsupported type '$type'\n";
		    }
		}
	    }

	    while ($line = $nextline->()) {
		next if $skip; # skip

		$errprefix = "file $filename line $lineno";

		if ($line =~ m/^\s+(\S+)(\s+(.*\S))?\s*$/) {
		    my ($k, $v) = ($1, $3);

		    eval {
			die "duplicate attribute\n" if defined($config->{$k});
			if (!$unknown) {
			    $v = $plugin->check_value($type, $k, $v, $sectionId);
			}
			$config->{$k} = $v;
		    };
		    if (my $err = $@) {
			warn "$errprefix (section '$sectionId') - unable to parse value of '$k': $err";
			push @$errors, {
			    context => $errprefix,
			    section => $sectionId,
			    key => $k,
			    err => $err,
			};
		    }

		} else {
		    warn "$errprefix (section '$sectionId') - ignore config line: $line\n";
		}
	    }

	    if ($unknown) {
		$config->{type} = $type;
		$ids->{$sectionId} = $config;
		$order->{$sectionId} = $pri++;
	    } elsif (!$skip && $type && $plugin && $config) {
		$config->{type} = $type;
		if (!$unknown) {
		    $config = eval { $config = $plugin->check_config($sectionId, $config, 1, 1); };
		    warn "$errprefix (skip section '$sectionId'): $@" if $@;
		}
		$ids->{$sectionId} = $config;
		$order->{$sectionId} = $pri++;
	    }

	} else {
	    warn "$errprefix - ignore config line: $line\n";
	}
    }

    my $cfg = {
	ids => $ids,
	order => $order,
	digest => $digest
    };
    $cfg->{errors} = $errors if scalar(@$errors) > 0;

    return $cfg;
}

sub check_config {
    my ($class, $sectionId, $config, $create, $skipSchemaCheck) = @_;

    my $type = $class->type();
    my $pdata = $class->private();
    my $opts = $pdata->{options}->{$type};

    my $settings = { type => $type };

    foreach my $k (keys %$config) {
	my $value = $config->{$k};

	die "can't change value of fixed parameter '$k'\n"
	    if !$create && defined($opts->{$k}) && $opts->{$k}->{fixed};

	if (defined($value)) {
	    my $tmp = $class->check_value($type, $k, $value, $sectionId, $skipSchemaCheck);
	    $settings->{$k} = $class->decode_value($type, $k, $tmp);
	} else {
	    die "got undefined value for option '$k'\n";
	}
    }

    if ($create) {
	# check if we have a value for all required options
	foreach my $k (keys %$opts) {
	    next if $opts->{$k}->{optional};
	    die "missing value for required option '$k'\n"
		if !defined($config->{$k});
	}
    }

    return $settings;
}

my $format_config_line = sub {
    my ($schema, $key, $value) = @_;

    my $ct = $schema->{type};

    die "property '$key' contains a line feed\n"
	if ($key =~ m/[\n\r]/) || ($value =~ m/[\n\r]/);

    if ($ct eq 'boolean') {
	return "\t$key " . ($value ? 1 : 0) . "\n"
	    if defined($value);
    } else {
	return "\t$key $value\n" if "$value" ne '';
    }
};

sub write_config {
    my ($class, $filename, $cfg, $allow_unknown) = @_;

    my $pdata = $class->private();
    my $propertyList = $pdata->{propertyList};

    my $out = '';

    my $ids = $cfg->{ids};
    my $order = $cfg->{order};

    my $maxpri = 0;
    foreach my $sectionId (keys %$ids) {
	my $pri = $order->{$sectionId};
	$maxpri = $pri if $pri && $pri > $maxpri;
    }
    foreach my $sectionId (keys %$ids) {
	if (!defined ($order->{$sectionId})) {
	    $order->{$sectionId} = ++$maxpri;
	}
    }

    foreach my $sectionId (sort {$order->{$a} <=> $order->{$b}} keys %$ids) {
	my $scfg = $ids->{$sectionId};
	my $type = $scfg->{type};
	my $opts = $pdata->{options}->{$type};

	die "unknown section type '$type'\n" if !$opts && !$allow_unknown;

	my $done_hash = {};

	my $data = $class->format_section_header($type, $sectionId, $scfg, $done_hash);

	if (!$opts && $allow_unknown) {
	    $done_hash->{type} = 1;
	    my @first = exists($scfg->{comment}) ? ('comment') : ();
	    for my $k (@first, sort keys %$scfg) {
		next if defined($done_hash->{$k});
		$done_hash->{$k} = 1;
		my $v = $scfg->{$k};
		$data .= "\t$k $v\n";
	    }
	    $out .= "$data\n";
	    next;
	}


	if ($scfg->{comment} && !$done_hash->{comment}) {
	    my $k = 'comment';
	    my $v = $class->encode_value($type, $k, $scfg->{$k});
	    $data .= &$format_config_line($propertyList->{$k}, $k, $v);
	}

	$data .= "\tdisable\n" if $scfg->{disable} && !$done_hash->{disable};

	$done_hash->{comment} = 1;
	$done_hash->{disable} = 1;

	my @option_keys = sort keys %$opts;
	foreach my $k (@option_keys) {
	    next if defined($done_hash->{$k});
	    next if $opts->{$k}->{optional};
	    $done_hash->{$k} = 1;
	    my $v = $scfg->{$k};
	    die "section '$sectionId' - missing value for required option '$k'\n"
		if !defined ($v);
	    $v = $class->encode_value($type, $k, $v);
	    $data .= &$format_config_line($propertyList->{$k}, $k, $v);
	}

	foreach my $k (@option_keys) {
	    next if defined($done_hash->{$k});
	    my $v = $scfg->{$k};
	    next if !defined($v);
	    $v = $class->encode_value($type, $k, $v);
	    $data .= &$format_config_line($propertyList->{$k}, $k, $v);
	}

	$out .= "$data\n";
    }

    return $out;
}

sub assert_if_modified {
    my ($cfg, $digest) = @_;

    PVE::Tools::assert_if_modified($cfg->{digest}, $digest);
}

sub delete_from_config {
    my ($config, $option_schema, $new_options, $to_delete) = @_;

    for my $k ($to_delete->@*) {
	my $d = $option_schema->{$k} || die "no such option '$k'\n";
	die "unable to delete required option '$k'\n" if !$d->{optional};
	die "unable to delete fixed option '$k'\n" if $d->{fixed};
	die "cannot set and delete property '$k' at the same time!\n"
	    if defined($new_options->{$k});
	delete $config->{$k};
    }

    return $config;
}

1;
Commit	Line	Data
212b08e8 DM	1	package PVE::SectionConfig;
	2
	3	use strict;
	4	use warnings;
848231af	5
7db4e5d7	6	use Carp;
212b08e8	7	use Digest::SHA;
848231af	8
212b08e8 DM	9	use PVE::Exception qw(raise_param_exc);
	10	use PVE::JSONSchema qw(get_standard_option);
	11
212b08e8 DM	12	my $defaultData = {
	13	options => {},
	14	plugins => {},
	15	plugindata => {},
	16	propertyList => {},
	17	};
	18
	19	sub private {
	20	die "overwrite me";
	21	return $defaultData;
	22	}
	23
	24	sub register {
	25	my ($class) = @_;
	26
	27	my $type = $class->type();
	28	my $pdata = $class->private();
	29
ebd2b0ac DM	30	die "duplicate plugin registration (type = $type)"
	31	if defined($pdata->{plugins}->{$type});
	32
212b08e8 DM	33	my $plugindata = $class->plugindata();
	34	$pdata->{plugindata}->{$type} = $plugindata;
	35	$pdata->{plugins}->{$type} = $class;
	36	}
	37
	38	sub type {
	39	die "overwrite me";
	40	}
	41
	42	sub properties {
	43	return {};
	44	}
	45
	46	sub options {
	47	return {};
cca9c864	48	}
212b08e8 DM	49
	50	sub plugindata {
	51	return {};
cca9c864	52	}
212b08e8 DM	53
212b08e8 DM	54	sub createSchema {
9c2e4034	55	my ($class, $skip_type) = @_;
212b08e8 DM	56
	57	my $pdata = $class->private();
	58	my $propertyList = $pdata->{propertyList};
a3530f55 DM	59	my $plugins = $pdata->{plugins};
	60
	61	my $props = {};
	62
	63	my $copy_property = sub {
	64	my ($src) = @_;
	65
	66	my $res = {};
	67	foreach my $k (keys %$src) {
	68	$res->{$k} = $src->{$k};
	69	}
	70
	71	return $res;
	72	};
	73
	74	foreach my $p (keys %$propertyList) {
9c2e4034 DM	75	next if $skip_type && $p eq 'type';
9c2e4034 DM	76
a3530f55 DM	77	if (!$propertyList->{$p}->{optional}) {
	78	$props->{$p} = $propertyList->{$p};
	79	next;
	80	}
	81
	82	my $required = 1;
	83
	84	my $copts = $class->options();
	85	$required = 0 if defined($copts->{$p}) && $copts->{$p}->{optional};
	86
	87	foreach my $t (keys %$plugins) {
	88	my $opts = $pdata->{options}->{$t} \|\| {};
	89	$required = 0 if !defined($opts->{$p}) \|\| $opts->{$p}->{optional};
	90	}
	91
	92	if ($required) {
	93	# make a copy, because we modify the optional property
	94	my $res = &$copy_property($propertyList->{$p});
	95	$res->{optional} = 0;
	96	$props->{$p} = $res;
	97	} else {
	98	$props->{$p} = $propertyList->{$p};
	99	}
	100	}
212b08e8 DM	101
	102	return {
	103	type => "object",
	104	additionalProperties => 0,
a3530f55	105	properties => $props,
212b08e8 DM	106	};
	107	}
	108
	109	sub updateSchema {
885641fb	110	my ($class, $single_class) = @_;
212b08e8 DM	111
	112	my $pdata = $class->private();
	113	my $propertyList = $pdata->{propertyList};
	114	my $plugins = $pdata->{plugins};
	115
	116	my $props = {};
	117
885641fb DM	118	my $filter_type = $class->type() if $single_class;
885641fb DM	119
212b08e8 DM	120	foreach my $p (keys %$propertyList) {
212b08e8 DM	121	next if $p eq 'type';
885641fb DM	122
	123	my $copts = $class->options();
	124
	125	next if defined($filter_type) && !defined($copts->{$p});
	126
212b08e8 DM	127	if (!$propertyList->{$p}->{optional}) {
	128	$props->{$p} = $propertyList->{$p};
	129	next;
	130	}
516dfb55 DM	131
	132	my $modifyable = 0;
	133
0d838035 DM	134	$modifyable = 1 if defined($copts->{$p}) && !$copts->{$p}->{fixed};
0d838035 DM	135
212b08e8	136	foreach my $t (keys %$plugins) {
516dfb55	137	my $opts = $pdata->{options}->{$t} \|\| {};
212b08e8	138	next if !defined($opts->{$p});
516dfb55	139	$modifyable = 1 if !$opts->{$p}->{fixed};
212b08e8	140	}
516dfb55 DM	141	next if !$modifyable;
	142
	143	$props->{$p} = $propertyList->{$p};
212b08e8 DM	144	}
212b08e8 DM	145
dc5eae7d	146	$props->{digest} = get_standard_option('pve-config-digest');
212b08e8 DM	147
	148	$props->{delete} = {
	149	type => 'string', format => 'pve-configid-list',
	150	description => "A list of settings you want to delete.",
	151	maxLength => 4096,
	152	optional => 1,
	153	};
	154
	155	return {
	156	type => "object",
	157	additionalProperties => 0,
	158	properties => $props,
	159	};
	160	}
	161
	162	sub init {
	163	my ($class) = @_;
	164
	165	my $pdata = $class->private();
	166
	167	foreach my $k (qw(options plugins plugindata propertyList)) {
	168	$pdata->{$k} = {} if !$pdata->{$k};
	169	}
	170
	171	my $plugins = $pdata->{plugins};
	172	my $propertyList = $pdata->{propertyList};
	173
	174	foreach my $type (keys %$plugins) {
	175	my $props = $plugins->{$type}->properties();
	176	foreach my $p (keys %$props) {
b732bea7	177	die "duplicate property '$p'" if defined($propertyList->{$p});
212b08e8 DM	178	my $res = $propertyList->{$p} = {};
	179	my $data = $props->{$p};
	180	for my $a (keys %$data) {
	181	$res->{$a} = $data->{$a};
	182	}
	183	$res->{optional} = 1;
	184	}
	185	}
	186
	187	foreach my $type (keys %$plugins) {
	188	my $opts = $plugins->{$type}->options();
	189	foreach my $p (keys %$opts) {
	190	die "undefined property '$p'" if !$propertyList->{$p};
	191	}
	192	$pdata->{options}->{$type} = $opts;
	193	}
	194
	195	$propertyList->{type}->{type} = 'string';
08aa41d7	196	$propertyList->{type}->{enum} = [sort keys %$plugins];
212b08e8 DM	197	}
	198
	199	sub lookup {
	200	my ($class, $type) = @_;
	201
7db4e5d7 TL	202	croak "cannot lookup undefined type!" if !defined($type);
7db4e5d7 TL	203
212b08e8 DM	204	my $pdata = $class->private();
	205	my $plugin = $pdata->{plugins}->{$type};
	206
	207	die "unknown section type '$type'\n" if !$plugin;
	208
	209	return $plugin;
	210	}
	211
	212	sub lookup_types {
	213	my ($class) = @_;
	214
	215	my $pdata = $class->private();
cca9c864	216
a7f30ebf	217	return [ sort keys %{$pdata->{plugins}} ];
212b08e8 DM	218	}
	219
	220	sub decode_value {
	221	my ($class, $type, $key, $value) = @_;
	222
	223	return $value;
	224	}
	225
	226	sub encode_value {
	227	my ($class, $type, $key, $value) = @_;
	228
	229	return $value;
	230	}
	231
	232	sub check_value {
	233	my ($class, $type, $key, $value, $storeid, $skipSchemaCheck) = @_;
	234
	235	my $pdata = $class->private();
	236
	237	return $value if $key eq 'type' && $type eq $value;
	238
	239	my $opts = $pdata->{options}->{$type};
cca9c864	240	die "unknown section type '$type'\n" if !$opts;
212b08e8 DM	241
	242	die "unexpected property '$key'\n" if !defined($opts->{$key});
	243
	244	my $schema = $pdata->{propertyList}->{$key};
	245	die "unknown property type\n" if !$schema;
	246
	247	my $ct = $schema->{type};
	248
	249	$value = 1 if $ct eq 'boolean' && !defined($value);
	250
	251	die "got undefined value\n" if !defined($value);
	252
	253	die "property contains a line feed\n" if $value =~ m/[\n\r]/;
	254
	255	if (!$skipSchemaCheck) {
	256	my $errors = {};
	257	PVE::JSONSchema::check_prop($value, $schema, '', $errors);
	258	if (scalar(keys %$errors)) {
	259	die "$errors->{$key}\n" if $errors->{$key};
	260	die "$errors->{_root}\n" if $errors->{_root};
	261	die "unknown error\n";
	262	}
	263	}
	264
bbca3bdc DM	265	if ($ct eq 'boolean' \|\| $ct eq 'integer' \|\| $ct eq 'number') {
	266	return $value + 0; # convert to number
	267	}
	268
212b08e8 DM	269	return $value;
	270	}
	271
	272	sub parse_section_header {
	273	my ($class, $line) = @_;
	274
	275	if ($line =~ m/^(\S+):\s(\S+)\s$/) {
	276	my ($type, $sectionId) = ($1, $2);
	277	my $errmsg = undef; # set if you want to skip whole section
	278	my $config = {}; # to return additional attributes
	279	return ($type, $sectionId, $errmsg, $config);
	280	}
	281	return undef;
	282	}
	283
	284	sub format_section_header {
2d63b598	285	my ($class, $type, $sectionId, $scfg, $done_hash) = @_;
212b08e8 DM	286
	287	return "$type: $sectionId\n";
	288	}
	289
	290
	291	sub parse_config {
c9ede1c3	292	my ($class, $filename, $raw, $allow_unknown) = @_;
212b08e8 DM	293
	294	my $pdata = $class->private();
	295
	296	my $ids = {};
	297	my $order = {};
	298
3c4d612a WB	299	$raw = '' if !defined($raw);
	300
	301	my $digest = Digest::SHA::sha1_hex($raw);
cca9c864	302
212b08e8 DM	303	my $pri = 1;
	304
	305	my $lineno = 0;
3c4d612a WB	306	my @lines = split(/\n/, $raw);
3c4d612a WB	307	my $nextline = sub {
e1fbb779	308	while (defined(my $line = shift @lines)) {
3c4d612a	309	$lineno++;
e1fbb779	310	return $line if ($line !~ /^\s*#/);
3c4d612a WB	311	}
3c4d612a WB	312	};
212b08e8	313
4b32ef6e	314	my $errors = [];
e1fbb779 FE	315	while (@lines) {
	316	my $line = $nextline->();
	317	next if !$line;
	318
212b08e8 DM	319	my $errprefix = "file $filename line $lineno";
	320
	321	my ($type, $sectionId, $errmsg, $config) = $class->parse_section_header($line);
	322	if ($config) {
c9ede1c3 WB	323	my $skip = 0;
c9ede1c3 WB	324	my $unknown = 0;
212b08e8 DM	325
	326	my $plugin;
	327
	328	if ($errmsg) {
c9ede1c3	329	$skip = 1;
212b08e8 DM	330	chomp $errmsg;
	331	warn "$errprefix (skip section '$sectionId'): $errmsg\n";
	332	} elsif (!$type) {
c9ede1c3	333	$skip = 1;
212b08e8 DM	334	warn "$errprefix (skip section '$sectionId'): missing type - internal error\n";
	335	} else {
	336	if (!($plugin = $pdata->{plugins}->{$type})) {
c9ede1c3 WB	337	if ($allow_unknown) {
	338	$unknown = 1;
	339	} else {
	340	$skip = 1;
	341	warn "$errprefix (skip section '$sectionId'): unsupported type '$type'\n";
	342	}
212b08e8 DM	343	}
	344	}
	345
9e594bd4	346	while ($line = $nextline->()) {
c9ede1c3	347	next if $skip; # skip
212b08e8 DM	348
	349	$errprefix = "file $filename line $lineno";
	350
	351	if ($line =~ m/^\s+(\S+)(\s+(.\S))?\s$/) {
	352	my ($k, $v) = ($1, $3);
cca9c864	353
212b08e8 DM	354	eval {
212b08e8 DM	355	die "duplicate attribute\n" if defined($config->{$k});
c9ede1c3 WB	356	if (!$unknown) {
	357	$v = $plugin->check_value($type, $k, $v, $sectionId);
	358	}
	359	$config->{$k} = $v;
212b08e8	360	};
4b32ef6e FE	361	if (my $err = $@) {
	362	warn "$errprefix (section '$sectionId') - unable to parse value of '$k': $err";
	363	push @$errors, {
	364	context => $errprefix,
	365	section => $sectionId,
	366	key => $k,
	367	err => $err,
	368	};
	369	}
212b08e8 DM	370
	371	} else {
	372	warn "$errprefix (section '$sectionId') - ignore config line: $line\n";
	373	}
	374	}
	375
c9ede1c3	376	if ($unknown) {
212b08e8	377	$config->{type} = $type;
c9ede1c3 WB	378	$ids->{$sectionId} = $config;
	379	$order->{$sectionId} = $pri++;
	380	} elsif (!$skip && $type && $plugin && $config) {
	381	$config->{type} = $type;
	382	if (!$unknown) {
	383	$config = eval { $config = $plugin->check_config($sectionId, $config, 1, 1); };
	384	warn "$errprefix (skip section '$sectionId'): $@" if $@;
	385	}
	386	$ids->{$sectionId} = $config;
212b08e8 DM	387	$order->{$sectionId} = $pri++;
	388	}
	389
	390	} else {
	391	warn "$errprefix - ignore config line: $line\n";
	392	}
	393	}
	394
4b32ef6e FE	395	my $cfg = {
	396	ids => $ids,
	397	order => $order,
	398	digest => $digest
	399	};
	400	$cfg->{errors} = $errors if scalar(@$errors) > 0;
212b08e8 DM	401
	402	return $cfg;
	403	}
	404
	405	sub check_config {
	406	my ($class, $sectionId, $config, $create, $skipSchemaCheck) = @_;
	407
	408	my $type = $class->type();
	409	my $pdata = $class->private();
	410	my $opts = $pdata->{options}->{$type};
	411
	412	my $settings = { type => $type };
	413
	414	foreach my $k (keys %$config) {
	415	my $value = $config->{$k};
d0ba18e1	416
212b08e8	417	die "can't change value of fixed parameter '$k'\n"
95244fd7	418	if !$create && defined($opts->{$k}) && $opts->{$k}->{fixed};
d0ba18e1	419
212b08e8 DM	420	if (defined($value)) {
	421	my $tmp = $class->check_value($type, $k, $value, $sectionId, $skipSchemaCheck);
	422	$settings->{$k} = $class->decode_value($type, $k, $tmp);
	423	} else {
	424	die "got undefined value for option '$k'\n";
	425	}
	426	}
	427
	428	if ($create) {
	429	# check if we have a value for all required options
	430	foreach my $k (keys %$opts) {
	431	next if $opts->{$k}->{optional};
	432	die "missing value for required option '$k'\n"
	433	if !defined($config->{$k});
	434	}
	435	}
	436
	437	return $settings;
	438	}
	439
	440	my $format_config_line = sub {
	441	my ($schema, $key, $value) = @_;
	442
	443	my $ct = $schema->{type};
	444
0cb4d663 DM	445	die "property '$key' contains a line feed\n"
	446	if ($key =~ m/[\n\r]/) \|\| ($value =~ m/[\n\r]/);
	447
212b08e8	448	if ($ct eq 'boolean') {
d152f8b0 WB	449	return "\t$key " . ($value ? 1 : 0) . "\n"
d152f8b0 WB	450	if defined($value);
212b08e8 DM	451	} else {
	452	return "\t$key $value\n" if "$value" ne '';
	453	}
	454	};
	455
	456	sub write_config {
c9ede1c3	457	my ($class, $filename, $cfg, $allow_unknown) = @_;
212b08e8 DM	458
	459	my $pdata = $class->private();
	460	my $propertyList = $pdata->{propertyList};
	461
	462	my $out = '';
	463
	464	my $ids = $cfg->{ids};
	465	my $order = $cfg->{order};
	466
	467	my $maxpri = 0;
	468	foreach my $sectionId (keys %$ids) {
cca9c864	469	my $pri = $order->{$sectionId};
212b08e8 DM	470	$maxpri = $pri if $pri && $pri > $maxpri;
	471	}
	472	foreach my $sectionId (keys %$ids) {
	473	if (!defined ($order->{$sectionId})) {
	474	$order->{$sectionId} = ++$maxpri;
cca9c864	475	}
212b08e8 DM	476	}
	477
	478	foreach my $sectionId (sort {$order->{$a} <=> $order->{$b}} keys %$ids) {
	479	my $scfg = $ids->{$sectionId};
	480	my $type = $scfg->{type};
	481	my $opts = $pdata->{options}->{$type};
	482
c9ede1c3	483	die "unknown section type '$type'\n" if !$opts && !$allow_unknown;
212b08e8	484
2d63b598 DM	485	my $done_hash = {};
	486
	487	my $data = $class->format_section_header($type, $sectionId, $scfg, $done_hash);
c9ede1c3 WB	488
	489	if (!$opts && $allow_unknown) {
	490	$done_hash->{type} = 1;
	491	my @first = exists($scfg->{comment}) ? ('comment') : ();
	492	for my $k (@first, sort keys %$scfg) {
	493	next if defined($done_hash->{$k});
	494	$done_hash->{$k} = 1;
	495	my $v = $scfg->{$k};
	496	$data .= "\t$k $v\n";
	497	}
	498	$out .= "$data\n";
	499	next;
	500	}
	501
	502
2d63b598	503	if ($scfg->{comment} && !$done_hash->{comment}) {
212b08e8 DM	504	my $k = 'comment';
	505	my $v = $class->encode_value($type, $k, $scfg->{$k});
	506	$data .= &$format_config_line($propertyList->{$k}, $k, $v);
	507	}
	508
2d63b598	509	$data .= "\tdisable\n" if $scfg->{disable} && !$done_hash->{disable};
212b08e8	510
2d63b598 DM	511	$done_hash->{comment} = 1;
2d63b598 DM	512	$done_hash->{disable} = 1;
212b08e8	513
df89e5eb DM	514	my @option_keys = sort keys %$opts;
df89e5eb DM	515	foreach my $k (@option_keys) {
2d63b598	516	next if defined($done_hash->{$k});
212b08e8 DM	517	next if $opts->{$k}->{optional};
	518	$done_hash->{$k} = 1;
	519	my $v = $scfg->{$k};
	520	die "section '$sectionId' - missing value for required option '$k'\n"
	521	if !defined ($v);
	522	$v = $class->encode_value($type, $k, $v);
	523	$data .= &$format_config_line($propertyList->{$k}, $k, $v);
	524	}
	525
df89e5eb	526	foreach my $k (@option_keys) {
212b08e8 DM	527	next if defined($done_hash->{$k});
	528	my $v = $scfg->{$k};
	529	next if !defined($v);
	530	$v = $class->encode_value($type, $k, $v);
	531	$data .= &$format_config_line($propertyList->{$k}, $k, $v);
	532	}
	533
	534	$out .= "$data\n";
	535	}
	536
	537	return $out;
	538	}
	539
	540	sub assert_if_modified {
	541	my ($cfg, $digest) = @_;
	542
a345b9d5	543	PVE::Tools::assert_if_modified($cfg->{digest}, $digest);
212b08e8 DM	544	}
212b08e8 DM	545
5028848d DC	546	sub delete_from_config {
	547	my ($config, $option_schema, $new_options, $to_delete) = @_;
	548
	549	for my $k ($to_delete->@*) {
	550	my $d = $option_schema->{$k} \|\| die "no such option '$k'\n";
	551	die "unable to delete required option '$k'\n" if !$d->{optional};
	552	die "unable to delete fixed option '$k'\n" if $d->{fixed};
	553	die "cannot set and delete property '$k' at the same time!\n"
	554	if defined($new_options->{$k});
	555	delete $config->{$k};
	556	}
	557
	558	return $config;
	559	}
	560
212b08e8	561	1;