class ShinkenTest(unittest.TestCase, _Unittest2CompatMixIn):
def setUp(self):
self.setup_with_file('etc/shinken_1r_1h_1s.cfg')
def setup_with_file(self, path):
time_hacker.set_my_time()
self.print_header()
# i am arbiter-like
self.broks = {}
self.me = None
self.log = logger
self.log.load_obj(self)
self.config_files = [path]
self.conf = Config()
buf = self.conf.read_config(self.config_files)
raw_objects = self.conf.read_config_buf(buf)
self.conf.create_objects_for_type(raw_objects, 'arbiter')
self.conf.create_objects_for_type(raw_objects, 'module')
self.conf.early_arbiter_linking()
self.conf.create_objects(raw_objects)
self.conf.instance_id = 0
self.conf.instance_name = 'test'
# Hack push_flavor, that is set by the dispatcher
self.conf.push_flavor = 0
self.conf.load_triggers()
#import pdb;pdb.set_trace()
self.conf.linkify_templates()
#import pdb;pdb.set_trace()
self.conf.apply_inheritance()
#import pdb;pdb.set_trace()
self.conf.explode()
#print "Aconf.services has %d elements" % len(self.conf.services)
self.conf.apply_implicit_inheritance()
self.conf.fill_default()
self.conf.remove_templates()
self.conf.compute_hash()
#print "conf.services has %d elements" % len(self.conf.services)
self.conf.override_properties()
self.conf.linkify()
self.conf.apply_dependencies()
self.conf.explode_global_conf()
self.conf.propagate_timezone_option()
self.conf.create_business_rules()
self.conf.create_business_rules_dependencies()
self.conf.is_correct()
if not self.conf.conf_is_correct:
print "The conf is not correct, I stop here"
self.conf.dump()
return
self.conf.clean()
self.confs = self.conf.cut_into_parts()
self.conf.prepare_for_sending()
self.conf.show_errors()
self.dispatcher = Dispatcher(self.conf, self.me)
scheddaemon = Shinken(None, False, False, False, None, None)
self.sched = Scheduler(scheddaemon)
scheddaemon.sched = self.sched
scheddaemon.modules_dir = modules_dir
scheddaemon.load_modules_manager()
# Remember to clean the logs we just created before launching tests
self.clear_logs()
m = MacroResolver()
m.init(self.conf)
self.sched.load_conf(self.conf, in_test=True)
e = ExternalCommandManager(self.conf, 'applyer')
self.sched.external_command = e
e.load_scheduler(self.sched)
e2 = ExternalCommandManager(self.conf, 'dispatcher')
e2.load_arbiter(self)
self.external_command_dispatcher = e2
self.sched.conf.accept_passive_unknown_check_results = False
self.sched.schedule()
def add(self, b):
if isinstance(b, Brok):
self.broks[b.id] = b
return
if isinstance(b, ExternalCommand):
self.sched.run_external_command(b.cmd_line)
def fake_check(self, ref, exit_status, output="OK"):
#print "fake", ref
now = time.time()
ref.schedule(force=True)
# now checks are schedule and we get them in
# the action queue
#check = ref.actions.pop()
check = ref.checks_in_progress[0]
self.sched.add(check) # check is now in sched.checks[]
# Allows to force check scheduling without setting its status nor
# output. Useful for manual business rules rescheduling, for instance.
if exit_status is None:
return
# fake execution
check.check_time = now
# and lie about when we will launch it because
# if not, the schedule call for ref
# will not really reschedule it because there
# is a valid value in the future
ref.next_chk = now - 0.5
check.get_outputs(output, 9000)
check.exit_status = exit_status
check.execution_time = 0.001
check.status = 'waitconsume'
self.sched.waiting_results.append(check)
def scheduler_loop(self, count, reflist, do_sleep=False, sleep_time=61, verbose=True):
for ref in reflist:
(obj, exit_status, output) = ref
obj.checks_in_progress = []
for loop in range(1, count + 1):
if verbose is True:
print "processing check", loop
for ref in reflist:
(obj, exit_status, output) = ref
obj.update_in_checking()
self.fake_check(obj, exit_status, output)
self.sched.manage_internal_checks()
self.sched.consume_results()
self.sched.get_new_actions()
self.sched.get_new_broks()
self.sched.scatter_master_notifications()
self.worker_loop(verbose)
for ref in reflist:
(obj, exit_status, output) = ref
obj.checks_in_progress = []
self.sched.update_downtimes_and_comments()
#time.sleep(ref.retry_interval * 60 + 1)
if do_sleep:
time.sleep(sleep_time)
def worker_loop(self, verbose=True):
self.sched.delete_zombie_checks()
self.sched.delete_zombie_actions()
checks = self.sched.get_to_run_checks(True, False, worker_name='tester')
actions = self.sched.get_to_run_checks(False, True, worker_name='tester')
#print "------------ worker loop checks ----------------"
#print checks
#print "------------ worker loop actions ----------------"
if verbose is True:
self.show_actions()
#print "------------ worker loop new ----------------"
for a in actions:
a.status = 'inpoller'
a.check_time = time.time()
a.exit_status = 0
self.sched.put_results(a)
if verbose is True:
self.show_actions()
#print "------------ worker loop end ----------------"
def show_logs(self):
print "--- logs <<<----------------------------------"
if hasattr(self, "sched"):
broks = self.sched.broks
else:
broks = self.broks
for brok in sorted(broks.values(), lambda x, y: x.id - y.id):
if brok.type == 'log':
brok.prepare()
safe_print("LOG: ", brok.data['log'])
print "--- logs >>>----------------------------------"
def show_actions(self):
print "--- actions <<<----------------------------------"
if hasattr(self, "sched"):
actions = self.sched.actions
else:
actions = self.actions
for a in sorted(actions.values(), lambda x, y: x.id - y.id):
if a.is_a == 'notification':
if a.ref.my_type == "host":
ref = "host: %s" % a.ref.get_name()
else:
ref = "host: %s svc: %s" % (a.ref.host.get_name(), a.ref.get_name())
print "NOTIFICATION %d %s %s %s %s" % (a.id, ref, a.type, time.asctime(time.localtime(a.t_to_go)), a.status)
elif a.is_a == 'eventhandler':
print "EVENTHANDLER:", a
print "--- actions >>>----------------------------------"
def show_and_clear_logs(self):
self.show_logs()
self.clear_logs()
def show_and_clear_actions(self):
self.show_actions()
self.clear_actions()
def count_logs(self):
if hasattr(self, "sched"):
broks = self.sched.broks
else:
broks = self.broks
return len([b for b in broks.values() if b.type == 'log'])
def count_actions(self):
if hasattr(self, "sched"):
actions = self.sched.actions
else:
actions = self.actions
return len(actions.values())
def clear_logs(self):
if hasattr(self, "sched"):
broks = self.sched.broks
else:
broks = self.broks
id_to_del = []
for b in broks.values():
if b.type == 'log':
id_to_del.append(b.id)
for id in id_to_del:
del broks[id]
def clear_actions(self):
if hasattr(self, "sched"):
self.sched.actions = {}
else:
self.actions = {}
def assert_log_match(self, index, pattern, no_match=False):
# log messages are counted 1...n, so index=1 for the first message
if not no_match:
self.assertGreaterEqual(self.count_logs(), index)
regex = re.compile(pattern)
lognum = 1
broks = sorted(self.sched.broks.values(), lambda x, y: x.id - y.id)
for brok in broks:
if brok.type == 'log':
brok.prepare()
if index == lognum:
if re.search(regex, brok.data['log']):
return
lognum += 1
self.assertTrue(no_match, "%s found a matched log line in broks :\n"
"index=%s pattern=%r\n"
"broks=%r" % (
'*HAVE*' if no_match else 'Not',
index, pattern, broks
))
def _any_log_match(self, pattern, assert_not):
regex = re.compile(pattern)
broks = getattr(self, 'sched', self).broks
broks = sorted(broks.values(), lambda x, y: x.id - y.id)
for brok in broks:
if brok.type == 'log':
brok.prepare()
if re.search(regex, brok.data['log']):
self.assertTrue(not assert_not,
"Found matching log line:\n"
"pattern = %r\nbrok log = %r" % (pattern, brok.data['log'])
)
return
self.assertTrue(assert_not,
"No matching log line found:\n"
"pattern = %r\n" "broks = %r" % (pattern, broks)
)
def assert_any_log_match(self, pattern):
self._any_log_match(pattern, assert_not=False)
def assert_no_log_match(self, pattern):
self._any_log_match(pattern, assert_not=True)
def get_log_match(self, pattern):
regex = re.compile(pattern)
res = []
for brok in sorted(self.sched.broks.values(), lambda x, y: x.id - y.id):
if brok.type == 'log':
if re.search(regex, brok.data['log']):
res.append(brok.data['log'])
return res
def print_header(self):
print "\n" + "#" * 80 + "\n" + "#" + " " * 78 + "#"
print "#" + string.center(self.id(), 78) + "#"
print "#" + " " * 78 + "#\n" + "#" * 80 + "\n"
def xtest_conf_is_correct(self):
self.print_header()
self.assertTrue(self.conf.conf_is_correct)
class ShinkenTest(unittest.TestCase):
def setUp(self):
self.setup_with_file('etc/nagios_1r_1h_1s.cfg')
def setup_with_file(self, path):
# i am arbiter-like
self.broks = {}
self.me = None
self.log = logger
self.log.load_obj(self)
self.config_files = [path]
self.conf = Config()
buf = self.conf.read_config(self.config_files)
raw_objects = self.conf.read_config_buf(buf)
self.conf.create_objects_for_type(raw_objects, 'arbiter')
self.conf.create_objects_for_type(raw_objects, 'module')
self.conf.early_arbiter_linking()
self.conf.create_objects(raw_objects)
self.conf.old_properties_names_to_new()
self.conf.instance_id = 0
self.conf.instance_name = 'test'
# Hack push_flavor, that is set by the dispatcher
self.conf.push_flavor = 0
self.conf.load_triggers()
self.conf.linkify_templates()
self.conf.apply_inheritance()
self.conf.explode()
#print "Aconf.services has %d elements" % len(self.conf.services)
self.conf.create_reversed_list()
self.conf.remove_twins()
self.conf.apply_implicit_inheritance()
self.conf.fill_default()
self.conf.remove_templates()
self.conf.compute_hash()
#print "conf.services has %d elements" % len(self.conf.services)
self.conf.create_reversed_list()
self.conf.pythonize()
self.conf.linkify()
self.conf.apply_dependencies()
self.conf.explode_global_conf()
self.conf.propagate_timezone_option()
self.conf.create_business_rules()
self.conf.create_business_rules_dependencies()
self.conf.is_correct()
if not self.conf.conf_is_correct:
print "The conf is not correct, I stop here"
return
self.confs = self.conf.cut_into_parts()
self.conf.prepare_for_sending()
self.conf.show_errors()
self.dispatcher = Dispatcher(self.conf, self.me)
scheddaemon = Shinken(None, False, False, False, None)
self.sched = Scheduler(scheddaemon)
scheddaemon.sched = self.sched
m = MacroResolver()
m.init(self.conf)
self.sched.load_conf(self.conf, in_test=True)
e = ExternalCommandManager(self.conf, 'applyer')
self.sched.external_command = e
e.load_scheduler(self.sched)
e2 = ExternalCommandManager(self.conf, 'dispatcher')
e2.load_arbiter(self)
self.external_command_dispatcher = e2
self.sched.schedule()
def add(self, b):
if isinstance(b, Brok):
self.broks[b.id] = b
return
if isinstance(b, ExternalCommand):
self.sched.run_external_command(b.cmd_line)
def fake_check(self, ref, exit_status, output="OK"):
#print "fake", ref
now = time.time()
ref.schedule(force=True)
# now checks are schedule and we get them in
# the action queue
#check = ref.actions.pop()
check = ref.checks_in_progress[0]
self.sched.add(check) # check is now in sched.checks[]
# fake execution
check.check_time = now
# and lie about when we will launch it because
# if not, the schedule call for ref
# will not really reschedule it because there
# is a valid value in the future
ref.next_chk = now - 0.5
check.get_outputs(output, 9000)
check.exit_status = exit_status
check.execution_time = 0.001
check.status = 'waitconsume'
self.sched.waiting_results.append(check)
def scheduler_loop(self, count, reflist, do_sleep=False, sleep_time=61):
for ref in reflist:
(obj, exit_status, output) = ref
obj.checks_in_progress = []
for loop in range(1, count + 1):
print "processing check", loop
for ref in reflist:
(obj, exit_status, output) = ref
obj.update_in_checking()
self.fake_check(obj, exit_status, output)
self.sched.manage_internal_checks()
self.sched.consume_results()
self.sched.get_new_actions()
self.sched.get_new_broks()
self.worker_loop()
for ref in reflist:
(obj, exit_status, output) = ref
obj.checks_in_progress = []
self.sched.update_downtimes_and_comments()
#time.sleep(ref.retry_interval * 60 + 1)
if do_sleep:
time.sleep(sleep_time)
def worker_loop(self):
self.sched.delete_zombie_checks()
self.sched.delete_zombie_actions()
checks = self.sched.get_to_run_checks(True,
False,
worker_name='tester')
actions = self.sched.get_to_run_checks(False,
True,
worker_name='tester')
#print "------------ worker loop checks ----------------"
#print checks
#print "------------ worker loop actions ----------------"
self.show_actions()
#print "------------ worker loop new ----------------"
for a in actions:
a.status = 'inpoller'
a.check_time = time.time()
a.exit_status = 0
self.sched.put_results(a)
self.show_actions()
#print "------------ worker loop end ----------------"
def show_logs(self):
print "--- logs <<<----------------------------------"
for brok in sorted(self.sched.broks.values(),
lambda x, y: x.id - y.id):
if brok.type == 'log':
brok.prepare()
print "LOG:", brok.data['log']
print "--- logs >>>----------------------------------"
def show_actions(self):
print "--- actions <<<----------------------------------"
for a in sorted(self.sched.actions.values(), lambda x, y: x.id - y.id):
if a.is_a == 'notification':
if a.ref.my_type == "host":
ref = "host: %s" % a.ref.get_name()
else:
ref = "host: %s svc: %s" % (a.ref.host.get_name(),
a.ref.get_name())
print "NOTIFICATION %d %s %s %s %s" % (
a.id, ref, a.type, time.asctime(time.localtime(
a.t_to_go)), a.status)
elif a.is_a == 'eventhandler':
print "EVENTHANDLER:", a
print "--- actions >>>----------------------------------"
def show_and_clear_logs(self):
self.show_logs()
self.clear_logs()
def show_and_clear_actions(self):
self.show_actions()
self.clear_actions()
def count_logs(self):
return len([b for b in self.sched.broks.values() if b.type == 'log'])
def count_actions(self):
return len(self.sched.actions.values())
def clear_logs(self):
id_to_del = []
for b in self.sched.broks.values():
if b.type == 'log':
id_to_del.append(b.id)
for id in id_to_del:
del self.sched.broks[id]
def clear_actions(self):
self.sched.actions = {}
def log_match(self, index, pattern):
# log messages are counted 1...n, so index=1 for the first message
if index > self.count_logs():
return False
else:
regex = re.compile(pattern)
lognum = 1
for brok in sorted(self.sched.broks.values(),
lambda x, y: x.id - y.id):
if brok.type == 'log':
brok.prepare()
if index == lognum:
if re.search(regex, brok.data['log']):
return True
lognum += 1
return False
def any_log_match(self, pattern):
regex = re.compile(pattern)
for brok in sorted(self.sched.broks.values(),
lambda x, y: x.id - y.id):
if brok.type == 'log':
brok.prepare()
if re.search(regex, brok.data['log']):
return True
return False
def get_log_match(self, pattern):
regex = re.compile(pattern)
res = []
for brok in sorted(self.sched.broks.values(),
lambda x, y: x.id - y.id):
if brok.type == 'log':
if re.search(regex, brok.data['log']):
res.append(brok.data['log'])
return res
def print_header(self):
print "#" * 80 + "\n" + "#" + " " * 78 + "#"
print "#" + string.center(self.id(), 78) + "#"
print "#" + " " * 78 + "#\n" + "#" * 80 + "\n"
def xtest_conf_is_correct(self):
self.print_header()
self.assert_(self.conf.conf_is_correct)
def find_modules_path(self):
""" Find the absolute path of the shinken module directory and returns it. """
import shinken
# BEWARE: this way of finding path is good if we still
# DO NOT HAVE CHANGE PWD!!!
# Now get the module path. It's in fact the directory modules
# inside the shinken directory. So let's find it.
print "modulemanager file", shinken.modulesmanager.__file__
modulespath = os.path.abspath(shinken.modulesmanager.__file__)
print "modulemanager absolute file", modulespath
# We got one of the files of
parent_path = os.path.dirname(os.path.dirname(modulespath))
modulespath = os.path.join(parent_path, 'shinken', 'modules')
print("Using modules path: %s" % (modulespath))
return modulespath
def do_load_modules(self):
self.modules_manager.load_and_init()
self.log.log("I correctly loaded the modules: [%s]" % (','.join(
[inst.get_name() for inst in self.modules_manager.instances])))
def init_livestatus(self, modconf=None):
self.livelogs = 'tmp/livelogs.db' + self.testid
if modconf is None:
modconf = Module({
'module_name': 'LiveStatus',
'module_type': 'livestatus',
'port': str(50000 + os.getpid()),
'pnp_path': 'tmp/pnp4nagios_test' + self.testid,
'host': '127.0.0.1',
'socket': 'live',
'name': 'test', #?
})
dbmodconf = Module({
'module_name':
'LogStore',
'module_type':
'logstore_sqlite',
'use_aggressive_sql':
"0",
'database_file':
self.livelogs,
'archive_path':
os.path.join(os.path.dirname(self.livelogs), 'archives'),
})
modconf.modules = [dbmodconf]
self.livestatus_broker = LiveStatus_broker(modconf)
self.livestatus_broker.create_queues()
#--- livestatus_broker.main
self.livestatus_broker.log = logger
# this seems to damage the logger so that the scheduler can't use it
#self.livestatus_broker.log.load_obj(self.livestatus_broker)
self.livestatus_broker.debug_output = []
self.livestatus_broker.modules_manager = ModulesManager(
'livestatus', self.livestatus_broker.find_modules_path(), [])
self.livestatus_broker.modules_manager.set_modules(
self.livestatus_broker.modules)
# We can now output some previouly silented debug ouput
self.livestatus_broker.do_load_modules()
for inst in self.livestatus_broker.modules_manager.instances:
if inst.properties["type"].startswith('logstore'):
f = getattr(inst, 'load', None)
if f and callable(f):
f(self.livestatus_broker) # !!! NOT self here !!!!
break
for s in self.livestatus_broker.debug_output:
print "errors during load", s
del self.livestatus_broker.debug_output
self.livestatus_broker.rg = LiveStatusRegenerator()
self.livestatus_broker.datamgr = datamgr
datamgr.load(self.livestatus_broker.rg)
self.livestatus_broker.query_cache = LiveStatusQueryCache()
self.livestatus_broker.query_cache.disable()
self.livestatus_broker.rg.register_cache(
self.livestatus_broker.query_cache)
#--- livestatus_broker.main
self.livestatus_broker.init()
self.livestatus_broker.db = self.livestatus_broker.modules_manager.instances[
0]
self.livestatus_broker.livestatus = LiveStatus(
self.livestatus_broker.datamgr, self.livestatus_broker.query_cache,
self.livestatus_broker.db, self.livestatus_broker.pnp_path,
self.livestatus_broker.from_q)
#--- livestatus_broker.do_main
self.livestatus_broker.db.open()
class ShinkenTest(unittest.TestCase):
def setUp(self):
self.setup_with_file('etc/nagios_1r_1h_1s.cfg')
def setup_with_file(self, path):
# i am arbiter-like
self.broks = {}
self.me = None
self.log = logger
self.log.load_obj(self)
self.config_files = [path]
self.conf = Config()
self.conf.read_config(self.config_files)
buf = self.conf.read_config(self.config_files)
raw_objects = self.conf.read_config_buf(buf)
self.conf.create_objects_for_type(raw_objects, 'arbiter')
self.conf.create_objects_for_type(raw_objects, 'module')
self.conf.early_arbiter_linking()
self.conf.create_objects(raw_objects)
self.conf.old_properties_names_to_new()
self.conf.instance_id = 0
self.conf.instance_name = 'test'
self.conf.linkify_templates()
self.conf.apply_inheritance()
self.conf.explode()
self.conf.create_reversed_list()
self.conf.remove_twins()
self.conf.apply_implicit_inheritance()
self.conf.fill_default()
self.conf.remove_templates()
self.conf.create_reversed_list()
self.conf.pythonize()
self.conf.linkify()
self.conf.apply_dependencies()
self.conf.explode_global_conf()
self.conf.propagate_timezone_option()
self.conf.create_business_rules()
self.conf.create_business_rules_dependencies()
self.conf.is_correct()
self.confs = self.conf.cut_into_parts()
self.conf.show_errors()
self.dispatcher = Dispatcher(self.conf, self.me)
scheddaemon = Shinken(None, False, False, False, None)
self.sched = Scheduler(scheddaemon)
scheddaemon.sched = self.sched
m = MacroResolver()
m.init(self.conf)
self.sched.load_conf(self.conf)
e = ExternalCommandManager(self.conf, 'applyer')
self.sched.external_command = e
e.load_scheduler(self.sched)
e2 = ExternalCommandManager(self.conf, 'dispatcher')
e2.load_arbiter(self)
self.external_command_dispatcher = e2
self.sched.schedule()
def add(self, b):
if isinstance(b, Brok):
self.broks[b.id] = b
return
if isinstance(b, ExternalCommand):
self.sched.run_external_command(b.cmd_line)
def fake_check(self, ref, exit_status, output="OK"):
#print "fake", ref
now = time.time()
ref.schedule(force=True)
#now checks are schedule and we get them in
#the action queue
check = ref.actions.pop()
self.sched.add(check) # check is now in sched.checks[]
# fake execution
check.check_time = now
# and lie about when we will launch it because
# if not, the schedule call for ref
# will not really reschedule it because there
# is a valid value in the future
ref.next_chk = now - 0.5
check.get_outputs(output, 9000)
check.exit_status = exit_status
check.execution_time = 0.001
check.status = 'waitconsume'
self.sched.waiting_results.append(check)
def scheduler_loop(self, count, reflist, do_sleep=False, sleep_time=61):
for ref in reflist:
(obj, exit_status, output) = ref
obj.checks_in_progress = []
for loop in range(1, count + 1):
print "processing check", loop
for ref in reflist:
(obj, exit_status, output) = ref
obj.update_in_checking()
self.fake_check(obj, exit_status, output)
self.sched.manage_internal_checks()
self.sched.consume_results()
self.sched.get_new_actions()
self.sched.get_new_broks()
self.worker_loop()
for ref in reflist:
(obj, exit_status, output) = ref
obj.checks_in_progress = []
self.sched.update_downtimes_and_comments()
#time.sleep(ref.retry_interval * 60 + 1)
if do_sleep:
time.sleep(sleep_time)
def worker_loop(self):
self.sched.delete_zombie_checks()
self.sched.delete_zombie_actions()
checks = self.sched.get_to_run_checks(True, False, worker_name='tester')
actions = self.sched.get_to_run_checks(False, True, worker_name='tester')
#print "------------ worker loop checks ----------------"
#print checks
#print "------------ worker loop actions ----------------"
self.show_actions()
#print "------------ worker loop new ----------------"
for a in actions:
a.status = 'inpoller'
a.check_time = time.time()
a.exit_status = 0
self.sched.put_results(a)
self.show_actions()
#print "------------ worker loop end ----------------"
def show_logs(self):
print "--- logs <<<----------------------------------"
for brok in sorted(self.sched.broks.values(), lambda x, y: x.id - y.id):
if brok.type == 'log':
print "LOG:", brok.data['log']
print "--- logs >>>----------------------------------"
def show_actions(self):
print "--- actions <<<----------------------------------"
for a in sorted(self.sched.actions.values(), lambda x, y: x.id - y.id):
if a.is_a == 'notification':
if a.ref.my_type == "host":
ref = "host: %s" % a.ref.get_name()
else:
ref = "host: %s svc: %s" % (a.ref.host.get_name(), a.ref.get_name())
print "NOTIFICATION %d %s %s %s %s" % (a.id, ref, a.type, time.asctime(time.localtime(a.t_to_go)), a.status)
elif a.is_a == 'eventhandler':
print "EVENTHANDLER:", a
print "--- actions >>>----------------------------------"
def show_and_clear_logs(self):
self.show_logs()
self.clear_logs()
def show_and_clear_actions(self):
self.show_actions()
self.clear_actions()
def count_logs(self):
return len([b for b in self.sched.broks.values() if b.type == 'log'])
def count_actions(self):
return len(self.sched.actions.values())
def clear_logs(self):
id_to_del = []
for b in self.sched.broks.values():
if b.type == 'log':
id_to_del.append(b.id)
for id in id_to_del:
del self.sched.broks[id]
def clear_actions(self):
self.sched.actions = {}
def log_match(self, index, pattern):
# log messages are counted 1...n, so index=1 for the first message
if index > self.count_logs():
return False
else:
regex = re.compile(pattern)
lognum = 1
for brok in sorted(self.sched.broks.values(), lambda x, y: x.id - y.id):
if brok.type == 'log':
if index == lognum:
if re.search(regex, brok.data['log']):
return True
lognum += 1
return False
def any_log_match(self, pattern):
regex = re.compile(pattern)
for brok in sorted(self.sched.broks.values(), lambda x, y: x.id - y.id):
if brok.type == 'log':
if re.search(regex, brok.data['log']):
return True
return False
def get_log_match(self, pattern):
regex = re.compile(pattern)
res = []
for brok in sorted(self.sched.broks.values(), lambda x, y: x.id - y.id):
if brok.type == 'log':
if re.search(regex, brok.data['log']):
res.append(brok.data['log'])
return res
def print_header(self):
print "#" * 80 + "\n" + "#" + " " * 78 + "#"
print "#" + string.center(self.id(), 78) + "#"
print "#" + " " * 78 + "#\n" + "#" * 80 + "\n"
def xtest_conf_is_correct(self):
self.print_header()
self.assert_(self.conf.conf_is_correct)
def init_livestatus(self):
self.livelogs = 'tmp/livelogs.db' + self.testid
self.db_archives = os.path.join(os.path.dirname(self.livelogs), 'archives')
self.pnp4nagios = 'tmp/pnp4nagios_test' + self.testid
self.livestatus_broker = Livestatus_broker(livestatus_modconf, '127.0.0.1', str(50000 + os.getpid()), 'live', [], self.livelogs, self.db_archives, 365, self.pnp4nagios, True)
self.livestatus_broker.create_queues()
#self.livestatus_broker.properties = {
# 'to_queue' : 0,
# 'from_queue' : 0
#
# }
self.livestatus_broker.init()
self.livestatus_broker.db = LiveStatusDb(self.livestatus_broker.database_file, self.livestatus_broker.archive_path, self.livestatus_broker.max_logs_age)
self.livestatus_broker.livestatus = LiveStatus(self.livestatus_broker.configs, self.livestatus_broker.hosts, self.livestatus_broker.services, self.livestatus_broker.contacts, self.livestatus_broker.hostgroups, self.livestatus_broker.servicegroups, self.livestatus_broker.contactgroups, self.livestatus_broker.timeperiods, self.livestatus_broker.commands, self.livestatus_broker.schedulers, self.livestatus_broker.pollers, self.livestatus_broker.reactionners, self.livestatus_broker.brokers, self.livestatus_broker.db, self.livestatus_broker.use_aggressive_sql, self.livestatus_broker.pnp_path, self.livestatus_broker.from_q)
class ShinkenTest(unittest.TestCase):
def setUp(self):
self.setup_with_file('etc/nagios_1r_1h_1s.cfg')
def setup_with_file(self, path):
# i am arbiter-like
self.broks = {}
self.me = None
self.log = logger
self.log.load_obj(self)
self.config_files = [path]
self.conf = Config()
buf = self.conf.read_config(self.config_files)
raw_objects = self.conf.read_config_buf(buf)
self.conf.create_objects_for_type(raw_objects, 'arbiter')
self.conf.create_objects_for_type(raw_objects, 'module')
self.conf.early_arbiter_linking()
self.conf.create_objects(raw_objects)
self.conf.old_properties_names_to_new()
self.conf.instance_id = 0
self.conf.instance_name = 'test'
# Hack push_flavor, that is set by the dispatcher
self.conf.push_flavor = 0
self.conf.load_triggers()
self.conf.linkify_templates()
self.conf.apply_inheritance()
self.conf.explode()
#print "Aconf.services has %d elements" % len(self.conf.services)
self.conf.create_reversed_list()
self.conf.remove_twins()
self.conf.apply_implicit_inheritance()
self.conf.fill_default()
self.conf.remove_templates()
self.conf.compute_hash()
#print "conf.services has %d elements" % len(self.conf.services)
self.conf.create_reversed_list()
self.conf.pythonize()
self.conf.linkify()
self.conf.apply_dependencies()
self.conf.explode_global_conf()
self.conf.propagate_timezone_option()
self.conf.create_business_rules()
self.conf.create_business_rules_dependencies()
self.conf.is_correct()
if not self.conf.conf_is_correct:
print "The conf is not correct, I stop here"
return
self.confs = self.conf.cut_into_parts()
self.conf.prepare_for_sending()
self.conf.show_errors()
self.dispatcher = Dispatcher(self.conf, self.me)
scheddaemon = Shinken(None, False, False, False, None)
self.sched = Scheduler(scheddaemon)
scheddaemon.sched = self.sched
m = MacroResolver()
m.init(self.conf)
self.sched.load_conf(self.conf, in_test=True)
e = ExternalCommandManager(self.conf, 'applyer')
self.sched.external_command = e
e.load_scheduler(self.sched)
e2 = ExternalCommandManager(self.conf, 'dispatcher')
e2.load_arbiter(self)
self.external_command_dispatcher = e2
self.sched.schedule()
def add(self, b):
if isinstance(b, Brok):
self.broks[b.id] = b
return
if isinstance(b, ExternalCommand):
self.sched.run_external_command(b.cmd_line)
def fake_check(self, ref, exit_status, output="OK"):
#print "fake", ref
now = time.time()
ref.schedule(force=True)
# now checks are schedule and we get them in
# the action queue
check = ref.actions.pop()
self.sched.add(check) # check is now in sched.checks[]
# fake execution
check.check_time = now
# and lie about when we will launch it because
# if not, the schedule call for ref
# will not really reschedule it because there
# is a valid value in the future
ref.next_chk = now - 0.5
check.get_outputs(output, 9000)
check.exit_status = exit_status
check.execution_time = 0.001
check.status = 'waitconsume'
self.sched.waiting_results.append(check)
def scheduler_loop(self, count, reflist, do_sleep=False, sleep_time=61):
for ref in reflist:
(obj, exit_status, output) = ref
obj.checks_in_progress = []
for loop in range(1, count + 1):
print "processing check", loop
for ref in reflist:
(obj, exit_status, output) = ref
obj.update_in_checking()
self.fake_check(obj, exit_status, output)
self.sched.manage_internal_checks()
self.sched.consume_results()
self.sched.get_new_actions()
self.sched.get_new_broks()
self.worker_loop()
for ref in reflist:
(obj, exit_status, output) = ref
obj.checks_in_progress = []
self.sched.update_downtimes_and_comments()
#time.sleep(ref.retry_interval * 60 + 1)
if do_sleep:
time.sleep(sleep_time)
def worker_loop(self):
self.sched.delete_zombie_checks()
self.sched.delete_zombie_actions()
checks = self.sched.get_to_run_checks(True, False, worker_name='tester')
actions = self.sched.get_to_run_checks(False, True, worker_name='tester')
#print "------------ worker loop checks ----------------"
#print checks
#print "------------ worker loop actions ----------------"
self.show_actions()
#print "------------ worker loop new ----------------"
for a in actions:
a.status = 'inpoller'
a.check_time = time.time()
a.exit_status = 0
self.sched.put_results(a)
self.show_actions()
#print "------------ worker loop end ----------------"
def show_logs(self):
print "--- logs <<<----------------------------------"
for brok in sorted(self.sched.broks.values(), lambda x, y: x.id - y.id):
if brok.type == 'log':
brok.prepare()
print "LOG:", brok.data['log']
print "--- logs >>>----------------------------------"
def show_actions(self):
print "--- actions <<<----------------------------------"
for a in sorted(self.sched.actions.values(), lambda x, y: x.id - y.id):
if a.is_a == 'notification':
if a.ref.my_type == "host":
ref = "host: %s" % a.ref.get_name()
else:
ref = "host: %s svc: %s" % (a.ref.host.get_name(), a.ref.get_name())
print "NOTIFICATION %d %s %s %s %s" % (a.id, ref, a.type, time.asctime(time.localtime(a.t_to_go)), a.status)
elif a.is_a == 'eventhandler':
print "EVENTHANDLER:", a
print "--- actions >>>----------------------------------"
def show_and_clear_logs(self):
self.show_logs()
self.clear_logs()
def show_and_clear_actions(self):
self.show_actions()
self.clear_actions()
def count_logs(self):
return len([b for b in self.sched.broks.values() if b.type == 'log'])
def count_actions(self):
return len(self.sched.actions.values())
def clear_logs(self):
id_to_del = []
for b in self.sched.broks.values():
if b.type == 'log':
id_to_del.append(b.id)
for id in id_to_del:
del self.sched.broks[id]
def clear_actions(self):
self.sched.actions = {}
def log_match(self, index, pattern):
# log messages are counted 1...n, so index=1 for the first message
if index > self.count_logs():
return False
else:
regex = re.compile(pattern)
lognum = 1
for brok in sorted(self.sched.broks.values(), lambda x, y: x.id - y.id):
if brok.type == 'log':
brok.prepare()
if index == lognum:
if re.search(regex, brok.data['log']):
return True
lognum += 1
return False
def any_log_match(self, pattern):
regex = re.compile(pattern)
for brok in sorted(self.sched.broks.values(), lambda x, y: x.id - y.id):
if brok.type == 'log':
brok.prepare()
if re.search(regex, brok.data['log']):
return True
return False
def get_log_match(self, pattern):
regex = re.compile(pattern)
res = []
for brok in sorted(self.sched.broks.values(), lambda x, y: x.id - y.id):
if brok.type == 'log':
if re.search(regex, brok.data['log']):
res.append(brok.data['log'])
return res
def print_header(self):
print "#" * 80 + "\n" + "#" + " " * 78 + "#"
print "#" + string.center(self.id(), 78) + "#"
print "#" + " " * 78 + "#\n" + "#" * 80 + "\n"
def xtest_conf_is_correct(self):
self.print_header()
self.assert_(self.conf.conf_is_correct)
def find_modules_path(self):
""" Find the absolute path of the shinken module directory and returns it. """
import shinken
# BEWARE: this way of finding path is good if we still
# DO NOT HAVE CHANGE PWD!!!
# Now get the module path. It's in fact the directory modules
# inside the shinken directory. So let's find it.
print "modulemanager file", shinken.modulesmanager.__file__
modulespath = os.path.abspath(shinken.modulesmanager.__file__)
print "modulemanager absolute file", modulespath
# We got one of the files of
parent_path = os.path.dirname(os.path.dirname(modulespath))
modulespath = os.path.join(parent_path, 'shinken', 'modules')
print("Using modules path: %s" % (modulespath))
return modulespath
def do_load_modules(self):
self.modules_manager.load_and_init()
self.log.log("I correctly loaded the modules: [%s]" % (','.join([inst.get_name() for inst in self.modules_manager.instances])))
def init_livestatus(self, modconf=None):
self.livelogs = 'tmp/livelogs.db' + self.testid
if modconf is None:
modconf = Module({'module_name': 'LiveStatus',
'module_type': 'livestatus',
'port': str(50000 + os.getpid()),
'pnp_path': 'tmp/pnp4nagios_test' + self.testid,
'host': '127.0.0.1',
'socket': 'live',
'name': 'test', #?
})
dbmodconf = Module({'module_name': 'LogStore',
'module_type': 'logstore_sqlite',
'use_aggressive_sql': "0",
'database_file': self.livelogs,
'archive_path': os.path.join(os.path.dirname(self.livelogs), 'archives'),
})
modconf.modules = [dbmodconf]
self.livestatus_broker = LiveStatus_broker(modconf)
self.livestatus_broker.create_queues()
#--- livestatus_broker.main
self.livestatus_broker.log = logger
# this seems to damage the logger so that the scheduler can't use it
#self.livestatus_broker.log.load_obj(self.livestatus_broker)
self.livestatus_broker.debug_output = []
self.livestatus_broker.modules_manager = ModulesManager('livestatus', self.livestatus_broker.find_modules_path(), [])
self.livestatus_broker.modules_manager.set_modules(self.livestatus_broker.modules)
# We can now output some previouly silented debug ouput
self.livestatus_broker.do_load_modules()
for inst in self.livestatus_broker.modules_manager.instances:
if inst.properties["type"].startswith('logstore'):
f = getattr(inst, 'load', None)
if f and callable(f):
f(self.livestatus_broker) # !!! NOT self here !!!!
break
for s in self.livestatus_broker.debug_output:
print "errors during load", s
del self.livestatus_broker.debug_output
self.livestatus_broker.rg = LiveStatusRegenerator()
self.livestatus_broker.datamgr = datamgr
datamgr.load(self.livestatus_broker.rg)
self.livestatus_broker.query_cache = LiveStatusQueryCache()
self.livestatus_broker.query_cache.disable()
self.livestatus_broker.rg.register_cache(self.livestatus_broker.query_cache)
#--- livestatus_broker.main
self.livestatus_broker.init()
self.livestatus_broker.db = self.livestatus_broker.modules_manager.instances[0]
self.livestatus_broker.livestatus = LiveStatus(self.livestatus_broker.datamgr, self.livestatus_broker.query_cache, self.livestatus_broker.db, self.livestatus_broker.pnp_path, self.livestatus_broker.from_q)
#--- livestatus_broker.do_main
self.livestatus_broker.db.open()
class ShinkenTest(unittest.TestCase):
def setUp(self):
self.setup_with_file('etc/shinken_1r_1h_1s.cfg')
def setup_with_file(self, path):
# i am arbiter-like
self.broks = {}
self.me = None
self.log = logger
self.log.load_obj(self)
self.config_files = [path]
self.conf = Config()
buf = self.conf.read_config(self.config_files)
raw_objects = self.conf.read_config_buf(buf)
self.conf.create_objects_for_type(raw_objects, 'arbiter')
self.conf.create_objects_for_type(raw_objects, 'module')
self.conf.early_arbiter_linking()
self.conf.create_objects(raw_objects)
self.conf.old_properties_names_to_new()
self.conf.instance_id = 0
self.conf.instance_name = 'test'
# Hack push_flavor, that is set by the dispatcher
self.conf.push_flavor = 0
self.conf.load_triggers()
self.conf.linkify_templates()
self.conf.apply_inheritance()
self.conf.explode()
#print "Aconf.services has %d elements" % len(self.conf.services)
self.conf.create_reversed_list()
self.conf.remove_twins()
self.conf.apply_implicit_inheritance()
self.conf.fill_default()
self.conf.remove_templates()
self.conf.compute_hash()
#print "conf.services has %d elements" % len(self.conf.services)
self.conf.create_reversed_list()
self.conf.override_properties()
self.conf.pythonize()
self.conf.linkify()
self.conf.apply_dependencies()
self.conf.explode_global_conf()
self.conf.propagate_timezone_option()
self.conf.create_business_rules()
self.conf.create_business_rules_dependencies()
self.conf.is_correct()
if not self.conf.conf_is_correct:
print "The conf is not correct, I stop here"
return
self.conf.clean()
self.confs = self.conf.cut_into_parts()
self.conf.prepare_for_sending()
self.conf.show_errors()
self.dispatcher = Dispatcher(self.conf, self.me)
scheddaemon = Shinken(None, False, False, False, None, None)
self.sched = Scheduler(scheddaemon)
scheddaemon.sched = self.sched
scheddaemon.modules_dir = modules_dir
scheddaemon.load_modules_manager()
# Remember to clean the logs we just created before launching tests
self.clear_logs()
m = MacroResolver()
m.init(self.conf)
self.sched.load_conf(self.conf, in_test=True)
e = ExternalCommandManager(self.conf, 'applyer')
self.sched.external_command = e
e.load_scheduler(self.sched)
e2 = ExternalCommandManager(self.conf, 'dispatcher')
e2.load_arbiter(self)
self.external_command_dispatcher = e2
self.sched.schedule()
def add(self, b):
if isinstance(b, Brok):
self.broks[b.id] = b
return
if isinstance(b, ExternalCommand):
self.sched.run_external_command(b.cmd_line)
def fake_check(self, ref, exit_status, output="OK"):
#print "fake", ref
now = time.time()
ref.schedule(force=True)
# now checks are schedule and we get them in
# the action queue
#check = ref.actions.pop()
check = ref.checks_in_progress[0]
self.sched.add(check) # check is now in sched.checks[]
# Allows to force check scheduling without setting its status nor
# output. Useful for manual business rules rescheduling, for instance.
if exit_status is None:
return
# fake execution
check.check_time = now
# and lie about when we will launch it because
# if not, the schedule call for ref
# will not really reschedule it because there
# is a valid value in the future
ref.next_chk = now - 0.5
check.get_outputs(output, 9000)
check.exit_status = exit_status
check.execution_time = 0.001
check.status = 'waitconsume'
self.sched.waiting_results.append(check)
def scheduler_loop(self,
count,
reflist,
do_sleep=False,
sleep_time=61,
verbose=True):
for ref in reflist:
(obj, exit_status, output) = ref
obj.checks_in_progress = []
for loop in range(1, count + 1):
if verbose is True:
print "processing check", loop
for ref in reflist:
(obj, exit_status, output) = ref
obj.update_in_checking()
self.fake_check(obj, exit_status, output)
self.sched.manage_internal_checks()
self.sched.consume_results()
self.sched.get_new_actions()
self.sched.get_new_broks()
self.worker_loop(verbose)
for ref in reflist:
(obj, exit_status, output) = ref
obj.checks_in_progress = []
self.sched.update_downtimes_and_comments()
#time.sleep(ref.retry_interval * 60 + 1)
if do_sleep:
time.sleep(sleep_time)
def worker_loop(self, verbose=True):
self.sched.delete_zombie_checks()
self.sched.delete_zombie_actions()
checks = self.sched.get_to_run_checks(True,
False,
worker_name='tester')
actions = self.sched.get_to_run_checks(False,
True,
worker_name='tester')
#print "------------ worker loop checks ----------------"
#print checks
#print "------------ worker loop actions ----------------"
if verbose is True:
self.show_actions()
#print "------------ worker loop new ----------------"
for a in actions:
a.status = 'inpoller'
a.check_time = time.time()
a.exit_status = 0
self.sched.put_results(a)
if verbose is True:
self.show_actions()
#print "------------ worker loop end ----------------"
def show_logs(self):
print "--- logs <<<----------------------------------"
for brok in sorted(self.sched.broks.values(),
lambda x, y: x.id - y.id):
if brok.type == 'log':
brok.prepare()
print "LOG:", brok.data['log']
print "--- logs >>>----------------------------------"
def show_actions(self):
print "--- actions <<<----------------------------------"
for a in sorted(self.sched.actions.values(), lambda x, y: x.id - y.id):
if a.is_a == 'notification':
if a.ref.my_type == "host":
ref = "host: %s" % a.ref.get_name()
else:
ref = "host: %s svc: %s" % (a.ref.host.get_name(),
a.ref.get_name())
print "NOTIFICATION %d %s %s %s %s" % (
a.id, ref, a.type, time.asctime(time.localtime(
a.t_to_go)), a.status)
elif a.is_a == 'eventhandler':
print "EVENTHANDLER:", a
print "--- actions >>>----------------------------------"
def show_and_clear_logs(self):
self.show_logs()
self.clear_logs()
def show_and_clear_actions(self):
self.show_actions()
self.clear_actions()
def count_logs(self):
return len([b for b in self.sched.broks.values() if b.type == 'log'])
def count_actions(self):
return len(self.sched.actions.values())
def clear_logs(self):
id_to_del = []
for b in self.sched.broks.values():
if b.type == 'log':
id_to_del.append(b.id)
for id in id_to_del:
del self.sched.broks[id]
def clear_actions(self):
self.sched.actions = {}
def log_match(self, index, pattern):
# log messages are counted 1...n, so index=1 for the first message
if index > self.count_logs():
return False
else:
regex = re.compile(pattern)
lognum = 1
for brok in sorted(self.sched.broks.values(),
lambda x, y: x.id - y.id):
if brok.type == 'log':
brok.prepare()
if index == lognum:
if re.search(regex, brok.data['log']):
return True
lognum += 1
return False
def any_log_match(self, pattern):
regex = re.compile(pattern)
for brok in sorted(self.sched.broks.values(),
lambda x, y: x.id - y.id):
if brok.type == 'log':
brok.prepare()
if re.search(regex, brok.data['log']):
return True
return False
def get_log_match(self, pattern):
regex = re.compile(pattern)
res = []
for brok in sorted(self.sched.broks.values(),
lambda x, y: x.id - y.id):
if brok.type == 'log':
if re.search(regex, brok.data['log']):
res.append(brok.data['log'])
return res
def print_header(self):
print "#" * 80 + "\n" + "#" + " " * 78 + "#"
print "#" + string.center(self.id(), 78) + "#"
print "#" + " " * 78 + "#\n" + "#" * 80 + "\n"
def xtest_conf_is_correct(self):
self.print_header()
self.assert_(self.conf.conf_is_correct)
class Shinken(BaseSatellite):
properties = BaseSatellite.properties.copy()
properties.update({
'pidfile': PathProp(default='schedulerd.pid'),
'port': IntegerProp(default='7768'),
'local_log': PathProp(default='schedulerd.log'),
})
# Create the shinken class:
# Create a Pyro server (port = arvg 1)
# then create the interface for arbiter
# Then, it wait for a first configuration
def __init__(self, config_file, is_daemon, do_replace, debug, debug_file, profile=''):
BaseSatellite.__init__(self, 'scheduler', config_file, is_daemon, do_replace, debug, debug_file)
self.interface = IForArbiter(self)
self.istats = IStats(self)
self.sched = Scheduler(self)
self.ichecks = None
self.ibroks = None
self.must_run = True
# Now the interface
self.uri = None
self.uri2 = None
# And possible links for satellites
# from now only pollers
self.pollers = {}
self.reactionners = {}
self.brokers = {}
def do_stop(self):
if self.http_daemon:
if self.ibroks:
self.http_daemon.unregister(self.ibroks)
if self.ichecks:
self.http_daemon.unregister(self.ichecks)
super(Shinken, self).do_stop()
def compensate_system_time_change(self, difference):
""" Compensate a system time change of difference for all hosts/services/checks/notifs """
logger.warning("A system time change of %d has been detected. Compensating..." % difference)
# We only need to change some value
self.program_start = max(0, self.program_start + difference)
if not hasattr(self.sched, "conf"):
# Race condition where time change before getting conf
return
# Then we compensate all host/services
for h in self.sched.hosts:
h.compensate_system_time_change(difference)
for s in self.sched.services:
s.compensate_system_time_change(difference)
# Now all checks and actions
for c in self.sched.checks.values():
# Already launch checks should not be touch
if c.status == 'scheduled' and c.t_to_go is not None:
t_to_go = c.t_to_go
ref = c.ref
new_t = max(0, t_to_go + difference)
if ref.check_period is not None:
# But it's no so simple, we must match the timeperiod
new_t = ref.check_period.get_next_valid_time_from_t(new_t)
# But maybe no there is no more new value! Not good :(
# Say as error, with error output
if new_t is None:
c.state = 'waitconsume'
c.exit_status = 2
c.output = '(Error: there is no available check time after time change!)'
c.check_time = time.time()
c.execution_time = 0
else:
c.t_to_go = new_t
ref.next_chk = new_t
# Now all checks and actions
for c in self.sched.actions.values():
# Already launch checks should not be touch
if c.status == 'scheduled':
t_to_go = c.t_to_go
# Event handler do not have ref
ref = getattr(c, 'ref', None)
new_t = max(0, t_to_go + difference)
# Notification should be check with notification_period
if c.is_a == 'notification':
if ref.notification_period:
# But it's no so simple, we must match the timeperiod
new_t = ref.notification_period.get_next_valid_time_from_t(new_t)
# And got a creation_time variable too
c.creation_time = c.creation_time + difference
# But maybe no there is no more new value! Not good :(
# Say as error, with error output
if new_t is None:
c.state = 'waitconsume'
c.exit_status = 2
c.output = '(Error: there is no available check time after time change!)'
c.check_time = time.time()
c.execution_time = 0
else:
c.t_to_go = new_t
def manage_signal(self, sig, frame):
logger.warning("Received a SIGNAL %s" % sig)
# If we got USR1, just dump memory
if sig == signal.SIGUSR1:
self.sched.need_dump_memory = True
elif sig == signal.SIGUSR2: #usr2, dump objects
self.sched.need_objects_dump = True
else: # if not, die :)
self.sched.die()
self.must_run = False
Daemon.manage_signal(self, sig, frame)
def do_loop_turn(self):
# Ok, now the conf
self.wait_for_initial_conf()
if not self.new_conf:
return
logger.info("New configuration received")
self.setup_new_conf()
logger.info("New configuration loaded")
self.sched.run()
def setup_new_conf(self):
pk = self.new_conf
conf_raw = pk['conf']
override_conf = pk['override_conf']
modules = pk['modules']
satellites = pk['satellites']
instance_name = pk['instance_name']
push_flavor = pk['push_flavor']
skip_initial_broks = pk['skip_initial_broks']
accept_passive_unknown_check_results = pk['accept_passive_unknown_check_results']
# horay, we got a name, we can set it in our stats objects
statsmgr.register(instance_name, 'scheduler')
t0 = time.time()
conf = cPickle.loads(conf_raw)
logger.debug("Conf received at %d. Unserialized in %d secs" % (t0, time.time() - t0))
self.new_conf = None
# Tag the conf with our data
self.conf = conf
self.conf.push_flavor = push_flavor
self.conf.instance_name = instance_name
self.conf.skip_initial_broks = skip_initial_broks
self.conf.accept_passive_unknown_check_results = accept_passive_unknown_check_results
self.cur_conf = conf
self.override_conf = override_conf
self.modules = modules
self.satellites = satellites
#self.pollers = self.app.pollers
if self.conf.human_timestamp_log:
logger.set_human_format()
# Now We create our pollers
for pol_id in satellites['pollers']:
# Must look if we already have it
already_got = pol_id in self.pollers
p = satellites['pollers'][pol_id]
self.pollers[pol_id] = p
if p['name'] in override_conf['satellitemap']:
p = dict(p) # make a copy
p.update(override_conf['satellitemap'][p['name']])
proto = 'http'
if p['use_ssl']:
proto = 'https'
uri = '%s://%s:%s/' % (proto, p['address'], p['port'])
self.pollers[pol_id]['uri'] = uri
self.pollers[pol_id]['last_connection'] = 0
# First mix conf and override_conf to have our definitive conf
for prop in self.override_conf:
#print "Overriding the property %s with value %s" % (prop, self.override_conf[prop])
val = self.override_conf[prop]
setattr(self.conf, prop, val)
if self.conf.use_timezone != '':
logger.debug("Setting our timezone to %s" % str(self.conf.use_timezone))
os.environ['TZ'] = self.conf.use_timezone
time.tzset()
if len(self.modules) != 0:
logger.debug("I've got %s modules" % str(self.modules))
# TODO: if scheduler had previous modules instanciated it must clean them!
self.modules_manager.set_modules(self.modules)
self.do_load_modules()
# give it an interface
# But first remove previous interface if exists
if self.ichecks is not None:
logger.debug("Deconnecting previous Check Interface")
self.http_daemon.unregister(self.ichecks)
# Now create and connect it
self.ichecks = IChecks(self.sched)
self.http_daemon.register(self.ichecks)
logger.debug("The Scheduler Interface uri is: %s" % self.uri)
# Same for Broks
if self.ibroks is not None:
logger.debug("Deconnecting previous Broks Interface")
self.http_daemon.unregister(self.ibroks)
# Create and connect it
self.ibroks = IBroks(self.sched)
self.http_daemon.register(self.ibroks)
logger.info("Loading configuration.")
self.conf.explode_global_conf()
# we give sched it's conf
self.sched.reset()
self.sched.load_conf(self.conf)
self.sched.load_satellites(self.pollers, self.reactionners)
# We must update our Config dict macro with good value
# from the config parameters
self.sched.conf.fill_resource_macros_names_macros()
#print "DBG: got macros", self.sched.conf.macros
# Creating the Macroresolver Class & unique instance
m = MacroResolver()
m.init(self.conf)
#self.conf.dump()
#self.conf.quick_debug()
# Now create the external commander
# it's a applyer: it role is not to dispatch commands,
# but to apply them
e = ExternalCommandManager(self.conf, 'applyer')
# Scheduler need to know about external command to
# activate it if necessary
self.sched.load_external_command(e)
# External command need the sched because he can raise checks
e.load_scheduler(self.sched)
# We clear our schedulers managed (it's us :) )
# and set ourself in it
self.schedulers = {self.conf.instance_id: self.sched}
# Give the arbiter the data about what I manage
# for me it's just my instance_id and my push flavor
def what_i_managed(self):
if hasattr(self, 'conf'):
return {self.conf.instance_id: self.conf.push_flavor}
else:
return {}
# our main function, launch after the init
def main(self):
try:
self.load_config_file()
self.look_for_early_exit()
self.do_daemon_init_and_start()
self.load_modules_manager()
self.http_daemon.register(self.interface)
self.http_daemon.register(self.istats)
#self.inject = Injector(self.sched)
#self.http_daemon.register(self.inject)
self.http_daemon.unregister(self.interface)
self.uri = self.http_daemon.uri
logger.info("[scheduler] General interface is at: %s" % self.uri)
self.do_mainloop()
except Exception, exp:
logger.critical("I got an unrecoverable error. I have to exit")
logger.critical("You can log a bug ticket at https://github.com/naparuba/shinken/issues/new to get help")
logger.critical("Back trace of it: %s" % (traceback.format_exc()))
raise
class ShinkenTest(unittest.TestCase):
def setUp(self):
self.setup_with_file('etc/nagios_1r_1h_1s.cfg')
def setup_with_file(self, path):
# i am arbiter-like
self.broks = {}
self.me = None
self.log = logger
self.log.load_obj(self)
self.config_files = [path]
self.conf = Config()
self.conf.read_config(self.config_files)
buf = self.conf.read_config(self.config_files)
raw_objects = self.conf.read_config_buf(buf)
self.conf.create_objects_for_type(raw_objects, 'arbiter')
self.conf.create_objects_for_type(raw_objects, 'module')
self.conf.early_arbiter_linking()
self.conf.create_objects(raw_objects)
self.conf.instance_id = 0
self.conf.instance_name = 'test'
self.conf.linkify_templates()
self.conf.apply_inheritance()
self.conf.explode()
self.conf.create_reversed_list()
self.conf.remove_twins()
self.conf.apply_implicit_inheritance()
self.conf.fill_default()
self.conf.clean_useless()
self.conf.pythonize()
self.conf.linkify()
self.conf.apply_dependancies()
self.conf.explode_global_conf()
self.conf.propagate_timezone_option()
self.conf.create_business_rules()
self.conf.create_business_rules_dependencies()
self.conf.is_correct()
self.confs = self.conf.cut_into_parts()
self.dispatcher = Dispatcher(self.conf, self.me)
scheddaemon = Shinken(None, False, False, False, None)
self.sched = Scheduler(scheddaemon)
scheddaemon.sched = self.sched
m = MacroResolver()
m.init(self.conf)
self.sched.load_conf(self.conf)
e = ExternalCommandManager(self.conf, 'applyer')
self.sched.external_command = e
e.load_scheduler(self.sched)
e2 = ExternalCommandManager(self.conf, 'dispatcher')
e2.load_arbiter(self)
self.external_command_dispatcher = e2
self.sched.schedule()
def add(self, b):
if isinstance(b, Brok):
self.broks[b.id] = b
return
if isinstance(b, ExternalCommand):
self.sched.run_external_command(b.cmd_line)
def fake_check(self, ref, exit_status, output="OK"):
#print "fake", ref
now = time.time()
ref.schedule(force=True)
#now checks are schedule and we get them in
#the action queue
check = ref.actions.pop()
self.sched.add(check) # check is now in sched.checks[]
# fake execution
check.check_time = now
elts_line1 = output.split('|')
#First line before | is output
check.output = elts_line1[0]
#After | is perfdata
if len(elts_line1) > 1:
check.perf_data = elts_line1[1]
else:
check.perf_data = ''
check.exit_status = exit_status
check.execution_time = 0.001
check.status = 'waitconsume'
self.sched.waiting_results.append(check)
def scheduler_loop(self, count, reflist, do_sleep=False, sleep_time=61):
for ref in reflist:
(obj, exit_status, output) = ref
obj.checks_in_progress = []
for loop in range(1, count + 1):
print "processing check", loop
for ref in reflist:
(obj, exit_status, output) = ref
obj.update_in_checking()
self.fake_check(obj, exit_status, output)
self.sched.manage_internal_checks()
self.sched.consume_results()
self.sched.get_new_actions()
self.sched.get_new_broks()
self.worker_loop()
for ref in reflist:
(obj, exit_status, output) = ref
obj.checks_in_progress = []
self.sched.update_downtimes_and_comments()
#time.sleep(ref.retry_interval * 60 + 1)
if do_sleep:
time.sleep(sleep_time)
def worker_loop(self):
self.sched.delete_zombie_checks()
self.sched.delete_zombie_actions()
checks = self.sched.get_to_run_checks(True, False, worker_name='tester')
actions = self.sched.get_to_run_checks(False, True, worker_name='tester')
#print "------------ worker loop checks ----------------"
#print checks
#print "------------ worker loop actions ----------------"
self.show_actions()
#print "------------ worker loop new ----------------"
for a in actions:
a.status = 'inpoller'
a.check_time = time.time()
a.exit_status = 0
self.sched.put_results(a)
self.show_actions()
#print "------------ worker loop end ----------------"
def show_logs(self):
print "--- logs <<<----------------------------------"
for brok in sorted(self.sched.broks.values(), lambda x, y: x.id - y.id):
if brok.type == 'log':
print "LOG:", brok.data['log']
print "--- logs >>>----------------------------------"
def show_actions(self):
print "--- actions <<<----------------------------------"
for a in sorted(self.sched.actions.values(), lambda x, y: x.id - y.id):
if a.is_a == 'notification':
if a.ref.my_type == "host":
ref = "host: %s" % a.ref.get_name()
else:
ref = "host: %s svc: %s" % (a.ref.host.get_name(), a.ref.get_name())
print "NOTIFICATION %d %s %s %s %s" % (a.id, ref, a.type, time.asctime(time.localtime(a.t_to_go)), a.status)
elif a.is_a == 'eventhandler':
print "EVENTHANDLER:", a
print "--- actions >>>----------------------------------"
def show_and_clear_logs(self):
self.show_logs()
self.clear_logs()
def show_and_clear_actions(self):
self.show_actions()
self.clear_actions()
def count_logs(self):
return len([b for b in self.sched.broks.values() if b.type == 'log'])
def count_actions(self):
return len(self.sched.actions.values())
def clear_logs(self):
id_to_del = []
for b in self.sched.broks.values():
if b.type == 'log':
id_to_del.append(b.id)
for id in id_to_del:
del self.sched.broks[id]
def clear_actions(self):
self.sched.actions = {}
def log_match(self, index, pattern):
# log messages are counted 1...n, so index=1 for the first message
if index > self.count_logs():
return False
else:
regex = re.compile(pattern)
lognum = 1
for brok in sorted(self.sched.broks.values(), lambda x, y: x.id - y.id):
if brok.type == 'log':
if index == lognum:
if re.search(regex, brok.data['log']):
return True
lognum += 1
return False
def any_log_match(self, pattern):
regex = re.compile(pattern)
for brok in sorted(self.sched.broks.values(), lambda x, y: x.id - y.id):
if brok.type == 'log':
if re.search(regex, brok.data['log']):
return True
return False
def get_log_match(self, pattern):
regex = re.compile(pattern)
res = []
for brok in sorted(self.sched.broks.values(), lambda x, y: x.id - y.id):
if brok.type == 'log':
if re.search(regex, brok.data['log']):
res.append(brok.data['log'])
return res
def print_header(self):
print "#" * 80 + "\n" + "#" + " " * 78 + "#"
print "#" + string.center(self.id(), 78) + "#"
print "#" + " " * 78 + "#\n" + "#" * 80 + "\n"
def xtest_conf_is_correct(self):
self.print_header()
self.assert_(self.conf.conf_is_correct)
class Shinken(BaseSatellite):
properties = BaseSatellite.properties.copy()
properties.update({
'pidfile': PathProp(default='/usr/local/shinken/var/schedulerd.pid'),
'port': IntegerProp(default='7768'),
'local_log': PathProp(default='/usr/local/shinken/var/schedulerd.log'),
})
#Create the shinken class:
#Create a Pyro server (port = arvg 1)
#then create the interface for arbiter
#Then, it wait for a first configuration
def __init__(self, config_file, is_daemon, do_replace, debug, debug_file):
BaseSatellite.__init__(self, 'scheduler', config_file, is_daemon, do_replace, debug, debug_file)
self.interface = IForArbiter(self)
self.sched = Scheduler(self)
self.ichecks = None
self.ibroks = None
self.must_run = True
# Now the interface
self.uri = None
self.uri2 = None
# And possible links for satellites
# from now only pollers
self.pollers = {}
self.reactionners = {}
def do_stop(self):
self.pyro_daemon.unregister(self.ibroks)
self.pyro_daemon.unregister(self.ichecks)
super(Shinken, self).do_stop()
def compensate_system_time_change(self, difference):
""" Compensate a system time change of difference for all hosts/services/checks/notifs """
logger.log('Warning: A system time change of %d has been detected. Compensating...' % difference)
# We only need to change some value
self.program_start = max(0, self.program_start + difference)
# Then we compasate all host/services
for h in self.sched.hosts:
h.compensate_system_time_change(difference)
for s in self.sched.services:
s.compensate_system_time_change(difference)
# Now all checks and actions
for c in self.sched.checks.values():
# Already launch checks should not be touch
if c.status == 'scheduled':
t_to_go = c.t_to_go
ref = c.ref
new_t = max(0, t_to_go + difference)
# But it's no so simple, we must match the timeperiod
new_t = ref.check_period.get_next_valid_time_from_t(new_t)
# But maybe no there is no more new value! Not good :(
# Say as error, with error output
if new_t is None:
c.state = 'waitconsume'
c.exit_status = 2
c.output = '(Error: there is no available check time after time change!)'
c.check_time = time.time()
c.execution_time = 0
else:
c.t_to_go = new_t
ref.next_chk = new_t
# Now all checks and actions
for c in self.sched.actions.values():
# Already launch checks should not be touch
if c.status == 'scheduled':
t_to_go = c.t_to_go
# Event handler do not have ref
ref = getattr(c, 'ref', None)
new_t = max(0, t_to_go + difference)
# Notification should be check with notification_period
if c.is_a == 'notification':
# But it's no so simple, we must match the timeperiod
new_t = ref.notification_period.get_next_valid_time_from_t(new_t)
# And got a creation_time variable too
c.creation_time = c.creation_time + difference
# But maybe no there is no more new value! Not good :(
# Say as error, with error output
if new_t is None:
c.state = 'waitconsume'
c.exit_status = 2
c.output = '(Error: there is no available check time after time change!)'
c.check_time = time.time()
c.execution_time = 0
else:
c.t_to_go = new_t
def manage_signal(self, sig, frame):
# If we got USR1, just dump memory
if sig == 10:
self.sched.need_dump_memory = True
else: # if not, die :)
self.sched.die()
self.must_run = False
Daemon.manage_signal(self, sig, frame)
def do_loop_turn(self):
# Ok, now the conf
self.wait_for_initial_conf()
if not self.new_conf:
return
print "Ok we've got conf"
self.setup_new_conf()
print "Configuration Loaded"
self.sched.run()
def setup_new_conf(self):
#self.use_ssl = self.app.use_ssl
(conf, override_conf, modules, satellites) = self.new_conf
self.new_conf = None
# In fact it make the scheduler just DIE as a bad guy.
# Must manage it better or not manage it at all!
#if self.cur_conf and self.cur_conf.magic_hash == conf.magic_hash:
# print("I received a conf with same hash than me, I skip it.")
# return
self.conf = conf
self.cur_conf = conf
self.override_conf = override_conf
self.modules = modules
self.satellites = satellites
#self.pollers = self.app.pollers
# Now We create our pollers
for pol_id in satellites['pollers']:
# Must look if we already have it
already_got = pol_id in self.pollers
p = satellites['pollers'][pol_id]
self.pollers[pol_id] = p
uri = pyro.create_uri(p['address'], p['port'], 'Schedulers', self.use_ssl)
self.pollers[pol_id]['uri'] = uri
self.pollers[pol_id]['last_connexion'] = 0
print "Got a poller", p
#First mix conf and override_conf to have our definitive conf
for prop in self.override_conf:
print "Overriding the property %s with value %s" % (prop, self.override_conf[prop])
val = self.override_conf[prop]
setattr(self.conf, prop, val)
if self.conf.use_timezone != 'NOTSET':
print "Setting our timezone to", self.conf.use_timezone
os.environ['TZ'] = self.conf.use_timezone
time.tzset()
print "I've got modules", self.modules
# TODO: if scheduler had previous modules instanciated it must clean them !
self.modules_manager.set_modules(self.modules)
self.do_load_modules()
# And start external ones too
self.modules_manager.start_external_instances()
# give it an interface
# But first remove previous interface if exists
if self.ichecks is not None:
print "Deconnecting previous Check Interface from pyro_daemon"
self.pyro_daemon.unregister(self.ichecks)
#Now create and connect it
self.ichecks = IChecks(self.sched)
self.uri = self.pyro_daemon.register(self.ichecks, "Checks")
print "The Checks Interface uri is:", self.uri
#Same for Broks
if self.ibroks is not None:
print "Deconnecting previous Broks Interface from pyro_daemon"
self.pyro_daemon.unregister(self.ibroks)
#Create and connect it
self.ibroks = IBroks(self.sched)
self.uri2 = self.pyro_daemon.register(self.ibroks, "Broks")
print "The Broks Interface uri is:", self.uri2
print("Loading configuration..")
self.conf.explode_global_conf()
#we give sched it's conf
self.sched.reset()
self.sched.load_conf(self.conf)
self.sched.load_satellites(self.pollers, self.reactionners)
#We must update our Config dict macro with good value
#from the config parameters
self.sched.conf.fill_resource_macros_names_macros()
#print "DBG: got macors", self.sched.conf.macros
#Creating the Macroresolver Class & unique instance
m = MacroResolver()
m.init(self.conf)
#self.conf.dump()
#self.conf.quick_debug()
#Now create the external commander
#it's a applyer : it role is not to dispatch commands,
#but to apply them
e = ExternalCommandManager(self.conf, 'applyer')
#Scheduler need to know about external command to
#activate it if necessery
self.sched.load_external_command(e)
#External command need the sched because he can raise checks
e.load_scheduler(self.sched)
# our main function, launch after the init
def main(self):
self.load_config_file()
self.do_daemon_init_and_start()
self.uri2 = self.pyro_daemon.register(self.interface, "ForArbiter")
print "The Arbiter Interface is at:", self.uri2
self.do_mainloop()
class Shinken(BaseSatellite):
properties = BaseSatellite.properties.copy()
properties.update({
'pidfile': PathProp(default='/usr/local/shinken/var/schedulerd.pid'),
'port': IntegerProp(default='7768'),
'local_log': PathProp(default='/usr/local/shinken/var/schedulerd.log'),
})
#Create the shinken class:
#Create a Pyro server (port = arvg 1)
#then create the interface for arbiter
#Then, it wait for a first configuration
def __init__(self, config_file, is_daemon, do_replace, debug, debug_file):
BaseSatellite.__init__(self, 'scheduler', config_file, is_daemon, do_replace, debug, debug_file)
self.interface = IForArbiter(self)
self.sched = Scheduler(self)
self.ichecks = None
self.ibroks = None
self.must_run = True
# Now the interface
self.uri = None
self.uri2 = None
# And possible links for satellites
# from now only pollers
self.pollers = {}
self.reactionners = {}
def do_stop(self):
self.pyro_daemon.unregister(self.ibroks)
self.pyro_daemon.unregister(self.ichecks)
super(Shinken, self).do_stop()
def compensate_system_time_change(self, difference):
""" Compensate a system time change of difference for all hosts/services/checks/notifs """
logger.log('Warning: A system time change of %d has been detected. Compensating...' % difference)
# We only need to change some value
self.program_start = max(0, self.program_start + difference)
# Then we compasate all host/services
for h in self.sched.hosts:
h.compensate_system_time_change(difference)
for s in self.sched.services:
s.compensate_system_time_change(difference)
# Now all checks and actions
for c in self.sched.checks.values():
# Already launch checks should not be touch
if c.status == 'scheduled':
t_to_go = c.t_to_go
ref = c.ref
new_t = max(0, t_to_go + difference)
# But it's no so simple, we must match the timeperiod
new_t = ref.check_period.get_next_valid_time_from_t(new_t)
# But maybe no there is no more new value! Not good :(
# Say as error, with error output
if new_t is None:
c.state = 'waitconsume'
c.exit_status = 2
c.output = '(Error: there is no available check time after time change!)'
c.check_time = time.time()
c.execution_time = 0
else:
c.t_to_go = new_t
ref.next_chk = new_t
# Now all checks and actions
for c in self.sched.actions.values():
# Already launch checks should not be touch
if c.status == 'scheduled':
t_to_go = c.t_to_go
# Event handler do not have ref
ref = getattr(c, 'ref', None)
new_t = max(0, t_to_go + difference)
# Notification should be check with notification_period
if c.is_a == 'notification':
# But it's no so simple, we must match the timeperiod
new_t = ref.notification_period.get_next_valid_time_from_t(new_t)
# And got a creation_time variable too
c.creation_time = c.creation_time + difference
# But maybe no there is no more new value! Not good :(
# Say as error, with error output
if new_t is None:
c.state = 'waitconsume'
c.exit_status = 2
c.output = '(Error: there is no available check time after time change!)'
c.check_time = time.time()
c.execution_time = 0
else:
c.t_to_go = new_t
def manage_signal(self, sig, frame):
# If we got USR1, just dump memory
if sig == 10:
self.sched.need_dump_memory = True
else: # if not, die :)
self.sched.die()
self.must_run = False
Daemon.manage_signal(self, sig, frame)
def do_loop_turn(self):
# Ok, now the conf
self.wait_for_initial_conf()
if not self.new_conf:
return
print "Ok we've got conf"
self.setup_new_conf()
print "Configuration Loaded"
self.sched.run()
def setup_new_conf(self):
#self.use_ssl = self.app.use_ssl
(conf, override_conf, modules, satellites) = self.new_conf
self.new_conf = None
# In fact it make the scheduler just DIE as a bad guy.
# Must manage it better or not manage it at all!
#if self.cur_conf and self.cur_conf.magic_hash == conf.magic_hash:
# print("I received a conf with same hash than me, I skip it.")
# return
self.conf = conf
self.cur_conf = conf
self.override_conf = override_conf
self.modules = modules
self.satellites = satellites
#self.pollers = self.app.pollers
# Now We create our pollers
for pol_id in satellites['pollers']:
# Must look if we already have it
already_got = pol_id in self.pollers
p = satellites['pollers'][pol_id]
self.pollers[pol_id] = p
uri = pyro.create_uri(p['address'], p['port'], 'Schedulers', self.use_ssl)
self.pollers[pol_id]['uri'] = uri
self.pollers[pol_id]['last_connexion'] = 0
print "Got a poller", p
#First mix conf and override_conf to have our definitive conf
for prop in self.override_conf:
print "Overriding the property %s with value %s" % (prop, self.override_conf[prop])
val = self.override_conf[prop]
setattr(self.conf, prop, val)
if self.conf.use_timezone != 'NOTSET':
print "Setting our timezone to", self.conf.use_timezone
os.environ['TZ'] = self.conf.use_timezone
time.tzset()
print "I've got modules", self.modules
# TODO: if scheduler had previous modules instanciated it must clean them !
self.modules_manager.set_modules(self.modules)
self.do_load_modules()
# And start external ones too
self.modules_manager.start_external_instances()
# give it an interface
# But first remove previous interface if exists
if self.ichecks is not None:
print "Deconnecting previous Check Interface from pyro_daemon"
self.pyro_daemon.unregister(self.ichecks)
#Now create and connect it
self.ichecks = IChecks(self.sched)
self.uri = self.pyro_daemon.register(self.ichecks, "Checks")
print "The Checks Interface uri is:", self.uri
#Same for Broks
if self.ibroks is not None:
print "Deconnecting previous Broks Interface from pyro_daemon"
self.pyro_daemon.unregister(self.ibroks)
#Create and connect it
self.ibroks = IBroks(self.sched)
self.uri2 = self.pyro_daemon.register(self.ibroks, "Broks")
print "The Broks Interface uri is:", self.uri2
print("Loading configuration..")
self.conf.explode_global_conf()
#we give sched it's conf
self.sched.reset()
self.sched.load_conf(self.conf)
self.sched.load_satellites(self.pollers, self.reactionners)
#We must update our Config dict macro with good value
#from the config parameters
self.sched.conf.fill_resource_macros_names_macros()
#print "DBG: got macors", self.sched.conf.macros
#Creating the Macroresolver Class & unique instance
m = MacroResolver()
m.init(self.conf)
#self.conf.dump()
#self.conf.quick_debug()
#Now create the external commander
#it's a applyer : it role is not to dispatch commands,
#but to apply them
e = ExternalCommandManager(self.conf, 'applyer')
#Scheduler need to know about external command to
#activate it if necessery
self.sched.load_external_command(e)
#External command need the sched because he can raise checks
e.load_scheduler(self.sched)
# our main function, launch after the init
def main(self):
self.load_config_file()
self.do_daemon_init_and_start()
self.uri2 = self.pyro_daemon.register(self.interface, "ForArbiter")
print "The Arbiter Interface is at:", self.uri2
self.do_mainloop()
class Shinken(BaseSatellite):
properties = BaseSatellite.properties.copy()
properties.update(
{
"pidfile": PathProp(default="schedulerd.pid"),
"port": IntegerProp(default="7768"),
"local_log": PathProp(default="schedulerd.log"),
}
)
# Create the shinken class:
# Create a Pyro server (port = arvg 1)
# then create the interface for arbiter
# Then, it wait for a first configuration
def __init__(self, config_file, is_daemon, do_replace, debug, debug_file):
BaseSatellite.__init__(self, "scheduler", config_file, is_daemon, do_replace, debug, debug_file)
self.interface = IForArbiter(self)
self.sched = Scheduler(self)
self.ichecks = None
self.ibroks = None
self.must_run = True
# Now the interface
self.uri = None
self.uri2 = None
# And possible links for satellites
# from now only pollers
self.pollers = {}
self.reactionners = {}
def do_stop(self):
if self.pyro_daemon:
if self.ibroks:
self.pyro_daemon.unregister(self.ibroks)
if self.ichecks:
self.pyro_daemon.unregister(self.ichecks)
super(Shinken, self).do_stop()
def compensate_system_time_change(self, difference):
""" Compensate a system time change of difference for all hosts/services/checks/notifs """
logger.log("Warning: A system time change of %d has been detected. Compensating..." % difference)
# We only need to change some value
self.program_start = max(0, self.program_start + difference)
# Then we compasate all host/services
for h in self.sched.hosts:
h.compensate_system_time_change(difference)
for s in self.sched.services:
s.compensate_system_time_change(difference)
# Now all checks and actions
for c in self.sched.checks.values():
# Already launch checks should not be touch
if c.status == "scheduled":
t_to_go = c.t_to_go
ref = c.ref
new_t = max(0, t_to_go + difference)
if ref.check_period is not None:
# But it's no so simple, we must match the timeperiod
new_t = ref.check_period.get_next_valid_time_from_t(new_t)
# But maybe no there is no more new value! Not good :(
# Say as error, with error output
if new_t is None:
c.state = "waitconsume"
c.exit_status = 2
c.output = "(Error: there is no available check time after time change!)"
c.check_time = time.time()
c.execution_time = 0
else:
c.t_to_go = new_t
ref.next_chk = new_t
# Now all checks and actions
for c in self.sched.actions.values():
# Already launch checks should not be touch
if c.status == "scheduled":
t_to_go = c.t_to_go
# Event handler do not have ref
ref = getattr(c, "ref", None)
new_t = max(0, t_to_go + difference)
# Notification should be check with notification_period
if c.is_a == "notification":
if ref.notification_period:
# But it's no so simple, we must match the timeperiod
new_t = ref.notification_period.get_next_valid_time_from_t(new_t)
# And got a creation_time variable too
c.creation_time = c.creation_time + difference
# But maybe no there is no more new value! Not good :(
# Say as error, with error output
if new_t is None:
c.state = "waitconsume"
c.exit_status = 2
c.output = "(Error: there is no available check time after time change!)"
c.check_time = time.time()
c.execution_time = 0
else:
c.t_to_go = new_t
def manage_signal(self, sig, frame):
# If we got USR1, just dump memory
if sig == 10:
self.sched.need_dump_memory = True
else: # if not, die :)
self.sched.die()
self.must_run = False
Daemon.manage_signal(self, sig, frame)
def do_loop_turn(self):
# Ok, now the conf
self.wait_for_initial_conf()
if not self.new_conf:
return
print "Ok we've got conf"
self.setup_new_conf()
print "Configuration Loaded"
self.sched.run()
def setup_new_conf(self):
# self.use_ssl = self.app.use_ssl
(conf, override_conf, modules, satellites) = self.new_conf
self.new_conf = None
# In fact it make the scheduler just DIE as a bad guy.
# Must manage it better or not manage it at all!
# if self.cur_conf and self.cur_conf.magic_hash == conf.magic_hash:
# print("I received a conf with same hash than me, I skip it.")
# return
self.conf = conf
self.cur_conf = conf
self.override_conf = override_conf
self.modules = modules
self.satellites = satellites
# self.pollers = self.app.pollers
if self.conf.human_timestamp_log:
logger.set_human_format()
# Now We create our pollers
for pol_id in satellites["pollers"]:
# Must look if we already have it
already_got = pol_id in self.pollers
p = satellites["pollers"][pol_id]
self.pollers[pol_id] = p
uri = pyro.create_uri(p["address"], p["port"], "Schedulers", self.use_ssl)
self.pollers[pol_id]["uri"] = uri
self.pollers[pol_id]["last_connection"] = 0
# First mix conf and override_conf to have our definitive conf
for prop in self.override_conf:
# print "Overriding the property %s with value %s" % (prop, self.override_conf[prop])
val = self.override_conf[prop]
setattr(self.conf, prop, val)
if self.conf.use_timezone != "":
print "Setting our timezone to", self.conf.use_timezone
os.environ["TZ"] = self.conf.use_timezone
time.tzset()
if len(self.modules) != 0:
print "I've got modules", self.modules
# TODO: if scheduler had previous modules instanciated it must clean them !
self.modules_manager.set_modules(self.modules)
self.do_load_modules()
# And start external ones too
self.modules_manager.start_external_instances()
# give it an interface
# But first remove previous interface if exists
if self.ichecks is not None:
print "Deconnecting previous Check Interface from pyro_daemon"
self.pyro_daemon.unregister(self.ichecks)
# Now create and connect it
self.ichecks = IChecks(self.sched)
self.uri = self.pyro_daemon.register(self.ichecks, "Checks")
print "The Checks Interface uri is:", self.uri
# Same for Broks
if self.ibroks is not None:
print "Deconnecting previous Broks Interface from pyro_daemon"
self.pyro_daemon.unregister(self.ibroks)
# Create and connect it
self.ibroks = IBroks(self.sched)
self.uri2 = self.pyro_daemon.register(self.ibroks, "Broks")
print "The Broks Interface uri is:", self.uri2
print ("Loading configuration..")
self.conf.explode_global_conf()
# we give sched it's conf
self.sched.reset()
self.sched.load_conf(self.conf)
self.sched.load_satellites(self.pollers, self.reactionners)
# We must update our Config dict macro with good value
# from the config parameters
self.sched.conf.fill_resource_macros_names_macros()
# print "DBG: got macors", self.sched.conf.macros
# Creating the Macroresolver Class & unique instance
m = MacroResolver()
m.init(self.conf)
# self.conf.dump()
# self.conf.quick_debug()
# Now create the external commander
# it's a applyer : it role is not to dispatch commands,
# but to apply them
e = ExternalCommandManager(self.conf, "applyer")
# Scheduler need to know about external command to
# activate it if necessery
self.sched.load_external_command(e)
# External command need the sched because he can raise checks
e.load_scheduler(self.sched)
# We clear our schedulers managed (it's us :) )
# and set ourself in it
self.schedulers = {self.conf.instance_id: self.sched}
# Give the arbiter the data about what I manage
# for me it's just my instance_id and my push flavor
def what_i_managed(self):
if hasattr(self, "conf"):
return {self.conf.instance_id: self.conf.push_flavor}
else:
return {}
# our main function, launch after the init
def main(self):
try:
self.load_config_file()
self.do_daemon_init_and_start()
self.uri2 = self.pyro_daemon.register(self.interface, "ForArbiter")
logger.log("[scheduler] General interface is at: %s" % self.uri2)
self.do_mainloop()
except Exception, exp:
logger.log("CRITICAL ERROR: I got an unrecoverable error. I have to exit")
logger.log("You can log a bug ticket at https://github.com/naparuba/shinken/issues/new to get help")
logger.log("Back trace of it: %s" % (traceback.format_exc()))
raise
class ShinkenTest(unittest.TestCase):
def setUp(self):
self.setup_with_file('etc/nagios_1r_1h_1s.cfg')
def setup_with_file(self, path):
# i am arbiter-like
self.broks = {}
self.me = None
self.log = logger
self.log.load_obj(self)
self.config_files = [path]
self.conf = Config()
self.conf.read_config(self.config_files)
buf = self.conf.read_config(self.config_files)
raw_objects = self.conf.read_config_buf(buf)
self.conf.create_objects_for_type(raw_objects, 'arbiter')
self.conf.create_objects_for_type(raw_objects, 'module')
self.conf.early_arbiter_linking()
self.conf.create_objects(raw_objects)
self.conf.instance_id = 0
self.conf.instance_name = 'test'
self.conf.linkify_templates()
self.conf.apply_inheritance()
self.conf.explode()
self.conf.create_reversed_list()
self.conf.remove_twins()
self.conf.apply_implicit_inheritance()
self.conf.fill_default()
self.conf.clean_useless()
self.conf.pythonize()
self.conf.linkify()
self.conf.apply_dependancies()
self.conf.explode_global_conf()
self.conf.propagate_timezone_option()
self.conf.create_business_rules()
self.conf.create_business_rules_dependencies()
self.conf.is_correct()
self.confs = self.conf.cut_into_parts()
self.dispatcher = Dispatcher(self.conf, self.me)
scheddaemon = Shinken(None, False, False, False, None)
self.sched = Scheduler(scheddaemon)
scheddaemon.sched = self.sched
m = MacroResolver()
m.init(self.conf)
self.sched.load_conf(self.conf)
e = ExternalCommandManager(self.conf, 'applyer')
self.sched.external_command = e
e.load_scheduler(self.sched)
e2 = ExternalCommandManager(self.conf, 'dispatcher')
e2.load_arbiter(self)
self.external_command_dispatcher = e2
self.sched.schedule()
def add(self, b):
if isinstance(b, Brok):
self.broks[b.id] = b
return
if isinstance(b, ExternalCommand):
self.sched.run_external_command(b.cmd_line)
def fake_check(self, ref, exit_status, output="OK"):
#print "fake", ref
now = time.time()
ref.schedule(force=True)
#now checks are schedule and we get them in
#the action queue
check = ref.actions.pop()
self.sched.add(check) # check is now in sched.checks[]
# fake execution
check.check_time = now
elts_line1 = output.split('|')
#First line before | is output
check.output = elts_line1[0]
#After | is perfdata
if len(elts_line1) > 1:
check.perf_data = elts_line1[1]
else:
check.perf_data = ''
check.exit_status = exit_status
check.execution_time = 0.001
check.status = 'waitconsume'
self.sched.waiting_results.append(check)
def scheduler_loop(self, count, reflist, do_sleep=False, sleep_time=61):
for ref in reflist:
(obj, exit_status, output) = ref
obj.checks_in_progress = []
for loop in range(1, count + 1):
print "processing check", loop
for ref in reflist:
(obj, exit_status, output) = ref
obj.update_in_checking()
self.fake_check(obj, exit_status, output)
self.sched.manage_internal_checks()
self.sched.consume_results()
self.sched.get_new_actions()
self.sched.get_new_broks()
self.worker_loop()
for ref in reflist:
(obj, exit_status, output) = ref
obj.checks_in_progress = []
self.sched.update_downtimes_and_comments()
#time.sleep(ref.retry_interval * 60 + 1)
if do_sleep:
time.sleep(sleep_time)
def worker_loop(self):
self.sched.delete_zombie_checks()
self.sched.delete_zombie_actions()
checks = self.sched.get_to_run_checks(True,
False,
worker_name='tester')
actions = self.sched.get_to_run_checks(False,
True,
worker_name='tester')
#print "------------ worker loop checks ----------------"
#print checks
#print "------------ worker loop actions ----------------"
self.show_actions()
#print "------------ worker loop new ----------------"
for a in actions:
a.status = 'inpoller'
a.check_time = time.time()
a.exit_status = 0
self.sched.put_results(a)
self.show_actions()
#print "------------ worker loop end ----------------"
def show_logs(self):
print "--- logs <<<----------------------------------"
for brok in sorted(self.sched.broks.values(),
lambda x, y: x.id - y.id):
if brok.type == 'log':
print "LOG:", brok.data['log']
print "--- logs >>>----------------------------------"
def show_actions(self):
print "--- actions <<<----------------------------------"
for a in sorted(self.sched.actions.values(), lambda x, y: x.id - y.id):
if a.is_a == 'notification':
if a.ref.my_type == "host":
ref = "host: %s" % a.ref.get_name()
else:
ref = "host: %s svc: %s" % (a.ref.host.get_name(),
a.ref.get_name())
print "NOTIFICATION %d %s %s %s %s" % (
a.id, ref, a.type, time.asctime(time.localtime(
a.t_to_go)), a.status)
elif a.is_a == 'eventhandler':
print "EVENTHANDLER:", a
print "--- actions >>>----------------------------------"
def show_and_clear_logs(self):
self.show_logs()
self.clear_logs()
def show_and_clear_actions(self):
self.show_actions()
self.clear_actions()
def count_logs(self):
return len([b for b in self.sched.broks.values() if b.type == 'log'])
def count_actions(self):
return len(self.sched.actions.values())
def clear_logs(self):
id_to_del = []
for b in self.sched.broks.values():
if b.type == 'log':
id_to_del.append(b.id)
for id in id_to_del:
del self.sched.broks[id]
def clear_actions(self):
self.sched.actions = {}
def log_match(self, index, pattern):
# log messages are counted 1...n, so index=1 for the first message
if index > self.count_logs():
return False
else:
regex = re.compile(pattern)
lognum = 1
for brok in sorted(self.sched.broks.values(),
lambda x, y: x.id - y.id):
if brok.type == 'log':
if index == lognum:
if re.search(regex, brok.data['log']):
return True
lognum += 1
return False
def any_log_match(self, pattern):
regex = re.compile(pattern)
for brok in sorted(self.sched.broks.values(),
lambda x, y: x.id - y.id):
if brok.type == 'log':
if re.search(regex, brok.data['log']):
return True
return False
def get_log_match(self, pattern):
regex = re.compile(pattern)
res = []
for brok in sorted(self.sched.broks.values(),
lambda x, y: x.id - y.id):
if brok.type == 'log':
if re.search(regex, brok.data['log']):
res.append(brok.data['log'])
return res
def print_header(self):
print "#" * 80 + "\n" + "#" + " " * 78 + "#"
print "#" + string.center(self.id(), 78) + "#"
print "#" + " " * 78 + "#\n" + "#" * 80 + "\n"
def xtest_conf_is_correct(self):
self.print_header()
self.assert_(self.conf.conf_is_correct)