summaryrefslogtreecommitdiff
path: root/lib/Vyatta
diff options
context:
space:
mode:
Diffstat (limited to 'lib/Vyatta')
-rwxr-xr-xlib/Vyatta/Config.pm1309
-rwxr-xr-xlib/Vyatta/ConfigDOMTree.pm366
-rwxr-xr-xlib/Vyatta/ConfigLoad.pm23
-rwxr-xr-xlib/Vyatta/ConfigOutput.pm230
4 files changed, 638 insertions, 1290 deletions
diff --git a/lib/Vyatta/Config.pm b/lib/Vyatta/Config.pm
index 8bcd84f..8067e05 100755
--- a/lib/Vyatta/Config.pm
+++ b/lib/Vyatta/Config.pm
@@ -21,16 +21,14 @@ package Vyatta::Config;
use strict;
-use Vyatta::ConfigDOMTree;
use File::Find;
+use lib '/opt/vyatta/share/perl5';
+use Cstore;
+
my %fields = (
- _changes_only_dir_base => $ENV{VYATTA_CHANGES_ONLY_DIR},
- _new_config_dir_base => $ENV{VYATTA_TEMP_CONFIG_DIR},
- _active_dir_base => $ENV{VYATTA_ACTIVE_CONFIGURATION_DIR},
- _vyatta_template_dir => $ENV{VYATTA_CONFIG_TEMPLATE},
- _current_dir_level => "/",
_level => undef,
+ _cstore => undef,
);
sub new {
@@ -39,892 +37,546 @@ sub new {
my $self = {
%fields,
};
-
bless $self, $class;
+ $self->{_cstore} = new Cstore();
return $self;
}
-sub _set_current_dir_level {
- my ($self) = @_;
- my $level = $self->{_level};
-
- $level =~ s/\//%2F/g;
- $level =~ s/\s+/\//g;
-
- $self->{_current_dir_level} = "/$level";
- return $self->{_current_dir_level};
+sub get_path_comps {
+ my ($self, $pstr) = @_;
+ $pstr = '' if (!defined($pstr));
+ $pstr = "$self->{_level} $pstr" if (defined($self->{_level}));
+ $pstr =~ s/^\s+//;
+ $pstr =~ s/\s+$//;
+ my @path_comps = split /\s+/, $pstr;
+ return \@path_comps;
+}
+
+############################################################
+# low-level API functions that have been converted to use
+# the cstore library.
+############################################################
+
+######
+# observers of current working config or active config during a commit.
+# * MOST users of this API should use these functions.
+# * these functions MUST NOT worry about the "deactivated" state, i.e.,
+# deactivated nodes are equivalent to having been deleted for these
+# functions. in other words, these functions are NOT "deactivate-aware".
+# * functions that can be used to observe "active config" can be used
+# outside a commit as well (only when observing active config, of course).
+#
+# note: these functions accept a third argument "$include_deactivated", but
+# it is for error checking purposes to ensure that all legacy
+# invocations have been fixed. the functions MUST NOT be called
+# with this argument.
+my $DIE_DEACT_MSG = 'This function is NOT deactivate-aware';
+
+## exists("path to node")
+# Returns true if specified node exists in working config.
+sub exists {
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ return 1
+ if ($self->{_cstore}->cfgPathExists($self->get_path_comps($path), undef));
+ return; # note: this return is needed. can't just return the return value
+ # of the above function since some callers expect "undef"
+ # as false.
}
-## setLevel("level")
-# if "level" is supplied, set the current level of the hierarchy we are working on
-# return the current level
-sub setLevel {
- my ($self, $level) = @_;
-
- $self->{_level} = $level if defined($level);
- $self->_set_current_dir_level();
-
- return $self->{_level};
+## existsOrig("path to node")
+# Returns true if specified node exists in active config.
+sub existsOrig {
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ return 1
+ if ($self->{_cstore}->cfgPathExists($self->get_path_comps($path), 1));
+ return; # note: this return is needed.
}
## listNodes("level")
-# return array of all nodes at "level"
-# level is relative
+# return array of all child nodes at "level" in working config.
sub listNodes {
- my ($self, $path, $disable) = @_;
- my @nodes = ();
-
- my $rpath = "";
- if ($path) {
- $path =~ s/\//%2F/g;
- $path =~ s/\s+/\//g;
- $rpath = $self->{_current_dir_level} . "/" . $path;
- } else {
- $rpath = $self->{_current_dir_level};
- }
- $path = $self->{_new_config_dir_base} . $rpath;
-
- #print "DEBUG Vyatta::Config->listNodes(): path = $path\n";
- opendir my $dir, $path or return ();
- @nodes = grep !/^\./, readdir $dir;
- closedir $dir;
-
- my @nodes_modified = ();
- while (@nodes) {
- my $tmp = pop (@nodes);
- $tmp =~ s/\n//g;
- #print "DEBUG Vyatta::Config->listNodes(): node = $tmp\n";
- my $ttmp = $rpath . "/" . $tmp;
- $tmp =~ s/%2F/\//g;
- $ttmp =~ s/\// /g;
- if (!defined $disable) {
- my ($status, undef) = $self->getDeactivated($ttmp);
- if (!defined($status) || $status eq 'active') {
- push @nodes_modified, $tmp;
- }
- }
- else {
- push @nodes_modified, $tmp;
- }
- }
-
- return @nodes_modified;
-}
-
-## isActive("path")
-# return true|false based on whether node path has
-# been processed or is active
-sub isActive {
- my ($self, $path, $disable) = @_;
- my @nodes = ();
-
- my @comp_node = split " ", $path;
-
- my $comp_node = pop(@comp_node);
- if (!defined $comp_node) {
- return 1;
- }
-
- my $rel_path = join(" ",@comp_node);
-
- my @nodes_modified = $self->listOrigPlusComNodes($rel_path,$disable);
- foreach my $node (@nodes_modified) {
- if ($node eq $comp_node) {
- return 0;
- }
- }
- return 1;
-}
-
-## listNodes("level")
-# return array of all nodes (active plus currently committed) at "level"
-# level is relative
-sub listOrigPlusComNodes {
- my ($self, $path, $disable) = @_;
- my @nodes = ();
-
- my @nodes_modified = $self->listNodes($path,$disable);
-
- #convert array to hash
- my %coll;
- my $coll;
- @coll{@nodes_modified} = @nodes_modified;
-
- my $level = $self->{_level};
- if (! defined $level) {
- $level = "";
- }
-
- my $dir_path = $level;
- if (defined $path) {
- $dir_path .= " " . $path;
- }
- $dir_path =~ s/ /\//g;
- $dir_path = "/".$dir_path;
-
- #now test against the inprocess file in the system
-# my $com_file = "/tmp/.changes_$$";
- my $com_file = "/tmp/.changes";
- if (-e $com_file) {
- open my $file, "<", $com_file;
- foreach my $line (<$file>) {
- my @node = split " ", $line; #split on space
- #$node[1] is of the form: system/login/blah
- #$coll is of the form: blah
-
-# print("comparing: $dir_path and $level to $node[1]\n");
-
- #first only consider $path matches against $node[1]
- if (!defined $dir_path || $node[1] =~ m/^$dir_path/) {
- #or does $node[1] match the beginning of the line for $path
-
- #if yes, then split the right side and find against the hash for the value...
- my $tmp;
- if (defined $dir_path) {
- $tmp = substr($node[1],length($dir_path));
- }
- else {
- $tmp = $node[1];
- }
-
- if (!defined $tmp || $tmp eq '') {
- next;
- }
-
- my @child = split "/",$tmp;
- my $child;
-
-# print("tmp: $tmp, $child[0], $child[1]\n");
- if ($child[0] =~ /^\s*$/ || !defined $child[0] || $child[0] eq '') {
- shift(@child);
- }
-
-# print("child value is: >$child[0]<\n");
-
- #now can we find this entry in the hash?
- #if '-' this is a delete and need to remove from hash
- if ($node[0] eq "-") {
- if (!defined $child[1]) {
- delete($coll{$child[0]});
- }
- }
- #if '+' this is a set and need to add to hash
- elsif ($node[0] eq "+" && $child[0] ne '') {
- $coll{$child[0]} = '1';
- }
- }
- }
- close $file;
- close $com_file;
- }
-
-#print "coll count: ".keys(%coll);
-
- #now convert hash to array and return
- @nodes_modified = ();
- @nodes_modified = keys(%coll);
- return @nodes_modified;
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ my $ref = $self->{_cstore}->cfgPathGetChildNodes(
+ $self->get_path_comps($path), undef);
+ return @{$ref};
}
## listOrigNodes("level")
-# return array of all original nodes (i.e., before any current change; i.e.,
-# in "working") at "level"
-# level is relative
+# return array of all child nodes at "level" in active config.
sub listOrigNodes {
- my ($self, $path, $disable) = @_;
- my @nodes = ();
-
- my $rpath = "";
- if (defined $path) {
- $path =~ s/\//%2F/g;
- $path =~ s/\s+/\//g;
- $rpath = $self->{_current_dir_level} . "/" . $path;
- }
- else {
- $rpath = $self->{_current_dir_level};
- }
- $path = $self->{_active_dir_base} . $rpath;
-
- #print "DEBUG Vyatta::Config->listNodes(): path = $path\n";
- opendir my $dir, "$path" or return ();
- @nodes = grep !/^\./, readdir $dir;
- closedir $dir;
-
- my @nodes_modified = ();
- while (@nodes) {
- my $tmp = pop (@nodes);
- $tmp =~ s/\n//g;
- #print "DEBUG Vyatta::Config->listNodes(): node = $tmp\n";
- my $ttmp = $rpath . "/" . $tmp;
- $tmp =~ s/%2F/\//g;
- $ttmp =~ s/\// /g;
- if (!defined $disable) {
- my ($status, undef) = $self->getDeactivated($ttmp);
- if (!defined($status) || $status eq 'local') {
- push @nodes_modified, $tmp;
- }
- }
- else {
- push @nodes_modified, $tmp;
- }
- }
-
- return @nodes_modified;
-}
-
-## returnParent("level")
-# return the name of parent node relative to the current hierarchy
-# in this case "level" is set to the parent dir ".. .."
-# for example
-sub returnParent {
- my ($self, $node) = @_;
- my @x, my $tmp;
-
- # split our hierarchy into vars on a stack
- my @level = split /\s+/, $self->{_level};
-
- # count the number of parents we need to lose
- # and then pop 1 less
- @x = split /\s+/, $node;
- for ($tmp = 1; $tmp < @x; $tmp++) {
- pop @level;
- }
-
- # return the parent
- $tmp = pop @level;
- return $tmp;
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ my $ref = $self->{_cstore}->cfgPathGetChildNodes(
+ $self->get_path_comps($path), 1);
+ return @{$ref};
}
## returnValue("node")
-# returns the value of "node" or undef if the node doesn't exist .
-# node is relative
+# return value of specified single-value node in working config.
+# return undef if fail to get value (invalid node, node doesn't exist,
+# not a single-value node, etc.).
sub returnValue {
- my ( $self, $node, $disable ) = @_;
- my $tmp;
-
- $node =~ s/\//%2F/g;
- $node =~ s/\s+/\//g;
-
- #getDeactivated
- my $ttmp = $self->{_current_dir_level} . "/" . $node;
- $ttmp =~ s/\// /g;
- #only return value if status is not disabled (i.e. local or both)
- if (!defined $disable) {
- my ($status, undef) = $self->getDeactivated($ttmp);
- if (!defined($status) || $status eq 'active') {
- return unless
- open my $file, '<',
- "$self->{_new_config_dir_base}$self->{_current_dir_level}/$node/node.val";
-
- read $file, $tmp, 16384;
- close $file;
-
- $tmp =~ s/\n$//;
- }
- }
- else {
- return unless
- open my $file, '<',
- "$self->{_new_config_dir_base}$self->{_current_dir_level}/$node/node.val";
-
- read $file, $tmp, 16384;
- close $file;
-
- $tmp =~ s/\n$//;
- }
- return $tmp;
-}
-
-## returnComment("node")
-# returns the value of "node" or undef if the node doesn't exist .
-# node is relative
-sub returnComment {
- my ( $self, $node ) = @_;
- my $tmp = undef;
-
- $node =~ s/\//%2F/g;
- $node =~ s/\s+/\//g;
-
- return unless
- open my $file, '<',
- "$self->{_new_config_dir_base}/$node/.comment";
-
- read $file, $tmp, 16384;
- close $file;
-
- $tmp =~ s/\n$//;
- return $tmp;
-}
-
-## returnOrigPlusComValue("node")
-# returns the value of "node" or undef if the node doesn't exist .
-# node is relative
-sub returnOrigPlusComValue {
- my ( $self, $path, $disable ) = @_;
-
- my $tmp = returnValue($self,$path,$disable);
-
- my $level = $self->{_level};
- if (! defined $level) {
- $level = "";
- }
- my $dir_path = $level;
- if (defined $path) {
- $dir_path .= " " . $path;
- }
- $dir_path =~ s/ /\//g;
- $dir_path = "/".$dir_path."/value";
-
- #now need to compare this against what I've done
- my $com_file = "/tmp/.changes";
- if (-e $com_file) {
- open my $file, "<", $com_file;
- foreach my $line (<$file>) {
- my @node = split " ", $line; #split on space
- if (index($node[1],$dir_path) != -1) {
- #found, now figure out if this a set or delete
- if ($node[0] eq '+') {
- my $pos = rindex($node[1],"/value:");
- $tmp = substr($node[1],$pos+7);
- }
- else {
- $tmp = "";
- }
- last;
- }
- }
- close $file;
- close $com_file;
- }
- return $tmp;
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ return $self->{_cstore}->cfgPathGetValue($self->get_path_comps($path),
+ undef);
}
-
## returnOrigValue("node")
-# returns the original value of "node" (i.e., before the current change; i.e.,
-# in "working") or undef if the node doesn't exist.
-# node is relative
+# return value of specified single-value node in active config.
+# return undef if fail to get value (invalid node, node doesn't exist,
+# not a single-value node, etc.).
sub returnOrigValue {
- my ( $self, $node, $disable ) = @_;
- my $tmp;
-
- $node =~ s/\//%2F/g;
- $node =~ s/\s+/\//g;
-
-
- #getDeactivated
- my $ttmp = $self->{_current_dir_level} . "/" . $node;
- $ttmp =~ s/\// /g;
- #only return value if status is not disabled (i.e. local or both)
- if (!defined $disable) {
- my ($status, undef) = $self->getDeactivated($ttmp);
- if (!defined($status) || $status eq 'local') {
- my $filepath = "$self->{_active_dir_base}$self->{_current_dir_level}/$node";
-
- return unless open my $file, '<', "$filepath/node.val";
-
- read $file, $tmp, 16384;
- close $file;
-
- $tmp =~ s/\n$//;
- }
- }
- else {
- my $filepath = "$self->{_active_dir_base}$self->{_current_dir_level}/$node";
-
- return unless open my $file, '<', "$filepath/node.val";
-
- read $file, $tmp, 16384;
- close $file;
-
- $tmp =~ s/\n$//;
- }
- return $tmp;
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ return $self->{_cstore}->cfgPathGetValue($self->get_path_comps($path), 1);
}
## returnValues("node")
-# returns an array of all the values of "node", or an empty array if the values do not exist.
-# node is relative
+# return array of values of specified multi-value node in working config.
+# return empty array if fail to get value (invalid node, node doesn't exist,
+# not a multi-value node, etc.).
sub returnValues {
- my $val = returnValue(@_);
- my @values = ();
- if (defined($val)) {
- @values = split("\n", $val);
- }
- return @values;
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ my $ref = $self->{_cstore}->cfgPathGetValues($self->get_path_comps($path),
+ undef);
+ return @{$ref};
}
-## returnValues("node")
-# returns an array of all the values of "node", or an empty array if the values do not exist.
-# node is relative
-sub returnOrigPlusComValues {
- my ( $self, $path, $disable ) = @_;
- my @values = returnOrigValues($self,$path,$disable);
+## returnOrigValues("node")
+# return array of values of specified multi-value node in active config.
+# return empty array if fail to get value (invalid node, node doesn't exist,
+# not a multi-value node, etc.).
+sub returnOrigValues {
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ my $ref = $self->{_cstore}->cfgPathGetValues($self->get_path_comps($path),
+ 1);
+ return @{$ref};
+}
+
+######
+# observers of the "effective" config.
+# they can be used
+# (1) outside a config session (e.g., op mode, daemons, callbacks, etc.).
+# OR
+# (2) during a config session
+#
+# HOWEVER, NOTE that the definition of "effective" is different under these
+# two scenarios.
+# (1) when used outside a config session, "effective" == "active".
+# in other words, in such cases the effective config is the same
+# as the running config.
+#
+# (2) when used during a config session, a config path (leading to either
+# a "node" or a "value") is "effective" if it is "in effect" at the
+# time when these observers are called. more detailed info can be
+# found in the library code.
+#
+# originally, these functions are exclusively for use during config
+# sessions. however, for some usage scenarios, it is useful to have a set
+# of API functions that can be used both during and outside config
+# sessions. therefore, definition (1) is added above for convenience.
+#
+# for example, a developer can use these functions in a script that can
+# be used both during a commit action and outside config mode, as long as
+# the developer is clearly aware of the difference between the above two
+# definitions.
+#
+# note that when used outside a config session (i.e., definition (1)),
+# these functions are equivalent to the observers for the "active" config.
+#
+# to avoid any confusiton, when possible (e.g., in a script that is
+# exclusively used in op mode), developers should probably use those
+# "active" observers explicitly when outside a config session instead
+# of these "effective" observers.
+#
+# it is also important to note that when used outside a config session,
+# due to race conditions, it is possible that the "observed" active config
+# becomes out-of-sync with the config that is actually "in effect".
+# specifically, this happens when two things occur simultaneously:
+# (a) an observer function is called from outside a config session.
+# AND
+# (b) someone invokes "commit" inside a config session (any session).
+#
+# this is because "commit" only updates the active config at the end after
+# all commit actions have been executed, so before the update happens,
+# some config nodes have already become "effective" but are not yet in the
+# "active config" and therefore are not observed by these functions.
+#
+# note that this is only a problem when the caller is outside config mode.
+# in such cases, the caller (which could be an op-mode command, a daemon,
+# a callback script, etc.) already must be able to handle config changes
+# that can happen at any time. if "what's configured" is more important,
+# using the "active config" should be fine as long as it is relatively
+# up-to-date. if the actual "system state" is more important, then the
+# caller should probably just check the system state in the first place
+# (instead of using these config observers).
+
+## isEffective("path")
+# return whether "path" is in "active" config when used outside config
+# session,
+# OR
+# return whether "path" is "effective" during current commit.
+# see above discussion about the two different definitions.
+#
+# "effective" means the path is in effect, i.e., any of the following is true:
+# (1) active && working
+# path is in both active and working configs, i.e., unchanged.
+# (2) !active && working && committed
+# path is not in active, has been set in working, AND has already
+# been committed, i.e., "commit" has already processed the
+# addition/update of the path.
+# (3) active && !working && !committed
+# path is in active, has been deleted from working, AND
+# has NOT been committed yet, i.e., "commit" (per priority) has not
+# processed the deletion of the path yet (or has processed it but
+# the action failed).
+#
+# note: during commit, deactivate has the same effect as delete. so as
+# far as this function (and any other commit observer functions) is
+# concerned, deactivated nodes don't exist.
+sub isEffective {
+ my ($self, $path) = @_;
+ return 1
+ if ($self->{_cstore}->cfgPathEffective($self->get_path_comps($path)));
+ return; # note: this return is needed.
+}
- #now parse the commit accounting file.
- my $level = $self->{_level};
- if (! defined $level) {
- $level = "";
- }
- my $dir_path = $level;
- if (defined $path) {
- $dir_path .= " " . $path;
- }
- $dir_path =~ s/ /\//g;
- $dir_path = "/".$dir_path."/value";
-
- #now need to compare this against what I've done
- my $com_file = "/tmp/.changes";
- if (-e $com_file) {
- open my $file, "<", $com_file;
- foreach my $line (<$file>) {
- my @node = split " ", $line; #split on space
- if (index($node[1],$dir_path) != -1) {
- #found, now figure out if this a set or delete
- my $pos = rindex($node[1],"/value:");
- my $tmp = substr($node[1],$pos+7);
- my $i = 0;
- my $match = 0;
- foreach my $v (@values) {
- if ($v eq $tmp) {
- $match = 1;
- last;
- }
- $i = $i + 1;
- }
- if ($node[0] eq '+') {
- #add value
- if ($match == 0) {
- push(@values,$tmp);
- }
- }
- else {
- #remove value
- if ($match == 1) {
- splice(@values,$i);
- }
- }
- }
- }
- close $file;
- close $com_file;
- }
- return @values;
+## isActive("path")
+# XXX this is the original API function. name is confusing ("active" could
+# be confused with "orig") but keep it for compatibility.
+# just call isEffective().
+# also, original function accepts "$disable" flag, which doesn't make
+# sense. for commit purposes, deactivated should be equivalent to
+# deleted.
+sub isActive {
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ return $self->isEffective($path);
+}
+
+## listEffectiveNodes("level")
+# return array of "effective" child nodes at "level" during current commit.
+# see isEffective() for definition of "effective".
+sub listEffectiveNodes {
+ my ($self, $path) = @_;
+ my $ref = $self->{_cstore}->cfgPathGetEffectiveChildNodes(
+ $self->get_path_comps($path));
+ return @{$ref};
+}
+
+## listOrigPlusComNodes("level")
+# XXX this is the original API function. name is confusing (it's neither
+# necessarily "orig" nor "plus") but keep it for compatibility.
+# just call listEffectiveNodes().
+# also, original function accepts "$disable" flag, which doesn't make
+# sense. for commit purposes, deactivated should be equivalent to
+# deleted.
+sub listOrigPlusComNodes {
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ return $self->listEffectiveNodes($path);
}
-## returnOrigValues("node")
-# returns an array of all the original values of "node" (i.e., before the
-# current change; i.e., in "working"), or an empty array if the values do not
-# exist.
-# node is relative
-sub returnOrigValues {
- my $val = returnOrigValue(@_);
- my @values = ();
- if (defined($val)) {
- @values = split("\n", $val);
- }
- return @values;
+## returnEffectiveValue("node")
+# return "effective" value of specified "node" during current commit.
+sub returnEffectiveValue {
+ my ($self, $path) = @_;
+ return $self->{_cstore}->cfgPathGetEffectiveValue(
+ $self->get_path_comps($path));
}
-## exists("node")
-# Returns true if the "node" exists.
-sub exists {
- my ( $self, $node, $disable ) = @_;
- $node =~ s/\//%2F/g;
- $node =~ s/\s+/\//g;
- #getDeactivated()
- my $ttmp = $self->{_current_dir_level} . "/" . $node;
- $ttmp =~ s/\// /g;
- if (!defined $disable) {
- my ($status, undef) = $self->getDeactivated($ttmp);
- #only return value if status is not disabled (i.e. local or both)
- if (defined($status) && ($status eq 'both' || $status eq 'local')) { #if a .disable is in local or active or both then return false
- return;
- }
- }
- return ( -d "$self->{_new_config_dir_base}$self->{_current_dir_level}/$node" );
+## returnOrigPlusComValue("node")
+# XXX this is the original API function. just call returnEffectiveValue().
+# also, original function accepts "$disable" flag.
+sub returnOrigPlusComValue {
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ return $self->returnEffectiveValue($path);
}
-## existsOrig("node")
-# Returns true if the "original node" exists.
-sub existsOrig {
- my ( $self, $node, $disable ) = @_;
- $node =~ s/\//%2F/g;
- $node =~ s/\s+/\//g;
-
- #getDeactivated()
- my $ttmp = $self->{_current_dir_level} . "/" . $node;
- $ttmp =~ s/\// /g;
- if (!defined $disable) {
- my ($status, undef) = $self->getDeactivated($ttmp);
- #only return value if status is not disabled (i.e. local or both)
- if (defined($status) && ($status eq 'both' || $status eq 'active')) { #if a .disable is in local or active or both then return false
- return;
- }
- }
+## returnEffectiveValues("node")
+# return "effective" values of specified "node" during current commit.
+sub returnEffectiveValues {
+ my ($self, $path) = @_;
+ my $ref = $self->{_cstore}->cfgPathGetEffectiveValues(
+ $self->get_path_comps($path));
+ return @{$ref};
+}
- return ( -d "$self->{_active_dir_base}$self->{_current_dir_level}/$node" );
+## returnOrigPlusComValues("node")
+# XXX this is the original API function. just call returnEffectiveValues().
+# also, original function accepts "$disable" flag.
+sub returnOrigPlusComValues {
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ return $self->returnEffectiveValues($path);
}
## isDeleted("node")
-# is the "node" deleted. node is relative. returns true or false
+# whether specified node has been deleted in working config
sub isDeleted {
- my ($self, $node, $disable) = @_;
- $node =~ s/\//%2F/g;
- $node =~ s/\s+/\//g;
-
- my $filepathAct
- = "$self->{_active_dir_base}$self->{_current_dir_level}/$node";
- my $filepathNew
- = "$self->{_new_config_dir_base}$self->{_current_dir_level}/$node";
-
- #getDeactivated()
- my $ttmp = $self->{_current_dir_level} . "/" . $node;
- $ttmp =~ s/\// /g;
- if (!defined $disable) {
- my ($status, undef) = $self->getDeactivated($ttmp);
- #only return value if status is not disabled (i.e. local or both)
- if (defined($status) && $status eq 'local') {
- return (-e $filepathAct);
- }
- }
-
- return ((-e $filepathAct) && !(-e $filepathNew));
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ return 1 if ($self->{_cstore}->cfgPathDeleted($self->get_path_comps($path)));
+ return; # note: this return is needed.
}
## listDeleted("level")
-# return array of deleted nodes in the "level"
-# "level" defaults to current
+# return array of deleted nodes at specified "level"
sub listDeleted {
- my ($self, $path, $disable) = @_;
- my @new_nodes = $self->listNodes($path,$disable);
- my @orig_nodes = $self->listOrigNodes($path,$disable);
- my %new_hash = map { $_ => 1 } @new_nodes;
- my @deleted = grep { !defined($new_hash{$_}) } @orig_nodes;
- return @deleted;
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ my $ref = $self->{_cstore}->cfgPathGetDeletedChildNodes(
+ $self->get_path_comps($path));
+ return @{$ref};
}
-## getAllDeactivated()
-# returns array of all deactivated nodes.
-#
-my @all_deactivated_nodes;
-sub getAllDeactivated {
- my ($self, $path) = @_;
- my $start_dir = $self->{_active_dir_base};
- find ( \&wanted, $start_dir );
- return @all_deactivated_nodes;
-}
-sub wanted {
- if ( $_ eq '.disable' ) {
- my $f = $File::Find::name;
- #now strip off leading path and trailing file
- $f = substr($f, length($ENV{VYATTA_ACTIVE_CONFIGURATION_DIR}));
- $f = substr($f, 0, length($f)-length("/.disable"));
- $f =~ s/\// /g;
- push @all_deactivated_nodes, $f;
- }
-}
-
-
-## isDeactivated("node")
-# returns back whether this node is in an active (false) or
-# deactivated (true) state.
-sub getDeactivated {
- my ($self, $node) = @_;
-
- if (!defined $node) {
- $node = $self->{_level};
- }
-
- # let's setup the filepath for the change_dir
- $node =~ s/\//%2F/g;
- $node =~ s/\s+/\//g;
- #now walk up parent in local and in active looking for '.disable' file
- $node =~ s/ /\//g;
-
- while (1) {
- my $filepath = "$self->{_new_config_dir_base}/$node";
- my $filepathActive = "$self->{_active_dir_base}/$node";
-
- my $local = $filepath . "/.disable";
- my $active = $filepathActive . "/.disable";
-
- if (-e $local && -e $active) {
- return ("both",$node);
- }
- elsif (-e $local && !(-e $active)) {
- return ("local",$node);
- }
- elsif (!(-e $local) && -e $active) {
- return ("active",$node);
- }
- my $pos = rindex($node, "/");
- if ($pos == -1) {
- last;
- }
- $node = substr($node,0,$pos);
- }
- return (undef,undef);
+## isAdded("node")
+# whether specified node has been added in working config
+sub isAdded {
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ return 1 if ($self->{_cstore}->cfgPathAdded($self->get_path_comps($path)));
+ return; # note: this return is needed.
}
## isChanged("node")
-# will check the change_dir to see if the "node" has been changed from a previous
-# value. returns true or false.
+# whether specified node has been changed in working config
+# XXX behavior is different from original implementation, which was
+# inconsistent between deleted nodes and deactivated nodes.
+# see cstore library source for details.
+# basically, a node is "changed" if it's "added", "deleted", or
+# "marked changed" (i.e., if any descendant changed).
sub isChanged {
- my ($self, $node, $disable) = @_;
-
- # let's setup the filepath for the change_dir
- $node =~ s/\//%2F/g;
- $node =~ s/\s+/\//g;
- my $filepath = "$self->{_changes_only_dir_base}$self->{_current_dir_level}/$node";
-
- if (!defined $disable) {
- my ($status,undef) = $self->getDeactivated($self->{_level}." ".$node);
- if (defined $status && ($status eq 'active' || $status eq 'local')) {
- return (defined $status);
- }
- }
-
-
- # if the node exists in the change dir, it's modified.
- return (-e $filepath);
-}
-
-## isAdded("node")
-# will compare the new_config_dir to the active_dir to see if the "node" has
-# been added. returns true or false.
-sub isAdded {
- my ($self, $node, $disable) = @_;
-
- #print "DEBUG Vyatta::Config->isAdded(): node $node\n";
- # let's setup the filepath for the modify dir
- $node =~ s/\//%2F/g;
- $node =~ s/\s+/\//g;
- my $filepathNewConfig = "$self->{_new_config_dir_base}$self->{_current_dir_level}/$node";
-
- #print "DEBUG Vyatta::Config->isAdded(): filepath $filepathNewConfig\n";
-
- # if the node doesn't exist in the modify dir, it's not
- # been added. so short circuit and return false.
- return unless (-e $filepathNewConfig);
-
- # now let's setup the path for the working dir
- my $filepathActive = "$self->{_active_dir_base}$self->{_current_dir_level}/$node";
-
- if (!defined $disable) {
- my ($status,undef) = $self->getDeactivated($self->{_level}." ".$node);
- if (defined $status && ($status eq 'active')) {
- return (defined $status);
- }
- }
-
- # if the node is in the active_dir it's not new
- return (! -e $filepathActive);
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ return 1 if ($self->{_cstore}->cfgPathChanged($self->get_path_comps($path)));
+ return; # note: this return is needed.
}
## listNodeStatus("level")
-# return a hash of the status of nodes at the current config level
+# return a hash of status of child nodes at specified level.
# node name is the hash key. node status is the hash value.
-# node status can be one of deleted, added, changed, or static
+# node status can be one of "deleted", "added", "changed", or "static".
sub listNodeStatus {
- my ($self, $path, $disable) = @_;
- my @nodes = ();
- my %nodehash = ();
-
- # find deleted nodes first
- @nodes = $self->listDeleted($path,$disable);
- foreach my $node (@nodes) {
- if ($node =~ /.+/) { $nodehash{$node} = "deleted" };
- }
-
- @nodes = ();
- @nodes = $self->listNodes($path,$disable);
- foreach my $node (@nodes) {
- if ($node =~ /.+/) {
- my $status = undef;
- if (!defined $disable) {
- ($status,undef) = $self->getDeactivated($self->{_level}." ".$node);
- }
- my $nodepath = $node;
- $nodepath = "$path $node" if ($path);
- #print "DEBUG Vyatta::Config->listNodeStatus(): node $node\n";
- # No deleted nodes -- added, changed, ot static only.
- if (defined $status && $status eq 'local') { $nodehash{$node} = "deleted"; }
- elsif (defined $status && $status eq 'active') { $nodehash{$node} = "added"; }
- elsif ($self->isAdded($nodepath,'true')) { $nodehash{$node} = "added"; }
- elsif ($self->isChanged($nodepath,'true')) { $nodehash{$node} = "changed"; }
- else { $nodehash{$node} = "static"; }
- }
- }
-
- return %nodehash;
-}
-
-############ DOM Tree ################
-
-#Create active DOM Tree
-sub createActiveDOMTree {
-
- my $self = shift;
-
- my $tree = new Vyatta::ConfigDOMTree($self->{_active_dir_base} . $self->{_current_dir_level},"active");
-
- return $tree;
+ my ($self, $path, $include_deactivated) = @_;
+ die $DIE_DEACT_MSG if (defined($include_deactivated));
+ my $ref = $self->{_cstore}->cfgPathGetChildNodesStatus(
+ $self->get_path_comps($path));
+ return %{$ref};
}
-#Create changes only DOM Tree
-sub createChangesOnlyDOMTree {
-
- my $self = shift;
-
- my $tree = new Vyatta::ConfigDOMTree($self->{_changes_only_dir_base} . $self->{_current_dir_level},
- "changes_only");
-
- return $tree;
+## getTmplChildren("level")
+# return list of child nodes in the template hierarchy at specified level.
+sub getTmplChildren {
+ my ($self, $path) = @_;
+ my $ref = $self->{_cstore}->tmplGetChildNodes($self->get_path_comps($path));
+ return @{$ref};
}
-#Create new config DOM Tree
-sub createNewConfigDOMTree {
-
- my $self = shift;
- my $level = $self->{_new_config_dir_base} . $self->{_current_dir_level};
-
- return new Vyatta::ConfigDOMTree($level, "new_config");
+## validateTmplPath("path")
+# return whether specified path is a valid template path
+sub validateTmplPath {
+ my ($self, $path, $validate_vals) = @_;
+ return 1 if ($self->{_cstore}->validateTmplPath($self->get_path_comps($path),
+ $validate_vals));
+ return; # note: this return is needed.
}
-
-###### functions for templates ######
-
-# $1: array representing the config node path.
-# returns the filesystem path to the template of the specified node,
-# or undef if the specified node path is not valid.
-sub getTmplPath {
- my $self = shift;
- my @cfg_path = @{$_[0]};
- my $tpath = $self->{_vyatta_template_dir};
- for my $p (@cfg_path) {
- if (-d "$tpath/$p") {
- $tpath .= "/$p";
- next;
+## parseTmplAll("path")
+# return hash ref of parsed template of specified path, undef if path is
+# invalid. note: if !allow_val, path must terminate at a "node", not "value".
+sub parseTmplAll {
+ my ($self, $path, $allow_val) = @_;
+ my $href = $self->{_cstore}->getParsedTmpl($self->get_path_comps($path),
+ $allow_val);
+ if (defined($href)) {
+ # some conversions are needed
+ if (defined($href->{is_value}) and $href->{is_value} eq '1') {
+ $href->{is_value} = 1;
}
- if (-d "$tpath/node.tag") {
- $tpath .= "/node.tag";
- next;
+ if (defined($href->{multi}) and $href->{multi} eq '1') {
+ $href->{multi} = 1;
+ }
+ if (defined($href->{tag}) and $href->{tag} eq '1') {
+ $href->{tag} = 1;
+ }
+ if (defined($href->{limit})) {
+ $href->{limit} = int($href->{limit});
}
- # the path is not valid!
- return;
}
- return $tpath;
+ return $href;
}
-sub isTagNode {
- my $self = shift;
- my $cfg_path_ref = shift;
- my $tpath = $self->getTmplPath($cfg_path_ref);
- return unless $tpath;
+sub hasTmplChildren {
+ my ($self, $path) = @_;
+ my $ref = $self->{_cstore}->tmplGetChildNodes($self->get_path_comps($path));
+ return if (!defined($ref));
+ return (scalar(@{$ref}) > 0);
+}
+
+
+######
+# "deactivate-aware" observers of current working config or active config.
+# * MUST ONLY be used by operations that NEED to distinguish between
+# deactivated nodes and deleted nodes. below is the list of operations
+# that are allowed to use these functions:
+# * configuration output (show, save, load)
+#
+# operations that are not on the above list MUST NOT use these
+# "deactivate-aware" functions.
+
+## deactivated("node")
+# return whether specified node is deactivated in working config.
+# note that this is different from "marked deactivated". if a node is
+# "marked deactivated", then the node itself and any descendants are
+# "deactivated".
+sub deactivated {
+ my ($self, $path) = @_;
+ return 1
+ if ($self->{_cstore}->cfgPathDeactivated($self->get_path_comps($path),
+ undef));
+ return; # note: this return is needed.
+}
+
+## deactivatedOrig("node")
+# return whether specified node is deactivated in active config.
+sub deactivatedOrig {
+ my ($self, $path) = @_;
+ return 1
+ if ($self->{_cstore}->cfgPathDeactivated($self->get_path_comps($path), 1));
+ return; # note: this return is needed.
+}
+
+## returnValuesDA("node")
+# DA version of returnValues()
+sub returnValuesDA {
+ my ($self, $path) = @_;
+ my $ref = $self->{_cstore}->cfgPathGetValuesDA($self->get_path_comps($path),
+ undef);
+ return @{$ref};
+}
+
+## returnOrigValuesDA("node")
+# DA version of returnOrigValues()
+sub returnOrigValuesDA {
+ my ($self, $path) = @_;
+ my $ref = $self->{_cstore}->cfgPathGetValuesDA($self->get_path_comps($path),
+ 1);
+ return @{$ref};
+}
+
+## returnValueDA("node")
+# DA version of returnValue()
+sub returnValueDA {
+ my ($self, $path) = @_;
+ return $self->{_cstore}->cfgPathGetValueDA($self->get_path_comps($path),
+ undef);
+}
+
+## returnOrigValueDA("node")
+# DA version of returnOrigValue()
+sub returnOrigValueDA {
+ my ($self, $path) = @_;
+ return $self->{_cstore}->cfgPathGetValueDA($self->get_path_comps($path), 1);
+}
+
+## listOrigNodesDA("level")
+# DA version of listOrigNodes()
+sub listOrigNodesDA {
+ my ($self, $path) = @_;
+ my $ref = $self->{_cstore}->cfgPathGetChildNodesDA(
+ $self->get_path_comps($path), 1);
+ return @{$ref};
+}
+
+## listNodeStatusDA("level")
+# DA version of listNodeStatus()
+sub listNodeStatusDA {
+ my ($self, $path) = @_;
+ my $ref = $self->{_cstore}->cfgPathGetChildNodesStatusDA(
+ $self->get_path_comps($path));
+ return %{$ref};
+}
- return (-d "$tpath/node.tag");
+## returnComment("node")
+# return comment of "node" or undef if comment doesn't exist
+sub returnComment {
+ my ($self, $path) = @_;
+ return $self->{_cstore}->cfgPathGetComment($self->get_path_comps($path),
+ undef);
}
-sub hasTmplChildren {
- my $self = shift;
- my $cfg_path_ref = shift;
- my $tpath = $self->getTmplPath($cfg_path_ref);
- return unless $tpath;
- opendir (my $tdir, $tpath) or return;
- my @tchildren = grep !/^node\.def$/, (grep !/^\./, (readdir $tdir));
- closedir $tdir;
+############################################################
+# high-level API functions (not using the cstore library directly)
+############################################################
- return (scalar(@tchildren) > 0);
+## setLevel("level")
+# set the current level of config hierarchy to specified level (if defined).
+# return the current level.
+sub setLevel {
+ my ($self, $level) = @_;
+ $self->{_level} = $level if defined($level);
+ return $self->{_level};
}
-# $cfg_path_ref: ref to array containing the node path.
-# returns ($is_multi, $is_text, $default),
-# or undef if specified node is not valid.
+## returnParent("..( ..)*")
+# return the name of ancestor node relative to the current level.
+# each level up is represented by a ".." in the argument.
+sub returnParent {
+ my ($self, $ppath) = @_;
+ my @pcomps = @{$self->get_path_comps()};
+ # we could call split in scalar context but that generates a warning
+ my @dummy = split(/\s+/, $ppath);
+ my $num = scalar(@dummy);
+ return if ($num > scalar(@pcomps));
+ return $pcomps[-$num];
+}
+
+## parseTmpl("path")
+# parse template of specified path and return ($is_multi, $is_text, $default)
+# or undef if specified path is not valid.
sub parseTmpl {
- my $self = shift;
- my $cfg_path_ref = shift;
- my ($is_multi, $is_text, $default) = (0, 0, undef);
- my $tpath = $self->getTmplPath($cfg_path_ref);
- return unless $tpath;
-
- if (! -r "$tpath/node.def") {
- return ($is_multi, $is_text);
- }
-
- open (my $tmpl, '<', "$tpath/node.def")
- or return ($is_multi, $is_text);
- foreach (<$tmpl>) {
- if (/^multi:/) {
- $is_multi = 1;
- }
- if (/^type:\s+txt\s*$/) {
- $is_text = 1;
- }
- if (/^default:\s+(\S+)\s*$/) {
- $default = $1;
- }
- }
- close $tmpl;
+ my ($self, $path) = @_;
+ my $href = $self->parseTmplAll($path);
+ return if (!defined($href));
+ my $is_multi = $href->{multi};
+ my $is_text = (defined($href->{type}) and $href->{type} eq 'txt');
+ my $default = $href->{default};
return ($is_multi, $is_text, $default);
}
-# $cfg_path: config path of the node.
-# returns a hash ref containing attributes in the template
-# or undef if specified node is not valid.
-sub parseTmplAll {
- my ($self, $cfg_path) = @_;
- my @pdirs = split(/ +/, $cfg_path);
- my %ret = ();
- my $tpath = $self->getTmplPath(\@pdirs);
- return unless $tpath;
-
- open(my $tmpl, '<', "$tpath/node.def")
- or return;
- foreach (<$tmpl>) {
- if (/^multi:\s*(\S+)?$/) {
- $ret{multi} = 1;
- $ret{limit} = $1;
- } elsif (/^tag:\s*(\S+)?$/) {
- $ret{tag} = 1;
- $ret{limit} = $1;
- } elsif (/^type:\s*(\S+),\s*(\S+)\s*$/) {
- $ret{type} = $1;
- $ret{type2} = $2;
- } elsif (/^type:\s*(\S+)\s*$/) {
- $ret{type} = $1;
- } elsif (/^default:\s*(\S.*)\s*$/) {
- $ret{default} = $1;
- if ($ret{default} =~ /^"(.*)"$/) {
- $ret{default} = $1;
- }
- } elsif (/^help:\s*(\S.*)$/) {
- $ret{help} = $1;
- } elsif (/^enumeration:\s*(\S+)$/) {
- $ret{enum} = $1;
- }
- }
- close($tmpl);
- return \%ret;
+## isTagNode("path")
+# whether specified path is a tag node.
+sub isTagNode {
+ my ($self, $path) = @_;
+ my $href = $self->parseTmplAll($path);
+ return (defined($href) and $href->{tag});
}
-# $cfg_path: config path of the node.
-# returns the list of the node's children in the template hierarchy.
-sub getTmplChildren {
- my ($self, $cfg_path) = @_;
- my @pdirs = split(/ +/, $cfg_path);
- my $tpath = $self->getTmplPath(\@pdirs);
- return () unless $tpath;
-
- opendir (my $tdir, $tpath) or return;
- my @tchildren = grep !/^node\.def$/, (grep !/^\./, (readdir $tdir));
- closedir $tdir;
-
- return @tchildren;
+## isLeafNode("path")
+# whether specified path is a "leaf node", i.e., single-/multi-value node.
+sub isLeafNode {
+ my ($self, $path) = @_;
+ my $href = $self->parseTmplAll($path, 1);
+ return (defined($href) and !$href->{is_value} and $href->{type}
+ and !$href->{tag});
}
-###### misc functions ######
+## isLeafValue("path")
+# whether specified path is a "leaf value", i.e., value of a leaf node.
+sub isLeafValue {
+ my ($self, $path) = @_;
+ my $href = $self->parseTmplAll($path, 1);
+ return (defined($href) and $href->{is_value} and !$href->{tag});
+}
# compare two value lists and return "deleted" and "added" lists.
# since this is for multi-value nodes, there is no "changed" (if a value's
@@ -988,4 +640,39 @@ sub compareValueLists {
return %comp_hash;
}
+############################################################
+# API functions that have not been converted
+############################################################
+
+# XXX the following function should not be needed. the only user is
+# ConfigLoad, which uses this to get all deactivated nodes in active
+# config and then reactivates everything on load.
+#
+# this works for "load" but not for "merge", which incorrectly
+# reactivates all deactivated nodes even if they are not in the config
+# file to be merged. see bug 5746.
+#
+# how to get rid of this function depends on how bug 5746 is going
+# to be fixed.
+## getAllDeactivated()
+# returns array of all deactivated nodes.
+my @all_deactivated_nodes;
+sub getAllDeactivated {
+ my ($self, $path) = @_;
+ my $start_dir = $ENV{VYATTA_ACTIVE_CONFIGURATION_DIR};
+ find ( \&wanted, $start_dir );
+ return @all_deactivated_nodes;
+}
+sub wanted {
+ if ( $_ eq '.disable' ) {
+ my $f = $File::Find::name;
+ #now strip off leading path and trailing file
+ $f = substr($f, length($ENV{VYATTA_ACTIVE_CONFIGURATION_DIR}));
+ $f = substr($f, 0, length($f)-length("/.disable"));
+ $f =~ s/\// /g;
+ push @all_deactivated_nodes, $f;
+ }
+}
+
1;
+
diff --git a/lib/Vyatta/ConfigDOMTree.pm b/lib/Vyatta/ConfigDOMTree.pm
deleted file mode 100755
index 87fc8f2..0000000
--- a/lib/Vyatta/ConfigDOMTree.pm
+++ /dev/null
@@ -1,366 +0,0 @@
-#
-# **** License ****
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# General Public License for more details.
-#
-# A copy of the GNU General Public License is available as
-# `/usr/share/common-licenses/GPL' in the Debian GNU/Linux distribution
-# or on the World Wide Web at `http://www.gnu.org/copyleft/gpl.html'.
-# You can also obtain it by writing to the Free Software Foundation,
-# Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
-# MA 02110-1301, USA.
-#
-# This code was originally developed by Vyatta, Inc.
-# Portions created by Vyatta are Copyright (C) 2005, 2006, 2007 Vyatta, Inc.
-# All Rights Reserved.
-#
-# Author: Oleg Moskalenko
-# Date: 2007
-# Description:
-#
-# **** End License ****
-#
-#
-
-package Vyatta::ConfigDOMTree;
-
-use strict;
-
-my %fields = (
- _dir => undef,
- _name => undef,
- _value => undef,
- _subnodes => undef
- );
-
-sub new {
-
- my $that = shift;
- my $dir = shift;
- my $name = shift;
-
- my $class = ref ($that) || $that;
-
- my $self = {
- %fields
- };
-
- bless $self, $class;
-
- $self->{_dir} = $dir;
- $self->{_name} = $name;
-
- return $self->_construct_dom_tree();
-}
-
-#Simple DOM Tree iteration and screen output
-#$1 - left screen offset (optional)
-sub print {
-
- my $self = shift;
- my $level = shift;
-
- my $tree = $self;
-
- if(!(defined $level)) {
- $level="";
- }
-
- if(defined $tree) {
-
- print("$level name=",$tree->getNodeName(),"\n");
-
- my $value = $tree->getNodeValue();
-
- if(defined $value) {
-
- print("$level value=$value\n");
-
- }
-
- my @subnodes = $tree->getSubNodes();
-
- while(@subnodes) {
-
- my $subnode = shift @subnodes;
- $subnode->print($level . " ");
- }
- }
-}
-
-#Return value of the tree node
-sub getNodeValue {
-
- my $self = shift;
- my $tree = $self;
-
- my $ret = undef;
-
- if(defined $tree) {
-
- $ret = $tree->{_value};
- }
-
- return $ret;
-}
-
-#Return value of the tree node.
-#If the value is nor defined, return empty string.
-sub getNodeValueAsString {
-
- my $self = shift;
- my $tree = $self;
-
- my $ret = undef;
-
- if(defined $tree) {
-
- $ret = $tree->getNodeValue();
- }
-
- if(!defined $ret) {
- $ret = "";
- }
-
- return $ret;
-}
-
-#Return name of the tree node
-sub getNodeName {
-
- my $self = shift;
- my $tree = $self;
-
- my $ret = undef;
-
- if(defined $tree) {
-
- $ret = $tree->{_name};
- }
-
- return $ret;
-}
-
-#Return array of subnodes of the tree node
-sub getSubNodes {
-
- my $self = shift;
- my $tree = $self;
-
- my @ret = ();
-
- if(defined $tree) {
-
- my $subnodes = $tree->{_subnodes};
-
- if(defined $subnodes) {
-
- @ret = values %{$subnodes};
-
- }
- }
-
- return @ret;
-}
-
-sub isLeafNode {
-
- my $self = shift;
- my $tree = $self;
-
- my $ret=undef;
-
- if(defined $tree) {
-
- if(defined $tree->{_value}) {
-
- if(! defined $tree->{_subnodes}) {
-
- $ret="true";
- }
- }
- }
-
- return $ret;
-}
-
-#Return subtree of the tree according to the path list
-#$1, $2, ... - path to the subtree
-sub getSubNode {
-
- my $self = shift;
- my $tree = $self;
-
- my $ret = undef;
-
- while(@_ && $tree) {
-
- my $subnode = shift (@_);
-
- my $subnodes = $tree->{_subnodes};
-
- if(defined $subnodes) {
-
- $tree = $subnodes->{$subnode};
-
- } else {
-
- $tree = undef;
-
- }
- }
-
- $ret=$tree;
-
- return $ret;
-}
-
-#Return value of the subnode of the tree according to the path list
-#$1, $2, ... - path to the subtree
-sub getSubNodeValue {
-
- my $self = shift;
- my $tree = $self;
-
- my $ret = undef;
-
- if(defined $tree) {
-
- my $node = $tree->getSubNode(@_);
-
- if(defined $node) {
-
- $ret=$node->getNodeValue();
- }
- }
-
- return $ret;
-}
-
-#Return value of the subnode of the tree according to the path list.
-#If the value is not defined, return empty string.
-#$1, $2, ... - path to the subtree
-sub getSubNodeValueAsString {
-
- my $self = shift;
- my $tree = $self;
-
- my $ret = undef;
-
- if(defined $tree) {
-
- my $node = $tree->getSubNode(@_);
-
- if(defined $node) {
-
- $ret=$node->getNodeValue();
- }
- }
-
- if(! defined $ret) {
- $ret = "";
- }
-
- return $ret;
-}
-
-#Check if there is a subnode with the specified path.
-#$1, $2, ... - path to the subtree
-sub subNodeExist {
-
- my $self = shift;
- my $tree = $self;
-
- my $ret = undef;
-
- if(defined $tree) {
-
- my $node = $tree->getSubNode(@_);
-
- if(defined $node) {
-
- $ret="true";
- }
- }
-
- return $ret;
-}
-
-#Return of the children of the node
-#$1, $2, ... - path to the subtree
-sub getSubNodesNumber {
-
- my $self = shift;
- my $tree = $self;
-
- my $ret = 0;
-
- if(defined $tree) {
-
- my $node = $tree->getSubNode(@_);
-
- if(defined $node) {
-
- my @subs = $node->getSubNodes();
-
- if(@subs) {
- $ret = $#subs + 1;
- }
- }
- }
-
- return $ret;
-}
-
-#private method: costruct DOM Tree according to the absolute path provided
-sub _construct_dom_tree {
-
- my $self = shift;
-
- my $subnodesNum=0;
- my $valuePresent=0;
-
- return unless defined $self;
-
- opendir my $dir, $self->{_dir} or return;
- my @entries = grep !/^\./, readdir $dir;
- closedir $dir;
-
- while(@entries) {
-
- my $entry = shift @entries;
-
- if($entry) {
- my $fn = $self->{_dir} . "/" . $entry;
- if( -f $fn) {
- if($entry eq "node.val") {
- my $value=`cat $fn`;
- while(chomp $value) {};
- $self->{_value} = $value;
- $valuePresent++;
- }
- } elsif (-d $fn) {
- my $subnode = new Vyatta::ConfigDOMTree($fn,$entry);
- if(defined $subnode) {
- if(! defined $self->{_subnodes} ) {
- $self->{_subnodes} = {};
- }
- $self->{_subnodes}->{$entry} = $subnode;
- $subnodesNum++;
- }
- }
- }
- }
-
- return if ( $valuePresent < 1 && $subnodesNum < 1 );
-
- return $self;
-}
-
-1;
diff --git a/lib/Vyatta/ConfigLoad.pm b/lib/Vyatta/ConfigLoad.pm
index c806c7f..d3d7dbb 100755
--- a/lib/Vyatta/ConfigLoad.pm
+++ b/lib/Vyatta/ConfigLoad.pm
@@ -1,4 +1,4 @@
-# Author: An-Cheng Huang <ancheng@vyatta.com>
+# Author: Vyatta <eng@vyatta.com>
# Date: 2007
# Description: Perl module for loading configuration.
@@ -261,8 +261,9 @@ my @delete_list = ();
sub findDeletedValues {
my $new_ref = $_[0];
my @active_path = @{$_[1]};
- my ($is_multi, $is_text) = $active_cfg->parseTmpl(\@active_path);
+
$active_cfg->setLevel(join ' ', @active_path);
+ my ($is_multi, $is_text) = $active_cfg->parseTmpl();
if ($is_multi) {
# for "multi:" nodes, need to sort the values by the original order.
my @nvals = getSortedMultiValues($new_ref, \@active_path);
@@ -287,10 +288,9 @@ sub findDeletedValues {
# $1: array ref representing current config path (active config)
sub findDeletedNodes {
my $new_ref = $_[0];
- my $ret_dis_flag = $_[1];
- my @active_path = @{$_[2]};
+ my @active_path = @{$_[1]};
$active_cfg->setLevel(join ' ', @active_path);
- my @active_nodes = $active_cfg->listOrigNodes(undef,$ret_dis_flag);
+ my @active_nodes = $active_cfg->listOrigNodesDA();
foreach (@active_nodes) {
if ($_ eq 'def') {
next;
@@ -303,7 +303,7 @@ sub findDeletedNodes {
my @plist = applySingleQuote(@active_path, $_);
push @delete_list, [\@plist, 0];
} else {
- findDeletedNodes($new_ref->{$_}, $ret_dis_flag, [ @active_path, $_ ]);
+ findDeletedNodes($new_ref->{$_}, [ @active_path, $_ ]);
}
}
}
@@ -317,8 +317,9 @@ my @set_list = ();
sub findSetValues {
my $new_ref = $_[0];
my @active_path = @{$_[1]};
- my ($is_multi, $is_text) = $active_cfg->parseTmpl(\@active_path);
+
$active_cfg->setLevel(join ' ', @active_path);
+ my ($is_multi, $is_text) = $active_cfg->parseTmpl();
if ($is_multi) {
# for "multi:" nodes, need to sort the values by the original order.
my @nvals = getSortedMultiValues($new_ref, \@active_path);
@@ -354,7 +355,7 @@ sub findSetNodes {
$active_cfg->setLevel(join ' ', @active_path);
my @active_nodes = $active_cfg->listOrigNodes();
my %active_hash = map { $_ => 1 } @active_nodes;
- my $nref = $active_cfg->parseTmplAll(join ' ', @active_path);
+ my $nref = $active_cfg->parseTmplAll();
if (defined($nref->{type}) and !defined($nref->{tag})) {
# we are at a leaf node.
findSetValues($new_ref, \@active_path);
@@ -385,11 +386,10 @@ sub findSetNodes {
sub getConfigDiff {
$active_cfg = new Vyatta::Config;
$new_cfg_ref = shift;
- my $ret_del_dis_nodes = shift;
@set_list = ();
# @disable_list = ();
@delete_list = ();
- findDeletedNodes($new_cfg_ref, $ret_del_dis_nodes, [ ]);
+ findDeletedNodes($new_cfg_ref, [ ]);
findSetNodes($new_cfg_ref, [ ]);
# need to filter out deletions of nodes with default values
@@ -401,7 +401,8 @@ sub getConfigDiff {
$file;
} @{${$del}[0]};
- my ($is_multi, $is_text, $default) = $active_cfg->parseTmpl(\@comps);
+ my ($is_multi, $is_text, $default)
+ = $active_cfg->parseTmpl(join ' ', @comps);
if (!defined($default)) {
push @new_delete_list, $del;
}
diff --git a/lib/Vyatta/ConfigOutput.pm b/lib/Vyatta/ConfigOutput.pm
index 1218a8d..acb2bb3 100755
--- a/lib/Vyatta/ConfigOutput.pm
+++ b/lib/Vyatta/ConfigOutput.pm
@@ -70,7 +70,9 @@ sub displayValues {
my $prefix = $_[2];
my $name = $_[3];
my $simple_show = $_[4];
- my ($is_multi, $is_text, $default) = $config->parseTmpl(\@cur_path);
+
+ $config->setLevel(join ' ', @cur_path);
+ my ($is_multi, $is_text, $default) = $config->parseTmpl();
if ($is_text) {
$default =~ /^"(.*)"$/;
my $txt = $1;
@@ -81,11 +83,10 @@ sub displayValues {
my $is_password = ($name =~ /^.*(passphrase|password|pre-shared-secret|key)$/);
my $HIDE_PASSWORD = '****************';
- $config->setLevel(join ' ', @cur_path);
if ($is_multi) {
- my @ovals = $config->returnOrigValues('','true');
- my @nvals = $config->returnValues('','true');
+ my @ovals = $config->returnOrigValuesDA();
+ my @nvals = $config->returnValuesDA();
if ($is_text) {
@ovals = map { (txt_need_quotes($_)) ? "\"$_\"" : "$_"; } @ovals;
@nvals = map { (txt_need_quotes($_)) ? "\"$_\"" : "$_"; } @nvals;
@@ -128,8 +129,8 @@ sub displayValues {
print "$dis$diff$prefix$name $nval\n";
}
} else {
- my $oval = $config->returnOrigValue('','true');
- my $nval = $config->returnValue('','true');
+ my $oval = $config->returnOrigValueDA();
+ my $nval = $config->returnValueDA();
if ($is_text) {
if (defined($oval) && txt_need_quotes($oval)) {
$oval = "\"$oval\"";
@@ -139,7 +140,7 @@ sub displayValues {
}
}
- my %cnodes = $config->listNodeStatus(undef,'true');
+ my %cnodes = $config->listNodeStatusDA();
my @cnames = sort keys %cnodes;
if (defined($simple_show)) {
@@ -189,16 +190,19 @@ sub displayDeletedOrigChildren {
if (defined($dont_show_as_deleted)) {
$dprefix = '';
}
- $config->setLevel('');
- my @children = $config->listOrigNodes(join(' ', @cur_path),'true');
+ $config->setLevel('');
+ my @children = $config->listOrigNodesDA(join(' ', @cur_path));
for my $child (sort @children) {
+ # reset level
+ $config->setLevel('');
+
if ($child eq 'node.val') {
# should not happen!
next;
}
- my $is_tag = $config->isTagNode([ @cur_path, $child ]);
+ my $is_tag = $config->isTagNode(join(' ', @cur_path, $child));
if (!defined $is_tag) {
my $path = join(' ',( @cur_path, $child ));
@@ -207,31 +211,37 @@ sub displayDeletedOrigChildren {
print "$prefix /* $comment */\n";
}
- my ($state, $n) = $config->getDeactivated($path);
- if (defined $state) {
- if ($state eq 'active') {
- $dis = '! ';
- }
- elsif ($state eq 'local') {
- if (defined($dont_show_as_deleted)) {
- $dis = ' ';
- }
- else {
- $dis = 'D ';
- }
- }
- else {
- $dis = '! ';
- }
- }
- else {
- $dis = ' ';
- }
+ # check deactivate state
+ my $de_working = $config->deactivated($path);
+ my $de_active = $config->deactivatedOrig($path);
+ if ($de_active) {
+ if ($de_working) {
+ # deactivated in both
+ $dis = '! ';
+ } else {
+ # deactivated only in active
+ $dis = '! ';
+ }
+ } else {
+ if ($de_working) {
+ # deactivated only in working
+ if (defined($dont_show_as_deleted)) {
+ $dis = ' ';
+ } else {
+ $dis = 'D ';
+ }
+ } else {
+ # deactivated in neither
+ $dis = ' ';
+ }
+ }
}
$config->setLevel(join ' ', (@cur_path, $child));
- my @cnames = grep(!/^def$/, sort($config->listOrigNodes(undef,'true')));
+ # remove listOrigNodesNoDef so it's one fewer function that uses
+ # the cstore implementation details at the perl API level.
+ my @cnames = grep(!/^def$/, sort($config->listOrigNodesDA()));
if ($cnames[0] eq 'node.val') {
displayValues([ @cur_path, $child ], $dis, $prefix, $child,
@@ -248,33 +258,37 @@ sub displayDeletedOrigChildren {
}
my $path = join(' ',( @cur_path, $child, $cname ));
+ $config->setLevel($path);
- my $comment = $config->returnComment($path);
+ my $comment = $config->returnComment();
if (defined $comment) {
print "$prefix /* $comment */\n";
}
- #need separate check here
- my ($state, $n) = $config->getDeactivated($path);
- if (defined $state) {
- if ($state eq 'active') {
- $dis = '! ';
- }
- elsif ($state eq 'local') {
- if (defined($dont_show_as_deleted)) {
- $dis = ' ';
- }
- else {
- $dis = 'D ';
- }
- }
- else {
- $dis = '! ';
- }
- }
- else {
- $dis = ' ';
- }
+ # check deactivate state
+ my $de_working = $config->deactivated();
+ my $de_active = $config->deactivatedOrig();
+ if ($de_active) {
+ if ($de_working) {
+ # deactivated in both
+ $dis = '! ';
+ } else {
+ # deactivated only in active
+ $dis = '! ';
+ }
+ } else {
+ if ($de_working) {
+ # deactivated only in working
+ if (defined($dont_show_as_deleted)) {
+ $dis = ' ';
+ } else {
+ $dis = 'D ';
+ }
+ } else {
+ # deactivated in neither
+ $dis = ' ';
+ }
+ }
print "$dis$dprefix$prefix$child $cname {\n";
displayDeletedOrigChildren([ @cur_path, $child, $cname ],
@@ -288,7 +302,7 @@ sub displayDeletedOrigChildren {
print "$dis$dprefix$prefix}\n";
}
} else {
- my $has_tmpl_children = $config->hasTmplChildren([ @cur_path, $child ]);
+ my $has_tmpl_children = $config->hasTmplChildren();
print "$dis$dprefix$prefix$child"
. ($has_tmpl_children ? " {\n$dis$dprefix$prefix}\n" : "\n");
}
@@ -323,7 +337,9 @@ sub displayChildren {
} elsif ($child_hash{$child} eq 'changed') {
$vdiff = '>';
}
- my $is_tag = $config->isTagNode([ @cur_path, $child ]);
+
+ $config->setLevel('');
+ my $is_tag = $config->isTagNode(join(' ', @cur_path, $child));
if (!defined($is_tag)) {
my $path = join(' ',( @cur_path, $child ));
@@ -332,30 +348,34 @@ sub displayChildren {
print "$prefix /* $comment */\n";
}
- my ($state, $n) = $config->getDeactivated($path);
- if (defined $state) {
- if ($state eq 'active') {
- if ($child_hash{$child} eq 'deleted') {
- $dis = '! ';
- }
- else {
- $dis = 'A ';
- }
- }
- elsif ($state eq 'local') {
- $dis = 'D ';
- }
- else {
- $dis = '! ';
- }
- }
- else {
- $dis = ' ';
- }
+ # check deactivate state
+ my $de_working = $config->deactivated($path);
+ my $de_active = $config->deactivatedOrig($path);
+ if ($de_active) {
+ if ($de_working) {
+ # deactivated in both
+ $dis = '! ';
+ } else {
+ # deactivated only in active
+ if ($child_hash{$child} eq 'deleted') {
+ $dis = '! ';
+ } else {
+ $dis = 'A ';
+ }
+ }
+ } else {
+ if ($de_working) {
+ # deactivated only in working
+ $dis = 'D ';
+ } else {
+ # deactivated in neither
+ $dis = ' ';
+ }
+ }
}
$config->setLevel(join ' ', (@cur_path, $child));
- my %cnodes = $config->listNodeStatus(undef,'true');
+ my %cnodes = $config->listNodeStatusDA();
my @cnames = sort keys %cnodes;
#if node.val exists and ct == 0 w/o def or ct ==1 w/ def
@@ -382,31 +402,36 @@ sub displayChildren {
}
my $path = join(' ',( @cur_path, $child, $cname ));
- my $comment = $config->returnComment($path);
+ $config->setLevel($path);
+ my $comment = $config->returnComment();
if (defined $comment) {
print "$prefix /* $comment */\n";
}
- my ($state, $n) = $config->getDeactivated($path);
- if (defined $state) {
- if ($state eq 'active') {
- if ($cnodes{$cname} eq 'deleted') {
- $dis = '! ';
- }
- else {
- $dis = 'A ';
- }
- }
- elsif ($state eq 'local') {
- $dis = 'D ';
- }
- else {
- $dis = '! ';
- }
- }
- else {
- $dis = ' ';
- }
+ # check deactivate state
+ my $de_working = $config->deactivated();
+ my $de_active = $config->deactivatedOrig();
+ if ($de_active) {
+ if ($de_working) {
+ # deactivated in both
+ $dis = '! ';
+ } else {
+ # deactivated only in active
+ if ($cnodes{$cname} eq 'deleted') {
+ $dis = '! ';
+ } else {
+ $dis = 'A ';
+ }
+ }
+ } else {
+ if ($de_working) {
+ # deactivated only in working
+ $dis = 'D ';
+ } else {
+ # deactivated in neither
+ $dis = ' ';
+ }
+ }
my $tdiff = ' ';
if ($cnodes{$cname} eq 'deleted') {
@@ -420,7 +445,7 @@ sub displayChildren {
$dis, "$prefix ");
} else {
$config->setLevel(join ' ', (@cur_path, $child, $cname));
- my %ccnodes = $config->listNodeStatus(undef,'true');
+ my %ccnodes = $config->listNodeStatusDA();
displayChildren(\%ccnodes, [ @cur_path, $child, $cname ],
$dis, "$prefix ");
}
@@ -439,7 +464,7 @@ sub displayChildren {
} else {
if ($child_hash{$child} eq 'deleted') {
$config->setLevel('');
- my @onodes = $config->listOrigNodes(join ' ', (@cur_path, $child), 'true');
+ my @onodes = $config->listOrigNodesDA(join ' ', (@cur_path, $child));
if ($#onodes == 0 && $onodes[0] eq 'node.val') {
displayValues([ @cur_path, $child ], $dis, $prefix, $child);
} else {
@@ -449,7 +474,7 @@ sub displayChildren {
}
} else {
my $has_tmpl_children
- = $config->hasTmplChildren([ @cur_path, $child ]);
+ = $config->hasTmplChildren();
print "$dis$diff$prefix$child"
. ($has_tmpl_children ? " {\n$dis$diff$prefix}\n" : "\n");
}
@@ -462,7 +487,7 @@ sub displayChildren {
sub outputNewConfig {
$config = new Vyatta::Config;
$config->setLevel(join ' ', @_);
- my %rnodes = $config->listNodeStatus(undef,'true');
+ my %rnodes = $config->listNodeStatusDA();
if (scalar(keys %rnodes) > 0) {
my @rn = keys %rnodes;
@@ -489,7 +514,8 @@ sub outputNewConfig {
if ($config->existsOrig() && ! $config->exists()) {
# this is a deleted node
print 'Configuration under "' . (join ' ', @_) . "\" has been deleted\n";
- } elsif (!defined($config->getTmplPath(\@_))) {
+ } elsif (!$config->validateTmplPath('', 1)) {
+ # validation of current path (including values) failed
print "Specified configuration path is not valid\n";
} else {
print 'Configuration under "' . (join ' ', @_) . "\" is empty\n";
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-20 04:26:56 +0000