diff --git a/changelogs/fragments/t9416_vyos_snmp_server_fixes.yml b/changelogs/fragments/t9416_vyos_snmp_server_fixes.yml index 668f8d27..1f7ca00a 100644 --- a/changelogs/fragments/t9416_vyos_snmp_server_fixes.yml +++ b/changelogs/fragments/t9416_vyos_snmp_server_fixes.yml @@ -1,22 +1,30 @@ --- bugfixes: - vyos_snmp_server - a trap target's community and port are rendered, as separate commands; before, they were silently dropped (T9415). - vyos_snmp_server - SNMPv3 trap-target port, protocol, type and user render with the trap target's address; before, they rendered an invalid "service snmp v3 trap-target port X" (T9416). - vyos_snmp_server - SNMPv3 trap-target authentication and privacy are rendered; before, they were silently dropped. - vyos_snmp_server - SNMPv3 trap-target port, protocol, type and user are read back as their values; before, a device with an SNMPv3 trap-target port made the module fail. + - vyos_snmp_server - an SNMPv3 user's mode is read back as its value; before, a device with an + SNMPv3 user mode made the module fail. + - vyos_snmp_server - an SNMPv3 view's exclude and mask render as separate commands; before, a + view with both rendered one invalid command. + - vyos_snmp_server - an SNMPv3 user's mode is read back as its value; before, a device with an + SNMPv3 user mode made the module fail. + - vyos_snmp_server - an SNMPv3 view's exclude and mask are rendered, as separate commands; before, + they were silently dropped. minor_changes: - vyos_snmp_server - new option snmp_v3.trap_targets.user. - vyos_snmp_server - new option trap_targets, a list of SNMPv2c trap targets (address, community, port); VyOS allows more than one, trap_target only allowed one (T9436). deprecated_features: - vyos_snmp_server - the trap_target option is deprecated since 7.0.0 in favour of trap_targets, and will be removed in version 8.0.0. It keeps working throughout 7.x, as a list of one trap target, and is mutually exclusive with trap_targets. breaking_changes: - vyos_snmp_server - the module's output (gathered, parsed, before and after) reports SNMPv2c trap targets as the list trap_targets instead of the single trap_target, so that more than one trap target on the device can be represented. diff --git a/plugins/module_utils/network/vyos/config/snmp_server/snmp_server.py b/plugins/module_utils/network/vyos/config/snmp_server/snmp_server.py index 8a39be73..fa2264aa 100644 --- a/plugins/module_utils/network/vyos/config/snmp_server/snmp_server.py +++ b/plugins/module_utils/network/vyos/config/snmp_server/snmp_server.py @@ -1,333 +1,338 @@ # # -*- coding: utf-8 -*- # Copyright 2022 Red Hat # GNU General Public License v3.0+ # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) # from __future__ import absolute_import, division, print_function __metaclass__ = type """ The vyos_snmp_server config file. It is in this file where the current configuration (as dict) is compared to the provided configuration (as dict) and the command set necessary to bring the current configuration to its desired end-state is created. """ import re from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.resource_module import ( ResourceModule, ) from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import ( dict_merge, get_from_dict, ) from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.facts.facts import Facts from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.rm_templates.snmp_server import ( Snmp_serverTemplate, ) class Snmp_server(ResourceModule): """ The vyos_snmp_server config class """ def __init__(self, module): super(Snmp_server, self).__init__( empty_fact_val={}, facts_module=Facts(module), module=module, resource="snmp_server", tmplt=Snmp_serverTemplate(), ) self.parsers = [ "contact", "description", "location", "smux_peer", "trap_source", ] def execute_module(self): """Execute the module :rtype: A dictionary :returns: The result from module execution """ if self.state not in ["parsed", "gathered"]: self.generate_commands() self.run_commands() return self.result def generate_commands(self): """Generate configuration commands to send based on want, have and desired state. """ if self.want.get("trap_target"): self.want.setdefault("trap_targets", []).append(self.want.pop("trap_target")) wantd = self._snmp_server_list_to_dict(self.want) haved = self._snmp_server_list_to_dict(self.have) # if state is merged, merge want onto have and then compare if self.state == "merged": wantd = dict_merge(haved, wantd) # if state is deleted, empty out wantd and set haved to wantd if self.state == "deleted": if haved: self.commands.append("delete service snmp") if self.state != "deleted": self._compare(want=wantd, have=haved) if self.state not in ["merged", "deleted"]: self._move_negate_commands() def _move_negate_commands(self): command_set = [] for cmd in self.commands: if re.search("delete service snmp", cmd): command_set.insert(0, cmd) else: command_set.append(cmd) self.commands = command_set def _compare(self, want, have): """Leverages the base class `compare()` method and populates the list of commands to be run by comparing the `want` and `have` data with the `parsers` defined for the Snmp_server network resource. """ self._compare_lists(want, have) self._compare_trap_targets(want, have) self._compare_snmp_v3(want, have) for key, value in want.items(): self.compare( parsers=self.parsers, want={key: value}, have={key: have.pop(key, "")}, ) for key, entry in have.items(): if entry: self.compare(parsers=self.parsers, want={}, have={key: entry}) def _compare_lists(self, want, have): parsers = [ "communities", "listen_addresses", ] for attrib in parsers: wdict = get_from_dict(want, attrib) or {} hdict = get_from_dict(have, attrib) or {} for key, entry in wdict.items(): # self.addcmd(entry, attrib, False) if attrib == "communities": for k, v in entry.items(): if k in ["clients", "networks"]: v.sort() h = {} if k != "name": if hdict.get(key): h = { "communities": { k: hdict[key].pop(k, ""), "name": key, }, } self.compare( parsers="communities", want={"communities": {k: v, "name": key}}, have=h, ) else: self.compare( parsers="listen_addresses", want={"listen_addresses": entry}, have={"listen_addresses": hdict.pop(key, {})}, ) have.pop(attrib, {}) # remove remaining items in have for replaced for key, entry in hdict.items(): if attrib == "communities": for k, v in entry.items(): if k != "name": self.compare( parsers="communities", have={"communities": {k: v, "name": key}}, want={}, ) else: self.compare(parsers=parsers, want={}, have={attrib: entry}) def _compare_trap_targets(self, want, have): """v2c trap targets, by address and option by option""" wdict = want.pop("trap_targets", {}) or {} hdict = have.pop("trap_targets", {}) or {} for address, wentry in wdict.items(): hentry = hdict.pop(address, {}) if not hentry and not (wentry.get("community") or wentry.get("port")): self.addcmd({"trap_targets": {"address": address}}, "trap_targets", False) for key in ("community", "port"): w = ( {"trap_targets": {"address": address, key: wentry[key]}} if wentry.get(key) else {} ) h = ( {"trap_targets": {"address": address, key: hentry[key]}} if hentry.get(key) else {} ) self.compare(parsers="trap_targets", want=w, have=h) # trap targets that want does not list (replaced, overridden) are deleted as a whole for address in hdict: self.addcmd({"trap_targets": {"address": address}}, "trap_targets", True) def _compare_snmp_v3(self, want, have): parsers = [ "snmp_v3.groups", "snmp_v3.trap_targets.port", "snmp_v3.trap_targets.protocol", "snmp_v3.trap_targets.type", "snmp_v3.trap_targets.user", "snmp_v3.users.group", "snmp_v3.users.mode", "snmp_v3.views", "snmp_v3.engine_id", ] attribute_dict = { "groups": "group", "trap_targets": "address", "users": "user", "views": "view", } wdict = get_from_dict(want, "snmp_v3") or {} hdict = get_from_dict(have, "snmp_v3") or {} for attrib in attribute_dict.keys(): wattrib = get_from_dict(wdict, attrib) or {} hattrib = get_from_dict(hdict, attrib) or {} for key, entry in wattrib.items(): self._compare_snmp_v3_auth_privacy(entry, hattrib.get(key, {}), attrib) + have_oid = hattrib.get(key, {}).get("oid") if attrib == "views" else None for k, v in entry.items(): if k != attribute_dict[attrib]: h = {} if hattrib.get(key): h = { "snmp_v3": { attrib: { k: hattrib[key].pop(k, ""), attribute_dict[attrib]: hattrib[key][ attribute_dict[attrib] ], }, }, } - self.compare( - parsers=parsers, - want={ - "snmp_v3": { - attrib: { - k: v, - attribute_dict[attrib]: entry[attribute_dict[attrib]], - }, + if attrib == "views" and k != "oid" and have_oid: + h["snmp_v3"][attrib]["oid"] = have_oid + w = { + "snmp_v3": { + attrib: { + k: v, + attribute_dict[attrib]: entry[attribute_dict[attrib]], }, }, - have=h, - ) + } + if attrib == "views" and k != "oid": + w["snmp_v3"][attrib]["oid"] = entry.get("oid") + self.compare(parsers=parsers, want=w, have=h) + # options left on the device are deleted below; keep the oid for their commands + if have_oid and hattrib.get(key) and set(hattrib[key]) - {"view", "oid"}: + hattrib[key]["oid"] = have_oid # remove remaining items in have for replaced for key, entry in hattrib.items(): self._compare_snmp_v3_auth_privacy({}, entry, attrib) self.compare(parsers=parsers, want={}, have={"snmp_v3": {attrib: entry}}) hdict.pop(attrib, {}) for key, entry in wdict.items(): # self.addcmd(entry, attrib, False) self.compare( parsers="snmp_v3.engine_id", want={"snmp_v3": {key: entry}}, have={"snmp_v3": {key: hdict.pop(key, {})}}, ) # remove remaining items in have for replaced for key, entry in hdict.items(): self.compare(parsers=parsers, want={}, have={"snmp_v3": {key: entry}}) def _compare_snmp_v3_auth_privacy(self, wattrib, hattrib, attrib): parsers = [ "snmp_v3.trap_targets.authentication", "snmp_v3.trap_targets.privacy", "snmp_v3.users.authentication", "snmp_v3.users.privacy", ] if attrib in ["trap_targets", "users"]: if attrib == "users": primary_key = "user" else: primary_key = "address" for key, entry in wattrib.items(): if key != primary_key and key in ["authentication", "privacy"]: self.compare( parsers=parsers, want={ "snmp_v3": { attrib: { key: entry, primary_key: wattrib[primary_key], }, }, }, have={ "snmp_v3": { attrib: { key: hattrib.pop(key, {}), primary_key: wattrib[primary_key], }, }, }, ) for key, entry in hattrib.items(): if key != primary_key and key in ["authentication", "privacy"]: self.compare( parsers=parsers, want={}, have={ "snmp_v3": { attrib: { key: entry, primary_key: hattrib[primary_key], }, }, }, ) def _snmp_server_list_to_dict(self, entry): param_dict = { "communities": "name", "listen_addresses": "address", "trap_targets": "address", } v3_param_dict = { "groups": "group", "users": "user", "views": "view", "trap_targets": "address", } for k, v in param_dict.items(): if k in entry: a_dict = {} for el in entry[k]: a_dict.update({el[v]: el}) entry[k] = a_dict for k, v in v3_param_dict.items(): if entry.get("snmp_v3") and k in entry.get("snmp_v3"): a_dict = {} for el in entry["snmp_v3"][k]: a_dict.update({el[v]: el}) entry["snmp_v3"][k] = a_dict return entry diff --git a/plugins/module_utils/network/vyos/rm_templates/snmp_server.py b/plugins/module_utils/network/vyos/rm_templates/snmp_server.py index e01a3e39..85a066bc 100644 --- a/plugins/module_utils/network/vyos/rm_templates/snmp_server.py +++ b/plugins/module_utils/network/vyos/rm_templates/snmp_server.py @@ -1,600 +1,600 @@ # -*- coding: utf-8 -*- # Copyright 2022 Red Hat # GNU General Public License v3.0+ # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) from __future__ import absolute_import, division, print_function __metaclass__ = type """ The Snmp_server parser templates file. This contains a list of parser definitions and associated functions that facilitates both facts gathering and native command generation for the given network resource. """ import re from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import ( NetworkTemplate, ) def _tmplt_snmp_server_communities(config_data): config_data = config_data["communities"] command = [] cmd = "service snmp community {name}".format(**config_data) if "authorization_type" in config_data: auth_cmd = cmd + " authorization {authorization_type}".format(**config_data) command.append(auth_cmd) if "clients" in config_data: for c in config_data["clients"]: client_cmd = cmd + " client " + c command.append(client_cmd) if "networks" in config_data: for n in config_data["networks"]: network_command = cmd + " network " + n command.append(network_command) if not command: command.append(cmd) return command def _tmplt_snmp_server_trap_target(config_data): config_data = config_data["trap_targets"] command = "service snmp trap-target {address}".format(**config_data) commands = [] if config_data.get("community"): commands.append(command + " community {community}".format(**config_data)) if config_data.get("port"): commands.append(command + " port {port}".format(**config_data)) return commands or command def _tmplt_snmp_server_v3_groups(config_data): config_data = config_data["snmp_v3"]["groups"] command = [] cmd = "service snmp v3 group {group}".format(**config_data) if "mode" in config_data: mode_cmd = cmd + " mode {mode}".format(**config_data) command.append(mode_cmd) if "seclevel" in config_data: sec_cmd = cmd + " seclevel {seclevel}".format(**config_data) command.append(sec_cmd) if "view" in config_data: view_cmd = cmd + " view {view}".format(**config_data) command.append(view_cmd) return command def _tmplt_snmp_server_v3_trap_target(config_data): config_data = config_data["snmp_v3"]["trap_targets"] command = "service snmp v3 trap-target {address}".format(**config_data) commands = [] for key, node in (("authentication", "auth"), ("privacy", "privacy")): values = config_data.get(key) or {} for option, leaf in ( ("type", "type"), ("encrypted_key", "encrypted-password"), ("plaintext_key", "plaintext-password"), ): if values.get(option): commands.append("{0} {1} {2} {3}".format(command, node, leaf, values[option])) return commands def _tmplt_snmp_server_v3_user(config_data): config_data = config_data["snmp_v3"]["users"] command = [] cmd = "service snmp v3 user {user}".format(**config_data) for k in ["authentication", "privacy"]: if config_data.get(k): config = config_data[k] if k == "authentication": val = " auth" else: val = " privacy" if "type" in config: type_cmd = cmd + val + " type {type}".format(**config) command.append(type_cmd) if "encrypted_key" in config: enc_cmd = cmd + val + " encrypted-password {encrypted_key}".format(**config) command.append(enc_cmd) if "plaintext_key" in config: plain_cmd = cmd + val + " plaintext-password {plaintext_key}".format(**config) command.append(plain_cmd) return command def _tmplt_snmp_server_v3_views(config_data): config_data = config_data["snmp_v3"]["views"] command = "service snmp v3 view {view} oid {oid}".format(**config_data) + commands = [] if "exclude" in config_data: - command += " exclude {exclude}".format(**config_data) + commands.append(command + " exclude {exclude}".format(**config_data)) if "mask" in config_data: - command += " mask {mask}".format(**config_data) - return command + commands.append(command + " mask {mask}".format(**config_data)) + return commands or command class Snmp_serverTemplate(NetworkTemplate): def __init__(self, lines=None, module=None): prefix = {"set": "set", "remove": "delete"} super(Snmp_serverTemplate, self).__init__( lines=lines, tmplt=self, prefix=prefix, module=module, ) # fmt: off PARSERS = [ # service snmp community <> { "name": "communities", "getval": re.compile( r""" ^set\sservice\ssnmp\scommunity \s+(?P\S+) \s*(?Pauthorization\srw|authorization\sro)? \s*(client\s(?P\S+))? \s*(network\s(?P\S+))? $""", re.VERBOSE, ), "setval": _tmplt_snmp_server_communities, "result": { "communities": { "{{ name }}": { "name": "{{ name }}", "clients": ['{{ client if client is defined else "None" }}'], "networks": ['{{ network if network is defined else "None" }}'], "authorization_type": '{{ auth.split(" ")[1] if auth is defined else None }}', }, }, }, }, # service snmp contact <> { "name": "contact", "getval": re.compile( r""" ^set\sservice\ssnmp\scontact \s+(?P\S+)\s*$""", re.VERBOSE, ), "setval": "service snmp contact {{ contact }}", "result": { "contact": "{{ name }}", }, }, # service snmp description <> { "name": "description", "getval": re.compile( r""" ^set\sservice\ssnmp\sdescription \s+(?P\S+)\s*$""", re.VERBOSE, ), "setval": "service snmp description {{ description }}", "result": { "description": "{{ name }}", }, }, # service snmp listen-address <> port <> { "name": "listen_addresses", "getval": re.compile( r""" ^set\sservice\ssnmp\slisten-address \s+(?P\S+) \s*(port)? \s*(?P\d+)? $""", re.VERBOSE, ), "setval": "service snmp listen-address {{ listen_addresses.address }}" "{{ (' port ' + listen_addresses.port|string) if listen_addresses.port is defined else '' }}", "result": { "listen_addresses": { "{{ addr }}": { "address": "{{ addr }}", "port": "{{ port }}", }, }, }, }, # service snmp location <> { "name": "location", "getval": re.compile( r""" ^set\sservice\ssnmp\slocation \s(?P.*) $""", re.VERBOSE, ), "setval": "service snmp location {{ '\\'' + location + '\\''}}", "result": { "location": "{{ name }}", }, }, # service snmp smux-peer <> { "name": "smux_peer", "getval": re.compile( r""" ^set\sservice\ssnmp\ssmux-peer \s+(?P\S+)\s*$""", re.VERBOSE, ), "setval": "service snmp smux-peer {{ smux_peer }}", "result": { "smux_peer": "{{ name }}", }, }, # service snmp trap-source <> { "name": "trap_source", "getval": re.compile( r""" ^set\sservice\ssnmp\strap-source \s+(?P\S+)\s*$""", re.VERBOSE, ), "setval": "service snmp trap-source {{ trap_source }}", "result": { "trap_source": "{{ name }}", }, }, # service snmp trap-target <> (one or more v2c trap targets) { "name": "trap_targets", "getval": re.compile( r""" ^set\sservice\ssnmp\strap-target \s+(?P\S+) \s*(?Pcommunity\s\S+)? \s*(?Pport\s\d+)? $""", re.VERBOSE, ), "setval": _tmplt_snmp_server_trap_target, "result": { "trap_targets": { "{{ name }}": { "address": "{{ name }}", "community": "{{ comm.split(" ")[1] if comm is defined else None }}", "port": "{{ port.split(" ")[1] if port is defined else None }}", }, }, }, }, # service snmp v3 engineid <> { "name": "snmp_v3.engine_id", "getval": re.compile( r""" ^set\sservice\ssnmp\sv3\sengineid \s+(?P\S+)\s*$""", re.VERBOSE, ), "setval": "service snmp v3 engineid {{ snmp_v3.engine_id }}", "result": { "snmp_v3": { "engine_id": "{{ name }}", }, }, }, # service snmp v3 group <> { "name": "snmp_v3.groups", "getval": re.compile( r""" ^set\sservice\ssnmp\sv3\sgroup \s+(?P\S+) \s*(?Pmode\s\S+)? \s*(?Pseclevel\s\S+)? \s*(?Pview\s\S+)? $""", re.VERBOSE, ), "setval": _tmplt_snmp_server_v3_groups, "result": { "snmp_v3": { "groups": { "{{ name }}": { "group": "{{ name }}", "mode": '{{ mode.split(" ")[1] if mode is defined else None }}', "seclevel": '{{ sec.split(" ")[1] if sec is defined else None }}', "view": '{{ view.split(" ")[1] if view is defined else None }}', }, }, }, }, }, # service snmp v3 trap-target <> auth <> { "name": "snmp_v3.trap_targets.authentication", "getval": re.compile( r""" ^set\sservice\ssnmp\sv3\strap-target \s+(?P\S+) \s+auth \s*(?Pencrypted-password\s\S+)? \s*(?Pplaintext-password\s\S+)? \s*(?Ptype\s\S+)? $""", re.VERBOSE, ), "setval": _tmplt_snmp_server_v3_trap_target, "result": { "snmp_v3": { "trap_targets": { "{{ name }}": { "address": "{{ name }}", "authentication": { "encrypted_key": '{{ enc.split(" ")[1] if enc is defined else None }}', "plaintext_key": '{{ plain.split(" ")[1] if plain is defined else None }}', "type": '{{ type.split(" ")[1] if type is defined else None }}', }, }, }, }, }, }, # service snmp v3 trap-target <> port <> { "name": "snmp_v3.trap_targets.port", "getval": re.compile( r""" ^set\sservice\ssnmp\sv3\strap-target \s+(?P\S+) \s+port\s+(?P\d+)\s*$""", re.VERBOSE, ), "setval": "service snmp v3 trap-target {{ snmp_v3.trap_targets.address }} port {{ snmp_v3.trap_targets.port }}", "result": { "snmp_v3": { "trap_targets": { "{{ name }}": { "address": "{{ name }}", "port": "{{ port }}", }, }, }, }, }, # service snmp v3 trap-target <> protocol <> { "name": "snmp_v3.trap_targets.protocol", "getval": re.compile( r""" ^set\sservice\ssnmp\sv3\strap-target \s+(?P\S+) \s+protocol\s+(?P\S+)\s*$""", re.VERBOSE, ), "setval": "service snmp v3 trap-target {{ snmp_v3.trap_targets.address }} protocol {{ snmp_v3.trap_targets.protocol }}", "result": { "snmp_v3": { "trap_targets": { "{{ name }}": { "address": "{{ name }}", "protocol": "{{ protocol }}", }, }, }, }, }, # service snmp v3 trap-target <> type <> { "name": "snmp_v3.trap_targets.type", "getval": re.compile( r""" ^set\sservice\ssnmp\sv3\strap-target \s+(?P\S+) \s+type\s+(?P\S+)\s*$""", re.VERBOSE, ), "setval": "service snmp v3 trap-target {{ snmp_v3.trap_targets.address }} type {{ snmp_v3.trap_targets.type }}", "result": { "snmp_v3": { "trap_targets": { "{{ name }}": { "address": "{{ name }}", "type": "{{ type }}", }, }, }, }, }, # service snmp v3 trap-target <> user <> { "name": "snmp_v3.trap_targets.user", "getval": re.compile( r""" ^set\sservice\ssnmp\sv3\strap-target \s+(?P\S+) \s+user\s+(?P\S+)\s*$""", re.VERBOSE, ), "setval": "service snmp v3 trap-target {{ snmp_v3.trap_targets.address }} user {{ snmp_v3.trap_targets.user }}", "result": { "snmp_v3": { "trap_targets": { "{{ name }}": { "address": "{{ name }}", "user": "{{ user }}", }, }, }, }, }, # service snmp v3 trap-target <> privacy <> { "name": "snmp_v3.trap_targets.privacy", "getval": re.compile( r""" ^set\sservice\ssnmp\sv3\strap-target \s+(?P\S+) \s+privacy \s*(?Pencrypted-password\s\S+)? \s*(?Pplaintext-password\s\S+)? \s*(?Ptype\s\S+)? $""", re.VERBOSE, ), "setval": _tmplt_snmp_server_v3_trap_target, "result": { "snmp_v3": { "trap_targets": { "{{ name }}": { "address": "{{ name }}", "privacy": { "encrypted_key": '{{ enc.split(" ")[1] if enc is defined else None }}', "plaintext_key": '{{ plain.split(" ")[1] if plain is defined else None }}', "type": '{{ type.split(" ")[1] if type is defined else None }}', }, }, }, }, }, }, # service snmp v3 user <> auth <> { "name": "snmp_v3.users.authentication", "getval": re.compile( r""" ^set\sservice\ssnmp\sv3\suser \s+(?P\S+) \s+auth \s*(?Pencrypted-password\s\S+)? \s*(?Pplaintext-password\s\S+)? \s*(?Ptype\s\S+)? $""", re.VERBOSE, ), "setval": _tmplt_snmp_server_v3_user, "result": { "snmp_v3": { "users": { "{{ name }}": { "user": "{{ name }}", "authentication": { "encrypted_key": '{{ enc.split(" ")[1] if enc is defined else None }}', "plaintext_key": '{{ plain.split(" ")[1] if plain is defined else None }}', "type": '{{ type.split(" ")[1] if type is defined else None }}', }, }, }, }, }, }, # service snmp v3 user <> privacy <> { "name": "snmp_v3.users.privacy", "getval": re.compile( r""" ^set\sservice\ssnmp\sv3\suser \s+(?P\S+) \s+privacy \s*(?Pencrypted-password\s\S+)? \s*(?Pplaintext-password\s\S+)? \s*(?Ptype\s\S+)? $""", re.VERBOSE, ), "setval": _tmplt_snmp_server_v3_user, "result": { "snmp_v3": { "users": { "{{ name }}": { "user": "{{ name }}", "privacy": { "encrypted_key": '{{ enc.split(" ")[1] if enc is defined else None }}', "plaintext_key": '{{ plain.split(" ")[1] if plain is defined else None }}', "type": '{{ type.split(" ")[1] if type is defined else None }}', }, }, }, }, }, }, # service snmp v3 user <> group <> { "name": "snmp_v3.users.group", "getval": re.compile( r""" ^set\sservice\ssnmp\sv3\suser \s+(?P\S+) \s+(?Pgroup\s.+)? $""", re.VERBOSE, ), "setval": "service snmp v3 user {{ snmp_v3.users.user }} group {{ snmp_v3.users.group }}", "result": { "snmp_v3": { "users": { "{{ name }}": { "user": "{{ name }}", "group": "{{ group.split(" ")[1] if group is defined else None }}", }, }, }, }, }, # service snmp v3 user <> mode <> { "name": "snmp_v3.users.mode", "getval": re.compile( r""" ^set\sservice\ssnmp\sv3\suser \s+(?P\S+) - \s+(?Pmode\s\S+)? - $""", + \s+mode\s+(?P\S+)\s*$""", re.VERBOSE, ), "setval": "service snmp v3 user {{ snmp_v3.users.user }} mode {{ snmp_v3.users.mode }}", "result": { "snmp_v3": { "users": { "{{ name }}": { "user": "{{ name }}", "mode": "{{ mode }}", }, }, }, }, }, # service snmp v3 view <> { "name": "snmp_v3.views", "getval": re.compile( r""" ^set\sservice\ssnmp\sv3\sview \s+(?P\S+) \s+(?Poid\s\S+) \s*(?Pexclude\s\S+)? \s*(?Pmask\s\S+)? $""", re.VERBOSE, ), "setval": _tmplt_snmp_server_v3_views, "result": { "snmp_v3": { "views": { "{{ name }}": { "view": "{{ name }}", "oid": '{{ oid.split(" ")[1] if oid is defined else None }}', "exclude": '{{ ex.split(" ")[1] if ex is defined else None }}', "mask": '{{ mask.split(" ")[1] if mask is defined else None }}', }, }, }, }, }, ] # fmt: on diff --git a/tests/unit/modules/network/vyos/test_vyos_snmp_server.py b/tests/unit/modules/network/vyos/test_vyos_snmp_server.py index 82513282..53f72bd6 100644 --- a/tests/unit/modules/network/vyos/test_vyos_snmp_server.py +++ b/tests/unit/modules/network/vyos/test_vyos_snmp_server.py @@ -1,632 +1,661 @@ # (c) 2021 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 . # Make coding more python3-ish from __future__ import absolute_import, division, print_function __metaclass__ = type from unittest.mock import patch from ansible_collections.vyos.vyos.plugins.modules import vyos_snmp_server from ansible_collections.vyos.vyos.tests.unit.modules.utils import set_module_args from .vyos_module import TestVyosModule, load_fixture class TestVyosSnmpServerModule(TestVyosModule): module = vyos_snmp_server def setUp(self): super(TestVyosSnmpServerModule, self).setUp() self.mock_get_resource_connection_config = patch( "ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.resource_module_base.get_resource_connection", ) self.get_resource_connection_config = self.mock_get_resource_connection_config.start() self.mock_get_resource_connection_facts = patch( "ansible_collections.ansible.netcommon.plugins.module_utils.network.common.facts.facts.get_resource_connection", ) self.get_resource_connection_facts = self.mock_get_resource_connection_facts.start() self.mock_execute_show_command = patch( "ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.facts.snmp_server.snmp_server.Snmp_serverFacts.get_config", ) self.execute_show_command = self.mock_execute_show_command.start() def tearDown(self): super(TestVyosSnmpServerModule, self).tearDown() self.mock_get_resource_connection_config.stop() self.mock_get_resource_connection_facts.stop() self.mock_execute_show_command.stop() def load_fixtures(self, commands=None, filename=None): if filename is None: filename = "vyos_snmp_server_config.cfg" def load_from_file(*args, **kwargs): output = load_fixture(filename) return output self.execute_show_command.side_effect = load_from_file def test_snmp_server_merged_idempotent(self): set_module_args( dict( config=dict( communities=[ dict( name="bridges", networks=["12.1.1.0/24", "1.1.1.0/24"], ), ], listen_addresses=[ dict(address="100.1.2.1", port=33), ], location="RDU, NC", snmp_v3=dict( users=[ dict( user="admin_user", authentication=dict(type="sha", plaintext_key="abc1234567"), privacy=dict(type="aes", plaintext_key="abc1234567"), ), dict( user="guest_user", authentication=dict(type="sha", plaintext_key="opq1234567"), privacy=dict(type="aes", plaintext_key="opq1234567"), ), ], ), ), state="merged", ), ) self.execute_module(changed=False, commands=[]) def test_snmp_server_replaced_idempotent(self): set_module_args( dict( config=dict( communities=[ dict( name="bridges", networks=["12.1.1.0/24", "1.1.1.0/24"], ), ], listen_addresses=[ dict(address="100.1.2.1", port=33), ], location="RDU, NC", snmp_v3=dict( users=[ dict( user="admin_user", authentication=dict(type="sha", plaintext_key="abc1234567"), privacy=dict(type="aes", plaintext_key="abc1234567"), ), dict( user="guest_user", authentication=dict(type="sha", plaintext_key="opq1234567"), privacy=dict(type="aes", plaintext_key="opq1234567"), ), ], ), ), state="replaced", ), ) self.execute_module(changed=False, commands=[]) def test_snmp_server_overridden_idempotent(self): set_module_args( dict( config=dict( communities=[ dict( name="bridges", networks=["12.1.1.0/24", "1.1.1.0/24"], ), ], listen_addresses=[ dict(address="100.1.2.1", port=33), ], location="RDU, NC", snmp_v3=dict( users=[ dict( user="admin_user", authentication=dict(type="sha", plaintext_key="abc1234567"), privacy=dict(type="aes", plaintext_key="abc1234567"), ), dict( user="guest_user", authentication=dict(type="sha", plaintext_key="opq1234567"), privacy=dict(type="aes", plaintext_key="opq1234567"), ), ], ), ), state="overridden", ), ) self.execute_module(changed=False, commands=[]) def test_snmp_server_merged(self): set_module_args( dict( config=dict( communities=[ dict( name="routers", clients=["12.1.1.0/24", "1.1.1.0/24"], authorization_type="rw", ), dict(name="switches", authorization_type="ro"), ], contact="admin@example.com", description="snmp_config", smux_peer="peer1", trap_source="1.1.1.1", trap_target=dict(address="10.10.1.1", community="switches", port="80"), snmp_v3=dict( engine_id="34", groups=[ dict( group="default", mode="rw", seclevel="priv", view="view1", ), ], trap_targets=[ dict( address="20.12.1.1", authentication=dict(type="sha", plaintext_key="abc1234567"), privacy=dict(type="aes", plaintext_key="abc1234567"), ), ], ), ), state="merged", ), ) commands = [ "set service snmp community routers client 1.1.1.0/24", "set service snmp community routers client 12.1.1.0/24", "set service snmp community routers authorization rw", "set service snmp community switches authorization ro", "set service snmp v3 group default mode rw", "set service snmp v3 group default seclevel priv", "set service snmp v3 group default view view1", "set service snmp v3 engineid 34", "set service snmp contact admin@example.com", "set service snmp description snmp_config", "set service snmp smux-peer peer1", "set service snmp trap-source 1.1.1.1", "set service snmp trap-target 10.10.1.1 community switches", "set service snmp trap-target 10.10.1.1 port 80", "set service snmp v3 trap-target 20.12.1.1 auth type sha", "set service snmp v3 trap-target 20.12.1.1 auth plaintext-password abc1234567", "set service snmp v3 trap-target 20.12.1.1 privacy type aes", "set service snmp v3 trap-target 20.12.1.1 privacy plaintext-password abc1234567", ] self.execute_module(changed=True, commands=commands) def test_snmp_server_replaced(self): set_module_args( dict( config=dict( communities=[ dict( name="routers", clients=["12.1.1.0/24", "1.1.1.0/24"], authorization_type="rw", ), dict(name="switches", authorization_type="ro"), ], contact="admin@example.com", description="snmp_config", smux_peer="peer1", trap_source="1.1.1.1", trap_target=dict(address="10.10.1.1", community="switches", port="80"), snmp_v3=dict( engine_id="34", groups=[ dict( group="default", mode="rw", seclevel="priv", view="view1", ), ], trap_targets=[ dict( address="20.12.1.1", authentication=dict(type="sha", plaintext_key="abc1234567"), privacy=dict(type="aes", plaintext_key="abc1234567"), ), ], ), ), state="replaced", ), ) commands = [ "set service snmp community routers client 1.1.1.0/24", "set service snmp community routers client 12.1.1.0/24", "set service snmp community routers authorization rw", "set service snmp community switches authorization ro", "delete service snmp community bridges network 1.1.1.0/24", "delete service snmp community bridges network 12.1.1.0/24", "delete service snmp listen-address 100.1.2.1 port 33", "set service snmp v3 group default mode rw", "set service snmp v3 group default seclevel priv", "set service snmp v3 group default view view1", "delete service snmp v3 user admin_user auth type sha", "delete service snmp v3 user admin_user auth plaintext-password abc1234567", "delete service snmp v3 user admin_user privacy type aes", "delete service snmp v3 user admin_user privacy plaintext-password abc1234567", "delete service snmp v3 user guest_user auth type sha", "delete service snmp v3 user guest_user auth plaintext-password opq1234567", "delete service snmp v3 user guest_user privacy type aes", "delete service snmp v3 user guest_user privacy plaintext-password opq1234567", "set service snmp v3 engineid 34", "set service snmp contact admin@example.com", "set service snmp description snmp_config", "set service snmp smux-peer peer1", "set service snmp trap-source 1.1.1.1", "set service snmp trap-target 10.10.1.1 community switches", "set service snmp trap-target 10.10.1.1 port 80", "set service snmp v3 trap-target 20.12.1.1 auth type sha", "set service snmp v3 trap-target 20.12.1.1 auth plaintext-password abc1234567", "set service snmp v3 trap-target 20.12.1.1 privacy type aes", "set service snmp v3 trap-target 20.12.1.1 privacy plaintext-password abc1234567", "delete service snmp location 'RDU, NC'", ] self.execute_module(changed=True, commands=commands) def test_snmp_server_overridden(self): set_module_args( dict( config=dict( communities=[ dict( name="routers", clients=["12.1.1.0/24", "1.1.1.0/24"], authorization_type="rw", ), dict(name="switches", authorization_type="ro"), ], contact="admin@example.com", description="snmp_config", smux_peer="peer1", trap_source="1.1.1.1", trap_target=dict(address="10.10.1.1", community="switches", port="80"), snmp_v3=dict( engine_id="34", groups=[ dict( group="default", mode="rw", seclevel="priv", view="view1", ), ], trap_targets=[ dict( address="20.12.1.1", authentication=dict(type="sha", plaintext_key="abc1234567"), privacy=dict(type="aes", plaintext_key="abc1234567"), ), ], ), ), state="overridden", ), ) commands = [ "set service snmp community routers client 1.1.1.0/24", "set service snmp community routers client 12.1.1.0/24", "set service snmp community routers authorization rw", "set service snmp community switches authorization ro", "delete service snmp community bridges network 1.1.1.0/24", "delete service snmp community bridges network 12.1.1.0/24", "delete service snmp listen-address 100.1.2.1 port 33", "set service snmp v3 group default mode rw", "set service snmp v3 group default seclevel priv", "set service snmp v3 group default view view1", "delete service snmp v3 user admin_user auth type sha", "delete service snmp v3 user admin_user auth plaintext-password abc1234567", "delete service snmp v3 user admin_user privacy type aes", "delete service snmp v3 user admin_user privacy plaintext-password abc1234567", "delete service snmp v3 user guest_user auth type sha", "delete service snmp v3 user guest_user auth plaintext-password opq1234567", "delete service snmp v3 user guest_user privacy type aes", "delete service snmp v3 user guest_user privacy plaintext-password opq1234567", "set service snmp v3 engineid 34", "set service snmp contact admin@example.com", "set service snmp description snmp_config", "set service snmp smux-peer peer1", "set service snmp trap-source 1.1.1.1", "set service snmp trap-target 10.10.1.1 community switches", "set service snmp trap-target 10.10.1.1 port 80", "set service snmp v3 trap-target 20.12.1.1 auth type sha", "set service snmp v3 trap-target 20.12.1.1 auth plaintext-password abc1234567", "set service snmp v3 trap-target 20.12.1.1 privacy type aes", "set service snmp v3 trap-target 20.12.1.1 privacy plaintext-password abc1234567", "delete service snmp location 'RDU, NC'", ] self.execute_module(changed=True, commands=commands) def test_snmp_server_deleted(self): set_module_args( dict( state="deleted", ), ) commands = ["delete service snmp"] self.execute_module(changed=True, commands=commands) def test_snmp_server_rendered(self): set_module_args( dict( config=dict( communities=[ dict( name="routers", clients=["12.1.1.0/24", "1.1.1.0/24"], authorization_type="rw", ), dict(name="switches", authorization_type="ro"), ], contact="admin@example.com", description="snmp_config", smux_peer="peer1", trap_source="1.1.1.1", trap_target=dict(address="10.10.1.1", community="switches", port="80"), snmp_v3=dict( engine_id="34", groups=[ dict( group="default", mode="rw", seclevel="priv", view="view1", ), ], trap_targets=[ dict( address="20.12.1.1", authentication=dict(type="sha", plaintext_key="abc1234567"), privacy=dict(type="aes", plaintext_key="abc1234567"), ), ], ), ), state="rendered", ), ) commands = [ "set service snmp community routers client 1.1.1.0/24", "set service snmp community routers client 12.1.1.0/24", "set service snmp community routers authorization rw", "set service snmp community switches authorization ro", "set service snmp v3 group default mode rw", "set service snmp v3 group default seclevel priv", "set service snmp v3 group default view view1", "set service snmp v3 engineid 34", "set service snmp contact admin@example.com", "set service snmp description snmp_config", "set service snmp smux-peer peer1", "set service snmp trap-source 1.1.1.1", "set service snmp trap-target 10.10.1.1 community switches", "set service snmp trap-target 10.10.1.1 port 80", "set service snmp v3 trap-target 20.12.1.1 auth type sha", "set service snmp v3 trap-target 20.12.1.1 auth plaintext-password abc1234567", "set service snmp v3 trap-target 20.12.1.1 privacy type aes", "set service snmp v3 trap-target 20.12.1.1 privacy plaintext-password abc1234567", ] result = self.execute_module(changed=False) self.assertEqual( sorted(result["rendered"]), sorted(commands), result["rendered"], ) def test_snmp_server_parsed(self): commands = [ "set service snmp community routers client 1.1.1.0/24", "set service snmp community routers client 12.1.1.0/24", "set service snmp community routers authorization rw", "set service snmp community switches authorization ro", "set service snmp v3 group default mode rw", "set service snmp v3 group default seclevel priv", "set service snmp v3 group default view view1", "set service snmp v3 engineid 34", "set service snmp contact admin@example.com", "set service snmp description snmp_config", "set service snmp smux-peer peer1", "set service snmp trap-source 1.1.1.1", "set service snmp trap-target 10.10.1.1", ] parsed_str = "\n".join(commands) set_module_args(dict(running_config=parsed_str, state="parsed")) result = self.execute_module(changed=False) parsed_list = { "communities": [ { "authorization_type": "rw", "clients": ["1.1.1.0/24", "12.1.1.0/24"], "name": "routers", }, {"authorization_type": "ro", "name": "switches"}, ], "contact": "admin@example.com", "description": "snmp_config", "smux_peer": "peer1", "snmp_v3": { "engine_id": "34", "groups": [ { "group": "default", "mode": "rw", "seclevel": "priv", "view": "view1", }, ], }, "trap_source": "1.1.1.1", "trap_targets": [{"address": "10.10.1.1"}], } self.assertEqual(parsed_list, result["parsed"]) def test_snmp_server_gathered(self): set_module_args(dict(state="gathered")) result = self.execute_module(changed=False) gathered_list = { "communities": [ {"name": "bridges", "networks": ["1.1.1.0/24", "12.1.1.0/24"]}, ], "listen_addresses": [{"address": "100.1.2.1", "port": 33}], "location": "RDU, NC", "snmp_v3": { "users": [ { "authentication": { "plaintext_key": "abc1234567", "type": "sha", }, "privacy": { "plaintext_key": "abc1234567", "type": "aes", }, "user": "admin_user", }, { "authentication": { "plaintext_key": "opq1234567", "type": "sha", }, "privacy": { "plaintext_key": "opq1234567", "type": "aes", }, "user": "guest_user", }, ], }, } self.assertEqual(gathered_list, result["gathered"]) def test_snmp_server_v3_trap_target_options_rendered(self): set_module_args( dict( config=dict( snmp_v3=dict( trap_targets=[ dict( address="192.0.2.20", port=1162, protocol="udp", type="inform", user="trapuser", ), ], ), ), state="rendered", ), ) self.assertEqual( sorted(self.execute_module(changed=False)["rendered"]), [ "set service snmp v3 trap-target 192.0.2.20 port 1162", "set service snmp v3 trap-target 192.0.2.20 protocol udp", "set service snmp v3 trap-target 192.0.2.20 type inform", "set service snmp v3 trap-target 192.0.2.20 user trapuser", ], ) def test_snmp_server_v3_trap_target_options_parsed(self): set_module_args( dict( running_config="set service snmp v3 trap-target 192.0.2.20 port '1162'\n" "set service snmp v3 trap-target 192.0.2.20 protocol 'udp'\n" "set service snmp v3 trap-target 192.0.2.20 type 'inform'\n" "set service snmp v3 trap-target 192.0.2.20 user 'trapuser'", state="parsed", ), ) self.assertEqual( self.execute_module(changed=False)["parsed"], { "snmp_v3": { "trap_targets": [ { "address": "192.0.2.20", "port": 1162, "protocol": "udp", "type": "inform", "user": "trapuser", }, ], }, }, ) def test_snmp_server_trap_targets_rendered(self): set_module_args( dict( config=dict( trap_targets=[ dict(address="192.0.2.10", community="public", port=1162), dict(address="192.0.2.11", community="private"), ], ), state="rendered", ), ) self.assertEqual( sorted(self.execute_module(changed=False)["rendered"]), [ "set service snmp trap-target 192.0.2.10 community public", "set service snmp trap-target 192.0.2.10 port 1162", "set service snmp trap-target 192.0.2.11 community private", ], ) def test_snmp_server_trap_targets_replaced(self): set_module_args( dict( config=dict(trap_targets=[dict(address="192.0.2.10", community="public")]), state="replaced", ), ) self.execute_module( changed=True, commands=[ "delete service snmp trap-target 192.0.2.11", "delete service snmp trap-target 192.0.2.10 port 1162", ], filename="vyos_snmp_server_trap_targets_config.cfg", ) + + def test_snmp_server_v3_user_mode_parsed(self): + set_module_args( + dict(running_config="set service snmp v3 user u1 mode 'ro'", state="parsed"), + ) + self.assertEqual( + self.execute_module(changed=False)["parsed"], + {"snmp_v3": {"users": [{"user": "u1", "mode": "ro"}]}}, + ) + + def test_snmp_server_v3_view_exclude_and_mask_rendered(self): + set_module_args( + dict( + config=dict( + snmp_v3=dict( + views=[dict(view="v1", oid="1.3.6", exclude="1.3.6.1", mask="ff")], + ), + ), + state="rendered", + ), + ) + self.assertEqual( + sorted(self.execute_module(changed=False)["rendered"]), + [ + "set service snmp v3 view v1 oid 1.3.6", + "set service snmp v3 view v1 oid 1.3.6 exclude 1.3.6.1", + "set service snmp v3 view v1 oid 1.3.6 mask ff", + ], + )