diff --git a/plugins/cliconf/vyos.py b/plugins/cliconf/vyos.py index 2eac7ce4..662fc8c5 100644 --- a/plugins/cliconf/vyos.py +++ b/plugins/cliconf/vyos.py @@ -1,363 +1,362 @@ # (c) 2017 Red Hat Inc. # # This file is part of Ansible # # Ansible is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # Ansible 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. # # You should have received a copy of the GNU General Public License # along with Ansible. If not, see . # from __future__ import absolute_import, division, print_function __metaclass__ = type DOCUMENTATION = """ author: Ansible Networking Team (@ansible-network) name: vyos short_description: Use vyos cliconf to run command on VyOS platform description: - This vyos plugin provides low level abstraction apis for sending and receiving CLI commands from VyOS network devices. version_added: 1.0.0 options: config_commands: description: - Specifies a list of commands that can make configuration changes to the target device. - When `ansible_network_single_user_mode` is enabled, if a command sent to the device is present in this list, the existing cache is invalidated. version_added: 2.0.0 type: list elements: str default: [] vars: - name: ansible_vyos_config_commands """ import json import re from ansible.errors import AnsibleConnectionFailure from ansible.module_utils._text import to_text from ansible.module_utils.common._collections_compat import Mapping from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.config import ( NetworkConfig, ) from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import ( to_list, ) from ansible.plugins.cliconf import CliconfBase from ansible_collections.vyos.vyos.plugins.cliconf_utils.vyosconf import ( VyosConf, ) class Cliconf(CliconfBase): __rpc__ = CliconfBase.__rpc__ + [ "commit", "discard_changes", "get_diff", "run_commands", ] def __init__(self, *args, **kwargs): super(Cliconf, self).__init__(*args, **kwargs) self._device_info = {} def get_device_info(self): if not self._device_info: device_info = {} device_info["network_os"] = "vyos" reply = self.get("show version") data = to_text(reply, errors="surrogate_or_strict").strip() match = re.search(r"Version:\s*(.*)", data) if match: device_info["network_os_version"] = match.group(1) if device_info["network_os_version"]: match = re.search(r"VyOS\s*(\d+\.\d+)", device_info["network_os_version"]) if match: device_info["network_os_major_version"] = match.group(1) match = re.search(r"(?:HW|Hardware) model:\s*(\S+)", data) if match: device_info["network_os_model"] = match.group(1) reply = self.get("show host name") device_info["network_os_hostname"] = to_text( reply, errors="surrogate_or_strict", ).strip() self._device_info = device_info return self._device_info def get_config(self, flags=None, format=None): if format: option_values = self.get_option_values() if format not in option_values["format"]: raise ValueError( "'format' value %s is invalid. Valid values of format are %s" % (format, ", ".join(option_values["format"])), ) if not flags: flags = [] if format == "text": command = "show configuration" else: command = "show configuration commands" command += " ".join(to_list(flags)) command = command.strip() out = self.send_command(command) return out def edit_config(self, candidate=None, commit=True, replace=None, comment=None): resp = {} operations = self.get_device_operations() self.check_edit_config_capability(operations, candidate, commit, replace, comment) results = [] requests = [] self.send_command("configure") for cmd in to_list(candidate): if not isinstance(cmd, Mapping): cmd = {"command": cmd} results.append(self.send_command(**cmd)) requests.append(cmd["command"]) out = self.get("compare") out = to_text(out, errors="surrogate_or_strict") diff_config = out if not out.startswith("No changes") else None if diff_config: if commit: try: self.commit(comment) except AnsibleConnectionFailure as e: msg = "commit failed: %s" % e.message self.discard_changes() raise AnsibleConnectionFailure(msg) else: self.send_command("exit") else: self.discard_changes() else: self.send_command("exit") if ( to_text(self._connection.get_prompt(), errors="surrogate_or_strict") .strip() .endswith("#") ): self.discard_changes() if diff_config: resp["diff"] = diff_config resp["response"] = results resp["request"] = requests return resp def get( self, command=None, prompt=None, answer=None, sendonly=False, newline=True, output=None, check_all=False, ): if not command: raise ValueError("must provide value of command to execute") if output: raise ValueError("'output' value %s is not supported for get" % output) return self.send_command( command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all, ) def commit(self, comment=None): if comment: command = 'commit comment "{0}"'.format(comment) else: command = "commit" self.send_command(command) def discard_changes(self): self.send_command("exit discard") def get_diff( self, candidate=None, running=None, diff_match="line", diff_ignore_lines=None, path=None, diff_replace=None, ): diff = {} device_operations = self.get_device_operations() option_values = self.get_option_values() if candidate is None and device_operations["supports_generate_diff"]: raise ValueError("candidate configuration is required to generate diff") if diff_match not in option_values["diff_match"]: raise ValueError( "'match' value %s in invalid, valid values are %s" % (diff_match, ", ".join(option_values["diff_match"])), ) if diff_replace: raise ValueError("'replace' in diff is not supported") if diff_ignore_lines: raise ValueError("'diff_ignore_lines' in diff is not supported") if path: raise ValueError("'path' in diff is not supported") set_format = candidate.startswith("set") or candidate.startswith("delete") candidate_obj = NetworkConfig(indent=4, contents=candidate) if not set_format: config = [c.line for c in candidate_obj.items] commands = list() # this filters out less specific lines for item in config: for index, entry in enumerate(commands): if item.startswith(entry): del commands[index] break commands.append(item) candidate_commands = ["set %s" % cmd.replace(" {", "") for cmd in commands] else: candidate_commands = str(candidate).strip().split("\n") if diff_match == "none": diff["config_diff"] = list(candidate_commands) return diff if diff_match == "smart": running_conf = VyosConf(running.splitlines()) candidate_conf = VyosConf(candidate_commands) diff["config_diff"] = running_conf.diff_commands_to(candidate_conf) return diff running_commands = [ str(c).replace("'", "") for c in running.splitlines() ] - updates = list() visited = set() for line in candidate_commands: item = str(line).replace("'", "") if not item.startswith("set") and not item.startswith("delete"): raise ValueError("line must start with either `set` or `delete`") elif item.startswith("set") and item not in running_commands: updates.append(line) elif item.startswith("delete"): if not running_commands: updates.append(line) else: item = re.sub(r"delete", "set", item) for entry in running_commands: if re.match(rf"^{re.escape(item)}\b", entry) and line not in visited: updates.append(line) visited.add(line) diff["config_diff"] = list(updates) return diff def run_commands(self, commands=None, check_rc=True): if commands is None: raise ValueError("'commands' value is required") responses = list() for cmd in to_list(commands): if not isinstance(cmd, Mapping): cmd = {"command": cmd} output = cmd.pop("output", None) if output: raise ValueError("'output' value %s is not supported for run_commands" % output) try: out = self.send_command(**cmd) except AnsibleConnectionFailure as e: if check_rc: raise out = getattr(e, "err", e) responses.append(out) return responses def get_device_operations(self): return { "supports_diff_replace": False, "supports_commit": True, "supports_rollback": False, "supports_defaults": False, "supports_onbox_diff": True, "supports_commit_comment": True, "supports_multiline_delimiter": False, "supports_diff_match": True, "supports_diff_ignore_lines": False, "supports_generate_diff": False, "supports_replace": False, } def get_option_values(self): return { "format": ["text", "set"], "diff_match": ["line", "smart", "none"], "diff_replace": [], "output": [], } def get_capabilities(self): result = super(Cliconf, self).get_capabilities() result["device_operations"] = self.get_device_operations() result.update(self.get_option_values()) return json.dumps(result) def set_cli_prompt_context(self): """ Make sure we are in the operational cli mode :return: None """ if self._connection.connected: self._update_cli_prompt_context(config_context="#", exit_command="exit discard") diff --git a/plugins/cliconf_utils/vyosconf.py b/plugins/cliconf_utils/vyosconf.py index 21c5872e..74e9d9fa 100644 --- a/plugins/cliconf_utils/vyosconf.py +++ b/plugins/cliconf_utils/vyosconf.py @@ -1,237 +1,237 @@ # # This file is part of Ansible # # Ansible is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # Ansible 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. # # You should have received a copy of the GNU General Public License # along with Ansible. If not, see . # from __future__ import absolute_import, division, print_function __metaclass__ = type import re KEEP_EXISTING_VALUES = "..." class VyosConf: def __init__(self, commands=None): self.config = {} - if type(commands) is list: + if isinstance(commands, list): self.run_commands(commands) def set_entry(self, path, leaf): """ This function sets a value in the configuration given a path. :param path: list of strings to traveser in the config :param leaf: value to set at the destination :return: dict """ target = self.config path = path + [leaf] for key in path: - if key not in target or type(target[key]) is not dict: + if key not in target or not isinstance(target[key], dict): target[key] = {} target = target[key] return self.config def del_entry(self, path, leaf): """ This function deletes a value from the configuration given a path and also removes all the parents that are now empty. :param path: list of strings to traveser in the config :param leaf: value to delete at the destination :return: dict """ target = self.config firstNoSiblingKey = None for key in path: if key not in target: return self.config if len(target[key]) <= 1: if firstNoSiblingKey is None: firstNoSiblingKey = [target, key] else: firstNoSiblingKey = None target = target[key] if firstNoSiblingKey is None: firstNoSiblingKey = [target, leaf] target = firstNoSiblingKey[0] targetKey = firstNoSiblingKey[1] del target[targetKey] return self.config def check_entry(self, path, leaf): """ This function checks if a value exists in the config. :param path: list of strings to traveser in the config :param leaf: value to check for existence :return: bool """ target = self.config path = path + [leaf] existing = [] for key in path: - if key not in target or type(target[key]) is not dict: + if key not in target or not isinstance(target[key], dict): return False existing.append(key) target = target[key] return True def parse_line(self, line): """ This function parses a given command from string. :param line: line to parse :return: [command, path, leaf] """ line = ( re.match(r"^('(.*)'|\"(.*)\"|([^#\"']*))*", line).group(0).strip() ) path = re.findall(r"('.*?'|\".*?\"|\S+)", line) leaf = path[-1] if leaf.startswith('"') and leaf.endswith('"'): leaf = leaf[1:-1] if leaf.startswith("'") and leaf.endswith("'"): leaf = leaf[1:-1] return [path[0], path[1:-1], leaf] def run_command(self, command): """ This function runs a given command string. :param command: command to run :return: dict """ [cmd, path, leaf] = self.parse_line(command) if cmd.startswith("set"): self.set_entry(path, leaf) if cmd.startswith("del"): self.del_entry(path, leaf) return self.config def run_commands(self, commands): """ This function runs a a list of command strings. :param commands: commands to run :return: dict """ for c in commands: self.run_command(c) return self.config def check_command(self, command): """ This function checkes a command for existance in the config. :param command: command to check :return: bool """ [cmd, path, leaf] = self.parse_line(command) if cmd.startswith("set"): return self.check_entry(path, leaf) if cmd.startswith("del"): return not self.check_entry(path, leaf) return True def check_commands(self, commands): """ This function checkes a list of commands for existance in the config. :param commands: list of commands to check :return: [bool] """ return [self.check_command(c) for c in commands] def quote_key(self, key): """ This function adds quotes to key if quotes are needed for correct parsing. :param key: str to wrap in quotes if needed :return: str """ if len(key) == 0: return "" if '"' in key: return "'" + key + "'" if "'" in key: return '"' + key + '"' if not re.match(r"^[a-zA-Z0-9./-]*$", key): return "'" + key + "'" return key def build_commands(self, structure=None, nested=False): """ This function builds a list of commands to recreate the current configuration. :return: [str] """ - if type(structure) is not dict: + if not isinstance(structure, dict): structure = self.config if len(structure) == 0: return [""] if nested else [] commands = [] for (key, value) in structure.items(): quoted_key = self.quote_key(key) for c in self.build_commands(value, True): commands.append((quoted_key + " " + c).strip()) if nested: return commands return ["set " + c for c in commands] def diff_to(self, other, structure): - if type(other) is not dict: + if not isinstance(other, dict): other = {} if len(structure) == 0: return ([], [""]) - if type(structure) is not dict: + if not isinstance(structure, dict): structure = {} if len(other) == 0: return ([""], []) if len(other) == 0 and len(structure) == 0: return ([], []) toset = [] todel = [] for key in structure.keys(): quoted_key = self.quote_key(key) if key in other: # keys in both configs, pls compare subkeys (subset, subdel) = self.diff_to(other[key], structure[key]) for s in subset: toset.append(quoted_key + " " + s) for d in subdel: todel.append(quoted_key + " " + d) else: # keys only in this, delete if KEEP_EXISTING_VALUES not set if KEEP_EXISTING_VALUES not in other: todel.append(quoted_key) continue # del for (key, value) in other.items(): if key == KEEP_EXISTING_VALUES: continue quoted_key = self.quote_key(key) if key not in structure: # keys only in other, pls set all subkeys (subset, subdel) = self.diff_to(other[key], None) for s in subset: toset.append(quoted_key + " " + s) return (toset, todel) def diff_commands_to(self, other): """ This function calculates the required commands to change the current into the given configuration. :param other: VyosConf :return: [str] """ (toset, todel) = self.diff_to(other.config, self.config) return ["delete " + c.strip() for c in todel] + [ "set " + c.strip() for c in toset ]