[vyos.config] T1758: use vyos.configtree for reading values,

instead of calling cli-shell-api.

1 files changed, 110 insertions, 114 deletions

diff --git a/python/vyos/config.py b/python/vyos/config.py
index c9c73b971..d70093531 100644
--- a/python/vyos/config.py
+++ b/python/vyos/config.py
@@ -1,4 +1,4 @@
-# Copyright 2017 VyOS maintainers and contributors <maintainers@vyos.io>
+# Copyright 2017, 2019 VyOS maintainers and contributors <maintainers@vyos.io>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -17,7 +17,7 @@
 A library for reading VyOS running config data.
 
 This library is used internally by all config scripts of VyOS,
-but its API should be considered stable and it is safe to use
+but its API should be considered stable and safe to use
 in user scripts.
 
 Note that this module will not work outside VyOS.
@@ -43,8 +43,8 @@ For example, under "system", the names of all valid child nodes are predefined
 
 To the contrary, children of the "system task-scheduler task" node can have arbitrary names.
 Such nodes are called *tag nodes*. This terminology is confusing but we keep using it for lack
-of a better word. The knowledge of whether in "task Foo" the "tag" is "task" or "Foo" is lost
-in time, luckily, the distinction is irrelevant in practice.
+of a better word. No one remembers if the "tag" in "task Foo" is "task" or "Foo",
+but the distinction is irrelevant in practice.
 
 Configuration modes
 ###################
@@ -53,21 +53,20 @@ VyOS has two distinct modes: operational mode and configuration mode. When a use
 the CLI is in the operational mode. In this mode, only the running (effective) config is accessible for reading.
 
 When a user enters the "configure" command, a configuration session is setup. Every config session
-has its *proposed* config built on top of the current running config. When changes are commited, if commit succeeds,
+has its *proposed* (or *session*) config built on top of the current running config. When changes are commited, if commit succeeds,
 the proposed config is merged into the running config.
 
-For this reason, this library has two sets of functions. The base versions, such as ``exists`` or ``return_value``
-are only usable in configuration mode. They take all nodes into account, in both proposed and running configs.
-Configuration scripts require access to uncommited changes for obvious reasons. Configuration mode completion helpers
-should also use these functions because not having nodes you've just created in completion is annoying.
+In configuration mode, "base" functions like `exists`, `return_value` return values from the session config,
+while functions prefixed "effective" return values from the running config.
+
+In operational mode, all functions return values from the running config.
 
-However, in operational mode, only the running config is available. Currently, you need to use special functions
-for reading it from operational mode scripts, they can be distinguished by the word "effective" in their names.
-In the future base versions may be made to detect if they are called from a config session or not.
 """
 
-import subprocess
 import re
+import subprocess
+
+import vyos.configtree
 
 
 class VyOSError(Exception):
@@ -89,17 +88,42 @@ class Config(object):
     """
     def __init__(self, session_env=None):
         self._cli_shell_api = "/bin/cli-shell-api"
-        self._level = ""
+        self._level = []
         if session_env:
             self.__session_env = session_env
         else:
             self.__session_env = None
 
+        # Running config can be obtained either from op or conf mode, it always succeeds
+        # (if config system is initialized at all).
+        running_config_text = self._run([self._cli_shell_api, '--show-active-only', '--show-show-defaults', 'showConfig'])
+
+        # Session config ("active") only exists in conf mode.
+        # Trying to obtain it from op mode will cause a fatal cli-shell-api error.
+        # If that happens, we assume that a script is running from op mode and use the running config
+        # for the "session config" variable as well.
+        try:
+            session_config_text = self._run([self._cli_shell_api, '--show-working-only', '--show-show-defaults', 'showConfig'])
+        except VyOSError:
+            session_config_text = running_config_text
+
+        self._session_config = vyos.configtree.ConfigTree(session_config_text)
+        self._running_config = vyos.configtree.ConfigTree(running_config_text)
+
     def _make_command(self, op, path):
         args = path.split()
         cmd = [self._cli_shell_api, op] + args
         return cmd
 
+    def _make_path(self, path):
+        # Backwards-compatibility stuff: original implementation used string paths
+        # libvyosconfig paths are lists, but since node names cannot contain whitespace,
+        # splitting at whitespace is reasonably safe.
+        # It may cause problems with exists() when it's used for checking values,
+        # since values may contain whitespace.
+        path = re.split(r'\s*', path)
+        return (self._level + path)
+
     def _run(self, cmd):
         if self.__session_env:
             p = subprocess.Popen(cmd, stdout=subprocess.PIPE, env=self.__session_env)
