def check_alive_instances(self):
# Only for external
for inst in self.instances:
if not inst in self.to_restart:
if inst.is_external and not inst.process.is_alive():
logger.error("The external module %s goes down unexpectedly!" % inst.get_name())
logger.info("Setting the module %s to restart" % inst.get_name())
# We clean its queues, they are no more useful
inst.clear_queues(self.manager)
self.to_restart.append(inst)
# Ok, no need to look at queue size now
continue
# Now look for man queue size. If above value, the module should got a huge problem
# and so bailout. It's not a perfect solution, more a watchdog
# If max_queue_size is 0, don't check this
if self.max_queue_size == 0:
continue
# Ok, go launch the dog!
queue_size = 0
try:
queue_size = inst.to_q.qsize()
except Exception, exp:
pass
if queue_size > self.max_queue_size:
logger.error("The external module %s got a too high brok queue size (%s > %s)!" % (inst.get_name(), queue_size, self.max_queue_size))
logger.info("Setting the module %s to restart" % inst.get_name())
# We clean its queues, they are no more useful
inst.clear_queues(self.manager)
self.to_restart.append(inst)
def add(self, elt):
cls_type = elt.__class__.my_type
if cls_type == 'brok':
# For brok, we TAG brok with our instance_id
elt.instance_id = 0
self.broks_internal_raised.append(elt)
return
elif cls_type == 'externalcommand':
logger.debug("Enqueuing an external command '%s'" % str(ExternalCommand.__dict__))
self.external_commands.append(elt)
# Maybe we got a Message from the modules, it's way to ask something
# like from now a full data from a scheduler for example.
elif cls_type == 'message':
# We got a message, great!
logger.debug(str(elt.__dict__))
if elt.get_type() == 'NeedData':
data = elt.get_data()
# Full instance id means: I got no data for this scheduler
# so give me all dumbass!
if 'full_instance_id' in data:
c_id = data['full_instance_id']
source = elt.source
logger.info('The module %s is asking me to get all initial data from the scheduler %d' % (source, c_id))
# so we just reset the connection and the running_id, it will just get all new things
try:
self.schedulers[c_id]['con'] = None
self.schedulers[c_id]['running_id'] = 0
except KeyError: # maybe this instance was not known, forget it
logger.warning("the module %s ask me a full_instance_id for an unknown ID (%d)!" % (source, c_id))
# Maybe a module tells me that it's dead, I must log it's last words...
if elt.get_type() == 'ICrash':
data = elt.get_data()
logger.error('the module %s just crash! Please look at the traceback:' % data['name'])
logger.error(data['trace'])
def hook_save_retention(self, daemon):
"""
main function that is called in the retention creation pass
"""
logger.debug("[MemcacheRetention] asking me to update the retention objects")
all_data = daemon.get_retention_data()
hosts = all_data['hosts']
services = all_data['services']
# Now the flat file method
for h_name in hosts:
try:
h = hosts[h_name]
key = self.normalize_key("HOST-%s" % h_name)
val = cPickle.dumps(h)
self.mc.set(key, val)
except:
logger.error("[MemcacheRetention] error while saving host %s" % key)
for (h_name, s_desc) in services:
try:
key = self.normalize_key("SERVICE-%s,%s" % (h_name, s_desc))
s = services[(h_name, s_desc)]
val = cPickle.dumps(s)
self.mc.set(key, val)
except:
logger.error("[MemcacheRetention] error while saving service %s" % key)
self.mc.disconnect_all()
logger.info("Retention information updated in Memcache")
def is_me(self, lookup_name):
logger.info("And arbiter is launched with the hostname:%s "
"from an arbiter point of view of addr:%s", self.host_name, socket.getfqdn())
if lookup_name:
return lookup_name == self.get_name()
else:
return self.host_name == socket.getfqdn() or self.host_name == socket.gethostname()
def dark():
r"""
.-.
|_:_|
/(_Y_)\
( \/M\/ )
'. _.'-/'-'\-'._
': _/.--'[[[[]'--.\_
': /_' : |::"| : '.\
': // ./ |oUU| \.' :\
': _:'..' \_|___|_/ : :|
':. .' |_[___]_| :.':\
[::\ | : | | : ; : \
'-' \/'.| |.' \ .;.' |
|\_ \ '-' : |
| \ \ .: : | |
| \ | '. : \ |
/ \ :. .; |
/ | | :__/ : \\
| | | \: | \ | ||
/ \ : : |: / |__| /|
snd | : : :_/_| /'._\ '--|_\
/___.-/_|-' \ \
'-'
"""
logger.info(dark.__doc__)
def hook_load_retention(self, daemon):
# Now the new redis way :)
logger.info("[RedisRetention] asking me to load retention objects")
# We got list of loaded data from retention server
ret_hosts = {}
ret_services = {}
# We must load the data and format as the scheduler want :)
for h in daemon.hosts:
key = self._get_host_key(h.host_name)
val = self.rc.get(key)
if val is not None:
val = cPickle.loads(val)
ret_hosts[h.host_name] = val
for s in daemon.services:
key = self._get_service_key(s.host.host_name,
s.service_description)
val = self.rc.get(key)
if val is not None:
val = cPickle.loads(val)
ret_services[(s.host.host_name, s.service_description)] = val
all_data = {'hosts': ret_hosts, 'services': ret_services}
# Ok, now come load them scheduler :)
daemon.restore_retention_data(all_data)
logger.info("[RedisRetention] Retention objects loaded successfully.")
return True
def main(self):
self.set_proctitle(self.name)
# Daemon like init
self.debug_output = []
self.modules_dir = modulesctx.get_modulesdir()
self.modules_manager = ModulesManager('webui', self.find_modules_path(), [])
self.modules_manager.set_modules(self.modules)
# We can now output some previously silenced debug output
self.do_load_modules()
for inst in self.modules_manager.instances:
f = getattr(inst, 'load', None)
if f and callable(f):
f(self)
for s in self.debug_output:
print s
del self.debug_output
# Check if the Bottle view dir really exist
if not os.path.exists(bottle.TEMPLATE_PATH[0]):
logger.error("[WebUI] The view path do not exist at %s" % bottle.TEMPLATE_PATH)
sys.exit(2)
# Check directories
# We check if the photo directory exists. If not, try to create it
for d in [self.photo_dir, self.share_dir, self.config_dir]:
logger.debug("[WebUI] Checking dir: %s", d)
if not os.path.exists(d):
try:
os.mkdir(d)
logger.info("[WebUI] Created dir: %s", d)
except Exception, exp:
logger.error("[WebUI] Dir creation failed: %s", exp)
def main(self):
try:
self.load_config_file()
# Setting log level
logger.setLevel(self.log_level)
# Force the debug level if the daemon is said to start with such level
if self.debug:
logger.setLevel('DEBUG')
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:
self.print_unrecoverable(traceback.format_exc())
raise
def init(self):
logger.info("Try to open SQLite database at %s" % (self.uri))
try:
self.db = sqlite3.connect(self.uri, check_same_thread=False)
except Exception, e:
logger.error("Error %s:" % e)
raise
def publish_archive(archive):
# Now really publish it
api_key = CONFIG['shinken.io']['api_key']
c = prepare_curl_connection('/push', post=1, verbose=1)
c.setopt(c.HTTPPOST, [("api_key", api_key),
("data",
(c.FORM_FILE, str(archive),
c.FORM_CONTENTTYPE, "application/x-gzip"))
])
response = StringIO()
c.setopt(pycurl.WRITEFUNCTION, response.write)
try:
c.perform()
except pycurl.error as exp:
logger.error("There was a critical error : %s", exp)
sys.exit(2)
return
r = c.getinfo(pycurl.HTTP_CODE)
c.close()
if r != 200:
logger.error("There was a critical error : %s", response.getvalue())
sys.exit(2)
else:
ret = json.loads(response.getvalue().replace('\\/', '/'))
status = ret.get('status')
text = ret.get('text')
if status == 200:
logger.info(text)
else:
logger.error(text)
sys.exit(2)
def launch_new_checks(self):
for chk in self.checks:
if chk.status == 'queue':
logger.info("[Android SMS] Launching SMS for command %s" % chk.command)
elts = chk.command.split(' ')
# Check the command call first
if len(elts) < 3:
chk.exit_status = 2
chk.get_outputs('The android SMS call %s is not valid. should be android_sms PHONENUMBER TEXT', 8012)
chk.status = 'done'
chk.execution_time = 0.1
continue
# Should be android_sms PHONE TEXT
phone = elts[1]
text = ' '.join(elts[2:])
# Go call the SMS :)
try:
self.android.smsSend(phone, text)
except Exception, exp:
chk.exit_status = 2
chk.get_outputs('The android SMS to %s got an error %s' % (phone, exp), 8012)
chk.status = 'done'
chk.execution_time = 0.1
continue
logger.info("[Android SMS] Send SMS %s to %s" % text, str(phone))
# And finish the notification
chk.exit_status = 1
chk.get_outputs('SMS sent to %s' % phone, 8012)
chk.status = 'done'
chk.execution_time = 0.01
def get_instance(plugin):
name = plugin.get_name()
logger.info("Get a Syslog broker for plugin %s" % (name))
# syslog.syslog priority defaults to (LOG_INFO | LOG_USER)
facility = syslog.LOG_USER
priority = syslog.LOG_INFO
# Get configuration values, if any
if hasattr(plugin, 'facility'):
facility = plugin.facility
if hasattr(plugin, 'priority'):
priority = plugin.priority
# Ensure config values have a string type compatible with
# SysLogHandler.encodePriority
if type(facility) in types.StringTypes:
facility = types.StringType(facility)
if type(priority) in types.StringTypes:
priority = types.StringType(priority)
# Convert facility / priority (integers or strings) to aggregated
# priority value
sh = SysLogHandler()
try:
priority = sh.encodePriority(facility, priority)
except TypeError, e:
logger.error("[%s] Couldn't get syslog priority, "
"reverting to defaults" % (name))
def hook_late_configuration(self, arb):
""" Read config and fill database """
mac_resol = MacroResolver()
mac_resol.init(arb.conf)
for serv in arb.conf.services:
if serv.check_command.command.module_type == 'snmp_booster':
try:
# Serialize service
dict_serv = dict_serialize(serv,
mac_resol,
self.datasource)
except Exception as exp:
logger.error("[SnmpBooster] [code 0907] [%s,%s] "
"%s" % (serv.host.get_name(),
serv.get_name(),
str(exp)))
continue
# We want to make a diff between arbiter insert and poller insert. Some backend may need it.
try:
self.db_client.update_service_init(dict_serv['host'],
dict_serv['service'],
dict_serv)
except Exception as exp:
logger.error("[SnmpBooster] [code 0909] [%s,%s] "
"%s" % (dict_serv['host'],
dict_serv['service'],
str(exp)))
continue
logger.info("[SnmpBooster] [code 0908] Done parsing")
# Disconnect from database
self.db_client.disconnect()
def manage_log_brok(self, brok):
"""
Parse a Shinken log brok to enqueue a log line for Index insertion
"""
d = date.today()
index_name = self.index_prefix + "-" + d.strftime("%Y.%m.%d")
line = brok.data["log"]
if re.match("^\[[0-9]*\] [A-Z][a-z]*.:", line):
# Match log which NOT have to be stored
logger.warning("[elastic-logs] do not store: %s", line)
return
logline = Logline(line=line)
logline_dict = logline.as_dict()
logline_dict.update({"@timestamp": datetime.utcfromtimestamp(int(logline_dict["time"])).isoformat() + "Z"})
values = {"_index": index_name, "_type": "shinken-logs", "_source": logline_dict}
# values = logline.as_dict()
if logline.logclass != LOGCLASS_INVALID:
logger.debug("[elastic-logs] store log line values: %s", values)
self.logs_cache.append(values)
else:
logger.info("[elastic-logs] This line is invalid: %s", line)
return
def manage_service_check_resultup_brok(self, b):
"""If a host is defined locally (in shinken) and not in GLPI,
we must not edit GLPI datas !
"""
if 'plugin_monitoring_servicescatalogs_id' not in b.data and\
'plugin_monitoring_services_id' not in b.data:
return list()
logger.info("GLPI : data in DB %s " % b.data)
new_data = copy.deepcopy(b.data)
new_data['last_check'] = time.strftime('%Y-%m-%d %H:%M:%S')
del new_data['perf_data']
del new_data['output']
del new_data['latency']
del new_data['execution_time']
try:
new_data['id'] = b.data['plugin_monitoring_servicescatalogs_id']
del new_data['plugin_monitoring_servicescatalogs_id']
table = 'glpi_plugin_monitoring_servicescatalogs'
except:
new_data['id'] = b.data['plugin_monitoring_services_id']
del new_data['plugin_monitoring_services_id']
table = 'glpi_plugin_monitoring_services'
where_clause = {'id' : new_data['id']}
#print "Update service : ", new_data
query = self.db_backend.create_update_query(table, new_data, where_clause)
return [query]
def load_config(app):
global params
import os
from webui2.config_parser import config_parser
try:
currentdir = os.path.dirname(os.path.realpath(__file__))
configuration_file = "%s/%s" % (currentdir, 'plugin.cfg')
logger.info("[WebUI-logs] Plugin configuration file: %s", configuration_file)
scp = config_parser('#', '=')
z = params.copy()
z.update(scp.parse_config(configuration_file))
params = z
params['logs_type'] = [item.strip() for item in params['logs_type'].split(',')]
if len(params['logs_hosts']) > 0:
params['logs_hosts'] = [item.strip() for item in params['logs_hosts'].split(',')]
if len(params['logs_services']) > 0:
params['logs_services'] = [item.strip() for item in params['logs_services'].split(',')]
logger.info("[WebUI-logs] configuration loaded.")
logger.info("[WebUI-logs] configuration, fetching types: %s", params['logs_type'])
logger.info("[WebUI-logs] configuration, hosts: %s", params['logs_hosts'])
logger.info("[WebUI-logs] configuration, services: %s", params['logs_services'])
return True
except Exception, exp:
logger.warning("[WebUI-logs] configuration file (%s) not available: %s", configuration_file, str(exp))
return False
def hook_save_retention(self, daemon):
"""
main function that is called in the retention creation pass
"""
try:
self.max_workers = cpu_count()
except NotImplementedError:
pass
t0 = time.time()
logger.debug("[MongodbRetention] asking me to update the retention objects")
all_data = daemon.get_retention_data()
processes = []
for i in xrange(self.max_workers):
proc = Process(target=self.job, args=(all_data, i, self.max_workers))
proc.start()
processes.append(proc)
# Allow 30s to join the sub-processes, should be enough
for proc in processes:
proc.join(30)
logger.info("Retention information updated in Mongodb (%.2fs)" % (time.time() - t0))
def get_objects(self):
if not hasattr(self, 'conn'):
logger.error("[MySQLImport]: Problem during init phase")
return {}
# Create variables for result
r = {}
cursor = self.conn.cursor(MySQLdb.cursors.DictCursor)
# For all parameters
for k, v in self.reqlist.iteritems():
r[k] = []
if(v != None):
result_set = {}
logger.info("[MySQLImport]: Getting %s configuration from database" % (k))
try:
cursor.execute(v)
result_set = cursor.fetchall()
except MySQLdb.Error, e:
logger.error("[MySQLImport]: Error %d: %s" % (e.args[0], e.args[1]))
# Create set with result
for row in result_set:
h = {}
for column in row:
if row[column]:
h[column] = row[column]
r[k].append(h)
def init_http(self):
logger.info("[WS_Arbiter] Starting WS arbiter http socket")
try:
self.srv = run(host=self.host, port=self.port, server='wsgirefselect')
except Exception, e:
logger.error("[WS_Arbiter] Exception : %s" % str(e))
raise
def get_coffee():
r"""
(
) (
___...(-------)-....___
.-"" ) ( ""-.
.-'``'|-._ ) _.-|
/ .--.| `""---...........---""` |
/ / | |
| | | |
\ \ | |
`\ `\ | |
`\ `| |
_/ /\ /
(__/ \ /
_..---""` \ /`""---.._
.-' \ / '-.
: `-.__ __.-' :
: ) ""---...---"" ( :
'._ `"--...___...--"` _.'
jgs \""--..__ __..--""/
'._ "'"----.....______.....----"'" _.'
`""--..,,_____ _____,,..--""`
`"'"----"'"`
"""
logger.info(get_coffee.__doc__)
def hook_save_retention(self, daemon):
log_mgr = logger
logger.info("[PickleRetentionGeneric] asking me to update the retention objects")
# Now the flat file method
try:
# Open a file near the path, with .tmp extension
# so in cae or problem, we do not lost the old one
f = open(self.path + ".tmp", "wb")
# We get interesting retention data from the daemon it self
all_data = daemon.get_retention_data()
# And we save it on file :)
# s = cPickle.dumps(all_data)
# s_compress = zlib.compress(s)
cPickle.dump(all_data, f, protocol=cPickle.HIGHEST_PROTOCOL)
# f.write(s_compress)
f.close()
# Now move the .tmp fiel to the real path
shutil.move(self.path + ".tmp", self.path)
except IOError, exp:
log_mgr.log("Error: retention file creation failed, %s" % str(exp))
return
def hook_save_retention(self, daemon):
"""
main function that is called in the retention creation pass
"""
logger.debug("[RedisRetention] asking me to update retention objects")
all_data = daemon.get_retention_data()
hosts = all_data['hosts']
services = all_data['services']
# Now the flat file method
for h_name in hosts:
h = hosts[h_name]
key = self._get_host_key(h_name)
val = cPickle.dumps(h)
if self.expire_time:
self.rc.set(key, val, ex=self.expire_time)
else:
self.rc.set(key, val)
for (h_name, s_desc) in services:
s = services[(h_name, s_desc)]
key = self._get_service_key(h_name, s_desc)
val = cPickle.dumps(s)
if self.expire_time:
self.rc.set(key, val, ex=self.expire_time)
else:
self.rc.set(key, val)
logger.info("Retention information updated in Redis")
def hook_late_configuration(self, arb):
# We will return external commands to the arbiter, so
# it can just manage it easily and in a generic way
ext_cmds = []
# If the file do not exist, we launch the command
# and we bail out
if not self._is_file_existing():
self._launch_command()
return
self._is_mapping_file_changed()
self._update_mapping()
additions, removed = self._got_mapping_changes()
for (father_k, son_k) in additions:
son_type, son_name = son_k
father_type, father_name = father_k
logger.info("[Hot dependencies] Linked son : %s and its father: %s" % (son_name, father_name))
if son_type == 'host' and father_type == 'host':
son = arb.conf.hosts.find_by_name(son_name)
father = arb.conf.hosts.find_by_name(father_name)
if son is not None and father is not None:
logger.debug("[Hot dependencies] Found! %s %s" % (son_name, father_name))
if not son.is_linked_with_host(father):
logger.debug("[Hot dependencies] Doing simple link between %s and %s" % (son.get_name(), father.get_name()))
# Add a dep link between the son and the father
son.add_host_act_dependency(father, ['w', 'u', 'd'], None, True)
else:
logger.debug("[Hot dependencies] Missing one of %s %s" % (son_name, father_name))
def commit_and_rotate_log_db(self):
"""Submit a commit or rotate the complete database file.
This function is called whenever the mainloop doesn't handle a request.
The database updates are committed every second.
Every day at 00:05 the database contents with a timestamp of past days
are moved to their own datafiles (one for each day). We wait until 00:05
because in a distributed environment even after 00:00 (on the broker host)
we might receive data from other hosts with a timestamp dating from yesterday.
"""
if self.read_only:
return
now = time.time()
if self.next_log_db_commit <= now:
self.commit()
logger.debug("[Logstore SQLite] commit.....")
self.next_log_db_commit = now + 1
if self.next_log_db_rotate <= now:
logger.info("[Logstore SQLite] at %s we rotate the database file" % time.asctime(time.localtime(now)))
# Take the current database file
# Move the messages into daily files
self.log_db_do_archive()
today = datetime.date.today()
today0005 = datetime.datetime(today.year, today.month, today.day, 0, 5, 0)
if now < time.mktime(today0005.timetuple()):
nextrotation = today0005
else:
nextrotation = today0005 + datetime.timedelta(days=1)
# See you tomorrow
self.next_log_db_rotate = time.mktime(nextrotation.timetuple())
logger.info("[Logstore SQLite] next rotation at %s " % time.asctime(time.localtime(self.next_log_db_rotate)))
def get_instance(plugin):
logger.info("Get a RawSocket broker for plugin %s" % plugin.get_name())
#Catch errors
#path = plugin.path
instance = RawSocket_broker(plugin)
return instance
def main(self):
self.set_proctitle(self.name)
self.set_exit_handler()
self.open()
input = [self.fifo]
while not self.interrupted:
if input == []:
time.sleep(1)
continue
try:
inputready, outputready, exceptready = select.select(input, [], [], 1)
except select.error, e:
if e.args[0] == errno.EINTR:
logger.info("[%s] Received exit signal. Bailing out." % self.get_name())
return
for s in inputready:
ext_cmds = self.get()
if ext_cmds:
for ext_cmd in ext_cmds:
self.from_q.put(ext_cmd)
else:
self.fifo = self.open()
if self.fifo is not None:
input = [self.fifo]
else:
input = []
def process_check_result(self, databuffer, IV):
# 208 is the size of fixed received data ... NSCA packets are 208+512 (720) or 208+4096 (4304)
if not databuffer:
logger.warning("[NSCA] Received an empty NSCA packet")
return
logger.debug("[NSCA] Received NSCA packet: %s", binascii.hexlify(databuffer))
payload_length = len(databuffer) - 208
if payload_length != 512 and payload_length != 4096:
logger.warning("[NSCA] Received packet with unusual payload length: %d.", payload_length)
if self.payload_length != -1 and payload_length != self.payload_length:
logger.warning("[NSCA] Dropping packet with incorrect payload length.")
return
(timestamp, rc, hostname, service, output) = self.read_check_result(databuffer, IV, payload_length)
current_time = time.time()
check_result_age = current_time - timestamp
if timestamp > current_time and self.check_future_packet:
logger.warning("[NSCA] Dropping packet with future timestamp.")
elif check_result_age > self.max_packet_age:
logger.info(
"[NSCA] Dropping packet with stale timestamp - packet was %s seconds old. Timestamp: %s for %s/%s" % \
(check_result_age, timestamp, hostname, service))
else:
self.post_command(timestamp, rc, hostname, service, output)
def do_pynag_con_init(self, id, type='scheduler'):
# Get the good links tab for looping..
links = self.get_links_from_type(type)
if links is None:
logger.debug('Type unknown for connection! %s', type)
return
if type == 'scheduler':
# If sched is not active, I do not try to init
# it is just useless
is_active = links[id]['active']
if not is_active:
return
# If we try to connect too much, we slow down our tests
if self.is_connection_try_too_close(links[id]):
return
# Ok, we can now update it
links[id]['last_connection'] = time.time()
# DBG: print "Init connection with", links[id]['uri']
running_id = links[id]['running_id']
# DBG: print "Running id before connection", running_id
uri = links[id]['uri']
try:
con = links[id]['con'] = HTTPClient(uri=uri, strong_ssl=links[id]['hard_ssl_name_check'])
except HTTPExceptions, exp:
# But the multiprocessing module is not compatible with it!
# so we must disable it immediately after
logger.info("Connection problem to the %s %s: %s", type, links[id]['name'], str(exp))
links[id]['con'] = None
return
def get_instance(plugin):
""" Return a module instance for the plugin manager """
logger.info("Get a NSCA arbiter module for plugin %s" % plugin.get_name())
host = getattr(plugin, 'host', '127.0.0.1')
if host == '*':
host = ''
port = int(getattr(plugin, 'port', '5667'))
buffer_length = int(getattr(plugin, 'buffer_length', '4096'))
payload_length = int(getattr(plugin, 'payload_length', '-1'))
encryption_method = int(getattr(plugin, 'encryption_method', '0'))
backlog = int(getattr(plugin, 'backlog', '10'))
password = getattr(plugin, 'password', '')
if password == "" and encryption_method != 0:
logger.error("[NSCA] No password specified whereas there is a encryption_method defined")
logger.warning("[NSCA] Setting password to dummy to avoid crash!")
password = "******"
max_packet_age = min(int(getattr(plugin, 'max_packet_age', '30')), 900)
check_future_packet = bool(getattr(plugin, 'check_future_packet', 0))
instance = NSCA_arbiter(plugin, host, port,
buffer_length, payload_length, encryption_method, password, max_packet_age, check_future_packet,
backlog)
return instance
def __init__(self, mod_conf, pub_endpoint, serialize_to):
from zmq import Context, PUB
BaseModule.__init__(self, mod_conf)
self.pub_endpoint = pub_endpoint
self.serialize_to = serialize_to
logger.info("[Zmq Broker] Binding to endpoint " + self.pub_endpoint)
# This doesn't work properly in init()
# sometimes it ends up beings called several
# times and the address becomes already in use.
self.context = Context()
self.s_pub = self.context.socket(PUB)
self.s_pub.bind(self.pub_endpoint)
# Load the correct serialization function
# depending on the serialization method
# chosen in the configuration.
if self.serialize_to == "msgpack":
from msgpack import Packer
packer = Packer(default=encode_monitoring_data)
self.serialize = lambda msg: packer.pack(msg)
elif self.serialize_to == "json":
self.serialize = lambda msg: json.dumps(msg, cls=SetEncoder)
else:
raise Exception("[Zmq Broker] No valid serialization method defined (Got " + str(self.serialize_to) + ")!")
def load_config(app):
global params
logger.info("[WebUI-worldmap] loading configuration ...")
properties = {
'worldmap-zoom': '{"default_zoom": 16}',
'worldmap-lng': '{"default_lng": 5.080625}',
'worldmap-lat': '{"default_lat": 45.054148}',
'worldmap-hosts': '{"hosts_level": [1,2,3,4,5]}',
'worldmap-services': '{"services_level": [1,2,3,4,5]}',
'worldmap-layer': '{"layer": ""}',
}
for p, default in properties.items():
params.update(
json.loads(app.prefs_module.get_ui_common_preference(p, default)))
logger.info("[WebUI-worldmap] configuration loaded.")
logger.info("[WebUI-worldmap] configuration, params: %s", params)
def manage_update_service_status_brok(self, b):
# Update business_impact value
host_name = b.data['host_name']
service_description = b.data['service_description']
service_id = host_name + '/' + service_description
if service_id not in self.services_downtime:
logger.info(
"[RawSocket] received service status update for an unknown service: %s",
service_id)
logger.info(
"[RawSocket] setting service status for unknown service: %s",
service_id)
self.services_downtime[service_id] = b.data[
'in_scheduled_downtime']
else:
logger.info(
"[RawSocket] received service status update: %s - downtime=%s",
(service_id, b.data['in_scheduled_downtime']))
self.services_downtime[service_id] = b.data[
'in_scheduled_downtime']
def manage_initial_broks_done_brok(self, b):
if self.con is None:
return
logger.info(
"[Active Directory UI] AD/LDAP: manage_initial_broks_done_brok, go for pictures"
)
searchScope = ldap.SCOPE_SUBTREE
## retrieve all attributes - again adjust to your needs - see documentation for more options
#retrieveAttributes = ["userPrincipalName", "thumbnailPhoto", "samaccountname", "email"]
logger.info("[Active Directory UI] Contacts? %d" %
len(self.app.datamgr.get_contacts()))
for c in self.app.datamgr.get_contacts():
logger.debug(
"[Active Directory UI] Doing photo lookup for contact: %s" %
c.get_name())
elts = self.find_contact_entry(c)
if elts is None:
logger.warning("[Active Directory UI] No ldap entry for %s" %
c.get_name())
continue
# Ok, try to get photo from the entry
try:
photo = elts[self.photo_attr][0]
try:
p = os.path.join(self.app.photo_dir, c.get_name() + '.jpg')
f = open(p, 'wb')
f.write(photo)
f.close()
logger.info("[Active Directory UI] Photo wrote for %s" %
c.get_name())
except Exception, exp:
logger.error("[Active Directory UI] Cannot write %s : %s" %
(p, str(exp)))
except KeyError:
logger.warning("[Active Directory UI] No photo for %s" %
c.get_name())
def tasks_are_working(self):
MAX_FAILED_LOOPS = 3
GOOD_ENOUGH_FINISHED_TASKS_PERCENTAGE = 4.5
GOOD_ENOUGH_FINISHED_TASKS_NUMBER = 5
logger.info('[SnmpPoller] tasks_are_working self.failed_loops=%d',
self.failed_loops)
if self.failed_loops == -1:
self.failed_loops = 0
return True
if self.last_unfinished_tasks > self.unfinished_tasks:
logger.info(
'[SnmpPoller] tasks_are_working last=%d <- unfinished=%d',
self.last_unfinished_tasks, self.unfinished_tasks)
self.last_unfinished_tasks = self.unfinished_tasks
return True
else:
self.failed_loops += 1
if self.failed_loops >= MAX_FAILED_LOOPS:
logger.info(
"[SnmpPoller] tasks_are_working (self.failed_loops >= MAX_FAILED_LOOPS!!) unfinished_tasks=%d init_unfinished_tasks=%d",
self.unfinished_tasks, self.init_unfinished_tasks)
try:
pct_unfinished_tasks = 100 * self.unfinished_tasks / float(
self.init_unfinished_tasks)
except:
logger.warning(
"[SnmpPoller] tasks_are_working: unfinished_tasks=%d init_unfinished_tasks=%d",
self.unfinished_tasks, self.init_unfinished_tasks)
pct_unfinished_tasks = 0
if pct_unfinished_tasks < GOOD_ENOUGH_FINISHED_TASKS_PERCENTAGE or self.unfinished_tasks < GOOD_ENOUGH_FINISHED_TASKS_NUMBER:
raise GoodEnoughSnmpPollerException(
"Unfinished tasks: %d (%.2f%%)" %
(self.unfinished_tasks, pct_unfinished_tasks))
else:
return False
else:
return True
def join_with_timeout(self, timeout):
logger.info("[SnmpPoller] join_with_timeout starts... tasks: %d",
self.unfinished_tasks)
self.last_unfinished_tasks = self.unfinished_tasks
self.init_unfinished_tasks = self.unfinished_tasks
self.all_tasks_done.acquire()
try:
endtime = time.time() + timeout
while self.unfinished_tasks:
self.all_tasks_done.wait(1) # let task start
remaining = endtime - time.time()
logger.info(
"[SnmpPoller] time remaining: %s unfinished tasks: %d",
remaining, self.unfinished_tasks)
syslog.syslog(
syslog.LOG_DEBUG,
"[SnmpPoller] time remaining: %s unfinished tasks: %d" %
(remaining, self.unfinished_tasks))
if not self.tasks_are_working():
raise TaskAreNotWorkingSnmpPollerException(
"[SnmpPoller] tasks are not working!")
if remaining <= 0.0:
logger.info("[SnmpPoller] timeout!")
raise TimeoutSnmpPollerException(
"[SnmpPoller] polling timeout!")
self.all_tasks_done.wait(5)
except Exception, exc:
logger.warning(
"[SnmpPoller] join_with_timeout Exception -> (%s: %s)!",
type(exc), str(exc))
try:
self.all_tasks_done.release()
# except RuntimeError, exc:
except Exception, exc:
logger.warning(
"[SnmpPoller] join_with_timeout->Exception->self.all_tasks_done.release RuntimeError (type=%s: %s)!",
type(exc), exc)
def __init__(self, mod_conf):
try:
import pymongo
except ImportError:
logger.error('[WebUI-MongoDBPreferences] Can not import pymongo'
'Please install it with a 3.x+ version from '
'https://pypi.python.org/pypi/pymongo')
raise
self.uri = getattr(mod_conf, 'uri', 'mongodb://localhost')
logger.info('[WebUI-MongoDBPreferences] mongo uri: %s' % self.uri)
self.replica_set = getattr(mod_conf, 'replica_set', None)
if self.replica_set and int(pymongo.version[0]) < 3:
logger.error(
'[WebUI-MongoDBPreferences] Can not initialize module with '
'replica_set because your pymongo lib is too old. '
'Please install it with a 3.x+ version from '
'https://pypi.python.org/pypi/pymongo')
return None
self.database = getattr(mod_conf, 'database', 'shinken')
self.username = getattr(mod_conf, 'username', None)
self.password = getattr(mod_conf, 'password', None)
logger.info('[WebUI-MongoDBPreferences] database: %s, user: %s',
self.database, self.username)
self.mongodb_fsync = getattr(mod_conf, 'mongodb_fsync',
"True") == "True"
self.is_connected = False
self.con = None
self.db = None
logger.info(
"[WebUI-MongoDBPreferences] Trying to open a Mongodb connection to %s, database: %s"
% (self.uri, self.database))
self.open()
def __init__(self, mod_conf):
self.uri = getattr(mod_conf, "uri", "mongodb://localhost")
logger.info("[WebUI-MongoDBPreferences] mongo uri: %s", self.uri)
self.replica_set = getattr(mod_conf, "replica_set", None)
if self.replica_set and int(pymongo.version[0]) < 3:
logger.error(
"[WebUI-MongoDBPreferences] Can not initialize module with "
"replica_set because your pymongo lib is too old. "
"Please install it with a 3.x+ version from "
"https://pypi.python.org/pypi/pymongo")
return
self.database = getattr(mod_conf, "database", "shinken")
self.username = getattr(mod_conf, "username", None)
self.password = getattr(mod_conf, "password", None)
logger.info("[WebUI-MongoDBPreferences] database: %s, user: %s",
self.database, self.username)
self.mongodb_fsync = getattr(mod_conf, "mongodb_fsync",
"True") == "True"
self.is_connected = False
self.con = None
self.db = None
if self.uri:
logger.info(
"[WebUI-MongoDBPreferences] Trying to open a Mongodb connection to %s, database: %s",
self.uri, self.database)
self.open()
else:
logger.warning(
"You do not have any MongoDB connection for user's preferences storage module installed. "
"The Web UI dashboard and user's preferences will not be saved."
)
def init(self):
if not os.path.exists(self.path):
logger.info(
"[Quorum] Trying to create a quorum file %s of %s size" %
(self.path, self.total_size))
# Opening the file in create mode, and fill with fuull size of 0
fd = os.open(FILE, os.O_CREAT | os.O_WRONLY)
os.write(fd, '\0' * self.total_size)
os.close(fd)
else:
# Assume that the file is quite as big as it should
f = os.open(FILE, os.O_RDWR)
end = os.lseek(f, 0, os.SEEK_END)
# if the end offset is too smal, try to increase it
if end < self.total_size:
logger.info(
"[Quorum] Trying to increase the quorum file %s of %s size"
% (self.path, self.total_size))
for p in range(end, self.total_size):
os.write(f, '\0')
os.close(f)
# Ok here we got a valid file
logger.info("[Quorum] Quorum file checked")
def check_authentication(self, username, password):
logger.info("[WebUI] Checking authentication for user: %s", username)
self.user_picture = None
c = self.datamgr.get_contact(username)
if not c:
logger.error(
"[WebUI] You need to have a contact having the same name as your user: %s",
username)
return False
logger.info("[WebUI] Requesting authentication for user: %s", username)
r = self.auth_module.check_auth(username, password)
if r:
user = User.from_contact(c,
picture=self.user_picture,
use_gravatar=self.gravatar)
self.user_picture = user.picture
logger.info("[WebUI] User picture: %s", self.user_picture)
return True
logger.warning("[WebUI] The user '%s' has not been authenticated.",
username)
return False
def init(self):
logger.info("I open the HOT dependency module")
def get_instance(plugin):
logger.info("[Dummy Arbiter] Get a Dummy arbiter module for plugin %s",
plugin.get_name())
instance = Dummy_arbiter(plugin)
return instance
def setup_new_conf(self):
conf = self.new_conf
self.new_conf = None
self.cur_conf = conf
# Got our name from the globals
if 'receiver_name' in conf['global']:
name = conf['global']['receiver_name']
else:
name = 'Unnamed receiver'
self.name = name
logger.load_obj(self, name)
self.direct_routing = conf['global']['direct_routing']
g_conf = conf['global']
# If we've got something in the schedulers, we do not want it anymore
for sched_id in conf['schedulers']:
already_got = False
# We can already got this conf id, but with another address
if sched_id in self.schedulers:
new_addr = conf['schedulers'][sched_id]['address']
old_addr = self.schedulers[sched_id]['address']
new_port = conf['schedulers'][sched_id]['port']
old_port = self.schedulers[sched_id]['port']
# Should got all the same to be ok :)
if new_addr == old_addr and new_port == old_port:
already_got = True
if already_got:
logger.info("[%s] We already got the conf %d (%s)" %
(self.name, sched_id,
conf['schedulers'][sched_id]['name']))
wait_homerun = self.schedulers[sched_id]['wait_homerun']
actions = self.schedulers[sched_id]['actions']
external_commands = self.schedulers[sched_id][
'external_commands']
con = self.schedulers[sched_id]['con']
s = conf['schedulers'][sched_id]
self.schedulers[sched_id] = s
if s['name'] in g_conf['satellitemap']:
s.update(g_conf['satellitemap'][s['name']])
uri = 'http://%s:%s/' % (s['address'], s['port'])
self.schedulers[sched_id]['uri'] = uri
if already_got:
self.schedulers[sched_id]['wait_homerun'] = wait_homerun
self.schedulers[sched_id]['actions'] = actions
self.schedulers[sched_id][
'external_commands'] = external_commands
self.schedulers[sched_id]['con'] = con
else:
self.schedulers[sched_id]['wait_homerun'] = {}
self.schedulers[sched_id]['actions'] = {}
self.schedulers[sched_id]['external_commands'] = []
self.schedulers[sched_id]['con'] = None
self.schedulers[sched_id]['running_id'] = 0
self.schedulers[sched_id]['active'] = s['active']
# Do not connect if we are a passive satellite
if self.direct_routing and not already_got:
# And then we connect to it :)
self.pynag_con_init(sched_id)
logger.debug("[%s] Sending us configuration %s" % (self.name, conf))
if not self.have_modules:
self.modules = mods = conf['global']['modules']
self.have_modules = True
logger.info("We received modules %s " % mods)
# Set our giving timezone from arbiter
use_timezone = conf['global']['use_timezone']
if use_timezone != 'NOTSET':
logger.info("Setting our timezone to %s" % use_timezone)
os.environ['TZ'] = use_timezone
time.tzset()
# Now create the external commander. It's just here to dispatch
# the commands to schedulers
e = ExternalCommandManager(None, 'receiver')
e.load_receiver(self)
self.external_command = e
class Broker(BaseSatellite):
properties = BaseSatellite.properties.copy()
properties.update({
'pidfile': PathProp(default='brokerd.pid'),
'port': IntegerProp(default=7772),
'local_log': PathProp(default='brokerd.log'),
})
def __init__(self, config_file, is_daemon, do_replace, debug, debug_file, profile=''):
super(Broker, self).__init__('broker', config_file, is_daemon, do_replace, debug,
debug_file)
# Our arbiters
self.arbiters = {}
# Our pollers, reactionners and receivers
self.pollers = {}
self.reactionners = {}
self.receivers = {}
# Modules are load one time
self.have_modules = False
# Can have a queue of external_commands given by modules
# will be processed by arbiter
self.external_commands = []
# All broks to manage
self.broks = deque() # broks to manage
self.external_module_broks = deque() # broks during this loop to send to external modules
self.broks_lock = threading.RLock() # to manage lock when managing broks
# broks raised this turn and that needs to be put in self.broks
self.broks_internal_raised = []
# broks raised by the arbiters, we need a lock so the push can be in parallel
# to our current activities and won't lock the arbiter
self.arbiter_broks = []
self.arbiter_broks_lock = threading.RLock()
self.timeout = 1.0
self.istats = IStats(self)
# Schedulers have some queues. We can simplify the call by adding
# elements into the proper queue just by looking at their type
# Brok -> self.broks
# TODO: better tag ID?
# External commands -> self.external_commands
def add(self, elt):
cls_type = elt.__class__.my_type
if cls_type == 'brok':
# For brok, we TAG brok with our instance_id
elt.instance_id = 0
self.broks_internal_raised.append(elt)
return
elif cls_type == 'externalcommand':
logger.debug("Enqueuing an external command '%s'", str(ExternalCommand.__dict__))
self.external_commands.append(elt)
# Maybe we got a Message from the modules, it's way to ask something
# like from now a full data from a scheduler for example.
elif cls_type == 'message':
# We got a message, great!
logger.debug(str(elt.__dict__))
if elt.get_type() == 'NeedData':
data = elt.get_data()
# Full instance id means: I got no data for this scheduler
# so give me all dumbass!
if 'full_instance_id' in data:
c_id = data['full_instance_id']
source = elt.source
logger.info('The module %s is asking me to get all initial data '
'from the scheduler %d',
source, c_id)
# so we just reset the connection and the running_id,
# it will just get all new things
try:
self.schedulers[c_id]['con'] = None
self.schedulers[c_id]['running_id'] = 0
except KeyError: # maybe this instance was not known, forget it
logger.warning("the module %s ask me a full_instance_id "
"for an unknown ID (%d)!", source, c_id)
# Maybe a module tells me that it's dead, I must log it's last words...
if elt.get_type() == 'ICrash':
data = elt.get_data()
logger.error('the module %s just crash! Please look at the traceback:',
data['name'])
logger.error(data['trace'])
# The module death will be looked for elsewhere and restarted.
# Get the good tabs for links by the kind. If unknown, return None
def get_links_from_type(self, d_type):
t = {'scheduler': self.schedulers,
'arbiter': self.arbiters,
'poller': self.pollers,
'reactionner': self.reactionners,
'receiver': self.receivers
}
if d_type in t:
return t[d_type]
return None
# Check if we do not connect to often to this
def is_connection_try_too_close(self, elt):
now = time.time()
last_connection = elt['last_connection']
if now - last_connection < 5:
return True
return False
# wrapper function for the real function do_
# just for timing the connection
def pynag_con_init(self, id, type='scheduler'):
_t = time.time()
r = self.do_pynag_con_init(id, type)
statsmgr.timing('con-init.%s' % type, time.time() - _t, 'perf')
return r
# initialize or re-initialize connection with scheduler or
# arbiter if type == arbiter
def do_pynag_con_init(self, id, type='scheduler'):
# Get the good links tab for looping..
links = self.get_links_from_type(type)
if links is None:
logger.debug('Type unknown for connection! %s', type)
return
# default timeout for daemons like pollers/reactionners/...
timeout = 3
data_timeout = 120
if type == 'scheduler':
# If sched is not active, I do not try to init
# it is just useless
is_active = links[id]['active']
if not is_active:
return
# schedulers also got real timeout to respect
timeout = links[id]['timeout']
data_timeout = links[id]['data_timeout']
# If we try to connect too much, we slow down our tests
if self.is_connection_try_too_close(links[id]):
return
# Ok, we can now update it
links[id]['last_connection'] = time.time()
# DBG: print "Init connection with", links[id]['uri']
running_id = links[id]['running_id']
# DBG: print "Running id before connection", running_id
uri = links[id]['uri']
try:
con = links[id]['con'] = HTTPClient(uri=uri,
strong_ssl=links[id]['hard_ssl_name_check'],
timeout=timeout, data_timeout=data_timeout)
except HTTPExceptions, exp:
# But the multiprocessing module is not compatible with it!
# so we must disable it immediately after
logger.info("Connection problem to the %s %s: %s", type, links[id]['name'], str(exp))
links[id]['con'] = None
return
try:
# initial ping must be quick
con.get('ping')
new_run_id = con.get('get_running_id')
new_run_id = float(new_run_id)
# data transfer can be longer
# The schedulers have been restarted: it has a new run_id.
# So we clear all verifs, they are obsolete now.
if new_run_id != running_id:
logger.debug("[%s] New running id for the %s %s: %s (was %s)",
self.name, type, links[id]['name'], new_run_id, running_id)
del links[id]['broks'][:]
# we must ask for a new full broks if
# it's a scheduler
if type == 'scheduler':
logger.debug("[%s] I ask for a broks generation to the scheduler %s",
self.name, links[id]['name'])
con.get('fill_initial_broks', {'bname': self.name}, wait='long')
# Ok all is done, we can save this new running id
links[id]['running_id'] = new_run_id
except HTTPExceptions, exp:
logger.info("Connection problem to the %s %s: %s", type, links[id]['name'], str(exp))
links[id]['con'] = None
return
def hook_late_configuration(self, conf):
logger.info("[Dummy Arbiter] Dummy in hook late config")
def get_instance(plugin):
logger.info("Get an PNP UI module for plugin %s" % plugin.get_name())
instance = PNP_Webui(plugin)
return instance
def resolve_daterange(self, dateranges, entry):
#print "Trying to resolve ", entry
res = re.search(
'(\d{4})-(\d{2})-(\d{2}) - (\d{4})-(\d{2})-(\d{2}) / (\d+)[\s\t]*([0-9:, -]+)',
entry)
if res is not None:
#print "Good catch 1"
(syear, smon, smday, eyear, emon, emday, skip_interval,
other) = res.groups()
dateranges.append(
CalendarDaterange(syear, smon, smday, 0, 0, eyear, emon, emday,
0, 0, skip_interval, other))
return
res = re.search('(\d{4})-(\d{2})-(\d{2}) / (\d+)[\s\t]*([0-9:, -]+)',
entry)
if res is not None:
#print "Good catch 2"
(syear, smon, smday, skip_interval, other) = res.groups()
eyear = syear
emon = smon
emday = smday
dateranges.append(
CalendarDaterange(syear, smon, smday, 0, 0, eyear, emon, emday,
0, 0, skip_interval, other))
return
res = re.search(
'(\d{4})-(\d{2})-(\d{2}) - (\d{4})-(\d{2})-(\d{2})[\s\t]*([0-9:, -]+)',
entry)
if res is not None:
#print "Good catch 3"
(syear, smon, smday, eyear, emon, emday, other) = res.groups()
dateranges.append(
CalendarDaterange(syear, smon, smday, 0, 0, eyear, emon, emday,
0, 0, 0, other))
return
res = re.search('(\d{4})-(\d{2})-(\d{2})[\s\t]*([0-9:, -]+)', entry)
if res is not None:
#print "Good catch 4"
(syear, smon, smday, other) = res.groups()
eyear = syear
emon = smon
emday = smday
dateranges.append(
CalendarDaterange(syear, smon, smday, 0, 0, eyear, emon, emday,
0, 0, 0, other))
return
res = re.search(
'([a-z]*) ([\d-]+) ([a-z]*) - ([a-z]*) ([\d-]+) ([a-z]*) / (\d+)[\s\t]*([0-9:, -]+)',
entry)
if res is not None:
#print "Good catch 5"
(swday, swday_offset, smon, ewday, ewday_offset, emon,
skip_interval, other) = res.groups()
dateranges.append(
MonthWeekDayDaterange(0, smon, 0, swday, swday_offset, 0, emon,
0, ewday, ewday_offset, skip_interval,
other))
return
res = re.search(
'([a-z]*) ([\d-]+) - ([a-z]*) ([\d-]+) / (\d+)[\s\t]*([0-9:, -]+)',
entry)
if res is not None:
#print "Good catch 6"
(t0, smday, t1, emday, skip_interval, other) = res.groups()
if t0 in Daterange.weekdays and t1 in Daterange.weekdays:
swday = t0
ewday = t1
swday_offset = smday
ewday_offset = emday
dateranges.append(
WeekDayDaterange(0, 0, 0, swday, swday_offset, 0, 0, 0,
ewday, ewday_offset, skip_interval,
other))
return
elif t0 in Daterange.months and t1 in Daterange.months:
smon = t0
emon = t1
dateranges.append(
MonthDateDaterange(0, smon, smday, 0, 0, 0, emon, emday, 0,
0, skip_interval, other))
return
elif t0 == 'day' and t1 == 'day':
dateranges.append(
MonthDayDaterange(0, 0, smday, 0, 0, 0, 0, emday, 0, 0,
skip_interval, other))
return
res = re.search(
'([a-z]*) ([\d-]+) - ([\d-]+) / (\d+)[\s\t]*([0-9:, -]+)', entry)
if res is not None:
#print "Good catch 7"
(t0, smday, emday, skip_interval, other) = res.groups()
if t0 in Daterange.weekdays:
swday = t0
swday_offset = smday
ewday = swday
ewday_offset = emday
dateranges.append(
WeekDayDaterange(0, 0, 0, swday, swday_offset, 0, 0, 0,
ewday, ewday_offset, skip_interval,
other))
return
elif t0 in Daterange.months:
smon = t0
emon = smon
dateranges.append(
MonthDateDaterange(0, smon, smday, 0, 0, 0, emon, emday, 0,
0, skip_interval, other))
return
elif t0 == 'day':
dateranges.append(
MonthDayDaterange(0, 0, smday, 0, 0, 0, 0, emday, 0, 0,
skip_interval, other))
return
res = re.search(
'([a-z]*) ([\d-]+) ([a-z]*) - ([a-z]*) ([\d-]+) ([a-z]*) [\s\t]*([0-9:, -]+)',
entry)
if res is not None:
#print "Good catch 8"
(swday, swday_offset, smon, ewday, ewday_offset, emon,
other) = res.groups()
#print "Debug:", (swday, swday_offset, smon, ewday, ewday_offset, emon, other)
dateranges.append(
MonthWeekDayDaterange(0, smon, 0, swday, swday_offset, 0, emon,
0, ewday, ewday_offset, 0, other))
return
res = re.search('([a-z]*) ([\d-]+) - ([\d-]+)[\s\t]*([0-9:, -]+)',
entry)
if res is not None:
#print "Good catch 9"
(t0, smday, emday, other) = res.groups()
if t0 in Daterange.weekdays:
swday = t0
swday_offset = smday
ewday = swday
ewday_offset = emday
dateranges.append(
WeekDayDaterange(0, 0, 0, swday, swday_offset, 0, 0, 0,
ewday, ewday_offset, 0, other))
return
elif t0 in Daterange.months:
smon = t0
emon = smon
dateranges.append(
MonthDateDaterange(0, smon, smday, 0, 0, 0, emon, emday, 0,
0, 0, other))
return
elif t0 == 'day':
dateranges.append(
MonthDayDaterange(0, 0, smday, 0, 0, 0, 0, emday, 0, 0, 0,
other))
return
res = re.search(
'([a-z]*) ([\d-]+) - ([a-z]*) ([\d-]+)[\s\t]*([0-9:, -]+)', entry)
if res is not None:
#print "Good catch 10"
(t0, smday, t1, emday, other) = res.groups()
if t0 in Daterange.weekdays and t1 in Daterange.weekdays:
swday = t0
ewday = t1
swday_offset = smday
ewday_offset = emday
dateranges.append(
WeekDayDaterange(0, 0, 0, swday, swday_offset, 0, 0, 0,
ewday, ewday_offset, 0, other))
return
elif t0 in Daterange.months and t1 in Daterange.months:
smon = t0
emon = t1
dateranges.append(
MonthDateDaterange(0, smon, smday, 0, 0, 0, emon, emday, 0,
0, 0, other))
return
elif t0 == 'day' and t1 == 'day':
dateranges.append(
MonthDayDaterange(0, 0, smday, 0, 0, 0, 0, emday, 0, 0, 0,
other))
return
res = re.search('([a-z]*) ([\d-]+) ([a-z]*)[\s\t]*([0-9:, -]+)', entry)
if res is not None:
#print "Good catch 11"
(t0, swday_offset, t1, other) = res.groups()
if t0 in Daterange.weekdays and t1 in Daterange.months:
swday = t0
smon = t1
emon = smon
ewday = swday
ewday_offset = swday_offset
dateranges.append(
MonthWeekDayDaterange(0, smon, 0, swday, swday_offset, 0,
emon, 0, ewday, ewday_offset, 0,
other))
return
res = re.search('([a-z]*) ([\d-]+)[\s\t]+([0-9:, -]+)', entry)
if res is not None:
#print "Good catch 12"
(t0, smday, other) = res.groups()
if t0 in Daterange.weekdays:
swday = t0
swday_offset = smday
ewday = swday
ewday_offset = swday_offset
dateranges.append(
WeekDayDaterange(0, 0, 0, swday, swday_offset, 0, 0, 0,
ewday, ewday_offset, 0, other))
return
if t0 in Daterange.months:
smon = t0
emon = smon
emday = smday
dateranges.append(
MonthDateDaterange(0, smon, smday, 0, 0, 0, emon, emday, 0,
0, 0, other))
return
if t0 == 'day':
emday = smday
dateranges.append(
MonthDayDaterange(0, 0, smday, 0, 0, 0, 0, emday, 0, 0, 0,
other))
return
res = re.search('([a-z]*)[\s\t]+([0-9:, -]+)', entry)
if res is not None:
#print "Good catch 13"
(t0, other) = res.groups()
if t0 in Daterange.weekdays:
day = t0
dateranges.append(StandardDaterange(day, other))
return
logger.info("[timeentry::%s] no match for %s" %
(self.get_name(), entry))
self.invalid_entries.append(entry)
def init(self):
logger.info("[Dummy Broker] Initialization of the dummy broker module")
def get_instance(mod_conf):
logger.info("[Dummy Broker] Get a Dummy broker module for plugin %s",
mod_conf.get_name())
instance = Dummy_broker(mod_conf)
return instance
def check_auth(self, username, password):
""" Check username/password.
If there is submodules, this method calls them one by one until one of them returns
True. If no submodule can authenticate the user, then we try with internal
authentication methods: htpasswd file, then contact password.
This method returns a User object if authentication succeeded, else it returns None
"""
self._user_login = None
self._authenticator = None
self._session = None
self._user_info = None
logger.info("[WebUI] Authenticating user '%s'", username)
if self.modules:
for mod in self.modules:
try:
logger.info("[WebUI] Authenticating user '%s' with %s",
username, mod.get_name())
if mod.check_auth(username, password):
logger.info("[WebUI] User '%s' is authenticated by %s",
username, mod.get_name())
self._authenticator = mod.get_name()
self._user_login = username
# Session identifier ?
f = getattr(mod, 'get_session', None)
if f and callable(f):
self._session = mod.get_session()
logger.info("[WebUI] User session: %s",
self._session)
# User information ?
f = getattr(mod, 'get_user_info', None)
if f and callable(f):
self._user_info = mod.get_user_info()
logger.info("[WebUI] User info: %s",
self._user_info)
except Exception as exp:
logger.warning(
"[WebUI] The mod %s raised an exception: %s", str(exp))
logger.warning("[WebUI] Back trace: %s" %
(traceback.format_exc()))
if not self._user_login:
logger.info("[WebUI] Internal htpasswd authentication")
if self.app.htpasswd_file and self.check_apache_htpasswd_auth(
username, password):
self._authenticator = 'htpasswd'
self._user_login = username
if not self._user_login:
logger.info("[WebUI] Internal alignak backend authentication")
if self.app.alignak_backend_endpoint:
if self.check_alignak_auth(username, password):
self._authenticator = 'alignak'
self._user_login = username
self._session = self.app.frontend.get_logged_user_token()
self._user_info = self.app.frontend.get_logged_user()
if not self._user_login:
logger.info("[WebUI] Internal contact authentication")
if self.check_cfg_password_auth(username, password):
self._authenticator = 'contact'
self._user_login = username
if self._user_login:
logger.info("[WebUI] user authenticated thanks to %s",
self._authenticator)
return self._user_login
return None
def init(self):
logger.info(
"[Dummy Arbiter] Initialization of the dummy arbiter module")
def init(self):
logger.info("[NRPEPoller] Initialization of the nrpe poller module")
self.i_am_dying = False
def __init__(self, modules, app):
self.modules = modules
self.app = app
if not modules:
logger.info("[WebUI] No module for %s. %s" %
(self.__class__.__name__, self._custom_log))
def get_instance(mod_conf):
logger.info("[NRPEPoller] Get a nrpe poller module for plugin %s" % mod_conf.get_name())
return Nrpe_poller(mod_conf)
def open(self):
"""Open a connection to the mongodb server and check the connection by updating a documetn in a collection"""
try:
from pymongo import MongoClient
except ImportError:
logger.error(
"[WebUI-MongoDBPreferences] Can not import pymongo.MongoClient"
)
raise
try:
if self.replica_set:
self.con = MongoClient(self.uri,
replicaSet=self.replica_set,
fsync=self.mongodb_fsync)
else:
self.con = MongoClient(self.uri, fsync=self.mongodb_fsync)
logger.info("[WebUI-MongoDBPreferences] connected to mongodb: %s",
self.uri)
self.db = getattr(self.con, self.database)
logger.info(
"[WebUI-MongoDBPreferences] connected to the database: %s",
self.database)
if self.username and self.password:
self.db.authenticate(self.username, self.password)
logger.info(
"[WebUI-MongoDBPreferences] user authenticated: %s",
self.username)
# Update a document test item in the collection to confirm correct connection
logger.info(
"[WebUI-MongoDBPreferences] updating connection test item in the collection ..."
)
self.db.ui_user_preferences.update_one(
{"_id": "test-ui_prefs"}, {"$set": {
"last_test": time.time()
}},
upsert=True)
logger.info(
"[WebUI-MongoDBPreferences] updated connection test item")
self.is_connected = True
logger.info(
"[WebUI-MongoDBPreferences] database connection established")
except Exception as exp:
logger.error("[WebUI-MongoDBPreferences] Exception: %s", str(exp))
logger.debug(
"[WebUI-MongoDBPreferences] Back trace of this kill: %s",
traceback.format_exc())
# Depending on exception type, should raise ...
self.is_connected = False
raise
return self.is_connected
def get_instance(plugin):
logger.info(
"[Logstore SQLite] Get an LogStore Sqlite module for plugin %s" %
plugin.get_name())
instance = LiveStatusLogStoreSqlite(plugin)
return instance
def do_loop_turn(self):
logger.info("[Dummy Arbiter] Raise a external command as example")
e = ExternalCommand('Viva la revolution')
self.from_q.put(e)
time.sleep(1)
def setup_new_conf(self):
conf = self.new_conf
self.new_conf = None
self.cur_conf = conf
# Got our name from the globals
if 'receiver_name' in conf['global']:
name = conf['global']['receiver_name']
else:
name = 'Unnamed receiver'
self.name = name
self.api_key = conf['global']['api_key']
self.secret = conf['global']['secret']
self.http_proxy = conf['global']['http_proxy']
self.statsd_host = conf['global']['statsd_host']
self.statsd_port = conf['global']['statsd_port']
self.statsd_prefix = conf['global']['statsd_prefix']
self.statsd_enabled = conf['global']['statsd_enabled']
statsmgr.register(self, self.name, 'receiver',
api_key=self.api_key, secret=self.secret, http_proxy=self.http_proxy,
statsd_host=self.statsd_host, statsd_port=self.statsd_port, statsd_prefix=self.statsd_prefix, statsd_enabled=self.statsd_enabled)
logger.load_obj(self, name)
self.direct_routing = conf['global']['direct_routing']
self.accept_passive_unknown_check_results = conf['global']['accept_passive_unknown_check_results']
g_conf = conf['global']
# If we've got something in the schedulers, we do not want it anymore
for sched_id in conf['schedulers']:
already_got = False
# We can already got this conf id, but with another address
if sched_id in self.schedulers:
new_addr = conf['schedulers'][sched_id]['address']
old_addr = self.schedulers[sched_id]['address']
new_port = conf['schedulers'][sched_id]['port']
old_port = self.schedulers[sched_id]['port']
# Should got all the same to be ok :)
if new_addr == old_addr and new_port == old_port:
already_got = True
if already_got:
logger.info("[%s] We already got the conf %d (%s)", self.name, sched_id, conf['schedulers'][sched_id]['name'])
wait_homerun = self.schedulers[sched_id]['wait_homerun']
actions = self.schedulers[sched_id]['actions']
external_commands = self.schedulers[sched_id]['external_commands']
con = self.schedulers[sched_id]['con']
s = conf['schedulers'][sched_id]
self.schedulers[sched_id] = s
if s['name'] in g_conf['satellitemap']:
s.update(g_conf['satellitemap'][s['name']])
proto = 'http'
if s['use_ssl']:
proto = 'https'
uri = '%s://%s:%s/' % (proto, s['address'], s['port'])
self.schedulers[sched_id]['uri'] = uri
if already_got:
self.schedulers[sched_id]['wait_homerun'] = wait_homerun
self.schedulers[sched_id]['actions'] = actions
self.schedulers[sched_id]['external_commands'] = external_commands
self.schedulers[sched_id]['con'] = con
else:
self.schedulers[sched_id]['wait_homerun'] = {}
self.schedulers[sched_id]['actions'] = {}
self.schedulers[sched_id]['external_commands'] = []
self.schedulers[sched_id]['con'] = None
self.schedulers[sched_id]['running_id'] = 0
self.schedulers[sched_id]['active'] = s['active']
self.schedulers[sched_id]['timeout'] = s['timeout']
self.schedulers[sched_id]['data_timeout'] = s['data_timeout']
# Do not connect if we are a passive satellite
if self.direct_routing and not already_got:
# And then we connect to it :)
self.pynag_con_init(sched_id)
logger.debug("[%s] Sending us configuration %s", self.name, conf)
if not self.have_modules:
self.modules = mods = conf['global']['modules']
self.have_modules = True
logger.info("We received modules %s ", mods)
# Set our giving timezone from arbiter
use_timezone = conf['global']['use_timezone']
if use_timezone != 'NOTSET':
logger.info("Setting our timezone to %s", use_timezone)
os.environ['TZ'] = use_timezone
time.tzset()
self.name, type, links[id]['name'], new_run_id, running_id)
del links[id]['broks'][:]
# we must ask for a new full broks if
# it's a scheduler
if type == 'scheduler':
logger.debug("[%s] I ask for a broks generation to the scheduler %s",
self.name, links[id]['name'])
con.get('fill_initial_broks', {'bname': self.name}, wait='long')
# Ok all is done, we can save this new running id
links[id]['running_id'] = new_run_id
except HTTPExceptions, exp:
logger.info("Connection problem to the %s %s: %s", type, links[id]['name'], str(exp))
links[id]['con'] = None
return
except KeyError, exp:
logger.info("the %s '%s' is not initialized: %s", type, links[id]['name'], str(exp))
links[id]['con'] = None
traceback.print_stack()
return
logger.info("Connection OK to the %s %s", type, links[id]['name'])
# Get a brok. Our role is to put it in the modules
# DO NOT CHANGE data of b!!!
# REF: doc/broker-modules.png (4-5)
def manage_brok(self, b):
# Call all modules if they catch the call
for mod in self.modules_manager.get_internal_instances():
try:
mod.manage_brok(b)
def hook_early_configuration(self, arb):
logger.info("[IpTag] in hook late config")
for h in arb.conf.hosts:
if not hasattr(h, 'address') and not hasattr(h, 'host_name'):
continue
if h.get_name() in self.ignore_hosts:
logger.debug("[IP Tag] Ignoring host %s" % h.get_name())
continue
# The address to resolve
addr = None
# By default take the address, if not, take host_name
if not hasattr(h, 'address'):
addr = h.host_name
else:
addr = h.address
logger.debug("[IP Tag] Looking for %s" % h.get_name())
logger.debug("[IP Tag] Address is %s" % str(addr))
h_ip = None
try:
IP(addr)
# If we reach here, it's it was a real IP :)
h_ip = addr
except:
pass
# Ok, try again with name resolution
if not h_ip:
try:
h_ip = socket.gethostbyname(addr)
except:
pass
# Ok, maybe we succeed :)
logger.debug("[IP Tag] Host ip is: %s" % str(h_ip))
# If we got an ip that match and the object do not already got
# the property, tag it!
if h_ip and h_ip in self.ip_range:
logger.debug("[IP Tag] Is in the range")
# 4 cases: append , replace and set
# append will join with the value if exist (on the END)
# prepend will join with the value if exist (on the BEGINING)
# replace will replace it if NOT existing
# set put the value even if the property exists
if self.method == 'append':
orig_v = getattr(h, self.property, '')
logger.debug("[IP Tag] Orig_v: %s" % str(orig_v))
new_v = ','.join([orig_v, self.value])
logger.debug("[IP Tag] Newv %s" % new_v)
setattr(h, self.property, new_v)
# Same but we put before
if self.method == 'prepend':
orig_v = getattr(h, self.property, '')
logger.debug("[File Tag] Orig_v: %s" % str(orig_v))
new_v = ','.join([self.value, orig_v])
logger.debug("[File Tag] Newv %s" % new_v)
setattr(h, self.property, new_v)
if self.method == 'replace':
if not hasattr(h, self.property):
# Ok, set the value!
setattr(h, self.property, self.value)
if self.method == 'set':
setattr(h, self.property, self.value)
def setup_new_conf(self):
conf = self.new_conf
self.cur_conf = conf
# Got our name from the globals
g_conf = conf['global']
if 'broker_name' in g_conf:
name = g_conf['broker_name']
else:
name = 'Unnamed broker'
self.name = name
props_to_get = ['broks_batch', 'api_key', 'secret', 'http_proxy',
'statsd_host', 'statsd_port', 'statsd_prefix',
'statsd_enabled', 'statsd_interval', 'statsd_types',
'statsd_pattern']
for prop in props_to_get:
v = g_conf[prop]
setattr(self, prop, v)
self.harakiri_threshold = parse_memory_expr(g_conf['harakiri_threshold'])
if self.harakiri_threshold is not None:
self.raw_conf = self.new_conf
else:
self.raw_conf = None
self.new_conf = None
if self.aggressive_memory_management:
free_memory()
# We got a name so we can update the logger and the stats global objects
logger.load_obj(self, name)
statsmgr.register(self, name, 'broker',
api_key=self.api_key,
secret=self.secret,
http_proxy=self.http_proxy,
statsd_host=self.statsd_host,
statsd_port=self.statsd_port,
statsd_prefix=self.statsd_prefix,
statsd_enabled=self.statsd_enabled,
statsd_interval=self.statsd_interval,
statsd_types=self.statsd_types,
statsd_pattern=self.statsd_pattern)
logger.debug("[%s] Sending us configuration %s", self.name, conf)
# If we've got something in the schedulers, we do not
# want it anymore
# self.schedulers.clear()
for sched_id in conf['schedulers']:
# Must look if we already have it to do not overdie our broks
already_got = False
# We can already got this conf id, but with another address
if sched_id in self.schedulers:
new_addr = conf['schedulers'][sched_id]['address']
old_addr = self.schedulers[sched_id]['address']
new_port = conf['schedulers'][sched_id]['port']
old_port = self.schedulers[sched_id]['port']
# Should got all the same to be ok :)
if new_addr == old_addr and new_port == old_port:
already_got = True
if already_got:
broks = self.schedulers[sched_id]['broks']
running_id = self.schedulers[sched_id]['running_id']
else:
broks = []
running_id = 0
s = conf['schedulers'][sched_id]
self.schedulers[sched_id] = s
# replacing scheduler address and port by those defined in satellitemap
if s['name'] in g_conf['satellitemap']:
s = dict(s) # make a copy
s.update(g_conf['satellitemap'][s['name']])
proto = 'http'
if s['use_ssl']:
proto = 'https'
uri = '%s://%s:%s/' % (proto, s['address'], s['port'])
self.schedulers[sched_id]['uri'] = uri
self.schedulers[sched_id]['broks'] = broks
self.schedulers[sched_id]['instance_id'] = s['instance_id']
self.schedulers[sched_id]['running_id'] = running_id
self.schedulers[sched_id]['active'] = s['active']
self.schedulers[sched_id]['last_connection'] = 0
self.schedulers[sched_id]['timeout'] = s['timeout']
self.schedulers[sched_id]['data_timeout'] = s['data_timeout']
logger.info("We have our schedulers: %s ", self.schedulers)
# Now get arbiter
for arb_id in conf['arbiters']:
# Must look if we already have it
already_got = arb_id in self.arbiters
if already_got:
broks = self.arbiters[arb_id]['broks']
else:
broks = []
a = conf['arbiters'][arb_id]
self.arbiters[arb_id] = a
# replacing arbiter address and port by those defined in satellitemap
if a['name'] in g_conf['satellitemap']:
a = dict(a) # make a copy
a.update(g_conf['satellitemap'][a['name']])
proto = 'http'
if a['use_ssl']:
proto = 'https'
uri = '%s://%s:%s/' % (proto, a['address'], a['port'])
self.arbiters[arb_id]['uri'] = uri
self.arbiters[arb_id]['broks'] = broks
self.arbiters[arb_id]['instance_id'] = 0 # No use so all to 0
self.arbiters[arb_id]['running_id'] = 0
self.arbiters[arb_id]['last_connection'] = 0
# We do not connect to the arbiter. Connection hangs
logger.info("We have our arbiters: %s ", self.arbiters)
# Now for pollers
for pol_id in conf['pollers']:
# Must look if we already have it
already_got = pol_id in self.pollers
if already_got:
broks = self.pollers[pol_id]['broks']
running_id = self.schedulers[sched_id]['running_id']
else:
broks = []
running_id = 0
p = conf['pollers'][pol_id]
self.pollers[pol_id] = p
# replacing poller address and port by those defined in satellitemap
if p['name'] in g_conf['satellitemap']:
p = dict(p) # make a copy
p.update(g_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]['broks'] = broks
self.pollers[pol_id]['instance_id'] = 0 # No use so all to 0
self.pollers[pol_id]['running_id'] = running_id
self.pollers[pol_id]['last_connection'] = 0
logger.info("We have our pollers: %s", self.pollers)
# Now reactionners
for rea_id in conf['reactionners']:
# Must look if we already have it
already_got = rea_id in self.reactionners
if already_got:
broks = self.reactionners[rea_id]['broks']
running_id = self.schedulers[sched_id]['running_id']
else:
broks = []
running_id = 0
r = conf['reactionners'][rea_id]
self.reactionners[rea_id] = r
# replacing reactionner address and port by those defined in satellitemap
if r['name'] in g_conf['satellitemap']:
r = dict(r) # make a copy
r.update(g_conf['satellitemap'][r['name']])
proto = 'http'
if r['use_ssl']:
proto = 'https'
uri = '%s://%s:%s/' % (proto, r['address'], r['port'])
self.reactionners[rea_id]['uri'] = uri
self.reactionners[rea_id]['broks'] = broks
self.reactionners[rea_id]['instance_id'] = 0 # No use so all to 0
self.reactionners[rea_id]['running_id'] = running_id
self.reactionners[rea_id]['last_connection'] = 0
logger.info("We have our reactionners: %s", self.reactionners)
# Now receivers
for rec_id in conf['receivers']:
# Must look if we already have it
already_got = rec_id in self.receivers
if already_got:
broks = self.receivers[rec_id]['broks']
running_id = self.schedulers[sched_id]['running_id']
else:
broks = []
running_id = 0
r = conf['receivers'][rec_id]
self.receivers[rec_id] = r
# replacing reactionner address and port by those defined in satellitemap
if r['name'] in g_conf['satellitemap']:
r = dict(r) # make a copy
r.update(g_conf['satellitemap'][r['name']])
proto = 'http'
if r['use_ssl']:
proto = 'https'
uri = '%s://%s:%s/' % (proto, r['address'], r['port'])
self.receivers[rec_id]['uri'] = uri
self.receivers[rec_id]['broks'] = broks
self.receivers[rec_id]['instance_id'] = 0 # No use so all to 0
self.receivers[rec_id]['running_id'] = running_id
self.receivers[rec_id]['last_connection'] = 0
if not self.have_modules:
self.modules = mods = conf['global']['modules']
self.have_modules = True
logger.info("We received modules %s ", mods)
# Ok now start, or restart them!
# Set modules, init them and start external ones
self.modules_manager.set_modules(self.modules)
self.do_load_modules()
self.modules_manager.start_external_instances()
# Set our giving timezone from arbiter
use_timezone = conf['global']['use_timezone']
if use_timezone != 'NOTSET':
logger.info("Setting our timezone to %s", use_timezone)
os.environ['TZ'] = use_timezone
time.tzset()
# Connection init with Schedulers
for sched_id in self.schedulers:
self.pynag_con_init(sched_id, type='scheduler')
for pol_id in self.pollers:
self.pynag_con_init(pol_id, type='poller')
for rea_id in self.reactionners:
self.pynag_con_init(rea_id, type='reactionner')
