File add-supportconfig-module-for-remote-calls-and-saltss.patch of Package salt.20998
From 9fba801c1e1e6136808dca80ccd7524ed483250e Mon Sep 17 00:00:00 2001
From: Bo Maryniuk <bo@suse.de>
Date: Fri, 19 Oct 2018 15:44:47 +0200
Subject: [PATCH] Add supportconfig module for remote calls and SaltSSH
Add log collector for remote purposes
Implement default archive name
Fix imports
Implement runner function
Remove targets data collector function as it is now called by a module instead
Add external method decorator marker
Add utility class for detecting exportable methods
Mark run method as an external function
Implement function setter
Fix imports
Setup config from __opts__
Use utility class
Remove utils class
Allow specify profile from the API parameter directly
Rename module by virtual name
Bypass parent subclass
Implement profiles listing (local only for now)
Specify profile from the state/call
Set default or personalised archive name
Add archives lister
Add personalised name element to the archive name
Use proper args/kwargs to the exported function
Add archives deletion function
Change log level when debugging rendered profiles
Add ability to directly pass profile source when taking local data
Add pillar profile support
Remove extra-line
Fix header
Change output format for deleting archives
Refactor logger output format
Add time/milliseconds to each log notification
Fix imports
Switch output destination by context
Add last archive function
Lintfix
Return consistent type
Change output format for deleted archives report
Implement report archive syncing to the reporting node
Send multiple files at once via rsync, instead of send one after another
Add sync stats formatter
Change signature: cleanup -> move. Update docstring.
Flush empty data from the output format
Report archfiles activity
Refactor imports
Do not remove retcode if it is EX_OK
Do not raise rsync error for undefined archives.
Update header
Add salt-support state module
Move all functions into a callable class object
Support __call__ function in state and command modules as default entrance that does not need to be specified in SLS state syntax
Access from the outside only allowed class methods
Pre-create destination of the archive, preventing single archive copied as a group name
Handle functions exceptions
Add unit test scaffold
Add LogCollector UT for testing regular message
Add LogCollector UT for testing INFO message
Add LogCollector UT for testing WARNING message
Replace hardcoded variables with defined constants
Add LogCollector UT for testing ERROR message
Test title attribute in msg method of LogCollector
Add UT for LogCollector on highlighter method
Add UT for LogCollector on put method
Fix docstrings
Add UT for archive name generator
Add UT for custom archive name
Fix docstring for the UT
Add UT for checking profiles list format
Add Unit Test for existing archives listing
Add UT for the last archive function
Create instance of the support class
Add UT for successfully deleting all archives
Add UT for deleting archives with failures
Add UI for formatting sync stats and order preservation
Add UT for testing sync failure when no archives has been specified
Add UT for last picked archive has not found
Add UT for last specified archive was not found
Bugfix: do not create an array with None element in it
Fix UT for found bugfix
Add UT for syncing no archives failure
Add UT for sync function
Add UT for run support function
Fix docstring for function "run"
lintfix: use 'salt.support.mock' and 'patch()'
Rewrite subdirectory creation and do not rely on Python3-only code
Lintfix: remove unused imports
Lintfix: regexp strings
Break-down oneliner if/else clause
Use ordered dictionary to preserve order of the state.
This has transparent effect to the current process: OrderedDict is the
same as just Python dict, except it is preserving order of the state
chunks.
Refactor state processing class.
Add __call__ function to process single-id syntax
Add backward-compatibility with default SLS syntax (id-per-call)
Lintfix: E1120 no value in argument 'name' for class constructor
Remove unused import
Check last function by full name
---
doc/ref/modules/all/index.rst | 1 +
doc/ref/states/all/index.rst | 1 +
salt/cli/support/__init__.py | 2 +-
salt/cli/support/collector.py | 14 +-
salt/loader.py | 6 +-
salt/modules/saltsupport.py | 405 ++++++++++++++++++++
salt/state.py | 38 +-
salt/states/saltsupport.py | 225 +++++++++++
salt/utils/args.py | 23 +-
salt/utils/decorators/__init__.py | 68 ++--
tests/unit/modules/test_saltsupport.py | 496 +++++++++++++++++++++++++
11 files changed, 1220 insertions(+), 59 deletions(-)
create mode 100644 salt/modules/saltsupport.py
create mode 100644 salt/states/saltsupport.py
create mode 100644 tests/unit/modules/test_saltsupport.py
diff --git a/doc/ref/modules/all/index.rst b/doc/ref/modules/all/index.rst
index 4c93972276..9fea7af07f 100644
--- a/doc/ref/modules/all/index.rst
+++ b/doc/ref/modules/all/index.rst
@@ -415,6 +415,7 @@ execution modules
salt_version
saltcheck
saltcloudmod
+ saltsupport
saltutil
schedule
scp_mod
diff --git a/doc/ref/states/all/index.rst b/doc/ref/states/all/index.rst
index 2664b4ce45..052efe4582 100644
--- a/doc/ref/states/all/index.rst
+++ b/doc/ref/states/all/index.rst
@@ -281,6 +281,7 @@ state modules
rvm
salt_proxy
saltmod
+ saltsupport
saltutil
schedule
selinux
diff --git a/salt/cli/support/__init__.py b/salt/cli/support/__init__.py
index 4fdf44186f..59c2609e07 100644
--- a/salt/cli/support/__init__.py
+++ b/salt/cli/support/__init__.py
@@ -47,7 +47,7 @@ def get_profile(profile, caller, runner):
if os.path.exists(profile_path):
try:
rendered_template = _render_profile(profile_path, caller, runner)
- log.trace("\n{d}\n{t}\n{d}\n".format(d="-" * 80, t=rendered_template))
+ log.debug("\n{d}\n{t}\n{d}\n".format(d="-" * 80, t=rendered_template))
data.update(yaml.load(rendered_template))
except Exception as ex:
log.debug(ex, exc_info=True)
diff --git a/salt/cli/support/collector.py b/salt/cli/support/collector.py
index a08a0b8c6e..1879cc5220 100644
--- a/salt/cli/support/collector.py
+++ b/salt/cli/support/collector.py
@@ -362,7 +362,7 @@ class SaltSupport(salt.utils.parsers.SaltSupportOptionParser):
return data
- def collect_local_data(self):
+ def collect_local_data(self, profile=None, profile_source=None):
"""
Collects master system data.
:return:
@@ -388,8 +388,8 @@ class SaltSupport(salt.utils.parsers.SaltSupportOptionParser):
self._local_run({"fun": func, "arg": args, "kwarg": kwargs})
)
- scenario = salt.cli.support.get_profile(
- self.config["support_profile"], call, run
+ scenario = profile_source or salt.cli.support.get_profile(
+ profile or self.config["support_profile"], call, run
)
for category_name in scenario:
self.out.put(category_name)
@@ -441,13 +441,6 @@ class SaltSupport(salt.utils.parsers.SaltSupportOptionParser):
return action_name.split(":")[0] or None
- def collect_targets_data(self):
- """
- Collects minion targets data
- :return:
- """
- # TODO: remote collector?
-
def _cleanup(self):
"""
Cleanup if crash/exception
@@ -551,7 +544,6 @@ class SaltSupport(salt.utils.parsers.SaltSupportOptionParser):
self.collector.open()
self.collect_local_data()
self.collect_internal_data()
- self.collect_targets_data()
self.collector.close()
archive_path = self.collector.archive_path
diff --git a/salt/loader.py b/salt/loader.py
index 8232ed632e..1ee40712e5 100644
--- a/salt/loader.py
+++ b/salt/loader.py
@@ -1843,8 +1843,10 @@ class LazyLoader(salt.utils.lazy.LazyDict):
}
for attr in getattr(mod, "__load__", dir(mod)):
- if attr.startswith("_"):
- # private functions are skipped
+ if attr.startswith("_") and attr != "__call__":
+ # private functions are skipped,
+ # except __call__ which is default entrance
+ # for multi-function batch-like state syntax
continue
func = getattr(mod, attr)
if not inspect.isfunction(func) and not isinstance(func, functools.partial):
diff --git a/salt/modules/saltsupport.py b/salt/modules/saltsupport.py
new file mode 100644
index 0000000000..e800e3bf1f
--- /dev/null
+++ b/salt/modules/saltsupport.py
@@ -0,0 +1,405 @@
+#
+# Author: Bo Maryniuk <bo@suse.de>
+#
+# Copyright 2018 SUSE LLC
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+:codeauthor: :email:`Bo Maryniuk <bo@suse.de>`
+
+Module to run salt-support within Salt.
+"""
+# pylint: disable=W0231,W0221
+
+
+import datetime
+import logging
+import os
+import re
+import sys
+import tempfile
+import time
+
+import salt.cli.support
+import salt.cli.support.intfunc
+import salt.defaults.exitcodes
+import salt.exceptions
+import salt.utils.decorators
+import salt.utils.dictupdate
+import salt.utils.odict
+import salt.utils.path
+import salt.utils.stringutils
+from salt.cli.support.collector import SaltSupport, SupportDataCollector
+
+__virtualname__ = "support"
+log = logging.getLogger(__name__)
+
+
+class LogCollector:
+ """
+ Output collector.
+ """
+
+ INFO = "info"
+ WARNING = "warning"
+ ERROR = "error"
+
+ class MessagesList(list):
+ def append(self, obj):
+ list.append(
+ self,
+ "{} - {}".format(
+ datetime.datetime.utcnow().strftime("%T.%f")[:-3], obj
+ ),
+ )
+
+ __call__ = append
+
+ def __init__(self):
+ self.messages = {
+ self.INFO: self.MessagesList(),
+ self.WARNING: self.MessagesList(),
+ self.ERROR: self.MessagesList(),
+ }
+
+ def msg(self, message, *args, **kwargs):
+ title = kwargs.get("title")
+ if title:
+ message = "{}: {}".format(title, message)
+ self.messages[self.INFO](message)
+
+ def info(self, message, *args, **kwargs):
+ self.msg(message)
+
+ def warning(self, message, *args, **kwargs):
+ self.messages[self.WARNING](message)
+
+ def error(self, message, *args, **kwargs):
+ self.messages[self.ERROR](message)
+
+ def put(self, message, *args, **kwargs):
+ self.messages[self.INFO](message)
+
+ def highlight(self, message, *values, **kwargs):
+ self.msg(message.format(*values))
+
+
+class SaltSupportModule(SaltSupport):
+ """
+ Salt Support module class.
+ """
+
+ def __init__(self):
+ """
+ Constructor
+ """
+ self.config = self.setup_config()
+
+ def setup_config(self):
+ """
+ Return current configuration
+ :return:
+ """
+ return __opts__
+
+ def _get_archive_name(self, archname=None):
+ """
+ Create default archive name.
+
+ :return:
+ """
+ archname = re.sub("[^a-z0-9]", "", (archname or "").lower()) or "support"
+ for grain in ["fqdn", "host", "localhost", "nodename"]:
+ host = __grains__.get(grain)
+ if host:
+ break
+ if not host:
+ host = "localhost"
+
+ return os.path.join(
+ tempfile.gettempdir(),
+ "{hostname}-{archname}-{date}-{time}.bz2".format(
+ archname=archname,
+ hostname=host,
+ date=time.strftime("%Y%m%d"),
+ time=time.strftime("%H%M%S"),
+ ),
+ )
+
+ @salt.utils.decorators.external
+ def profiles(self):
+ """
+ Get list of profiles.
+
+ :return:
+ """
+ return {
+ "standard": salt.cli.support.get_profiles(self.config),
+ "custom": [],
+ }
+
+ @salt.utils.decorators.external
+ def archives(self):
+ """
+ Get list of existing archives.
+ :return:
+ """
+ arc_files = []
+ tmpdir = tempfile.gettempdir()
+ for filename in os.listdir(tmpdir):
+ mtc = re.match(r"\w+-\w+-\d+-\d+\.bz2", filename)
+ if mtc and len(filename) == mtc.span()[-1]:
+ arc_files.append(os.path.join(tmpdir, filename))
+
+ return arc_files
+
+ @salt.utils.decorators.external
+ def last_archive(self):
+ """
+ Get the last available archive
+ :return:
+ """
+ archives = {}
+ for archive in self.archives():
+ archives[int(archive.split(".")[0].split("-")[-1])] = archive
+
+ return archives and archives[max(archives)] or None
+
+ @salt.utils.decorators.external
+ def delete_archives(self, *archives):
+ """
+ Delete archives
+ :return:
+ """
+ # Remove paths
+ _archives = []
+ for archive in archives:
+ _archives.append(os.path.basename(archive))
+ archives = _archives[:]
+
+ ret = {"files": {}, "errors": {}}
+ for archive in self.archives():
+ arc_dir = os.path.dirname(archive)
+ archive = os.path.basename(archive)
+ if archives and archive in archives or not archives:
+ archive = os.path.join(arc_dir, archive)
+ try:
+ os.unlink(archive)
+ ret["files"][archive] = "removed"
+ except Exception as err:
+ ret["errors"][archive] = str(err)
+ ret["files"][archive] = "left"
+
+ return ret
+
+ def format_sync_stats(self, cnt):
+ """
+ Format stats of the sync output.
+
+ :param cnt:
+ :return:
+ """
+ stats = salt.utils.odict.OrderedDict()
+ if cnt.get("retcode") == salt.defaults.exitcodes.EX_OK:
+ for line in cnt.get("stdout", "").split(os.linesep):
+ line = line.split(": ")
+ if len(line) == 2:
+ stats[line[0].lower().replace(" ", "_")] = line[1]
+ cnt["transfer"] = stats
+ del cnt["stdout"]
+
+ # Remove empty
+ empty_sections = []
+ for section in cnt:
+ if not cnt[section] and section != "retcode":
+ empty_sections.append(section)
+ for section in empty_sections:
+ del cnt[section]
+
+ return cnt
+
+ @salt.utils.decorators.depends("rsync")
+ @salt.utils.decorators.external
+ def sync(self, group, name=None, host=None, location=None, move=False, all=False):
+ """
+ Sync the latest archive to the host on given location.
+
+ CLI Example:
+
+ .. code-block:: bash
+
+ salt '*' support.sync group=test
+ salt '*' support.sync group=test name=/tmp/myspecial-12345-67890.bz2
+ salt '*' support.sync group=test name=/tmp/myspecial-12345-67890.bz2 host=allmystuff.lan
+ salt '*' support.sync group=test name=/tmp/myspecial-12345-67890.bz2 host=allmystuff.lan location=/opt/
+
+ :param group: name of the local directory to which sync is going to put the result files
+ :param name: name of the archive. Latest, if not specified.
+ :param host: name of the destination host for rsync. Default is master, if not specified.
+ :param location: local destination directory, default temporary if not specified
+ :param move: move archive file[s]. Default is False.
+ :param all: work with all available archives. Default is False (i.e. latest available)
+
+ :return:
+ """
+ tfh, tfn = tempfile.mkstemp()
+ processed_archives = []
+ src_uri = uri = None
+
+ last_arc = self.last_archive()
+ if name:
+ archives = [name]
+ elif all:
+ archives = self.archives()
+ elif last_arc:
+ archives = [last_arc]
+ else:
+ archives = []
+
+ for name in archives:
+ err = None
+ if not name:
+ err = "No support archive has been defined."
+ elif not os.path.exists(name):
+ err = 'Support archive "{}" was not found'.format(name)
+ if err is not None:
+ log.error(err)
+ raise salt.exceptions.SaltInvocationError(err)
+
+ if not uri:
+ src_uri = os.path.dirname(name)
+ uri = "{host}:{loc}".format(
+ host=host or __opts__["master"],
+ loc=os.path.join(location or tempfile.gettempdir(), group),
+ )
+
+ os.write(tfh, salt.utils.stringutils.to_bytes(os.path.basename(name)))
+ os.write(tfh, salt.utils.stringutils.to_bytes(os.linesep))
+ processed_archives.append(name)
+ log.debug("Syncing {filename} to {uri}".format(filename=name, uri=uri))
+ os.close(tfh)
+
+ if not processed_archives:
+ raise salt.exceptions.SaltInvocationError("No archives found to transfer.")
+
+ ret = __salt__["rsync.rsync"](
+ src=src_uri,
+ dst=uri,
+ additional_opts=["--stats", "--files-from={}".format(tfn)],
+ )
+ ret["files"] = {}
+ for name in processed_archives:
+ if move:
+ salt.utils.dictupdate.update(ret, self.delete_archives(name))
+ log.debug("Deleting {filename}".format(filename=name))
+ ret["files"][name] = "moved"
+ else:
+ ret["files"][name] = "copied"
+
+ try:
+ os.unlink(tfn)
+ except OSError as err:
+ log.error(
+ "Cannot remove temporary rsync file {fn}: {err}".format(fn=tfn, err=err)
+ )
+
+ return self.format_sync_stats(ret)
+
+ @salt.utils.decorators.external
+ def run(self, profile="default", pillar=None, archive=None, output="nested"):
+ """
+ Run Salt Support on the minion.
+
+ profile
+ Set available profile name. Default is "default".
+
+ pillar
+ Set available profile from the pillars.
+
+ archive
+ Override archive name. Default is "support". This results to "hostname-support-YYYYMMDD-hhmmss.bz2".
+
+ output
+ Change the default outputter. Default is "nested".
+
+ CLI Example:
+
+ .. code-block:: bash
+
+ salt '*' support.run
+ salt '*' support.run profile=network
+ salt '*' support.run pillar=something_special
+ """
+
+ class outputswitch:
+ """
+ Output switcher on context
+ """
+
+ def __init__(self, output_device):
+ self._tmp_out = output_device
+ self._orig_out = None
+
+ def __enter__(self):
+ self._orig_out = salt.cli.support.intfunc.out
+ salt.cli.support.intfunc.out = self._tmp_out
+
+ def __exit__(self, *args):
+ salt.cli.support.intfunc.out = self._orig_out
+
+ self.out = LogCollector()
+ with outputswitch(self.out):
+ self.collector = SupportDataCollector(
+ archive or self._get_archive_name(archname=archive), output
+ )
+ self.collector.out = self.out
+ self.collector.open()
+ self.collect_local_data(
+ profile=profile, profile_source=__pillar__.get(pillar)
+ )
+ self.collect_internal_data()
+ self.collector.close()
+
+ return {"archive": self.collector.archive_path, "messages": self.out.messages}
+
+
+def __virtual__():
+ """
+ Set method references as module functions aliases
+ :return:
+ """
+ support = SaltSupportModule()
+
+ def _set_function(obj):
+ """
+ Create a Salt function for the SaltSupport class.
+ """
+
+ def _cmd(*args, **kwargs):
+ """
+ Call support method as a function from the Salt.
+ """
+ _kwargs = {}
+ for kw in kwargs:
+ if not kw.startswith("__"):
+ _kwargs[kw] = kwargs[kw]
+ return obj(*args, **_kwargs)
+
+ _cmd.__doc__ = obj.__doc__
+ return _cmd
+
+ for m_name in dir(support):
+ obj = getattr(support, m_name)
+ if getattr(obj, "external", False):
+ setattr(sys.modules[__name__], m_name, _set_function(obj))
+
+ return __virtualname__
diff --git a/salt/state.py b/salt/state.py
index beab2cb16c..b1bce4e0cd 100644
--- a/salt/state.py
+++ b/salt/state.py
@@ -1547,7 +1547,9 @@ class State:
names = []
if state.startswith("__"):
continue
- chunk = {"state": state, "name": name}
+ chunk = OrderedDict()
+ chunk["state"] = state
+ chunk["name"] = name
if orchestration_jid is not None:
chunk["__orchestration_jid__"] = orchestration_jid
if "__sls__" in body:
@@ -2150,9 +2152,16 @@ class State:
ret = self.call_parallel(cdata, low)
else:
self.format_slots(cdata)
- ret = self.states[cdata["full"]](
- *cdata["args"], **cdata["kwargs"]
- )
+ if cdata["full"].split(".")[-1] == "__call__":
+ # __call__ requires OrderedDict to preserve state order
+ # kwargs are also invalid overall
+ ret = self.states[cdata["full"]](
+ cdata["args"], module=None, state=cdata["kwargs"]
+ )
+ else:
+ ret = self.states[cdata["full"]](
+ *cdata["args"], **cdata["kwargs"]
+ )
self.states.inject_globals = {}
if (
"check_cmd" in low
@@ -3188,10 +3197,31 @@ class State:
running.update(errors)
return running
+ def inject_default_call(self, high):
+ """
+ Sets .call function to a state, if not there.
+
+ :param high:
+ :return:
+ """
+ for chunk in high:
+ state = high[chunk]
+ for state_ref in state:
+ needs_default = True
+ for argset in state[state_ref]:
+ if isinstance(argset, str):
+ needs_default = False
+ break
+ if needs_default:
+ order = state[state_ref].pop(-1)
+ state[state_ref].append("__call__")
+ state[state_ref].append(order)
+
def call_high(self, high, orchestration_jid=None):
"""
Process a high data call and ensure the defined states.
"""
+ self.inject_default_call(high)
errors = []
# If there is extension data reconcile it
high, ext_errors = self.reconcile_extend(high)
diff --git a/salt/states/saltsupport.py b/salt/states/saltsupport.py
new file mode 100644
index 0000000000..fb0c9e0372
--- /dev/null
+++ b/salt/states/saltsupport.py
@@ -0,0 +1,225 @@
+#
+# Author: Bo Maryniuk <bo@suse.de>
+#
+# Copyright 2018 SUSE LLC
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+r"""
+:codeauthor: :email:`Bo Maryniuk <bo@suse.de>`
+
+Execution of Salt Support from within states
+============================================
+
+State to collect support data from the systems:
+
+.. code-block:: yaml
+
+ examine_my_systems:
+ support.taken:
+ - profile: default
+
+ support.collected:
+ - group: somewhere
+ - move: true
+
+"""
+import logging
+import os
+import tempfile
+
+import salt.exceptions
+
+# Import salt modules
+import salt.fileclient
+import salt.utils.decorators.path
+import salt.utils.odict
+
+log = logging.getLogger(__name__)
+__virtualname__ = "support"
+
+
+class SaltSupportState:
+ """
+ Salt-support.
+ """
+
+ EXPORTED = ["collected", "taken"]
+
+ def get_kwargs(self, data):
+ kwargs = {}
+ for keyset in data:
+ kwargs.update(keyset)
+
+ return kwargs
+
+ def __call__(self, state):
+ """
+ Call support.
+
+ :param args:
+ :param kwargs:
+ :return:
+ """
+ ret = {
+ "name": state.pop("name"),
+ "changes": {},
+ "result": True,
+ "comment": "",
+ }
+
+ out = {}
+ functions = ["Functions:"]
+ try:
+ for ref_func, ref_kwargs in state.items():
+ if ref_func not in self.EXPORTED:
+ raise salt.exceptions.SaltInvocationError(
+ "Function {} is not found".format(ref_func)
+ )
+ out[ref_func] = getattr(self, ref_func)(**self.get_kwargs(ref_kwargs))
+ functions.append(" - {}".format(ref_func))
+ ret["comment"] = "\n".join(functions)
+ except Exception as ex:
+ ret["comment"] = str(ex)
+ ret["result"] = False
+ ret["changes"] = out
+
+ return ret
+
+ def check_destination(self, location, group):
+ """
+ Check destination for the archives.
+ :return:
+ """
+ # Pre-create destination, since rsync will
+ # put one file named as group
+ try:
+ destination = os.path.join(location, group)
+ if os.path.exists(destination) and not os.path.isdir(destination):
+ raise salt.exceptions.SaltException(
+ 'Destination "{}" should be directory!'.format(destination)
+ )
+ if not os.path.exists(destination):
+ os.makedirs(destination)
+ log.debug("Created destination directory for archives: %s", destination)
+ else:
+ log.debug(
+ "Archives destination directory %s already exists", destination
+ )
+ except OSError as err:
+ log.error(err)
+
+ def collected(
+ self, group, filename=None, host=None, location=None, move=True, all=True
+ ):
+ """
+ Sync archives to a central place.
+
+ :param name:
+ :param group:
+ :param filename:
+ :param host:
+ :param location:
+ :param move:
+ :param all:
+ :return:
+ """
+ ret = {
+ "name": "support.collected",
+ "changes": {},
+ "result": True,
+ "comment": "",
+ }
+ location = location or tempfile.gettempdir()
+ self.check_destination(location, group)
+ ret["changes"] = __salt__["support.sync"](
+ group, name=filename, host=host, location=location, move=move, all=all
+ )
+
+ return ret
+
+ def taken(self, profile="default", pillar=None, archive=None, output="nested"):
+ """
+ Takes minion support config data.
+
+ :param profile:
+ :param pillar:
+ :param archive:
+ :param output:
+ :return:
+ """
+ ret = {
+ "name": "support.taken",
+ "changes": {},
+ "result": True,
+ }
+
+ result = __salt__["support.run"](
+ profile=profile, pillar=pillar, archive=archive, output=output
+ )
+ if result.get("archive"):
+ ret[
+ "comment"
+ ] = "Information about this system has been saved to {} file.".format(
+ result["archive"]
+ )
+ ret["changes"]["archive"] = result["archive"]
+ ret["changes"]["messages"] = {}
+ for key in ["info", "error", "warning"]:
+ if result.get("messages", {}).get(key):
+ ret["changes"]["messages"][key] = result["messages"][key]
+ else:
+ ret["comment"] = ""
+
+ return ret
+
+
+_support_state = SaltSupportState()
+
+
+def __call__(*args, **kwargs):
+ """
+ SLS single-ID syntax processing.
+
+ module:
+ This module reference, equals to sys.modules[__name__]
+
+ state:
+ Compiled state in preserved order. The function supposed to look
+ at first level array of functions.
+
+ :param cdata:
+ :param kwargs:
+ :return:
+ """
+ return _support_state(kwargs.get("state", {}))
+
+
+def taken(name, profile="default", pillar=None, archive=None, output="nested"):
+ return _support_state.taken(
+ profile=profile, pillar=pillar, archive=archive, output=output
+ )
+
+
+def collected(
+ name, group, filename=None, host=None, location=None, move=True, all=True
+):
+ return _support_state.collected(
+ group=group, filename=filename, host=host, location=location, move=move, all=all
+ )
+
+
+def __virtual__():
+ """
+ Salt Support state
+ """
+ return __virtualname__
diff --git a/salt/utils/args.py b/salt/utils/args.py
index 87afdd3597..102402500c 100644
--- a/salt/utils/args.py
+++ b/salt/utils/args.py
@@ -1,8 +1,6 @@
-# -*- coding: utf-8 -*-
"""
Functions used for CLI argument handling
"""
-from __future__ import absolute_import, print_function, unicode_literals
import copy
import fnmatch
@@ -17,6 +15,7 @@ import salt.utils.jid
import salt.utils.versions
import salt.utils.yaml
from salt.exceptions import SaltInvocationError
+from salt.utils.odict import OrderedDict
log = logging.getLogger(__name__)
@@ -70,9 +69,9 @@ def invalid_kwargs(invalid_kwargs, raise_exc=True):
"""
if invalid_kwargs:
if isinstance(invalid_kwargs, dict):
- new_invalid = ["{0}={1}".format(x, y) for x, y in invalid_kwargs.items()]
+ new_invalid = ["{}={}".format(x, y) for x, y in invalid_kwargs.items()]
invalid_kwargs = new_invalid
- msg = "The following keyword arguments are not valid: {0}".format(
+ msg = "The following keyword arguments are not valid: {}".format(
", ".join(invalid_kwargs)
)
if raise_exc:
@@ -259,7 +258,7 @@ def get_function_argspec(func, is_class_method=None):
and this is not always wanted.
"""
if not callable(func):
- raise TypeError("{0} is not a callable".format(func))
+ raise TypeError("{} is not a callable".format(func))
if hasattr(func, "__wrapped__"):
func = func.__wrapped__
@@ -279,7 +278,7 @@ def get_function_argspec(func, is_class_method=None):
try:
sig = inspect.signature(func)
except TypeError:
- raise TypeError("Cannot inspect argument list for '{0}'".format(func))
+ raise TypeError("Cannot inspect argument list for '{}'".format(func))
else:
# argspec-related functions are deprecated in Python 3 in favor of
# the new inspect.Signature class, and will be removed at some
@@ -439,7 +438,7 @@ def format_call(
ret = initial_ret is not None and initial_ret or {}
ret["args"] = []
- ret["kwargs"] = {}
+ ret["kwargs"] = OrderedDict()
aspec = get_function_argspec(fun, is_class_method=is_class_method)
@@ -470,7 +469,7 @@ def format_call(
used_args_count = len(ret["args"]) + len(args)
args_count = used_args_count + len(missing_args)
raise SaltInvocationError(
- "{0} takes at least {1} argument{2} ({3} given)".format(
+ "{} takes at least {} argument{} ({} given)".format(
fun.__name__, args_count, args_count > 1 and "s" or "", used_args_count
)
)
@@ -506,18 +505,18 @@ def format_call(
# In case this is being called for a state module
"full",
# Not a state module, build the name
- "{0}.{1}".format(fun.__module__, fun.__name__),
+ "{}.{}".format(fun.__module__, fun.__name__),
),
)
else:
- msg = "{0} and '{1}' are invalid keyword arguments for '{2}'".format(
- ", ".join(["'{0}'".format(e) for e in extra][:-1]),
+ msg = "{} and '{}' are invalid keyword arguments for '{}'".format(
+ ", ".join(["'{}'".format(e) for e in extra][:-1]),
list(extra.keys())[-1],
ret.get(
# In case this is being called for a state module
"full",
# Not a state module, build the name
- "{0}.{1}".format(fun.__module__, fun.__name__),
+ "{}.{}".format(fun.__module__, fun.__name__),
),
)
diff --git a/salt/utils/decorators/__init__.py b/salt/utils/decorators/__init__.py
index 940d0a90f2..b06cf0abc8 100644
--- a/salt/utils/decorators/__init__.py
+++ b/salt/utils/decorators/__init__.py
@@ -1,10 +1,7 @@
-# -*- coding: utf-8 -*-
"""
Helpful decorators for module writing
"""
-# Import python libs
-from __future__ import absolute_import, print_function, unicode_literals
import errno
import inspect
@@ -15,13 +12,10 @@ import time
from collections import defaultdict
from functools import wraps
-# Import salt libs
import salt.utils.args
import salt.utils.data
import salt.utils.versions
from salt.exceptions import CommandExecutionError, SaltConfigurationError
-
-# Import 3rd-party libs
from salt.ext import six
from salt.log import LOG_LEVELS
@@ -32,7 +26,7 @@ if getattr(sys, "getwindowsversion", False):
log = logging.getLogger(__name__)
-class Depends(object):
+class Depends:
"""
This decorator will check the module when it is loaded and check that the
dependencies passed in are in the globals of the module. If not, it will
@@ -121,7 +115,7 @@ class Depends(object):
@staticmethod
def run_command(dependency, mod_name, func_name):
- full_name = "{0}.{1}".format(mod_name, func_name)
+ full_name = "{}.{}".format(mod_name, func_name)
log.trace("Running '%s' for '%s'", dependency, full_name)
if IS_WINDOWS:
args = salt.utils.args.shlex_split(dependency, posix=False)
@@ -145,8 +139,8 @@ class Depends(object):
It will modify the "functions" dict and remove/replace modules that
are missing dependencies.
"""
- for dependency, dependent_dict in six.iteritems(cls.dependency_dict[kind]):
- for (mod_name, func_name), (frame, params) in six.iteritems(dependent_dict):
+ for dependency, dependent_dict in cls.dependency_dict[kind].items():
+ for (mod_name, func_name), (frame, params) in dependent_dict.items():
if mod_name != tgt_mod:
continue
# Imports from local context take presedence over those from the global context.
@@ -232,7 +226,7 @@ class Depends(object):
except (AttributeError, KeyError):
pass
- mod_key = "{0}.{1}".format(mod_name, func_name)
+ mod_key = "{}.{}".format(mod_name, func_name)
# if we don't have this module loaded, skip it!
if mod_key not in functions:
@@ -267,9 +261,7 @@ def timing(function):
mod_name = function.__module__[16:]
else:
mod_name = function.__module__
- fstr = "Function %s.%s took %.{0}f seconds to execute".format(
- sys.float_info.dig
- )
+ fstr = "Function %s.%s took %.{}f seconds to execute".format(sys.float_info.dig)
log.profile(fstr, mod_name, function.__name__, end_time - start_time)
return ret
@@ -291,13 +283,13 @@ def memoize(func):
def _memoize(*args, **kwargs):
str_args = []
for arg in args:
- if not isinstance(arg, six.string_types):
- str_args.append(six.text_type(arg))
+ if not isinstance(arg, str):
+ str_args.append(str(arg))
else:
str_args.append(arg)
args_ = ",".join(
- list(str_args) + ["{0}={1}".format(k, kwargs[k]) for k in sorted(kwargs)]
+ list(str_args) + ["{}={}".format(k, kwargs[k]) for k in sorted(kwargs)]
)
if args_ not in cache:
cache[args_] = func(*args, **kwargs)
@@ -306,7 +298,7 @@ def memoize(func):
return _memoize
-class _DeprecationDecorator(object):
+class _DeprecationDecorator:
"""
Base mix-in class for the deprecation decorator.
Takes care of a common functionality, used in its derivatives.
@@ -359,7 +351,7 @@ class _DeprecationDecorator(object):
try:
return self._function(*args, **kwargs)
except TypeError as error:
- error = six.text_type(error).replace(
+ error = str(error).replace(
self._function, self._orig_f_name
) # Hide hidden functions
log.error(
@@ -374,7 +366,7 @@ class _DeprecationDecorator(object):
self._function.__name__,
error,
)
- six.reraise(*sys.exc_info())
+ raise
else:
raise CommandExecutionError(
"Function is deprecated, but the successor function was not found."
@@ -626,11 +618,11 @@ class _WithDeprecated(_DeprecationDecorator):
if use_deprecated and use_superseded:
raise SaltConfigurationError(
- "Function '{0}' is mentioned both in deprecated "
+ "Function '{}' is mentioned both in deprecated "
"and superseded sections. Please remove any of that.".format(full_name)
)
old_function = self._globals.get(
- self._with_name or "_{0}".format(function.__name__)
+ self._with_name or "_{}".format(function.__name__)
)
if self._policy == self.OPT_IN:
self._function = function if use_superseded else old_function
@@ -782,12 +774,30 @@ def ensure_unicode_args(function):
@wraps(function)
def wrapped(*args, **kwargs):
- if six.PY2:
- return function(
- *salt.utils.data.decode_list(args),
- **salt.utils.data.decode_dict(kwargs)
- )
- else:
- return function(*args, **kwargs)
+ return function(*args, **kwargs)
return wrapped
+
+
+def external(func):
+ """
+ Mark function as external.
+
+ :param func:
+ :return:
+ """
+
+ def f(*args, **kwargs):
+ """
+ Stub.
+
+ :param args:
+ :param kwargs:
+ :return:
+ """
+ return func(*args, **kwargs)
+
+ f.external = True
+ f.__doc__ = func.__doc__
+
+ return f
diff --git a/tests/unit/modules/test_saltsupport.py b/tests/unit/modules/test_saltsupport.py
new file mode 100644
index 0000000000..f9ce7be29a
--- /dev/null
+++ b/tests/unit/modules/test_saltsupport.py
@@ -0,0 +1,496 @@
+"""
+ :codeauthor: Bo Maryniuk <bo@suse.de>
+"""
+
+
+import datetime
+
+import salt.exceptions
+from salt.modules import saltsupport
+from tests.support.mixins import LoaderModuleMockMixin
+from tests.support.mock import NO_MOCK, NO_MOCK_REASON, MagicMock, patch
+from tests.support.unit import TestCase, skipIf
+
+try:
+ import pytest
+except ImportError:
+ pytest = None
+
+
+@skipIf(not bool(pytest), "Pytest required")
+@skipIf(NO_MOCK, NO_MOCK_REASON)
+class SaltSupportModuleTestCase(TestCase, LoaderModuleMockMixin):
+ """
+ Test cases for salt.modules.support::SaltSupportModule
+ """
+
+ def setup_loader_modules(self):
+ return {saltsupport: {}}
+
+ @patch("tempfile.gettempdir", MagicMock(return_value="/mnt/storage"))
+ @patch("salt.modules.saltsupport.__grains__", {"fqdn": "c-3po"})
+ @patch("time.strftime", MagicMock(return_value="000"))
+ def test_get_archive_name(self):
+ """
+ Test archive name construction.
+
+ :return:
+ """
+ support = saltsupport.SaltSupportModule()
+ assert support._get_archive_name() == "/mnt/storage/c-3po-support-000-000.bz2"
+
+ @patch("tempfile.gettempdir", MagicMock(return_value="/mnt/storage"))
+ @patch("salt.modules.saltsupport.__grains__", {"fqdn": "c-3po"})
+ @patch("time.strftime", MagicMock(return_value="000"))
+ def test_get_custom_archive_name(self):
+ """
+ Test get custom archive name.
+
+ :return:
+ """
+ support = saltsupport.SaltSupportModule()
+ temp_name = support._get_archive_name(archname="Darth Wader")
+ assert temp_name == "/mnt/storage/c-3po-darthwader-000-000.bz2"
+ temp_name = support._get_archive_name(archname="Яйця з сіллю")
+ assert temp_name == "/mnt/storage/c-3po-support-000-000.bz2"
+ temp_name = support._get_archive_name(archname="!@#$%^&*()Fillip J. Fry")
+ assert temp_name == "/mnt/storage/c-3po-fillipjfry-000-000.bz2"
+
+ @patch(
+ "salt.cli.support.get_profiles",
+ MagicMock(return_value={"message": "Feature was not beta tested"}),
+ )
+ def test_profiles_format(self):
+ """
+ Test profiles format.
+
+ :return:
+ """
+ support = saltsupport.SaltSupportModule()
+ profiles = support.profiles()
+ assert "custom" in profiles
+ assert "standard" in profiles
+ assert "message" in profiles["standard"]
+ assert profiles["custom"] == []
+ assert profiles["standard"]["message"] == "Feature was not beta tested"
+
+ @patch("tempfile.gettempdir", MagicMock(return_value="/mnt/storage"))
+ @patch(
+ "os.listdir",
+ MagicMock(
+ return_value=[
+ "one-support-000-000.bz2",
+ "two-support-111-111.bz2",
+ "trash.bz2",
+ "hostname-000-000.bz2",
+ "three-support-wrong222-222.bz2",
+ "000-support-000-000.bz2",
+ ]
+ ),
+ )
+ def test_get_existing_archives(self):
+ """
+ Get list of existing archives.
+
+ :return:
+ """
+ support = saltsupport.SaltSupportModule()
+ out = support.archives()
+ assert len(out) == 3
+ for name in [
+ "/mnt/storage/one-support-000-000.bz2",
+ "/mnt/storage/two-support-111-111.bz2",
+ "/mnt/storage/000-support-000-000.bz2",
+ ]:
+ assert name in out
+
+ def test_last_archive(self):
+ """
+ Get last archive name
+ :return:
+ """
+ support = saltsupport.SaltSupportModule()
+ support.archives = MagicMock(
+ return_value=[
+ "/mnt/storage/one-support-000-000.bz2",
+ "/mnt/storage/two-support-111-111.bz2",
+ "/mnt/storage/three-support-222-222.bz2",
+ ]
+ )
+ assert support.last_archive() == "/mnt/storage/three-support-222-222.bz2"
+
+ @patch("os.unlink", MagicMock(return_value=True))
+ def test_delete_all_archives_success(self):
+ """
+ Test delete archives
+ :return:
+ """
+ support = saltsupport.SaltSupportModule()
+ support.archives = MagicMock(
+ return_value=[
+ "/mnt/storage/one-support-000-000.bz2",
+ "/mnt/storage/two-support-111-111.bz2",
+ "/mnt/storage/three-support-222-222.bz2",
+ ]
+ )
+ ret = support.delete_archives()
+ assert "files" in ret
+ assert "errors" in ret
+ assert not bool(ret["errors"])
+ assert bool(ret["files"])
+ assert isinstance(ret["errors"], dict)
+ assert isinstance(ret["files"], dict)
+
+ for arc in support.archives():
+ assert ret["files"][arc] == "removed"
+
+ @patch(
+ "os.unlink",
+ MagicMock(
+ return_value=False,
+ side_effect=[
+ OSError("Decreasing electron flux"),
+ OSError("Solar flares interference"),
+ None,
+ ],
+ ),
+ )
+ def test_delete_all_archives_failure(self):
+ """
+ Test delete archives failure
+ :return:
+ """
+ support = saltsupport.SaltSupportModule()
+ support.archives = MagicMock(
+ return_value=[
+ "/mnt/storage/one-support-000-000.bz2",
+ "/mnt/storage/two-support-111-111.bz2",
+ "/mnt/storage/three-support-222-222.bz2",
+ ]
+ )
+ ret = support.delete_archives()
+ assert "files" in ret
+ assert "errors" in ret
+ assert bool(ret["errors"])
+ assert bool(ret["files"])
+ assert isinstance(ret["errors"], dict)
+ assert isinstance(ret["files"], dict)
+
+ assert ret["files"]["/mnt/storage/three-support-222-222.bz2"] == "removed"
+ assert ret["files"]["/mnt/storage/one-support-000-000.bz2"] == "left"
+ assert ret["files"]["/mnt/storage/two-support-111-111.bz2"] == "left"
+
+ assert len(ret["errors"]) == 2
+ assert (
+ ret["errors"]["/mnt/storage/one-support-000-000.bz2"]
+ == "Decreasing electron flux"
+ )
+ assert (
+ ret["errors"]["/mnt/storage/two-support-111-111.bz2"]
+ == "Solar flares interference"
+ )
+
+ def test_format_sync_stats(self):
+ """
+ Test format rsync stats for preserving ordering of the keys
+
+ :return:
+ """
+ support = saltsupport.SaltSupportModule()
+ stats = """
+robot: Bender
+cute: Leela
+weird: Zoidberg
+professor: Farnsworth
+ """
+ f_stats = support.format_sync_stats({"retcode": 0, "stdout": stats})
+ assert list(f_stats["transfer"].keys()) == [
+ "robot",
+ "cute",
+ "weird",
+ "professor",
+ ]
+ assert list(f_stats["transfer"].values()) == [
+ "Bender",
+ "Leela",
+ "Zoidberg",
+ "Farnsworth",
+ ]
+
+ @patch("tempfile.mkstemp", MagicMock(return_value=(0, "dummy")))
+ @patch("os.close", MagicMock())
+ def test_sync_no_archives_failure(self):
+ """
+ Test sync failed when no archives specified.
+
+ :return:
+ """
+ support = saltsupport.SaltSupportModule()
+ support.archives = MagicMock(return_value=[])
+
+ with pytest.raises(salt.exceptions.SaltInvocationError) as err:
+ support.sync("group-name")
+ assert "No archives found to transfer" in str(err)
+
+ @patch("tempfile.mkstemp", MagicMock(return_value=(0, "dummy")))
+ @patch("os.path.exists", MagicMock(return_value=False))
+ def test_sync_last_picked_archive_not_found_failure(self):
+ """
+ Test sync failed when archive was not found (last picked)
+
+ :return:
+ """
+ support = saltsupport.SaltSupportModule()
+ support.archives = MagicMock(
+ return_value=[
+ "/mnt/storage/one-support-000-000.bz2",
+ "/mnt/storage/two-support-111-111.bz2",
+ "/mnt/storage/three-support-222-222.bz2",
+ ]
+ )
+
+ with pytest.raises(salt.exceptions.SaltInvocationError) as err:
+ support.sync("group-name")
+ assert (
+ ' Support archive "/mnt/storage/three-support-222-222.bz2" was not found'
+ in str(err)
+ )
+
+ @patch("tempfile.mkstemp", MagicMock(return_value=(0, "dummy")))
+ @patch("os.path.exists", MagicMock(return_value=False))
+ def test_sync_specified_archive_not_found_failure(self):
+ """
+ Test sync failed when archive was not found (last picked)
+
+ :return:
+ """
+ support = saltsupport.SaltSupportModule()
+ support.archives = MagicMock(
+ return_value=[
+ "/mnt/storage/one-support-000-000.bz2",
+ "/mnt/storage/two-support-111-111.bz2",
+ "/mnt/storage/three-support-222-222.bz2",
+ ]
+ )
+
+ with pytest.raises(salt.exceptions.SaltInvocationError) as err:
+ support.sync("group-name", name="lost.bz2")
+ assert ' Support archive "lost.bz2" was not found' in str(err)
+
+ @patch("tempfile.mkstemp", MagicMock(return_value=(0, "dummy")))
+ @patch("os.path.exists", MagicMock(return_value=False))
+ @patch("os.close", MagicMock())
+ def test_sync_no_archive_to_transfer_failure(self):
+ """
+ Test sync failed when no archive was found to transfer
+
+ :return:
+ """
+ support = saltsupport.SaltSupportModule()
+ support.archives = MagicMock(return_value=[])
+ with pytest.raises(salt.exceptions.SaltInvocationError) as err:
+ support.sync("group-name", all=True)
+ assert "No archives found to transfer" in str(err)
+
+ @patch("tempfile.mkstemp", MagicMock(return_value=(0, "dummy")))
+ @patch("os.path.exists", MagicMock(return_value=True))
+ @patch("os.close", MagicMock())
+ @patch("os.write", MagicMock())
+ @patch("os.unlink", MagicMock())
+ @patch(
+ "salt.modules.saltsupport.__salt__", {"rsync.rsync": MagicMock(return_value={})}
+ )
+ def test_sync_archives(self):
+ """
+ Test sync archives
+ :return:
+ """
+ support = saltsupport.SaltSupportModule()
+ support.archives = MagicMock(
+ return_value=[
+ "/mnt/storage/one-support-000-000.bz2",
+ "/mnt/storage/two-support-111-111.bz2",
+ "/mnt/storage/three-support-222-222.bz2",
+ ]
+ )
+ out = support.sync("group-name", host="buzz", all=True, move=False)
+ assert "files" in out
+ for arc_name in out["files"]:
+ assert out["files"][arc_name] == "copied"
+ assert saltsupport.os.unlink.call_count == 1
+ assert saltsupport.os.unlink.call_args_list[0][0][0] == "dummy"
+ calls = []
+ for call in saltsupport.os.write.call_args_list:
+ assert len(call) == 2
+ calls.append(call[0])
+ assert calls == [
+ (0, b"one-support-000-000.bz2"),
+ (0, b"\n"),
+ (0, b"two-support-111-111.bz2"),
+ (0, b"\n"),
+ (0, b"three-support-222-222.bz2"),
+ (0, b"\n"),
+ ]
+
+ @patch("salt.modules.saltsupport.__pillar__", {})
+ @patch("salt.modules.saltsupport.SupportDataCollector", MagicMock())
+ def test_run_support(self):
+ """
+ Test run support
+ :return:
+ """
+ saltsupport.SupportDataCollector(None, None).archive_path = "dummy"
+ support = saltsupport.SaltSupportModule()
+ support.collect_internal_data = MagicMock()
+ support.collect_local_data = MagicMock()
+ out = support.run()
+
+ for section in ["messages", "archive"]:
+ assert section in out
+ assert out["archive"] == "dummy"
+ for section in ["warning", "error", "info"]:
+ assert section in out["messages"]
+ ld_call = support.collect_local_data.call_args_list[0][1]
+ assert "profile" in ld_call
+ assert ld_call["profile"] == "default"
+ assert "profile_source" in ld_call
+ assert ld_call["profile_source"] is None
+ assert support.collector.open.call_count == 1
+ assert support.collector.close.call_count == 1
+ assert support.collect_internal_data.call_count == 1
+
+
+@skipIf(not bool(pytest), "Pytest required")
+@skipIf(NO_MOCK, NO_MOCK_REASON)
+class LogCollectorTestCase(TestCase, LoaderModuleMockMixin):
+ """
+ Test cases for salt.modules.support::LogCollector
+ """
+
+ def setup_loader_modules(self):
+ return {saltsupport: {}}
+
+ def test_msg(self):
+ """
+ Test message to the log collector.
+
+ :return:
+ """
+ utcmock = MagicMock()
+ utcmock.utcnow = MagicMock(return_value=datetime.datetime.utcfromtimestamp(0))
+ with patch("datetime.datetime", utcmock):
+ msg = "Upgrading /dev/null device"
+ out = saltsupport.LogCollector()
+ out.msg(msg, title="Here")
+ assert saltsupport.LogCollector.INFO in out.messages
+ assert (
+ type(out.messages[saltsupport.LogCollector.INFO])
+ == saltsupport.LogCollector.MessagesList
+ )
+ assert out.messages[saltsupport.LogCollector.INFO] == [
+ "00:00:00.000 - {}: {}".format("Here", msg)
+ ]
+
+ def test_info_message(self):
+ """
+ Test info message to the log collector.
+
+ :return:
+ """
+ utcmock = MagicMock()
+ utcmock.utcnow = MagicMock(return_value=datetime.datetime.utcfromtimestamp(0))
+ with patch("datetime.datetime", utcmock):
+ msg = "SIMM crosstalk during tectonic stress"
+ out = saltsupport.LogCollector()
+ out.info(msg)
+ assert saltsupport.LogCollector.INFO in out.messages
+ assert (
+ type(out.messages[saltsupport.LogCollector.INFO])
+ == saltsupport.LogCollector.MessagesList
+ )
+ assert out.messages[saltsupport.LogCollector.INFO] == [
+ "00:00:00.000 - {}".format(msg)
+ ]
+
+ def test_put_message(self):
+ """
+ Test put message to the log collector.
+
+ :return:
+ """
+ utcmock = MagicMock()
+ utcmock.utcnow = MagicMock(return_value=datetime.datetime.utcfromtimestamp(0))
+ with patch("datetime.datetime", utcmock):
+ msg = "Webmaster kidnapped by evil cult"
+ out = saltsupport.LogCollector()
+ out.put(msg)
+ assert saltsupport.LogCollector.INFO in out.messages
+ assert (
+ type(out.messages[saltsupport.LogCollector.INFO])
+ == saltsupport.LogCollector.MessagesList
+ )
+ assert out.messages[saltsupport.LogCollector.INFO] == [
+ "00:00:00.000 - {}".format(msg)
+ ]
+
+ def test_warning_message(self):
+ """
+ Test warning message to the log collector.
+
+ :return:
+ """
+ utcmock = MagicMock()
+ utcmock.utcnow = MagicMock(return_value=datetime.datetime.utcfromtimestamp(0))
+ with patch("datetime.datetime", utcmock):
+ msg = "Your e-mail is now being delivered by USPS"
+ out = saltsupport.LogCollector()
+ out.warning(msg)
+ assert saltsupport.LogCollector.WARNING in out.messages
+ assert (
+ type(out.messages[saltsupport.LogCollector.WARNING])
+ == saltsupport.LogCollector.MessagesList
+ )
+ assert out.messages[saltsupport.LogCollector.WARNING] == [
+ "00:00:00.000 - {}".format(msg)
+ ]
+
+ def test_error_message(self):
+ """
+ Test error message to the log collector.
+
+ :return:
+ """
+ utcmock = MagicMock()
+ utcmock.utcnow = MagicMock(return_value=datetime.datetime.utcfromtimestamp(0))
+ with patch("datetime.datetime", utcmock):
+ msg = "Learning curve appears to be fractal"
+ out = saltsupport.LogCollector()
+ out.error(msg)
+ assert saltsupport.LogCollector.ERROR in out.messages
+ assert (
+ type(out.messages[saltsupport.LogCollector.ERROR])
+ == saltsupport.LogCollector.MessagesList
+ )
+ assert out.messages[saltsupport.LogCollector.ERROR] == [
+ "00:00:00.000 - {}".format(msg)
+ ]
+
+ def test_hl_message(self):
+ """
+ Test highlighter message to the log collector.
+
+ :return:
+ """
+ utcmock = MagicMock()
+ utcmock.utcnow = MagicMock(return_value=datetime.datetime.utcfromtimestamp(0))
+ with patch("datetime.datetime", utcmock):
+ out = saltsupport.LogCollector()
+ out.highlight("The {} TTYs became {} TTYs and vice versa", "real", "pseudo")
+ assert saltsupport.LogCollector.INFO in out.messages
+ assert (
+ type(out.messages[saltsupport.LogCollector.INFO])
+ == saltsupport.LogCollector.MessagesList
+ )
+ assert out.messages[saltsupport.LogCollector.INFO] == [
+ "00:00:00.000 - The real TTYs became " "pseudo TTYs and vice versa"
+ ]
--
2.29.2
