1335 lines
43 KiB
Python
1335 lines
43 KiB
Python
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# (c) 2017, Ansible by Red Hat, inc
|
|
# 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
|
|
|
|
|
|
DOCUMENTATION = """
|
|
module: iosxr_logging
|
|
author:
|
|
- Trishna Guha (@trishnaguha)
|
|
- Kedar Kekan (@kedarX)
|
|
short_description: Configuration management of system logging services on network
|
|
devices
|
|
description:
|
|
- This module provides declarative management configuration of system logging (syslog)
|
|
on Cisco IOS XR devices.
|
|
version_added: 1.0.0
|
|
deprecated:
|
|
alternative: iosxr_logging_global
|
|
why: Updated module released with more functionality.
|
|
removed_at_date: '2023-08-01'
|
|
requirements:
|
|
- ncclient >= 0.5.3 when using netconf
|
|
- lxml >= 4.1.1 when using netconf
|
|
notes:
|
|
- This module works with connection C(network_cli) and C(netconf). See L(the IOS-XR
|
|
Platform Options,../network/user_guide/platform_iosxr.html).
|
|
options:
|
|
dest:
|
|
description:
|
|
- Destination for system logging (syslog) messages.
|
|
choices:
|
|
- host
|
|
- console
|
|
- monitor
|
|
- buffered
|
|
- file
|
|
type: str
|
|
name:
|
|
description:
|
|
- When C(dest) = I(file) name indicates file-name
|
|
- When C(dest) = I(host) name indicates the host-name or ip-address of syslog
|
|
server.
|
|
type: str
|
|
vrf:
|
|
description:
|
|
- vrf name when syslog server is configured, C(dest) = C(host)
|
|
type: str
|
|
default: default
|
|
size:
|
|
description:
|
|
- Size of buffer when C(dest) = C(buffered). The acceptable value is in the range
|
|
I(307200 to 125000000 bytes). Default 307200
|
|
- Size of file when C(dest) = C(file). The acceptable value is in the range I(1
|
|
to 2097152)KB. Default 2 GB
|
|
type: int
|
|
facility:
|
|
description:
|
|
- To configure the type of syslog facility in which system logging (syslog) messages
|
|
are sent to syslog servers Optional config for C(dest) = C(host)
|
|
default: local7
|
|
type: str
|
|
hostnameprefix:
|
|
description:
|
|
- To append a hostname prefix to system logging (syslog) messages logged to syslog
|
|
servers. Optional config for C(dest) = C(host)
|
|
type: str
|
|
level:
|
|
description:
|
|
- Specifies the severity level for the logging.
|
|
type: str
|
|
default: debugging
|
|
aliases:
|
|
- severity
|
|
choices: ["emergencies", "alerts", "critical", "errors", "warning", "notifications", "informational", "debugging"]
|
|
path:
|
|
description:
|
|
Set file path.
|
|
type: str
|
|
aggregate:
|
|
description: List of syslog logging configuration definitions.
|
|
type: list
|
|
elements: dict
|
|
suboptions:
|
|
dest:
|
|
description:
|
|
- Destination for system logging (syslog) messages.
|
|
choices:
|
|
- host
|
|
- console
|
|
- monitor
|
|
- buffered
|
|
- file
|
|
type: str
|
|
name:
|
|
description:
|
|
- When C(dest) = I(file) name indicates file-name
|
|
- When C(dest) = I(host) name indicates the host-name or ip-address of syslog
|
|
server.
|
|
type: str
|
|
path:
|
|
description:
|
|
Set file path.
|
|
type: str
|
|
vrf:
|
|
description:
|
|
- vrf name when syslog server is configured, C(dest) = C(host)
|
|
type: str
|
|
size:
|
|
description:
|
|
- Size of buffer when C(dest) = C(buffered). The acceptable value is in the range
|
|
I(307200 to 125000000 bytes). Default 307200
|
|
- Size of file when C(dest) = C(file). The acceptable value is in the range I(1
|
|
to 2097152)KB. Default 2 GB
|
|
type: int
|
|
facility:
|
|
description:
|
|
- To configure the type of syslog facility in which system logging (syslog) messages
|
|
are sent to syslog servers Optional config for C(dest) = C(host)
|
|
type: str
|
|
hostnameprefix:
|
|
description:
|
|
- To append a hostname prefix to system logging (syslog) messages logged to syslog
|
|
servers. Optional config for C(dest) = C(host)
|
|
type: str
|
|
level:
|
|
description:
|
|
- Specifies the severity level for the logging.
|
|
type: str
|
|
aliases:
|
|
- severity
|
|
choices: ["emergencies", "alerts", "critical", "errors", "warning", "notifications", "informational", "debugging"]
|
|
state:
|
|
description:
|
|
- Existential state of the logging configuration on the node.
|
|
choices:
|
|
- present
|
|
- absent
|
|
type: str
|
|
state:
|
|
description:
|
|
- Existential state of the logging configuration on the node.
|
|
default: present
|
|
choices:
|
|
- present
|
|
- absent
|
|
type: str
|
|
extends_documentation_fragment:
|
|
- cisco.iosxr.iosxr
|
|
"""
|
|
|
|
EXAMPLES = """
|
|
- name: configure logging for syslog server host
|
|
cisco.iosxr.iosxr_logging:
|
|
dest: host
|
|
name: 10.10.10.1
|
|
level: critical
|
|
state: present
|
|
|
|
- name: add hostnameprefix configuration
|
|
cisco.iosxr.iosxr_logging:
|
|
hostnameprefix: host1
|
|
state: absent
|
|
|
|
- name: add facility configuration
|
|
cisco.iosxr.iosxr_logging:
|
|
facility: local1
|
|
state: present
|
|
|
|
- name: configure console logging level
|
|
cisco.iosxr.iosxr_logging:
|
|
dest: console
|
|
level: debugging
|
|
state: present
|
|
|
|
- name: configure monitor logging level
|
|
cisco.iosxr.iosxr_logging:
|
|
dest: monitor
|
|
level: errors
|
|
state: present
|
|
|
|
- name: configure syslog to a file
|
|
cisco.iosxr.iosxr_logging:
|
|
dest: file
|
|
name: file_name
|
|
size: 2048
|
|
level: errors
|
|
state: present
|
|
|
|
- name: configure buffered logging with size
|
|
cisco.iosxr.iosxr_logging:
|
|
dest: buffered
|
|
size: 5100000
|
|
|
|
- name: Configure logging using aggregate
|
|
cisco.iosxr.iosxr_logging:
|
|
aggregate:
|
|
- {dest: console, level: warning}
|
|
- {dest: buffered, size: 4800000}
|
|
- {dest: file, name: file3, size: 2048}
|
|
- {dest: host, name: host3, level: critical}
|
|
|
|
- name: Delete logging using aggregate
|
|
cisco.iosxr.iosxr_logging:
|
|
aggregate:
|
|
- {dest: console, level: warning}
|
|
- {dest: buffered, size: 4800000}
|
|
- {dest: file, name: file3, size: 2048}
|
|
- {dest: host, name: host3, level: critical}
|
|
state: absent
|
|
"""
|
|
|
|
RETURN = """
|
|
commands:
|
|
description: The list of configuration mode commands to send to the device
|
|
returned: always (empty list when no commands to send)
|
|
type: list
|
|
sample:
|
|
- logging 10.10.10.1 vrf default severity debugging
|
|
- logging facility local7
|
|
- logging hostnameprefix host1
|
|
- logging console critical
|
|
- logging buffered 2097153
|
|
- logging buffered warnings
|
|
- logging monitor errors
|
|
- logging file log_file maxfilesize 1024 severity info
|
|
xml:
|
|
description: NetConf rpc xml sent to device with transport C(netconf)
|
|
returned: always (empty list when no xml rpc to send)
|
|
type: list
|
|
sample:
|
|
- '<config xmlns:xc="urn:ietf:params:xml:ns:netconf:base:1.0">
|
|
<syslog xmlns="http://cisco.com/ns/yang/Cisco-IOS-XR-infra-syslog-cfg">
|
|
<files>
|
|
<file xc:operation="delete">
|
|
<file-name>file1</file-name>
|
|
<file-log-attributes>
|
|
<max-file-size>2097152</max-file-size>
|
|
<severity>2</severity>
|
|
</file-log-attributes>
|
|
</file>
|
|
</files>
|
|
</syslog>
|
|
</config>'
|
|
"""
|
|
|
|
import re
|
|
import collections
|
|
from copy import deepcopy
|
|
from distutils.version import LooseVersion
|
|
|
|
from ansible.module_utils._text import to_text
|
|
from ansible.module_utils.basic import AnsibleModule
|
|
from ansible_collections.cisco.iosxr.plugins.module_utils.network.iosxr.iosxr import (
|
|
get_config,
|
|
load_config,
|
|
build_xml,
|
|
get_capabilities,
|
|
get_os_version,
|
|
)
|
|
from ansible_collections.cisco.iosxr.plugins.module_utils.network.iosxr.iosxr import (
|
|
iosxr_argument_spec,
|
|
etree_findall,
|
|
)
|
|
from ansible_collections.cisco.iosxr.plugins.module_utils.network.iosxr.iosxr import (
|
|
is_netconf,
|
|
is_cliconf,
|
|
etree_find,
|
|
)
|
|
from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import (
|
|
remove_default_spec,
|
|
)
|
|
|
|
|
|
severity_level = {
|
|
"emergency": "0",
|
|
"alert": "1",
|
|
"critical": "2",
|
|
"error": "3",
|
|
"warning": "4",
|
|
"notice": "5",
|
|
"info": "6",
|
|
"debug": "7",
|
|
"disable": "15",
|
|
}
|
|
|
|
severity_transpose = {
|
|
"emergencies": "emergency",
|
|
"alerts": "alert",
|
|
"critical": "critical",
|
|
"errors": "error",
|
|
"warning": "warning",
|
|
"notifications": "notice",
|
|
"informational": "info",
|
|
"debugging": "debug",
|
|
}
|
|
|
|
|
|
class ConfigBase(object):
|
|
def __init__(self, module):
|
|
self._flag = None
|
|
self._module = module
|
|
self._result = {"changed": False, "warnings": []}
|
|
self._want = list()
|
|
self._have = list()
|
|
|
|
def validate_size(self, value, type=None):
|
|
if value:
|
|
if type == "buffer":
|
|
if value and not int(307200) <= value <= int(125000000):
|
|
self._module.fail_json(
|
|
msg="buffer size must be between 307200 and 125000000"
|
|
)
|
|
elif type == "file":
|
|
if value and not int(1) <= value <= int(2097152):
|
|
self._module.fail_json(
|
|
msg="file size must be between 1 and 2097152"
|
|
)
|
|
return value
|
|
|
|
def map_params_to_obj(self, required_if=None):
|
|
aggregate = self._module.params.get("aggregate")
|
|
if aggregate:
|
|
for item in aggregate:
|
|
for key in item:
|
|
if item.get(key) is None:
|
|
item[key] = self._module.params[key]
|
|
|
|
d = item.copy()
|
|
|
|
if d["dest"] not in ("host", "file"):
|
|
d["name"] = None
|
|
|
|
if d["dest"] == "buffered":
|
|
if d["size"] is not None:
|
|
d["size"] = str(
|
|
self.validate_size(d["size"], "buffer")
|
|
)
|
|
else:
|
|
d["size"] = str(307200)
|
|
elif d["dest"] == "file":
|
|
if d["size"] is not None:
|
|
d["size"] = str(self.validate_size(d["size"], "file"))
|
|
else:
|
|
d["size"] = str(2097152)
|
|
else:
|
|
d["size"] = None
|
|
|
|
if self._flag == "NC":
|
|
d["level"] = severity_transpose[d["level"]]
|
|
|
|
self._want.append(d)
|
|
|
|
else:
|
|
params = self._module.params
|
|
if params["dest"] not in ("host", "file"):
|
|
params["name"] = None
|
|
|
|
if params["dest"] == "buffered":
|
|
if params["size"] is not None:
|
|
params["size"] = str(
|
|
self.validate_size(params["size"], "buffer")
|
|
)
|
|
else:
|
|
params["size"] = str(307200)
|
|
elif params["dest"] == "file":
|
|
if params["size"] is not None:
|
|
params["size"] = str(
|
|
self.validate_size(params["size"], "file")
|
|
)
|
|
else:
|
|
params["size"] = str(2097152)
|
|
else:
|
|
params["size"] = None
|
|
|
|
if self._flag == "NC":
|
|
params["level"] = severity_transpose[params["level"]]
|
|
|
|
self._want.append(
|
|
{
|
|
"dest": params["dest"],
|
|
"name": params["name"],
|
|
"vrf": params["vrf"],
|
|
"size": params["size"],
|
|
"path": params["path"],
|
|
"facility": params["facility"],
|
|
"level": params["level"],
|
|
"hostnameprefix": params["hostnameprefix"],
|
|
"state": params["state"],
|
|
}
|
|
)
|
|
|
|
|
|
class CliConfiguration(ConfigBase):
|
|
def __init__(self, module):
|
|
super(CliConfiguration, self).__init__(module)
|
|
self._file_list = set()
|
|
self._host_list = set()
|
|
|
|
def map_obj_to_commands(self, os_version):
|
|
commands = list()
|
|
for want_item in self._want:
|
|
dest = want_item["dest"]
|
|
name = want_item["name"]
|
|
size = want_item["size"]
|
|
path = want_item["path"]
|
|
facility = want_item["facility"]
|
|
level = want_item["level"]
|
|
vrf = want_item["vrf"]
|
|
hostnameprefix = want_item["hostnameprefix"]
|
|
state = want_item["state"]
|
|
del want_item["state"]
|
|
|
|
have_size = None
|
|
have_console_level = None
|
|
have_monitor_level = None
|
|
have_prefix = None
|
|
have_facility = None
|
|
|
|
for item in self._have:
|
|
if item["dest"] == "buffered":
|
|
have_size = item["size"]
|
|
if item["dest"] == "console":
|
|
have_console_level = item["level"]
|
|
if item["dest"] == "monitor":
|
|
have_monitor_level = item["level"]
|
|
if item["dest"] is None and item["hostnameprefix"] is not None:
|
|
have_prefix = item["hostnameprefix"]
|
|
if (
|
|
item["dest"] is None
|
|
and item["hostnameprefix"] is None
|
|
and item["facility"] is not None
|
|
):
|
|
have_facility = item["facility"]
|
|
|
|
if state == "absent":
|
|
if dest == "host" and name in self._host_list:
|
|
commands.append("no logging {0} vrf {1}".format(name, vrf))
|
|
elif dest == "file" and name in self._file_list:
|
|
commands.append("no logging file {0}".format(name))
|
|
elif dest == "console" and have_console_level is not None:
|
|
commands.append("no logging {0}".format(dest))
|
|
elif dest == "monitor" and have_monitor_level:
|
|
commands.append("no logging {0}".format(dest))
|
|
elif dest == "buffered" and have_size:
|
|
commands.append("no logging {0}".format(dest))
|
|
|
|
if (
|
|
dest is None
|
|
and hostnameprefix is not None
|
|
and have_prefix == hostnameprefix
|
|
):
|
|
commands.append(
|
|
"no logging hostnameprefix {0}".format(hostnameprefix)
|
|
)
|
|
if (
|
|
dest is None
|
|
and facility is not None
|
|
and have_facility == facility
|
|
):
|
|
commands.append("no logging facility {0}".format(facility))
|
|
|
|
if state == "present":
|
|
if dest == "host" and name not in self._host_list:
|
|
if level == "errors" or level == "informational":
|
|
level = severity_transpose[level]
|
|
commands.append(
|
|
"logging {0} vrf {1} severity {2}".format(
|
|
name, vrf, level
|
|
)
|
|
)
|
|
elif dest == "file" and name not in self._file_list:
|
|
if level == "errors" or level == "informational":
|
|
level = severity_transpose[level]
|
|
if os_version and LooseVersion(os_version) > LooseVersion(
|
|
"7.0"
|
|
):
|
|
commands.append(
|
|
"logging file {0} path {1} maxfilesize {2} severity {3}".format(
|
|
name, path, size, level
|
|
)
|
|
)
|
|
else:
|
|
commands.append(
|
|
"logging file {0} maxfilesize {1} severity {2}".format(
|
|
name, size, level
|
|
)
|
|
)
|
|
elif dest == "buffered" and (
|
|
have_size is None
|
|
or (have_size is not None and size != have_size)
|
|
):
|
|
commands.append("logging buffered {0}".format(size))
|
|
elif dest == "console" and (
|
|
have_console_level is None
|
|
or (
|
|
have_console_level is not None
|
|
and have_console_level != level
|
|
)
|
|
):
|
|
commands.append("logging console {0}".format(level))
|
|
elif dest == "monitor" and (
|
|
have_monitor_level is None
|
|
or (
|
|
have_monitor_level is not None
|
|
and have_monitor_level != level
|
|
)
|
|
):
|
|
commands.append("logging monitor {0}".format(level))
|
|
|
|
if (
|
|
dest is None
|
|
and hostnameprefix is not None
|
|
and (
|
|
have_prefix is None
|
|
or (
|
|
have_prefix is not None
|
|
and hostnameprefix != have_prefix
|
|
)
|
|
)
|
|
):
|
|
commands.append(
|
|
"logging hostnameprefix {0}".format(hostnameprefix)
|
|
)
|
|
if (
|
|
dest is None
|
|
and hostnameprefix is None
|
|
and facility != have_facility
|
|
):
|
|
commands.append("logging facility {0}".format(facility))
|
|
|
|
self._result["commands"] = commands
|
|
if commands:
|
|
commit = not self._module.check_mode
|
|
diff = load_config(self._module, commands, commit=commit)
|
|
if diff:
|
|
self._result["diff"] = dict(prepared=diff)
|
|
self._result["changed"] = True
|
|
|
|
def parse_facility(self, line):
|
|
match = re.search(r"logging facility (\S+)", line, re.M)
|
|
facility = None
|
|
if match:
|
|
facility = match.group(1)
|
|
|
|
return facility
|
|
|
|
def parse_size(self, line, dest):
|
|
size = None
|
|
|
|
if dest == "buffered":
|
|
match = re.search(r"logging buffered (\S+)", line, re.M)
|
|
if match:
|
|
try:
|
|
int_size = int(match.group(1))
|
|
except ValueError:
|
|
int_size = None
|
|
|
|
if int_size is not None:
|
|
if isinstance(int_size, int):
|
|
size = str(match.group(1))
|
|
if dest == "file":
|
|
match = re.search(
|
|
r"logging file (\S+) (path\s\S+\s)?maxfilesize (\S+)",
|
|
line,
|
|
re.M,
|
|
)
|
|
if match:
|
|
try:
|
|
if "path" in line:
|
|
int_size = int(match.group(2))
|
|
else:
|
|
int_size = int(match.group(1))
|
|
except ValueError:
|
|
int_size = None
|
|
|
|
if int_size is not None:
|
|
if isinstance(int_size, int):
|
|
size = str(int_size)
|
|
|
|
return size
|
|
|
|
def parse_path(self, line, dest):
|
|
path = None
|
|
|
|
if dest == "file":
|
|
match = re.search(r"logging file (\S+) (path\s\S+\s)", line, re.M)
|
|
if match:
|
|
try:
|
|
path = to_text(
|
|
match.group(2), errors="surrogate_or_strict"
|
|
)
|
|
except ValueError:
|
|
path = None
|
|
|
|
return path
|
|
|
|
def parse_hostnameprefix(self, line):
|
|
prefix = None
|
|
match = re.search(r"logging hostnameprefix (\S+)", line, re.M)
|
|
if match:
|
|
prefix = match.group(1)
|
|
return prefix
|
|
|
|
def parse_name(self, line, dest):
|
|
name = None
|
|
if dest == "file":
|
|
match = re.search(r"logging file (\S+)", line, re.M)
|
|
if match:
|
|
name = match.group(1)
|
|
elif dest == "host":
|
|
match = re.search(r"logging (\S+)", line, re.M)
|
|
if match:
|
|
name = match.group(1)
|
|
|
|
return name
|
|
|
|
def parse_level(self, line, dest):
|
|
level_group = (
|
|
"emergencies",
|
|
"alerts",
|
|
"critical",
|
|
"errors",
|
|
"warning",
|
|
"notifications",
|
|
"informational",
|
|
"debugging",
|
|
)
|
|
|
|
level = None
|
|
match = re.search(r"logging {0} (\S+)".format(dest), line, re.M)
|
|
if match:
|
|
if match.group(1) in level_group:
|
|
level = match.group(1)
|
|
|
|
return level
|
|
|
|
def parse_dest(self, line, group):
|
|
dest_group = ("console", "monitor", "buffered", "file")
|
|
dest = None
|
|
if group in dest_group:
|
|
dest = group
|
|
elif "vrf" in line:
|
|
dest = "host"
|
|
|
|
return dest
|
|
|
|
def parse_vrf(self, line, dest):
|
|
vrf = None
|
|
if dest == "host":
|
|
match = re.search(r"logging (\S+) vrf (\S+)", line, re.M)
|
|
if match:
|
|
vrf = match.group(2)
|
|
return vrf
|
|
|
|
def map_config_to_obj(self):
|
|
data = get_config(self._module, config_filter="logging")
|
|
lines = data.split("\n")
|
|
|
|
for line in lines:
|
|
match = re.search(r"logging (\S+)", line, re.M)
|
|
if match:
|
|
dest = self.parse_dest(line, match.group(1))
|
|
name = self.parse_name(line, dest)
|
|
if dest == "host" and name is not None:
|
|
self._host_list.add(name)
|
|
if dest == "file" and name is not None:
|
|
self._file_list.add(name)
|
|
|
|
self._have.append(
|
|
{
|
|
"dest": dest,
|
|
"name": name,
|
|
"size": self.parse_size(line, dest),
|
|
"path": self.parse_path(line, dest),
|
|
"facility": self.parse_facility(line),
|
|
"level": self.parse_level(line, dest),
|
|
"vrf": self.parse_vrf(line, dest),
|
|
"hostnameprefix": self.parse_hostnameprefix(line),
|
|
}
|
|
)
|
|
|
|
def run(self, os_version):
|
|
self.map_params_to_obj()
|
|
self.map_config_to_obj()
|
|
self.map_obj_to_commands(os_version)
|
|
|
|
return self._result
|
|
|
|
|
|
class NCConfiguration(ConfigBase):
|
|
def __init__(self, module):
|
|
super(NCConfiguration, self).__init__(module)
|
|
self._flag = "NC"
|
|
self._log_file_meta = collections.OrderedDict()
|
|
self._log_host_meta = collections.OrderedDict()
|
|
self._log_console_meta = collections.OrderedDict()
|
|
self._log_monitor_meta = collections.OrderedDict()
|
|
self._log_buffered_meta = collections.OrderedDict()
|
|
self._log_facility_meta = collections.OrderedDict()
|
|
self._log_prefix_meta = collections.OrderedDict()
|
|
|
|
def map_obj_to_xml_rpc(self, os_version):
|
|
file_attribute_path = "file-log-attributes"
|
|
if os_version and LooseVersion(os_version) > LooseVersion("7.0.0"):
|
|
file_attribute_path = "file-specification"
|
|
self._log_file_meta.update(
|
|
[
|
|
(
|
|
"files",
|
|
{
|
|
"xpath": "syslog/files",
|
|
"tag": True,
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"file",
|
|
{
|
|
"xpath": "syslog/files/file",
|
|
"tag": True,
|
|
"operation": "edit",
|
|
"attrib": "operation",
|
|
},
|
|
),
|
|
(
|
|
"a:name",
|
|
{
|
|
"xpath": "syslog/files/file/file-name",
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"file-attrib",
|
|
{
|
|
"xpath": "syslog/files/file/"
|
|
+ file_attribute_path,
|
|
"tag": True,
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"a:size",
|
|
{
|
|
"xpath": "syslog/files/file/"
|
|
+ file_attribute_path
|
|
+ "/max-file-size",
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"a:level",
|
|
{
|
|
"xpath": "syslog/files/file/"
|
|
+ file_attribute_path
|
|
+ "/severity",
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"a:path",
|
|
{
|
|
"xpath": "syslog/files/file/"
|
|
+ file_attribute_path
|
|
+ "/path",
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
]
|
|
)
|
|
else:
|
|
self._log_file_meta.update(
|
|
[
|
|
(
|
|
"files",
|
|
{
|
|
"xpath": "syslog/files",
|
|
"tag": True,
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"file",
|
|
{
|
|
"xpath": "syslog/files/file",
|
|
"tag": True,
|
|
"operation": "edit",
|
|
"attrib": "operation",
|
|
},
|
|
),
|
|
(
|
|
"a:name",
|
|
{
|
|
"xpath": "syslog/files/file/file-name",
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"file-attrib",
|
|
{
|
|
"xpath": "syslog/files/file/"
|
|
+ file_attribute_path,
|
|
"tag": True,
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"a:size",
|
|
{
|
|
"xpath": "syslog/files/file/"
|
|
+ file_attribute_path
|
|
+ "/max-file-size",
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"a:level",
|
|
{
|
|
"xpath": "syslog/files/file/"
|
|
+ file_attribute_path
|
|
+ "/severity",
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
]
|
|
)
|
|
self._log_host_meta.update(
|
|
[
|
|
(
|
|
"host-server",
|
|
{
|
|
"xpath": "syslog/host-server",
|
|
"tag": True,
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"vrfs",
|
|
{
|
|
"xpath": "syslog/host-server/vrfs",
|
|
"tag": True,
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"vrf",
|
|
{
|
|
"xpath": "syslog/host-server/vrfs/vrf",
|
|
"tag": True,
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"a:vrf",
|
|
{
|
|
"xpath": "syslog/host-server/vrfs/vrf/vrf-name",
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"ipv4s",
|
|
{
|
|
"xpath": "syslog/host-server/vrfs/vrf/ipv4s",
|
|
"tag": True,
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"ipv4",
|
|
{
|
|
"xpath": "syslog/host-server/vrfs/vrf/ipv4s/ipv4",
|
|
"tag": True,
|
|
"operation": "edit",
|
|
"attrib": "operation",
|
|
},
|
|
),
|
|
(
|
|
"a:name",
|
|
{
|
|
"xpath": "syslog/host-server/vrfs/vrf/ipv4s/ipv4/address",
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"ipv4-sev",
|
|
{
|
|
"xpath": "syslog/host-server/vrfs/vrf/ipv4s/ipv4/ipv4-severity-port",
|
|
"tag": True,
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"a:level",
|
|
{
|
|
"xpath": "syslog/host-server/vrfs/vrf/ipv4s/ipv4/ipv4-severity-port/severity",
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
]
|
|
)
|
|
self._log_console_meta.update(
|
|
[
|
|
(
|
|
"a:enable-console",
|
|
{
|
|
"xpath": "syslog/enable-console-logging",
|
|
"operation": "edit",
|
|
"attrib": "operation",
|
|
},
|
|
),
|
|
(
|
|
"console",
|
|
{
|
|
"xpath": "syslog/console-logging",
|
|
"tag": True,
|
|
"operation": "edit",
|
|
"attrib": "operation",
|
|
},
|
|
),
|
|
(
|
|
"a:console-level",
|
|
{
|
|
"xpath": "syslog/console-logging/logging-level",
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
]
|
|
)
|
|
self._log_monitor_meta.update(
|
|
[
|
|
(
|
|
"monitor",
|
|
{
|
|
"xpath": "syslog/monitor-logging",
|
|
"tag": True,
|
|
"operation": "edit",
|
|
"attrib": "operation",
|
|
},
|
|
),
|
|
(
|
|
"a:monitor-level",
|
|
{
|
|
"xpath": "syslog/monitor-logging/logging-level",
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
]
|
|
)
|
|
self._log_buffered_meta.update(
|
|
[
|
|
(
|
|
"buffered",
|
|
{
|
|
"xpath": "syslog/buffered-logging",
|
|
"tag": True,
|
|
"operation": "edit",
|
|
"attrib": "operation",
|
|
},
|
|
),
|
|
(
|
|
"a:size",
|
|
{
|
|
"xpath": "syslog/buffered-logging/buffer-size",
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
(
|
|
"a:level",
|
|
{
|
|
"xpath": "syslog/buffered-logging/logging-level",
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
]
|
|
)
|
|
self._log_facility_meta.update(
|
|
[
|
|
(
|
|
"facility",
|
|
{
|
|
"xpath": "syslog/logging-facilities",
|
|
"tag": True,
|
|
"operation": "edit",
|
|
"attrib": "operation",
|
|
},
|
|
),
|
|
(
|
|
"a:facility",
|
|
{
|
|
"xpath": "syslog/logging-facilities/facility-level",
|
|
"operation": "edit",
|
|
},
|
|
),
|
|
]
|
|
)
|
|
self._log_prefix_meta.update(
|
|
[
|
|
(
|
|
"a:hostnameprefix",
|
|
{
|
|
"xpath": "syslog/host-name-prefix",
|
|
"operation": "edit",
|
|
"attrib": "operation",
|
|
},
|
|
)
|
|
]
|
|
)
|
|
|
|
state = self._module.params["state"]
|
|
|
|
_get_filter = build_xml("syslog", opcode="filter")
|
|
running = get_config(
|
|
self._module, source="running", config_filter=_get_filter
|
|
)
|
|
|
|
file_ele = etree_findall(running, "file")
|
|
file_list = list()
|
|
if len(file_ele):
|
|
for file in file_ele:
|
|
file_name = etree_find(file, "file-name")
|
|
file_list.append(
|
|
file_name.text if file_name is not None else None
|
|
)
|
|
vrf_ele = etree_findall(running, "vrf")
|
|
host_list = list()
|
|
for vrf in vrf_ele:
|
|
host_ele = etree_findall(vrf, "ipv4")
|
|
for host in host_ele:
|
|
host_name = etree_find(host, "address")
|
|
host_list.append(
|
|
host_name.text if host_name is not None else None
|
|
)
|
|
|
|
console_ele = etree_find(running, "console-logging")
|
|
console_level = (
|
|
etree_find(console_ele, "logging-level")
|
|
if console_ele is not None
|
|
else None
|
|
)
|
|
have_console = (
|
|
console_level.text if console_level is not None else None
|
|
)
|
|
|
|
monitor_ele = etree_find(running, "monitor-logging")
|
|
monitor_level = (
|
|
etree_find(monitor_ele, "logging-level")
|
|
if monitor_ele is not None
|
|
else None
|
|
)
|
|
have_monitor = (
|
|
monitor_level.text if monitor_level is not None else None
|
|
)
|
|
|
|
buffered_ele = etree_find(running, "buffered-logging")
|
|
buffered_size = (
|
|
etree_find(buffered_ele, "buffer-size")
|
|
if buffered_ele is not None
|
|
else None
|
|
)
|
|
have_buffered = (
|
|
buffered_size.text if buffered_size is not None else None
|
|
)
|
|
|
|
facility_ele = etree_find(running, "logging-facilities")
|
|
facility_level = (
|
|
etree_find(facility_ele, "facility-level")
|
|
if facility_ele is not None
|
|
else None
|
|
)
|
|
have_facility = (
|
|
facility_level.text if facility_level is not None else None
|
|
)
|
|
|
|
prefix_ele = etree_find(running, "host-name-prefix")
|
|
have_prefix = prefix_ele.text if prefix_ele is not None else None
|
|
|
|
file_params = list()
|
|
host_params = list()
|
|
console_params = dict()
|
|
monitor_params = dict()
|
|
buffered_params = dict()
|
|
facility_params = dict()
|
|
prefix_params = dict()
|
|
|
|
opcode = None
|
|
if state == "absent":
|
|
opcode = "delete"
|
|
for item in self._want:
|
|
if item["dest"] == "file" and item["name"] in file_list:
|
|
item["level"] = severity_level[item["level"]]
|
|
file_params.append(item)
|
|
elif item["dest"] == "host" and item["name"] in host_list:
|
|
item["level"] = severity_level[item["level"]]
|
|
host_params.append(item)
|
|
elif item["dest"] == "console" and have_console:
|
|
console_params.update({"console-level": item["level"]})
|
|
elif item["dest"] == "monitor" and have_monitor:
|
|
monitor_params.update({"monitor-level": item["level"]})
|
|
elif item["dest"] == "buffered" and have_buffered:
|
|
buffered_params["size"] = (
|
|
str(item["size"]) if item["size"] else None
|
|
)
|
|
buffered_params["level"] = (
|
|
item["level"] if item["level"] else None
|
|
)
|
|
elif (
|
|
item["dest"] is None
|
|
and item["hostnameprefix"] is None
|
|
and item["facility"] is not None
|
|
and have_facility
|
|
):
|
|
facility_params.update({"facility": item["facility"]})
|
|
elif (
|
|
item["dest"] is None
|
|
and item["hostnameprefix"] is not None
|
|
and have_prefix
|
|
):
|
|
prefix_params.update(
|
|
{"hostnameprefix": item["hostnameprefix"]}
|
|
)
|
|
elif state == "present":
|
|
opcode = "merge"
|
|
for item in self._want:
|
|
if item["dest"] == "file":
|
|
item["level"] = severity_level[item["level"]]
|
|
file_params.append(item)
|
|
elif item["dest"] == "host":
|
|
item["level"] = severity_level[item["level"]]
|
|
host_params.append(item)
|
|
elif item["dest"] == "console":
|
|
console_params.update({"console-level": item["level"]})
|
|
elif item["dest"] == "monitor":
|
|
monitor_params.update({"monitor-level": item["level"]})
|
|
elif item["dest"] == "buffered":
|
|
buffered_params["size"] = (
|
|
str(item["size"]) if item["size"] else None
|
|
)
|
|
buffered_params["level"] = (
|
|
item["level"] if item["level"] else None
|
|
)
|
|
elif (
|
|
item["dest"] is None
|
|
and item["hostnameprefix"] is None
|
|
and item["facility"] is not None
|
|
):
|
|
facility_params.update({"facility": item["facility"]})
|
|
elif (
|
|
item["dest"] is None and item["hostnameprefix"] is not None
|
|
):
|
|
prefix_params.update(
|
|
{"hostnameprefix": item["hostnameprefix"]}
|
|
)
|
|
|
|
self._result["xml"] = []
|
|
_edit_filter_list = list()
|
|
if opcode:
|
|
if len(file_params):
|
|
_edit_filter_list.append(
|
|
build_xml(
|
|
"syslog",
|
|
xmap=self._log_file_meta,
|
|
params=file_params,
|
|
opcode=opcode,
|
|
)
|
|
)
|
|
if len(host_params):
|
|
_edit_filter_list.append(
|
|
build_xml(
|
|
"syslog",
|
|
xmap=self._log_host_meta,
|
|
params=host_params,
|
|
opcode=opcode,
|
|
)
|
|
)
|
|
if len(console_params):
|
|
_edit_filter_list.append(
|
|
build_xml(
|
|
"syslog",
|
|
xmap=self._log_console_meta,
|
|
params=console_params,
|
|
opcode=opcode,
|
|
)
|
|
)
|
|
if len(monitor_params):
|
|
_edit_filter_list.append(
|
|
build_xml(
|
|
"syslog",
|
|
xmap=self._log_monitor_meta,
|
|
params=monitor_params,
|
|
opcode=opcode,
|
|
)
|
|
)
|
|
if len(buffered_params):
|
|
_edit_filter_list.append(
|
|
build_xml(
|
|
"syslog",
|
|
xmap=self._log_buffered_meta,
|
|
params=buffered_params,
|
|
opcode=opcode,
|
|
)
|
|
)
|
|
if len(facility_params):
|
|
_edit_filter_list.append(
|
|
build_xml(
|
|
"syslog",
|
|
xmap=self._log_facility_meta,
|
|
params=facility_params,
|
|
opcode=opcode,
|
|
)
|
|
)
|
|
if len(prefix_params):
|
|
_edit_filter_list.append(
|
|
build_xml(
|
|
"syslog",
|
|
xmap=self._log_prefix_meta,
|
|
params=prefix_params,
|
|
opcode=opcode,
|
|
)
|
|
)
|
|
|
|
diff = None
|
|
if len(_edit_filter_list):
|
|
commit = not self._module.check_mode
|
|
diff = load_config(
|
|
self._module,
|
|
_edit_filter_list,
|
|
commit=commit,
|
|
running=running,
|
|
nc_get_filter=_get_filter,
|
|
)
|
|
if diff:
|
|
if self._module._diff:
|
|
self._result["diff"] = dict(prepared=diff)
|
|
|
|
self._result["xml"] = _edit_filter_list
|
|
self._result["changed"] = True
|
|
|
|
def run(self, os_version):
|
|
self.map_params_to_obj()
|
|
self.map_obj_to_xml_rpc(os_version)
|
|
|
|
return self._result
|
|
|
|
|
|
def main():
|
|
""" main entry point for module execution
|
|
"""
|
|
element_spec = dict(
|
|
dest=dict(
|
|
type="str",
|
|
choices=["host", "console", "monitor", "buffered", "file"],
|
|
),
|
|
name=dict(type="str"),
|
|
size=dict(type="int"),
|
|
path=dict(type="str"),
|
|
vrf=dict(type="str", default="default"),
|
|
facility=dict(type="str", default="local7"),
|
|
hostnameprefix=dict(type="str"),
|
|
level=dict(
|
|
type="str",
|
|
default="debugging",
|
|
aliases=["severity"],
|
|
choices=[
|
|
"emergencies",
|
|
"alerts",
|
|
"critical",
|
|
"errors",
|
|
"warning",
|
|
"notifications",
|
|
"informational",
|
|
"debugging",
|
|
],
|
|
),
|
|
state=dict(default="present", choices=["present", "absent"]),
|
|
)
|
|
|
|
aggregate_spec = deepcopy(element_spec)
|
|
|
|
# remove default in aggregate spec, to handle common arguments
|
|
remove_default_spec(aggregate_spec)
|
|
|
|
mutually_exclusive = [("dest", "facility", "hostnameprefix")]
|
|
|
|
required_if = [
|
|
("dest", "host", ["name"]),
|
|
("dest", "file", ["name"]),
|
|
("dest", "buffered", ["size"]),
|
|
("dest", "console", ["level"]),
|
|
("dest", "monitor", ["level"]),
|
|
]
|
|
|
|
argument_spec = dict(
|
|
aggregate=dict(
|
|
type="list",
|
|
elements="dict",
|
|
options=aggregate_spec,
|
|
mutually_exclusive=mutually_exclusive,
|
|
required_if=required_if,
|
|
)
|
|
)
|
|
|
|
argument_spec.update(element_spec)
|
|
argument_spec.update(iosxr_argument_spec)
|
|
|
|
module = AnsibleModule(
|
|
argument_spec=argument_spec,
|
|
mutually_exclusive=mutually_exclusive,
|
|
required_if=required_if,
|
|
supports_check_mode=True,
|
|
)
|
|
config_object = None
|
|
if is_cliconf(module):
|
|
config_object = CliConfiguration(module)
|
|
os_version = get_os_version(module)
|
|
elif is_netconf(module):
|
|
config_object = NCConfiguration(module)
|
|
os_version = (
|
|
get_capabilities(module)
|
|
.get("device_info")
|
|
.get("network_os_version")
|
|
)
|
|
|
|
if config_object:
|
|
result = config_object.run(os_version)
|
|
module.exit_json(**result)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|