@@ -126,7 +150,7 @@ class Config(object):
         # Make sure there's always a space between default path (level)
         # and path supplied as method argument
         # XXX: for small strings in-place concatenation is not a problem
-        self._level = path + " "
+        self._level = re.split(r'\s*', path)
 
     def get_level(self):
         """
@@ -135,7 +159,7 @@ class Config(object):
         Returns:
             str: current edit level
         """
-        return(self._level.strip())
+        return(self._level)
 
     def exists(self, path):
         """
@@ -148,11 +172,20 @@ class Config(object):
             This function cannot be used outside a configuration sessions.
             In operational mode scripts, use ``exists_effective``.
         """
-        try:
-            self._run(self._make_command('exists', self._level + path))
+        if self._session_config.exists(self._make_path(path)):
             return True
-        except VyOSError:
-            return False
+        else:
+            # libvyosconfig exists() works only for _nodes_, not _values_
+            # libvyattacfg one also worked for values, so we emulate that case here
+            path = re.split(r'\s*', path)
+            path_without_value = path[:-1]
+            path_str = " ".join(path_without_value)
+            try:
+                value = self._session_config.return_value(self._make_path(path_str))
+                return (value == path[-1])
+            except vyos.configtree.ConfigTreeError:
+                # node doesn't exist at all
+                return False
 
     def session_changed(self):
         """
@@ -203,7 +236,8 @@ class Config(object):
             It also returns False if node doesn't exist.
         """
         try:
-            self._run(self._make_command('isMulti', self._level + path))
+            path = " ".join(self._level) + " " + path
+            self._run(self._make_command('isMulti', path))
             return True
         except VyOSError:
             return False
@@ -220,7 +254,8 @@ class Config(object):
             It also returns False if node doesn't exist.
         """
         try:
-            self._run(self._make_command('isTag', self._level + path))
+            path = " ".join(self._level) + " " + path
+            self._run(self._make_command('isTag', path))
             return True
         except VyOSError:
             return False
@@ -237,7 +272,8 @@ class Config(object):
             It also returns False if node doesn't exist.
         """
         try:
-            self._run(self._make_command('isLeaf', self._level + path))
+            path = " ".join(self._level) + " " + path
+            self._run(self._make_command('isLeaf', path))
             return True
         except VyOSError:
             return False
@@ -254,9 +290,6 @@ class Config(object):
             str: Node value, if it has any
             None: if node is valueless *or* if it doesn't exist
 
-        Raises:
-            VyOSError: if node is not a single-value leaf node
-
         Note:
             Due to the issue with treatment of valueless nodes by this function,
             valueless nodes should be checked with ``exists`` instead.
@@ -264,17 +297,15 @@ class Config(object):
             This function cannot be used outside a configuration session.
             In operational mode scripts, use ``return_effective_value``.
         """
-        full_path = self._level + path
-        if self.is_multi(path):
-            raise VyOSError("Cannot use return_value on multi node: {0}".format(full_path))
-        elif not self.is_leaf(path):
-            raise VyOSError("Cannot use return_value on non-leaf node: {0}".format(full_path))
+        try:
+            value = self._session_config.return_value(self._make_path(path))
+        except vyos.configtree.ConfigTreeError:
+            value = None
+
+        if not value:
+            return(default)
         else:
-            try:
-                out = self._run(self._make_command('returnValue', full_path))
-                return out
-            except VyOSError:
-                return(default)
+            return(value)
 
     def return_values(self, path, default=[]):
         """
@@ -285,27 +316,21 @@ class Config(object):
 
         Returns:
             str list: Node values, if it has any
-            None: if node does not exist
-
-        Raises:
-            VyOSError: if node is not a multi-value leaf node
+            []: if node does not exist
 
         Note:
             This function cannot be used outside a configuration session.
             In operational mode scripts, use ``return_effective_values``.
         """
-        full_path = self._level + path
-        if not self.is_multi(path):
-            raise VyOSError("Cannot use return_values on non-multi node: {0}".format(full_path))
-        elif not self.is_leaf(path):
-            raise VyOSError("Cannot use return_values on non-leaf node: {0}".format(full_path))
+        try:
+            values = self._session_config.return_values(self._make_path(path))
+        except vyos.configtree.ConfigTreeError:
+            values = []
+
+        if not values:
+            return(default)
         else:
-            try:
-                out = self._run(self._make_command('returnValues', full_path))
-                values = re.findall(r"\'(.*?)\'", out)
-                return values
-            except VyOSError:
-                return(default)
+            return(values)
 
     def list_nodes(self, path, default=[]):
         """
