def test_nrpe_poller(self):
if os.name == 'nt':
return
mod = nrpe_poller.Nrpe_poller(modconf)
sl = get_instance(mod)
# Look if we really change our commands
print sl.__dict__
sl.id = 1
sl.i_am_dying = False
manager = Manager()
to_queue = manager.Queue()
from_queue = manager.Queue() # list()
control_queue = Queue()
# We prepare a check in the to_queue
status = 'queue'
command = "$USER1$/check_nrpe -H localhost33 -n -u -t 5 -c check_load3 -a 20" # -a arg1 arg2 arg3"
ref = None
t_to_to = time.time()
c = Check(status, command, ref, t_to_to)
msg = Message(id=0, type='Do', data=c)
to_queue.put(msg)
# The worker will read a message by loop. We want it to
# do 2 loops, so we fake a message, adn the Number 2 is a real
# exit one
msg1 = Message(id=0, type='All is good, continue')
msg2 = Message(id=0, type='Die')
control_queue.put(msg1)
for _ in xrange(1, 2):
control_queue.put(msg1)
# control_queue.put(msg1)
# control_queue.put(msg1)
# control_queue.put(msg1)
# control_queue.put(msg1)
control_queue.put(msg2)
sl.work(to_queue, from_queue, control_queue)
o = from_queue.get() # pop()
print "O", o
print o.__dict__
self.assert_(o.status == 'done')
self.assert_(o.exit_status == 2)
def ask_reinit(self, c_id):
# Do not ask data too quickly, very dangerous
# one a minute
if time.time() - self.last_need_data_send > 60:
print "I ask the broker for instance id data:", c_id
msg = Message(id=0, type='NeedData', data={'full_instance_id': c_id}, source=self.get_name())
self.from_q.put(msg)
self.last_need_data_send = time.time()
return
def manage_brok_thread(self):
logger.debug("[WebUI] manage_brok_thread start ...")
while True:
start = time.clock()
l = self.to_q.get()
# try to relaunch dead module
self.check_and_del_zombie_modules()
logger.debug(
"[WebUI] manage_brok_thread got %d broks, queue length: %d",
len(l), self.to_q.qsize())
for b in l:
b.prepare()
self.wait_for_no_readers()
try:
self.rg.manage_brok(b)
# Question:
# Do not send broks to internal modules ...
# No internal WebUI modules have something to do with broks!
for mod in self.modules_manager.get_internal_instances():
try:
mod.manage_brok(b)
except Exception, exp:
logger.warning(
"[WebUI] The mod %s raise an exception: %s, I'm tagging it to restart later",
mod.get_name(), str(exp))
logger.debug("[WebUI] Exception type: %s",
self.name, type(exp))
logger.debug("[WebUI] Back trace of this kill: %s",
traceback.format_exc())
self.modules_manager.set_to_restart(mod)
except Exception, exp:
logger.error("[WebUI] manage_brok_thread exception")
msg = Message(id=0,
type='ICrash',
data={
'name': self.get_name(),
'exception': exp,
'trace': traceback.format_exc()
})
self.from_q.put(msg)
# wait 2 sec so we know that the broker got our message, and die
time.sleep(2)
# No need to raise here, we are in a thread, exit!
os._exit(2)
finally:
def test_nrpe_poller(self):
inst = self._setup_nrpe(modconf)
manager = Manager()
to_queue = manager.Queue()
from_queue = manager.Queue()
control_queue = Queue()
# We prepare a check in the to_queue
status = 'queue'
command = "$USER1$/check_nrpe -H localhost33 -n -u -t 5 -c check_load3 -a 20" # -a arg1 arg2 arg3"
ref = None
t_to_to = time.time()
c = Check(status, command, ref, t_to_to)
msg = Message(id=0, type='Do', data=c)
to_queue.put(msg)
# The worker will read a message by loop. We want it to
# do 2 loops, so we fake a message, adn the Number 2 is a real
# exit one
msg1 = Message(id=0, type='All is good, continue')
msg2 = Message(id=0, type='Die')
control_queue.put(msg1)
for _ in xrange(1, 2):
control_queue.put(msg1)
control_queue.put(msg2)
inst.work(to_queue, from_queue, control_queue)
chk = from_queue.get()
self.assertEqual('done', chk.status)
self.assertEqual(2, chk.exit_status)
def manage_update_program_status_brok(self, b):
data = b.data
c_id = data['instance_id']
if c_id not in self.instance_ids:
# Do not ask data too quickly, very dangerous
# one a minute
if time.time() - self.last_need_data_send > 60:
print "I ask the broker for instance id data :", c_id
msg = Message(id=0,
type='NeedData',
data={'full_instance_id': c_id})
self.from_q.put(msg)
self.last_need_data_send = time.time()
return
# We have only one config here, with id 0
c = self.configs[0]
self.update_element(c, data)
def main(self):
self.set_proctitle(self.name)
self.log = logger
self.log.load_obj(self)
try:
self.do_main()
except Exception, ex:
logger.warning('[hokuto] error! ' + ex.message)
logger.debug(traceback.format_exc())
msg = Message(id=0, type='ICrash', data={
'name': self.get_name(),
'exception': exp,
'trace': traceback.format_exc()
})
self.from_q.put(msg)
# wait 2 sec so we know that the broker got our message, and die
time.sleep(2)
# (try to) clean before exit
self.do_stop()
raise
def main(self, stand_alone=False):
"""
Module main function
"""
self.stand_alone = stand_alone
if self.stand_alone:
setproctitle(self.name)
else:
self.set_proctitle(self.name)
# Modules management
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)
logger.info("[WebUI] modules %s", 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
logger.info("[WebUI] loaded modules %s", self.modules)
# 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)
# Load internal sub modules
self.auth_module = AuthMetaModule(
AuthMetaModule.find_modules(
self.modules_manager.get_internal_instances()), self)
self.prefs_module = PrefsMetaModule(
PrefsMetaModule.find_modules(
self.modules_manager.get_internal_instances()), self)
self.logs_module = LogsMetaModule(
LogsMetaModule.find_modules(
self.modules_manager.get_internal_instances()), self)
self.graphs_module = GraphsMetaModule(
GraphsMetaModule.find_modules(
self.modules_manager.get_internal_instances()), self)
self.helpdesk_module = HelpdeskMetaModule(
HelpdeskMetaModule.find_modules(
self.modules_manager.get_internal_instances()), self)
# Data manager
self.datamgr = WebUIDataManager(self.rg, self.frontend,
self.alignak_backend_objects)
self.helper = helper
# Check directories
# We check if the photo directory exists. If not, try to create it
for dir in [self.share_dir, self.photo_dir, self.config_dir]:
logger.debug("[WebUI] Checking dir: %s", dir)
if not os.path.exists(dir):
try:
# os.mkdir(dir)
os.makedirs(dir, mode=0o777)
logger.info("[WebUI] Created directory: %s", dir)
except Exception as e:
logger.error(
"[WebUI] Directory creation failed: %s, error: %s",
dir, str(e))
else:
logger.debug("[WebUI] Still existing directory: %s", dir)
# Bottle objects
self.request = bottle.request
self.response = bottle.response
try:
# I register my exit function
self.set_exit_handler()
# First load the additional plugins so they will have the lead on URI routes
if self.additional_plugins_dir:
self.load_plugins(self.additional_plugins_dir)
# Modules can also override some views if need
for inst in self.modules_manager.instances:
f = getattr(inst, 'get_webui_plugins_path', None)
if f and callable(f):
mod_plugins_path = os.path.abspath(f(self))
self.load_plugins(mod_plugins_path)
# Then look at the plugins into core and load all we can there
core_plugin_dir = os.path.join(
os.path.abspath(os.path.dirname(__file__)), 'plugins')
self.load_plugins(core_plugin_dir)
# Declare the whole app static files AFTER the plugin ones
self.declare_common_static()
# Mount Web UI application
# if self.endpoint:
# root_app.mount(self.endpoint, webui_app)
# logger.info("[WebUI] root routes: %s", root_app.routes)
# for route in webui_app.routes:
# logger.info("[WebUI] route: %s", route)
for route in webui_app.routes:
logger.info("[WebUI] route: %s", route)
# We will protect the operations on
# the non read+write with a lock and
# 2 int
self.global_lock = threading.RLock()
self.nb_readers = 0
self.nb_writers = 0
self.data_thread = None
self.ls_thread = None
# For alignak backend ...
if self.frontend:
# Launch the livestate thread ...
self.ls_thread = threading.Thread(None, self.manage_ls_thread,
'lsthread')
self.ls_thread.start()
else:
# Launch the data thread ...
self.data_thread = threading.Thread(None,
self.manage_brok_thread,
'datathread')
self.data_thread.start()
# TODO: look for alive and killing
logger.info("[WebUI] starting Web UI server on %s:%d ...",
self.host, self.port)
bottle.TEMPLATES.clear()
webui_app.run(host=self.host,
port=self.port,
server=self.http_backend,
**self.serveropts)
except Exception as e:
if self.stand_alone:
logger.error("[WebUI] do_main exception: %s", str(e))
logger.error("[WebUI] traceback: %s", traceback.format_exc())
exit(1)
else:
msg = Message(id=0,
type='ICrash',
data={
'name': self.get_name(),
'exception': e,
'trace': traceback.format_exc()
})
self.from_q.put(msg)
# wait 2 sec so we know that the broker got our message, and die
time.sleep(2)
raise
class Webui_broker(BaseModule, Daemon):
def __init__(self, modconf):
BaseModule.__init__(self, modconf)
self.plugins = []
self.modconf = modconf
# Web server configuration
self.host = getattr(modconf, 'host', '0.0.0.0')
self.port = int(getattr(modconf, 'port', '7767'))
self.auth_secret = getattr(modconf, 'auth_secret',
'secret').encode('utf8', 'replace')
# TODO : common preferences
self.play_sound = to_bool(getattr(modconf, 'play_sound', '0'))
# TODO : common preferences
self.login_text = getattr(modconf, 'login_text', None)
# TODO : common preferences
self.company_logo = getattr(modconf, 'company_logo', 'default_company')
if self.company_logo == '':
# Set a dummy value if webui.cfg value is empty to force using the default logo ...
self.company_logo = 'abcdef'
# TODO : common preferences
self.gravatar = to_bool(getattr(modconf, 'gravatar', '0'))
# TODO : common preferences
self.allow_html_output = to_bool(
getattr(modconf, 'allow_html_output', '0'))
# TODO : common preferences
#self.max_output_length = int(getattr(modconf, 'max_output_length', '100'))
# TODO : common preferences
self.refresh_period = int(getattr(modconf, 'refresh_period', '60'))
# Use element tag as image or use text
self.tag_as_image = to_bool(getattr(modconf, 'tag_as_image', '0'))
# Manage user's ACL
self.manage_acl = to_bool(getattr(modconf, 'manage_acl', '1'))
self.allow_anonymous = to_bool(getattr(modconf, 'allow_anonymous',
'0'))
# Advanced options
self.http_backend = getattr(modconf, 'http_backend', 'auto')
self.remote_user_enable = getattr(modconf, 'remote_user_enable', '0')
self.remote_user_variable = getattr(modconf, 'remote_user_variable',
'X_REMOTE_USER')
self.serveropts = {}
umask = getattr(modconf, 'umask', None)
if umask is not None:
self.serveropts['umask'] = int(umask)
bindAddress = getattr(modconf, 'bindAddress', None)
if bindAddress:
self.serveropts['bindAddress'] = str(bindAddress)
# Apache htpasswd file for authentication
self.htpasswd_file = getattr(modconf, 'htpasswd_file',
'/etc/shinken/htpasswd.users')
logger.info("[WebUI] htpasswd file: %s", self.htpasswd_file)
if self.htpasswd_file:
if not os.path.exists(self.htpasswd_file):
logger.warning("[WebUI] htpasswd file '%s' does not exist.",
self.htpasswd_file)
self.htpasswd_file = None
# Load the config dir and make it an absolute path
self.config_dir = getattr(modconf, 'config_dir', 'share')
self.config_dir = os.path.abspath(self.config_dir)
logger.info("[WebUI] Config dir: %s", self.config_dir)
# Load the share dir and make it an absolute path
self.share_dir = getattr(modconf, 'share_dir', 'share')
self.share_dir = os.path.abspath(self.share_dir)
logger.info("[WebUI] Share dir: %s", self.share_dir)
# Load the photo dir and make it an absolute path
self.photo_dir = getattr(modconf, 'photos_dir', 'photos')
self.photo_dir = os.path.abspath(self.photo_dir)
logger.info("[WebUI] Photo dir: %s", self.photo_dir)
self.user_picture = ''
# @mohierf: still useful ? No value in webui.cfg, so always False ...
# self.embeded_graph = to_bool(getattr(modconf, 'embeded_graph', '0'))
# Look for an additional pages dir
self.additional_plugins_dir = getattr(modconf,
'additional_plugins_dir', '')
if self.additional_plugins_dir:
self.additional_plugins_dir = os.path.abspath(
self.additional_plugins_dir)
logger.info("[WebUI] Additional plugins dir: %s",
self.additional_plugins_dir)
# Web UI timezone
self.timezone = getattr(modconf, 'timezone', 'Europe/Paris')
if self.timezone:
logger.info("[WebUI] Setting our timezone to %s", self.timezone)
os.environ['TZ'] = self.timezone
time.tzset()
logger.info("[WebUI] parameter timezone: %s", self.timezone)
# Visual alerting thresholds
# Used in the dashboard view to select background color for percentages
self.hosts_states_warning = int(
getattr(modconf, 'hosts_states_warning', '95'))
self.hosts_states_critical = int(
getattr(modconf, 'hosts_states_critical', '90'))
self.services_states_warning = int(
getattr(modconf, 'services_states_warning', '95'))
self.services_states_critical = int(
getattr(modconf, 'services_states_critical', '90'))
# Web UI information
self.app_version = getattr(modconf, 'about_version', WEBUI_VERSION)
self.app_copyright = getattr(modconf, 'about_copyright',
WEBUI_COPYRIGHT)
self.app_release = getattr(modconf, 'about_release',
WEBUI_RELEASENOTES)
# We will save all widgets
self.widgets = {}
# We need our regenerator now (before main) so if we are in a scheduler,
# rg will be able to skip some broks
self.rg = Regenerator()
# My bottle object ...
self.bottle = bottle
bottle.BaseTemplate.defaults['app'] = self
# Called by Broker so we can do init stuff
def init(self):
logger.info("[WebUI] Initializing ...")
self.rg.load_external_queue(self.from_q)
# This is called only when we are in a scheduler
# and just before we are started. So we can gain time, and
# just load all scheduler objects without fear :) (we
# will be in another process, so we will be able to hack objects
# if need)
def hook_pre_scheduler_mod_start(self, sched):
print "pre_scheduler_mod_start::", sched.__dict__
self.rg.load_from_scheduler(sched)
# In a scheduler we will have a filter of what we really want as a brok
def want_brok(self, b):
return self.rg.want_brok(b)
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)
# :TODO:maethor:150724: Complete with other function names
self.auth_module = AuthMetaModule(
AuthMetaModule.find_modules(
self.modules_manager.get_internal_instances()), self)
self.prefs_module = PrefsMetaModule(
PrefsMetaModule.find_modules(
self.modules_manager.get_internal_instances()), self)
self.logs_module = LogsMetaModule(
LogsMetaModule.find_modules(
self.modules_manager.get_internal_instances()), self)
self.graphs_module = GraphsMetaModule(
GraphsMetaModule.find_modules(
self.modules_manager.get_internal_instances()), self)
self.helpdesk_module = HelpdeskMetaModule(
HelpdeskMetaModule.find_modules(
self.modules_manager.get_internal_instances()), self)
# Data manager
self.datamgr = WebUIDataManager(self.rg)
self.helper = helper
self.request = request
self.response = response
self.template_call = template
# :TODO:maethor:150717: Doesn't work
#username = self.request.get_cookie("user", secret=self.auth_secret)
#if username:
#self.user = User.from_contact(self.datamgr.get_contact(username), self.gravatar)
#else:
#self.user = None
try:
self.do_main()
except Exception, exp:
msg = Message(id=0,
type='ICrash',
data={
'name': self.get_name(),
'exception': exp,
'trace': traceback.format_exc()
})
self.from_q.put(msg)
# wait 2 sec so we know that the broker got our message, and die
time.sleep(2)
raise