Current File : //lib/python3/dist-packages/sos/cleaner/preppers/__init__.py
# Copyright 2023 Red Hat, Inc. Jake Hunsaker <jhunsake@redhat.com>
# This file is part of the sos project: https://github.com/sosreport/sos
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
# version 2 of the GNU General Public License.
#
# See the LICENSE file in the source distribution for further information.
import logging
class SoSPrepper():
"""
A prepper is a way to prepare loaded mappings with selected items within
an sos report prior to beginning the full obfuscation routine.
This was previously handled directly within archives, however this is a bit
cumbersome and doesn't allow for all the flexibility we could use in this
effort.
Preppers are separated from parsers but will leverage them in order to feed
parser-matched strings from files highlighted by a Prepper() to the
appropriate mapping for initial obfuscation.
Preppers may specify their own priority in order to influence the order in
which mappings are prepped. Further, Preppers have two ways to prepare
the maps - either by generating a list of filenames or via directly pulling
content out of select files without the assistance of a parser. A lower
priority value means the prepper should run sooner than those with higher
values.
For the former approach, `Prepper._get_$parser_file_list()` should be used
and should yield filenames that exist in target archives. For the latter,
the `Prepper._get_items_for_$map()` should be used.
Finally, a `regex_items` dict is available for storing individual regex
items for parsers that rely on them. These items will be added after all
files and other individual items are handled. This dict has keys set to
parser/mapping names, and the values should be sets of items, so preppers
should add to them like so:
self.regex_items['hostname'].add('myhostname')
"""
name = 'Undefined'
priority = 100
def __init__(self, options):
self.regex_items = {
'hostname': set(),
'ip': set(),
'ipv6': set(),
'keyword': set(),
'mac': set(),
'username': set()
}
self.opts = options
self.soslog = logging.getLogger('sos')
self.ui_log = logging.getLogger('sos_ui')
def _fmt_log_msg(self, msg):
return f"[prepper:{self.name}] {msg}"
def log_debug(self, msg):
self.soslog.debug(self._fmt_log_msg(msg))
def log_info(self, msg):
self.soslog.info(self._fmt_log_msg(msg))
def log_error(self, msg):
self.soslog.error(self._fmt_log_msg(msg))
def get_parser_file_list(self, parser, archive):
"""
Helper that calls the appropriate Prepper method for the specified
parser. This allows Preppers to be able to provide items for multiple
types of parsers without needing to handle repetitious logic to
determine which parser we're interested within each individual call.
The convention to use is to define `_get_$parser_file_list()` methods
within Preppers, e.g. `_get_hostname_file_list()` would be used to
provide filenames for the hostname parser. If such a method is not
defined within a Prepper for a given parser, we handle that here so
that individual Preppers do not need to.
:param parser: The _name_ of the parser to get a file list for
:type parser: ``str``
:param archive: The archive we are operating on currently for the
specified parser
:type archive: ``SoSObfuscationArchive``
:returns: A list of filenames within the archive to prep with
:rtype: ``list``
"""
_check = f"_get_{parser}_file_list"
if hasattr(self, _check):
return getattr(self, _check)(archive)
return []
def get_items_for_map(self, mapping, archive):
"""
Similar to `get_parser_file_list()`, a helper for calling the specific
method for generating items for the given `map`. This allows Preppers
to be able to provide items for multiple types of maps, without the
need to handle repetitious logic to determine which parser we're
interested in within each individual call.
:param mapping: The _name_ of the mapping to get items for
:type mapping: ``str``
:param archive: The archive we are operating on currently for the
specified parser
:type archive: ``SoSObfuscationArchive``
:returns: A list of distinct items to obfuscate without using a parser
:rtype: ``list``
"""
_check = f"_get_items_for_{mapping}"
if hasattr(self, _check):
return getattr(self, _check)(archive)
return []
# vim: set et ts=4 sw=4 :
Mini Shell