@@ -317,26 +342,16 @@ class Config(object):
         Returns:
             string list: child node names
 
-        Raises:
-            VyOSError: if the node is not a tag node
-
-        Note:
-            There is no way to list all children of a non-tag node in
-            the current config backend.
-
-            This function cannot be used outside a configuration session.
-            In operational mode scripts, use ``list_effective_nodes``.
         """
-        full_path = self._level + path
-        if self.is_tag(path):
-            try:
-                out = self._run(self._make_command('listNodes', full_path))
-                values = re.findall(r"\'(.*?)\'", out)
-                return values
-            except VyOSError:
-                return(default)
+        try:
+            nodes = self._session_config.list_nodes(self._make_path(path))
+        except vyos.configtree.ConfigTreeError:
+            nodes = []
+
+        if not nodes:
+            return(default)
         else:
-            raise VyOSError("Cannot use list_nodes on a non-tag node: {0}".format(full_path))
+            return(nodes)
 
     def exists_effective(self, path):
         """
@@ -352,11 +367,7 @@ class Config(object):
             This function is safe to use in operational mode. In configuration mode,
             it ignores uncommited changes.
         """
-        try:
-            self._run(self._make_command('existsEffective', self._level + path))
-            return True
-        except VyOSError:
-            return False
+        return(self._running_config.exists(self._make_path(path)))
 
     def return_effective_value(self, path, default=None):
         """
@@ -368,21 +379,17 @@ class Config(object):
 
         Returns:
             str: Node value
-
-        Raises:
-            VyOSError: if node is not a multi-value leaf node
         """
-        full_path = self._level + path
-        if self.is_multi(path):
-            raise VyOSError("Cannot use return_effective_value on multi node: {0}".format(full_path))
-        elif not self.is_leaf(path):
-            raise VyOSError("Cannot use return_effective_value on non-leaf node: {0}".format(full_path))
+        try:
+            value = self._running_config.return_value(self._make_path(path))
+        except vyos.configtree.ConfigTreeError:
+            value = None
+
+        if not value:
+            return(default)
         else:
-            try:
-                out = self._run(self._make_command('returnEffectiveValue', full_path))
-                return out
-            except VyOSError:
-                return(default)
+            return(value)
+
 
     def return_effective_values(self, path, default=[]):
         """
@@ -393,22 +400,16 @@ class Config(object):
 
         Returns:
             str list: A list of values
-
-        Raises:
-            VyOSError: if node is not a multi-value leaf node
         """
-        full_path = self._level + path
-        if not self.is_multi(path):
-            raise VyOSError("Cannot use return_effective_values on non-multi node: {0}".format(full_path))
-        elif not self.is_leaf(path):
-            raise VyOSError("Cannot use return_effective_values on non-leaf node: {0}".format(full_path))
+        try:
+            values = self._running_config.return_values(self._make_path(path))
+        except vyos.configtree.ConfigTreeError:
+            values = []
+
+        if not values:
+            return(default)
         else:
-            try:
-                out = self._run(self._make_command('returnEffectiveValues', full_path))
-                values = re.findall(r"\'(.*?)\'", out)
-                return values
-            except VyOSError:
-                return(default)
+            return(values)
 
     def list_effective_nodes(self, path, default=[]):
         """
@@ -422,18 +423,13 @@ class Config(object):
 
         Raises:
             VyOSError: if the node is not a tag node
-
-        Note:
-            There is no way to list all children of a non-tag node in
-            the current config backend.
         """
-        full_path = self._level + path
-        if self.is_tag(path):
-            try:
-                out = self._run(self._make_command('listEffectiveNodes', full_path))
-                values = out.split()
-                return list(map(lambda x: re.sub(r'^\'(.*)\'$', r'\1',x), values))
-            except VyOSError:
-                return(default)
+        try:
+            nodes = self._running_config.list_nodes(self._make_path(path))
+        except vyos.configtree.ConfigTreeError:
+            nodes = []
+
+        if not nodes:
+            return(default)
         else:
-            raise VyOSError("Cannot use list_effective_nodes on a non-tag node: {0}".format(full_path))
+            return(nodes)