def main(mode): __opts__ = salt.config.client_config('%s/plugins/salt/etc/salt/master' % gl.get_value('wkdir')) event = salt.utils.event.MasterEvent(__opts__['sock_dir']) for eachevent in event.iter_events(full=True): ret = eachevent['data'] print eachevent if "salt/job/" in eachevent['tag']: #Return Event if ret.has_key('id') and ret.has_key('jid') and ( ret.has_key('return') or ret.has_key('stdout')): try: ret['fun'] except: ret['fun'] = 'ssh.shell' finally: pass #Ignore saltutil.find_job event if ret['fun'] == "saltutil.find_job" or ret[ 'fun'] == "mine.update": continue # 重写SALT-SSH模块中无法获取success状态,统一获取retcode代码 ret['success'] = ret['retcode'] try: ret['return'] except: ret['return'] = ret['stdout'] + ret['stderr'] finally: pass if mode == 'rundaemon': # write SQL mode (存在阻塞问题) #i=1 #while True: # sql = ''' select count(*) as count from apscheduler_logs where jid=%s ''' # result = readDb(sql,(ret['jid'],)) # if result[0].get('count') == 0 and (ret['fun'] == 'cmd.run' or ret['fun'] == 'ssh.shell'): # time.sleep(1) #延迟写入数据库1s # if i > 10: # break # i+=1 # else: # sql = ''' UPDATE apscheduler_logs SET full_ret=CONCAT(full_ret,"_sep_",%s),run_status=%s where jid=%s ''' # break #writeDb(sql,(json.dumps(ret),ret['success'],ret['jid'])) # # storage result file mkdir('%s/plugins/salt/jid/%s' % (gl.get_value('wkdir'), ret['jid'][0:8])) rfile = open( '%s/plugins/salt/jid/%s/%s' % (gl.get_value('wkdir'), ret['jid'][0:8], ret['jid']), 'a') rfile.write('%s\n' % json.dumps(ret)) rfile.close() else: print ret # Other Event else: pass
def EventLog2db(): event = salt.utils.event.MasterEvent('/var/run/salt/master') for eachevent in event.iter_events(full=True): ret = eachevent['data'] if ("ret" in eachevent['tag']) and ret.has_key('fun') and ret['return'] <> '' and ret['fun'] == "cmd.run": logger.info( 'update Salt return: %s - %s' % (ret["jid"], time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))) db_session.UpdateSaltReturns(str(ret["success"]), ret["return"], json.dumps(ret), ret["_stamp"], ret["jid"])
def run(config, argv): args = docopt(__doc__, argv=argv) sys.stdout.write('Listening for events\n') event = salt.utils.event.MasterEvent('/var/run/salt/master') for data in event.iter_events(): print(data)
def run(self): """ Enter into the server loop """ salt.utils.process.appendproctitle(self.__class__.__name__) # instantiate some classes inside our new process with salt.utils.event.get_event( self.opts["__role"], self.opts["sock_dir"], self.opts["transport"], opts=self.opts, listen=True, ) as event: self.wrap = ReactWrap(self.opts) for data in event.iter_events(full=True): # skip all events fired by ourselves if data["data"].get("user") == self.wrap.event_user: continue if data["tag"].endswith("salt/reactors/manage/add"): _data = data["data"] res = self.add_reactor(_data["event"], _data["reactors"]) event.fire_event( { "reactors": self.list_all(), "result": res }, "salt/reactors/manage/add-complete", ) elif data["tag"].endswith("salt/reactors/manage/delete"): _data = data["data"] res = self.delete_reactor(_data["event"]) event.fire_event( { "reactors": self.list_all(), "result": res }, "salt/reactors/manage/delete-complete", ) elif data["tag"].endswith("salt/reactors/manage/list"): event.fire_event( {"reactors": self.list_all()}, "salt/reactors/manage/list-results", ) else: reactors = self.list_reactors(data["tag"]) if not reactors: continue chunks = self.reactions(data["tag"], data["data"], reactors) if chunks: try: self.call_reactions(chunks) except SystemExit: log.warning("Exit ignored by reactor")
def run(self): ''' Enter into the server loop ''' salt.utils.process.appendproctitle(self.__class__.__name__) # instantiate some classes inside our new process with salt.utils.event.get_event(self.opts['__role'], self.opts['sock_dir'], self.opts['transport'], opts=self.opts, listen=True) as event: self.wrap = ReactWrap(self.opts) for data in event.iter_events(full=True): # skip all events fired by ourselves if data['data'].get('user') == self.wrap.event_user: continue if data['tag'].endswith('salt/reactors/manage/add'): _data = data['data'] res = self.add_reactor(_data['event'], _data['reactors']) event.fire_event( { 'reactors': self.list_all(), 'result': res }, 'salt/reactors/manage/add-complete') elif data['tag'].endswith('salt/reactors/manage/delete'): _data = data['data'] res = self.delete_reactor(_data['event']) event.fire_event( { 'reactors': self.list_all(), 'result': res }, 'salt/reactors/manage/delete-complete') elif data['tag'].endswith('salt/reactors/manage/list'): event.fire_event({'reactors': self.list_all()}, 'salt/reactors/manage/list-results') else: reactors = self.list_reactors(data['tag']) if not reactors: continue chunks = self.reactions(data['tag'], data['data'], reactors) if chunks: try: self.call_reactions(chunks) except SystemExit: log.warning('Exit ignored by reactor')
def main(self): # defer import to prevent salt to mess with logging import salt.syspaths as syspaths import salt.config import salt.utils.event master_conf = os.path.join(syspaths.CONFIG_DIR, 'master') opts = salt.config.client_config(master_conf) logger.debug("Initialize MasterEvent with %s", opts['sock_dir']) event = salt.utils.event.MasterEvent(opts['sock_dir']) try: for data in event.iter_events(full=True): logger.info("Event: %s", data) except KeyboardInterrupt: sys.exit(0)
def main(self): # defer import to prevent salt to mess with logging import salt.syspaths as syspaths import salt.config import salt.utils.event master_conf = os.path.join(syspaths.CONFIG_DIR, "master") opts = salt.config.client_config(master_conf) logger.debug("Initialize MasterEvent with %s", opts["sock_dir"]) event = salt.utils.event.MasterEvent(opts["sock_dir"]) try: for data in event.iter_events(full=True): logger.info("Event: %s", data) except KeyboardInterrupt: sys.exit(0)
def salt_master_events(): log = logging.getLogger(__name__) log.debug('Starting Cloudseed Salt Events Reactor') event = salt.utils.event.MasterEvent('/var/run/salt/master') for data in event.iter_events(tag='cloudseed'): log.debug('%s', data) action = data.get('fun', None) if action in ('create.master', 'create.minion'): index = { 'create.master': cloudseed.agent.actions.register_master, 'create.minion': cloudseed.agent.actions.register_minion } try: index[action](data['return']) except Exception as e: log.exception(e)
def salt_master_events(): log = logging.getLogger(__name__) log.debug("Starting Cloudseed Salt Events Reactor") event = salt.utils.event.MasterEvent("/var/run/salt/master") for data in event.iter_events(tag="cloudseed"): log.debug("%s", data) action = data.get("fun", None) if action in ("create.master", "create.minion"): index = { "create.master": cloudseed.agent.actions.register_master, "create.minion": cloudseed.agent.actions.register_minion, } try: index[action](data["return"]) except Exception as e: log.exception(e)
def run(self): event = salt.utils.event.MasterEvent(__opts__["sock_dir"]) for eachevent in event.iter_events(full=True): if "salt/job/" in eachevent["tag"]: data = eachevent["data"] if data.has_key("return"): if data["fun"] in [ "grains.append", "grains.remove", "grains.setval", "grains.setvals", "grains.items"]: """Filter grains function""" LOG.debug("%s grains action %s %s" % (data["id"], data["fun"], data["return"])) getattr(self, data["fun"].split(".")[1])\ (data["id"], data["return"]) elif data["fun"] in [ "saltutil.sync_grains", "saltutil.sync_all", "saltutil.sync_modules", "saltutil.refresh_pillar"]: """Filter pillar function""" LOG.debug("%s pillar action %s %s" % (data["id"], data["fun"], data["return"])) id = data["id"] if self.is_same(id): LOG.debug("%s pillar has update, update" % id) data = self.get_by_cache(id) values["id"] = id values["type"] = "server" values["property"] = data models.insert_or_update(values) else: LOG.debug("%s pillar has not update, continue" % id) if data["fun"] == "grains.delval": if data.has_key("return") and data["success"]: LOG.debug("grains action %s %s for %s" % (data["fun"], data["id"], data["return"])) getattr(self, "delval")(data["id"], data["fun_args"])
def get_event(self): __opts__ = salt.config.client_config(self.salt_config_path) event = salt.utils.event.MasterEvent(__opts__['sock_dir']) for eachevent in event.iter_events(full=True): try: date = time.strftime('%Y-%m-%d', time.localtime()) log_path = os.path.join(os.path.dirname(__file__), date + '.log') event_tag = eachevent['tag'] event_data = eachevent['data'] if event_data.has_key('fun') and event_data.has_key('id') and event_data.has_key('return'): if event_data['fun'] == "cmd.run": id = salt_returner_ext.insert_sql.delay(event_tag, event_data) self.write_log(id, log_path) else: msg = event_data self.write_log(msg, log_path) else: msg = event_data self.write_log(msg, log_path) except Exception, e: error_log_path = os.path.join(os.path.dirname(__file__), date + '_error.log') msg = e self.write_log(msg, error_log_path)
except OSError: print 'first fork error!' os._exit(1) event = salt.utils.event.MasterEvent('/var/run/salt/master') flag = False reg = re.compile('salt/job/([0-9]+)/new') reg1 = reg #a process to exec. command, but will sleep some time #another process listen the event #if we use this method, we can filter the event through func. name record = {} failedrecord = {} jid = 0 #try: for eachevent in event.iter_events(tag='salt/job', full=True): eachevent = dict(eachevent) result = reg.findall(eachevent['tag']) if not flag and result: flag = True jid = result[0] print " job_id: " + jid print " Command: " + dict(eachevent['data'])['fun'] + ' ' + str( dict(eachevent['data'])['arg']) print " RunAs: " + dict(eachevent['data'])['user'] print "exec_time: " + dict(eachevent['data'])['_stamp'] print "host_list: " + str(dict(eachevent['data'])['minions']) sys.stdout.flush() record[jid] = eachevent['data']['minions'] failedrecord[jid] = [] reg1 = re.compile('salt/job/' + jid + '/ret/([0-9.]+)')
def run(self): ''' Enter into the server loop ''' salt.utils.process.appendproctitle(self.__class__.__name__) # instantiate some classes inside our new process with salt.utils.event.get_event(self.opts['__role'], self.opts['sock_dir'], self.opts['transport'], opts=self.opts, listen=True) as event: self.wrap = ReactWrap(self.opts) for data in event.iter_events(full=True): # skip all events fired by ourselves if data['data'].get('user') == self.wrap.event_user: continue # NOTE: these events must contain the masters key in order to be accepted # see salt.runners.reactor for the requesting interface if 'salt/reactors/manage' in data['tag']: master_key = salt.utils.master.get_master_key( 'root', self.opts) if data['data'].get('key') != master_key: log.error( 'received salt/reactors/manage event without matching master_key. discarding' ) continue if data['tag'].endswith('salt/reactors/manage/is_leader'): event.fire_event( { 'result': self.is_leader, 'user': self.wrap.event_user }, 'salt/reactors/manage/leader/value') if data['tag'].endswith('salt/reactors/manage/set_leader'): # we only want to register events from the local master if data['data'].get('id') == self.opts['id']: self.is_leader = data['data']['value'] event.fire_event( { 'result': self.is_leader, 'user': self.wrap.event_user }, 'salt/reactors/manage/leader/value') if data['tag'].endswith('salt/reactors/manage/add'): _data = data['data'] res = self.add_reactor(_data['event'], _data['reactors']) event.fire_event( { 'reactors': self.list_all(), 'result': res, 'user': self.wrap.event_user }, 'salt/reactors/manage/add-complete') elif data['tag'].endswith('salt/reactors/manage/delete'): _data = data['data'] res = self.delete_reactor(_data['event']) event.fire_event( { 'reactors': self.list_all(), 'result': res, 'user': self.wrap.event_user }, 'salt/reactors/manage/delete-complete') elif data['tag'].endswith('salt/reactors/manage/list'): event.fire_event( { 'reactors': self.list_all(), 'user': self.wrap.event_user }, 'salt/reactors/manage/list-results') # do not handle any reactions if not leader in cluster if not self.is_leader: continue else: reactors = self.list_reactors(data['tag']) if not reactors: continue chunks = self.reactions(data['tag'], data['data'], reactors) if chunks: if self.opts['master_stats']: _data = data['data'] start = time.time() try: self.call_reactions(chunks) except SystemExit: log.warning('Exit ignored by reactor') if self.opts['master_stats']: stats = salt.utils.event.update_stats( self.stats, start, _data) self._post_stats(stats)
if deleted_instance == 1: logging.debug("Trove Instance %s which belongs Tenant %s is DELETED" % (trove_instance_id, tenant_id)) return False elif deleted_instance == 0: logging.debug("Trove Instance %s which belongs Tenant %s is DELETED" % (trove_instance_id, tenant_id)) return True logging.warning("Trove Instance matching Error %s which belongs Tenant %s" % (trove_instance_id, tenant_id)) return False except mdb.Error, e: print "Error executing DB Query" raise e logging.warning("Trove Instance matching Error %s which belongs Tenant" % (trove_instance_id, tenant_id)) for data in event.iter_events(tag='auth'): if data['act'] == "pend": salt_key_id = data['id'] if salt_key_id == "trove-salt-box.dbaas-internal": logging.debug("Salt Key trove-salt-box.dbaas-internal accepted") accept_Salt_key(salt_key_id) else: print salt_key_id.split('.') trove_ins_id = salt_key_id.split('.')[1] trove_tenant_id = salt_key_id.split('.')[2] logging.debug("Trove ID : %s" % trove_ins_id) logging.debug("Tenant ID : %s" % trove_tenant_id) if check_valid_trove_instance(trove_ins_id, trove_tenant_id): logging.debug("Salt Key %s seems to be from a valid guest instance" % salt_key_id) accept_Salt_key(salt_key_id)
import salt.config import salt.utils.event import os import time opts = salt.config.client_config('/etc/salt/master') event = salt.utils.event.get_event('master', sock_dir=opts['sock_dir'], transport=opts['transport'], opts=opts) os.system('cls' if os.name == 'nt' else 'clear') start_time = None for event_data in event.iter_events(tag='formula_status'): if start_time == None: start_time = time.time() data, tag = event_data["data"], event_data["tag"] progress_curr = data.get("progress_curr", False) progress_max = data.get("progress_max", False) if progress_curr and progress_max: print "Formula Progress:", (float(progress_curr) / float(progress_max)) * 100, "%", data.get( "message", ""), "-", int(time.time() - start_time), "s" else: print data.get("message", "Status updated!"), "-", int(time.time() - start_time), "s"
#!/bin/env python import json import salt.utils.event from common.db import DB opts = salt.config.client_config('/etc/salt/master') # Listen Salt Master Event System event = salt.utils.event.MasterEvent(opts['sock_dir']) for event_info in event.iter_events(full=True): ret = event_info['data'] if "salt/job/" in event_info['tag']: # Return Event if 'id' in ret and 'return' in ret: # Ignore saltutil.find_job event if ret['fun'] == "saltutil.find_job": continue db = DB() print(ret) db.insert("salt_return", json.dumps(ret, ensure_ascii=False)) db.close_mysql() # Other Event else: pass
import salt.config import salt.utils.event import os import time opts = salt.config.client_config('/etc/salt/master') event = salt.utils.event.get_event( 'master', sock_dir=opts['sock_dir'], transport=opts['transport'], opts=opts) os.system('cls' if os.name == 'nt' else 'clear') start_time = None for event_data in event.iter_events(tag='formula_status'): if start_time == None: start_time = time.time() data, tag = event_data["data"], event_data["tag"] progress_curr = data.get("progress_curr", False) progress_max = data.get("progress_max", False) if progress_curr and progress_max: print "Formula Progress:", (float(progress_curr) / float(progress_max)) * 100, "%", data.get("message", ""), "-", int(time.time() - start_time), "s" else: print data.get("message", "Status updated!"), "-", int(time.time() - start_time), "s"
#!/usr/bin/python import salt.config import salt.utils.event import log __opts__ = salt.config.client_config('/etc/salt/master') loger = log.Log("salt") loger.set_Path('./logs/') event = salt.utils.event.MasterEvent(__opts__['sock_dir']) for eachevent in event.iter_events(full=True): ret = eachevent['data'] if "salt/job/" in eachevent['tag']: if ret.has_key('id') and ret.has_key('return'): if ret['fun'] == "saltutil.find_job": continue try: msg = str(ret['jid']) + " " + str(ret['id']) + " " + str( ret['fun']) + " " + str(ret['fun_args']) + " " + str( ret['retcode']) + " " + str(ret['success']) loger.set_Level("info") except: msg = ret if str(ret['success']) != "True" or int(ret['retcode']) != 0: loger.set_Level("error") loger.set_Name("msg") loger.add_Msg(msg) elif "salt/auth" in eachevent['tag']: try: msg = str(ret['_stamp']) + " " + str(ret['act']) + " " + str( ret['id']) + " " + str(ret['result'])
# Import salt modules import salt.config import salt.utils.event # Import third party libs import MySQLdb __opts__ = salt.config.client_config('/etc/salt/master') # Create MySQL connect conn = MySQLdb.connect(host=__opts__['mysql.host'], user=__opts__['mysql.user'], passwd=__opts__['mysql.pass'], db=__opts__['mysql.db'], port=__opts__['mysql.port']) cursor = conn.cursor() # Listen Salt Master Event System event = salt.utils.event.MasterEvent(__opts__['sock_dir']) for eachevent in event.iter_events(full=True): ret = eachevent['data'] if "salt/job/" in eachevent['tag']: # Return Event if ret.has_key('id') and ret.has_key('return'): # Igonre saltutil.find_job event if ret['fun'] == "saltutil.find_job": continue sql = '''INSERT INTO `salt_returns` (`fun`, `jid`, `returns`, `id`, `success`, `full_ret` ) VALUES (%s, %s, %s, %s, %s, %s)''' cursor.execute(sql, (ret['fun'], ret['jid'], json.dumps(ret['return']), ret['id'], ret['success'], json.dumps(ret))) cursor.execute("COMMIT")
def rerun(): inflight = {} # a dictionary for jobs with pending returned results repeat_count = 0 m = None client = salt.client.LocalClient('/etc/salt/minion') for data in event.iter_events(tag='rerun', full=True): # this is the inner event loop... # print 'data =', (data) target = data['data']['id'] fun = data['data']['data']['fun'] fun_args = data['data']['data']['fun_args'] RERUN_IT = True REDUCER_CALLBACK = True if fun == 'test.arg': # Interactive commands for controlling the mapper enter here... # We repurpose the existing salt test.arg command # # >>> salt "test.arg <command> <args> <kwargs> --return=rerun" # # to control the runner # RERUN_IT = False # ...don't rerun control commands REDUCER_CALLBACK = False # don't callback results from control commands command = fun_args[0].lower() if command == 'abort': print "\"abort\" received, now terminating runner..." return False elif command == 'reset': print "\"reset\" received, now restarting..." return True elif command == 'run': print "run" RERUN_IT = True elif command == 'stop': print "stop" elif command == 'pause': print "pause" elif command == 'stats': print "repeat_count = ", (repeat_count) print "results = ", (m.statit()) elif command == 'mapit': print "mapit" if not m: # run this only once... try: module_name = fun_args[1].split('.')[0] # from module_name import _mapper mod = __import__(module_name) mod = getattr(mod, '_mapper') # this module has a "_mapper" class so use it... m = mod(fun_args[1]) repeat = m.partializer(fun_args[2:]) except: # not a map-reduce style module, so use base mapper class m = mapper(fun_args[1]) repeat = m.partializer(fun_args[2:]) # RERUN_IT = True # # ...causes the initial "partializer" command to be run if REDUCER_CALLBACK: # only callback the reducer if we got "real" results from a salt # execution module if inflight[data['data']['data']['jid']]: # TODO: This should not happen. Investigate why and prevent it m.reducer(data['data']['data']['return']) inflight.pop(data['data']['data']['jid']) try: mod except: RERUN_IT = False # This is NOT a MR enabled salt execution module so don't rerun it else: RERUN_IT = False # ...ignore this spurious event if RERUN_IT: try: my_fun = m.module_name my_fun_args = repeat.next() print "my_fun_args = ", (my_fun_args) minions = client.cmd_async(target, my_fun, my_fun_args, ret='rerun') inflight[minions] = True print "sending...", (my_fun), (my_fun_args), (minions) repeat_count += 1 print 'repeat =', (repeat_count) except StopIteration: print "done." if len(inflight) == 0: # all the results in, ok to terminate exit([m.statit()])
def run(self): """ Enter into the server loop """ salt.utils.process.appendproctitle(self.__class__.__name__) if self.opts[ "reactor_niceness"] and not salt.utils.platform.is_windows(): log.info("Reactor setting niceness to %i", self.opts["reactor_niceness"]) os.nice(self.opts["reactor_niceness"]) # instantiate some classes inside our new process with salt.utils.event.get_event( self.opts["__role"], self.opts["sock_dir"], self.opts["transport"], opts=self.opts, listen=True, ) as event: self.wrap = ReactWrap(self.opts) for data in event.iter_events(full=True): # skip all events fired by ourselves if data["data"].get("user") == self.wrap.event_user: continue # NOTE: these events must contain the masters key in order to be accepted # see salt.runners.reactor for the requesting interface if "salt/reactors/manage" in data["tag"]: master_key = salt.utils.master.get_master_key( "root", self.opts) if data["data"].get("key") != master_key: log.error( "received salt/reactors/manage event without matching" " master_key. discarding") continue if data["tag"].endswith("salt/reactors/manage/is_leader"): event.fire_event({"result": self.is_leader}, "salt/reactors/manage/leader/value") if data["tag"].endswith("salt/reactors/manage/set_leader"): # we only want to register events from the local master if data["data"].get("id") == self.opts["id"]: self.is_leader = data["data"]["value"] event.fire_event({"result": self.is_leader}, "salt/reactors/manage/leader/value") if data["tag"].endswith("salt/reactors/manage/add"): _data = data["data"] res = self.add_reactor(_data["event"], _data["reactors"]) event.fire_event( { "reactors": self.list_all(), "result": res }, "salt/reactors/manage/add-complete", ) elif data["tag"].endswith("salt/reactors/manage/delete"): _data = data["data"] res = self.delete_reactor(_data["event"]) event.fire_event( { "reactors": self.list_all(), "result": res }, "salt/reactors/manage/delete-complete", ) elif data["tag"].endswith("salt/reactors/manage/list"): event.fire_event( {"reactors": self.list_all()}, "salt/reactors/manage/list-results", ) else: # do not handle any reactions if not leader in cluster if not self.is_leader: continue else: reactors = self.list_reactors(data["tag"]) if not reactors: continue chunks = self.reactions(data["tag"], data["data"], reactors) if chunks: try: self.call_reactions(chunks) except SystemExit: log.warning("Exit ignored by reactor")
import salt.utils.event event = salt.utils.event.MasterEvent('/var/run/salt/master') for data in event.iter_events(full=True): print data print '------'
def rerun(): inflight = {} # a dictionary for jobs with pending returned results repeat_count = 0 m = None client = salt.client.LocalClient('/etc/salt/minion') for data in event.iter_events(tag='rerun', full=True): # this is the inner event loop... # print 'data =', (data) target = data['data']['id'] fun = data['data']['data']['fun'] fun_args = data['data']['data']['fun_args'] RERUN_IT = True REDUCER_CALLBACK = True if fun == 'test.arg': # Interactive commands for controlling the mapper enter here... # We repurpose the existing salt test.arg command # # >>> salt "test.arg <command> <args> <kwargs> --return=rerun" # # to control the runner # RERUN_IT = False # ...don't rerun control commands REDUCER_CALLBACK = False # don't callback results from control commands command = fun_args[0].lower() if command == 'abort': print "\"abort\" received, now terminating runner..." return False elif command == 'reset': print "\"reset\" received, now restarting..." return True elif command == 'run': print "run" RERUN_IT = True elif command == 'stop': print "stop" elif command == 'pause': print "pause" elif command == 'stats': print "repeat_count = ", (repeat_count) print "results = ", (m.statit()) elif command == 'mapit': print "mapit" if not m: # run this only once... try: module_name = fun_args[1].split('.')[0] # from module_name import _mapper mod = __import__(module_name) mod = getattr(mod, '_mapper') # this module has a "_mapper" class so use it... m = mod(fun_args[1]) repeat = m.partializer(fun_args[2:]) except: # not a map-reduce style module, so use base mapper class m = mapper(fun_args[1]) repeat = m.partializer(fun_args[2:]) # RERUN_IT = True # # ...causes the initial "partializer" command to be run if REDUCER_CALLBACK: # only callback the reducer if we got "real" results from a salt # execution module if inflight[data['data']['data']['jid']]: # TODO: This should not happen. Investigate why and prevent it m.reducer(data['data']['data']['return']) inflight.pop(data['data']['data']['jid']) try: mod except: RERUN_IT = False # This is NOT a MR enabled salt execution module so don't rerun it else: RERUN_IT = False # ...ignore this spurious event if RERUN_IT: try: my_fun = m.module_name my_fun_args = repeat.next() print "my_fun_args = ", (my_fun_args) minions = client.cmd_async(target, my_fun, my_fun_args, ret='rerun') inflight[minions] = True print "sending...", (my_fun), (my_fun_args), (minions) repeat_count += 1 print 'repeat =', (repeat_count) except StopIteration: print "done." if len(inflight) == 0: # all the results in, ok to terminate exit([m.statit()])