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()])
