golden hour

/opt/saltstack/salt/lib/python3.10/site-packages/salt/returners

File/Folder	Size	Actions
__init__.py	5.98 KB
__pycache__	-
appoptics_return.py	6.11 KB
carbon_return.py	8.24 KB
cassandra_cql_return.py	15.14 KB
cassandra_return.py	2.41 KB
couchbase_return.py	8.88 KB
couchdb_return.py	10.35 KB
django_return.py	2.57 KB
elasticsearch_return.py	12.18 KB
etcd_return.py	7.9 KB
highstate_return.py	15.59 KB
influxdb_return.py	8.03 KB
kafka_return.py	2.12 KB
librato_return.py	4.29 KB
local.py	541 B
local_cache.py	17.39 KB
mattermost_returner.py	4.08 KB
memcache_return.py	5.72 KB
mongo_future_return.py	10.01 KB
mongo_return.py	6.06 KB
multi_returner.py	2.82 KB
mysql.py	18.81 KB
nagios_nrdp_return.py	4.92 KB
odbc.py	7.77 KB
pgjsonb.py	17.36 KB
postgres.py	10.33 KB
postgres_local_cache.py	10.82 KB
pushover_returner.py	6.55 KB
rawfile_json.py	2.23 KB
redis_return.py	8.55 KB
sentry_return.py	5.24 KB
slack_returner.py	6.02 KB
slack_webhook_return.py	11.22 KB
sms_return.py	2.64 KB
smtp_return.py	8.2 KB
splunk.py	5.84 KB
sqlite3_return.py	7.73 KB
syslog_return.py	5.26 KB
telegram_return.py	1.92 KB
xmpp_return.py	4.81 KB
zabbix_return.py	2.45 KB

Edit: multi_returner.py

"""
Read/Write multiple returners

"""

import logging

import salt.minion

log = logging.getLogger(__name__)

CONFIG_KEY = "multi_returner"

# cache of the master mininon for this returner
MMINION = None

def _mminion():
    """
    Create a single mminion for this module to use, instead of reloading all the time
    """
    global MMINION

if MMINION is None:
        MMINION = salt.minion.MasterMinion(__opts__)

return MMINION

def prep_jid(nocache=False, passed_jid=None):
    """
    Call both with prep_jid on all returners in multi_returner

TODO: finish this, what do do when you get different jids from 2 returners...
    since our jids are time based, this make this problem hard, because they
    aren't unique, meaning that we have to make sure that no one else got the jid
    and if they did we spin to get a new one, which means "locking" the jid in 2
    returners is non-trivial
    """

jid = passed_jid
    for returner_ in __opts__[CONFIG_KEY]:
        if jid is None:
            jid = _mminion().returners["{}.prep_jid".format(returner_)](nocache=nocache)
        else:
            r_jid = _mminion().returners["{}.prep_jid".format(returner_)](
                nocache=nocache
            )
            if r_jid != jid:
                log.debug("Uhh.... crud the jids do not match")
    return jid

def returner(load):
    """
    Write return to all returners in multi_returner
    """
    for returner_ in __opts__[CONFIG_KEY]:
        _mminion().returners["{}.returner".format(returner_)](load)

def save_load(jid, clear_load, minions=None):
    """
    Write load to all returners in multi_returner
    """
    for returner_ in __opts__[CONFIG_KEY]:
        _mminion().returners["{}.save_load".format(returner_)](jid, clear_load)

def save_minions(jid, minions, syndic_id=None):  # pylint: disable=unused-argument
    """
    Included for API consistency
    """

def get_load(jid):
    """
    Merge the load data from all returners
    """
    ret = {}
    for returner_ in __opts__[CONFIG_KEY]:
        ret.update(_mminion().returners["{}.get_load".format(returner_)](jid))

return ret

def get_jid(jid):
    """
    Merge the return data from all returners
    """
    ret = {}
    for returner_ in __opts__[CONFIG_KEY]:
        ret.update(_mminion().returners["{}.get_jid".format(returner_)](jid))

return ret

def get_jids():
    """
    Return all job data from all returners
    """
    ret = {}
    for returner_ in __opts__[CONFIG_KEY]:
        ret.update(_mminion().returners["{}.get_jids".format(returner_)]())

return ret

def clean_old_jobs():
    """
    Clean out the old jobs from all returners (if you have it)
    """
    for returner_ in __opts__[CONFIG_KEY]:
        fstr = "{}.clean_old_jobs".format(returner_)
        if fstr in _mminion().returners:
            _mminion().returners[fstr]()