def run(self):
"""
Starts the web server.
"""
app.run(host=Config.get_config_value('Webserver', 'interface'),
port=int(Config.get_config_value('Webserver', 'port')))
def _get_swap_info():
"""
Gets template variables filled with the last swap check
@return: Dictionary of template variables
"""
vars = dict()
if int(data.last_check.memory.swap_size) != 0:
# On Mac, the swap is unlimited (only limited by the available hard drive size)
if data.last_check.memory.swap_size == data.last_check.memory.total:
vars['configuration'] = 'unlimited'
else:
vars['configuration'] = 'limited'
vars['percent'] = int(data.last_check.memory.swap_used) * 100 / int(data.last_check.memory.swap_size)
vars['used'] = data.last_check.memory.swap_used
vars['free'] = data.last_check.memory.swap_free
vars['total'] = data.last_check.memory.swap_size
if vars['percent'] >= int(Config.get_config_value('Alerts', 'swap_alert')):
vars['state'] = STATE_ALERT
elif vars['percent'] >= int(Config.get_config_value('Alerts', 'swap_warning')):
vars['state'] = STATE_WARNING
else:
vars['state'] = STATE_OK
else:
# No swap available on this host
vars['configuration'] = 'undefined'
return vars
def _get_disks_info():
"""
Gets template variables filled with disks data
@return: Dictionary of template variables
"""
all_disks = []
if data.last_check.disks is not None:
for disk in data.last_check.disks.disks:
check_disk = {
'name': disk.name.decode('utf-8'),
'display_name': disk.display_name.decode('utf-8'),
'uuid': disk.uuid,
'used': disk.used,
'free': disk.free,
'size': disk.size,
'percent': int(round(disk.used, 0) * 100 / int(disk.size))
}
if check_disk['percent'] >= int(Config.get_config_value('Alerts', 'disk_alert')):
check_disk['state'] = STATE_ALERT
elif check_disk['percent'] >= int(Config.get_config_value('Alerts', 'disk_warning')):
check_disk['state'] = STATE_WARNING
else:
check_disk['state'] = STATE_OK
all_disks.append(check_disk)
return all_disks
def run(self):
"""
Starts the web server.
"""
app.run(
host=Config.get_config_value('Webserver', 'interface'),
port=int(Config.get_config_value('Webserver', 'port'))
)
def __init__(self):
"""
Manages the small webserver.
"""
threading.Thread.__init__(self)
# Register events...
cherrypy.engine.subscribe('graceful', self.stop)
# Update the configuration...
cherrypy.config.update({'server.socket_host': Config.getConfigValue('Webserver', 'interface'),
'server.socket_port': int(Config.getConfigValue('Webserver', 'port'))})
cherrypy.config.update({'tools.staticdir.root': WebServer.current_dir})
cherrypy.config.update({'log.screen': False})
# Serving static content
confStaticContent = {
'/statics': {
'tools.staticdir.dir': 'statics',
'tools.staticdir.on': True
},
'/css': {
'tools.staticdir.dir': 'css',
'tools.staticdir.on': True
},
'/img': {
'tools.staticdir.dir': 'img',
'tools.staticdir.on': True
},
'/js': {
'tools.staticdir.dir': 'js',
'tools.staticdir.on': True
},
'/media': {
'tools.staticdir.dir': 'media',
'tools.staticdir.on': True
},
'/api/check': {
'request.dispatch': self.setupRoutes()
}
}
# Using Pages class (see below)
webApplication = cherrypy.tree.mount(Pages(self.env), '/', confStaticContent)
# Disable screen log (standard out)
if False == Config.CR_CONFIG_ENABLE_DEBUG_MODE:
cherrypy.log.error_log.propagate = False
cherrypy.log.access_log.propagate = False
self.start()
def run(self):
"""
Executes checks.
"""
# Getting informations about the current host
Checks.hostEntity = self.MyCollector.get_infos()
while Checks.performChecks:
if self.tickPerformCheck <= self.tickCount:
crLog.writeDebug('---- New check -----')
# Checking CPU
if crUtilsText.textToBool(Config.getConfigValue('Checks', 'enable_cpu_check')):
crLog.writeDebug('Doing a CPU check...')
Checks.last_check_cpu = self.MyCollector.get_cpu()
# Checking memory
if crUtilsText.textToBool(Config.getConfigValue('Checks', 'enable_memory_check')):
crLog.writeDebug('Doing a memory check...')
Checks.last_check_memory = self.MyCollector.get_memory()
# Checking Load Average
if crUtilsText.textToBool(Config.getConfigValue('Checks', 'enable_load_check')):
crLog.writeDebug('Doing a load average check...')
Checks.last_check_loadAverage = self.MyCollector.get_loadaverage()
# Checking disks informations
if crUtilsText.textToBool(Config.getConfigValue('Checks', 'enable_disks_check')):
crLog.writeDebug('Doing a disk check....')
Checks.last_check_disk = self.MyCollector.get_disks()
# Updating last check date...
Checks.last_check_date = datetime.datetime.now() # Update the last check date
# Wait 60 seconds before next checks...
crLog.writeDebug('All checks are done')
crLog.writeDebug('Next checks in ' + str(self.tickPerformCheck) + ' seconds...')
self.tickCount = 0
# new tick
self.tickCount += 1
time.sleep(1)
def refresh_standalone_status(self):
if convert_text_to_bool(Config.get_config_value('Webserver', 'enable')) is True:
self.standalone_status_text.set_text('Standalone app is enabled')
self.standalone_status.set_attr_map({None: 'text green'})
else:
self.standalone_status_text.set_text('Standalone app is disabled')
self.standalone_status.set_attr_map({None: 'text red'})
def api_check():
"""
Entry point of /api/checks
@return: flask.Response
"""
try:
interval = int(Config.get_config_value('Checks', 'interval'))
except NameError:
interval = int(Config.CR_CONFIG_DEFAULT_CHECKS_INTERVAL)
vars = {
'date': datetime_to_timestamp(data.last_check.date),
'interval': interval,
'system': {
'timestamp': datetime_to_timestamp(datetime.datetime.now())
},
'uptime': {
'seconds': data.last_check.load.uptime,
'boot_date': datetime_to_timestamp(data.last_check.date) - int(data.last_check.load.uptime)
},
'cpu': _get_cpu_info(),
'memory': _get_memory_info(),
'swap': _get_swap_info(),
'load': _get_load_info(),
'disks': _get_disks_info()
}
return flask.Response(response=json.dumps(vars),
status=200,
mimetype="application/json")
def refresh_standalone_status(self):
if convert_text_to_bool(Config.get_config_value('Webserver',
'enable')) is True:
self.standalone_status_text.set_text('Standalone app is enabled')
self.standalone_status.set_attr_map({None: 'text green'})
else:
self.standalone_status_text.set_text('Standalone app is disabled')
self.standalone_status.set_attr_map({None: 'text red'})
def run(self):
"""
Constructor.
"""
isError = False # If True, there are one or more errors when CentralReport is trying to start
# Preparing Logs
crLog.configLog(Config.CR_CONFIG_ENABLE_DEBUG_MODE)
crLog.writeInfo('CentralReport is starting...')
CentralReport.startingDate = datetime.datetime.now() # Starting date
CentralReport.configuration = Config() # Getting config object
# Getting current OS...
if (Config.HOST_CURRENT == Config.HOST_MAC) | (Config.HOST_CURRENT == Config.HOST_DEBIAN) | (
Config.HOST_CURRENT == Config.HOST_UBUNTU):
crLog.writeInfo(Config.HOST_CURRENT + ' detected. Starting ThreadChecks...')
CentralReport.checks_thread = crThreads.Checks() # Launching checks thread
else:
isError = True
crLog.writeCritical('Sorry, but your OS is not supported yet...')
# Is webserver enabled?
if not isError & crUtilsText.textToBool(Config.getConfigValue('Webserver', 'enable')):
crLog.writeInfo('Enabling the webserver')
CentralReport.webserver_thread = WebServer()
else:
crLog.writeInfo('Webserver is disabled by configuration file')
if not isError:
crLog.writeInfo('CentralReport started!')
while CentralReport.isRunning:
try:
if not Config.CR_CONFIG_ENABLE_DEBUG_MODE:
# If .pid file is not found, we must stop CR (only in production environment)
try:
pf = file(self.pidfile, 'r')
pf.close()
except IOError:
crLog.writeError('Pid file is not found. CentralReport must stop itself.')
CentralReport.isRunning = False
self.stop()
time.sleep(1)
except KeyboardInterrupt:
# Stopping CR
crLog.writeFatal('KeyboardInterrupt exception. Stopping CentralReport...')
CentralReport.isRunning = False
self.stop()
else:
crLog.writeError('Error launching CentralReport!')
def modify_config(self, key, value):
"""
Modifies one value in the config file
"""
cr_config = Config()
array_key = key.split(":")
try:
Config.set_config_value(array_key[0], array_key[1], value)
except Exception as e:
print (e.message)
return False
try:
cr_config.write_config_file()
except Exception as e:
print (e.message)
return False
return True
def _get_load_info():
"""
Gets template variables filled with the last load average check
@return: Dictionary of template variables
"""
vars = {
'1m': data.last_check.load.last1m,
'5m': data.last_check.load.last5m,
'15m': data.last_check.load.last15m
}
load_percent = (float(data.last_check.load.last1m) * 100) / int(cr.host.get_current_host().cpu_count)
if load_percent >= int(Config.get_config_value('Alerts', 'load_alert')):
vars['state'] = STATE_ALERT
elif load_percent >= int(Config.get_config_value('Alerts', 'load_warning')):
vars['state'] = STATE_WARNING
else:
vars['state'] = STATE_OK
return vars
def _get_cpu_info():
"""
Gets template variables filled with the last CPU check
@return: Dictionary of template variables
"""
vars = {
'percent': int(data.last_check.cpu.user) + int(data.last_check.cpu.system),
'user': data.last_check.cpu.user,
'system': data.last_check.cpu.system,
'idle': data.last_check.cpu.idle
}
if int(Config.get_config_value('Alerts', 'cpu_alert')) <= vars['percent']:
vars['state'] = STATE_ALERT
elif int(Config.get_config_value('Alerts', 'cpu_warning')) <= vars['percent']:
vars['state'] = STATE_WARNING
else:
vars['state'] = STATE_OK
return vars
def _get_memory_info():
"""
Gets template variables filled with the last memory check
@return: Dictionary of template variables
"""
vars = {
'percent': (int(data.last_check.memory.total) - int(data.last_check.memory.free)) * 100 / int(data.last_check.memory.total),
'total': data.last_check.memory.total,
'active': data.last_check.memory.active,
'inactive': data.last_check.memory.inactive,
'resident': data.last_check.memory.resident,
'free': data.last_check.memory.free
}
if vars['percent'] >= int(Config.get_config_value('Alerts', 'memory_alert')):
vars['state'] = STATE_ALERT
elif vars['percent'] >= int(Config.get_config_value('Alerts', 'memory_warning')):
vars['state'] = STATE_WARNING
else:
vars['state'] = STATE_OK
return vars
def api_date_check(self):
tmpl = self.env.get_template('json/date_check.json')
cherrypy.response.headers['Content-Type'] = 'application/json'
tmpl_vars = dict()
if Checks.last_check_date is None:
tmpl_vars['last_timestamp'] = '0'
tmpl_vars['last_fulldate'] = 'Never'
else:
tmpl_vars['last_timestamp'] = crUtilsDate.datetimeToTimestamp(Checks.last_check_date)
tmpl_vars['last_fulldate'] = Checks.last_check_date.strftime("%Y-%m-%d %H:%M:%S")
tmpl_vars['current_timestamp'] = crUtilsDate.datetimeToTimestamp(datetime.datetime.now())
try:
tmpl_vars['checks_interval'] = int(Config.getConfigValue('Checks', 'interval'))
except:
tmpl_vars['checks_interval'] = int(Config.CR_CONFIG_DEFAULT_CHECKS_INTERVAL)
return tmpl.render(tmpl_vars)
def __init__(self):
threading.Thread.__init__(self)
log.log_debug('ThreadChecks is starting...') # Standard output
if cr.host.get_current_host().os == cr.host.OS_MAC:
self.MyCollector = collectors.MacCollector()
elif cr.host.get_current_host().family == cr.host.FAMILY_LINUX:
self.MyCollector = collectors.DebianCollector()
else:
raise TypeError
# Perform a check every xx ticks (1 tick = 1 second)
try:
self.tickPerformCheck = int(Config.get_config_value('Checks', 'interval'))
except:
self.tickPerformCheck = 60
log.log_debug('Interval between two checks: %s seconds' % self.tickPerformCheck)
self.start()
def __init__(self):
threading.Thread.__init__(self)
crLog.writeDebug('ThreadChecks is starting...') # Standard output
# What is the current os?
if Config.HOST_CURRENT == Config.HOST_MAC:
self.MyCollector = crCollectors.MacCollector()
elif (Config.HOST_CURRENT == Config.HOST_DEBIAN) \
| (Config.HOST_CURRENT == Config.HOST_UBUNTU):
self.MyCollector = crCollectors.DebianCollector()
# Perform a check every xx ticks (1 tick = 1 second)
try:
self.tickPerformCheck = int(Config.getConfigValue('Checks', 'interval'))
except:
self.tickPerformCheck = 60
crLog.writeDebug('Interval between two checks: ' + str(self.tickPerformCheck) + ' seconds')
self.start()
def modify_config(self, key, value):
"""
Modifies one value in the config file
"""
cr_config = Config()
array_key = key.split(':')
try:
Config.set_config_value(array_key[0], array_key[1], value)
except Exception as e:
print(e.message)
return False
try:
cr_config.write_config_file()
except Exception as e:
print(e.message)
return False
return True
def run(self):
"""
Constructor.
"""
is_error = False # If True, there are one or more errors when CentralReport is trying to start
log.log_info("------------------------------------------------")
log.log_info("CentralReport is starting...")
log.log_info("Current user: "******"Debug", "log_level")
except:
log_level = "INFO"
log.change_log_level(log_level)
# Starting the check thread...
if host.get_current_host().os != host.OS_UNKNOWN:
log.log_info("%s detected. Starting ThreadChecks..." % host.get_current_host().os)
CentralReport.checks_thread = threads.Checks() # Launching checks thread
else:
is_error = True
log.log_critical("Sorry, but your OS is not supported yet...")
# Starting the internal webserver...
if not is_error and text.convert_text_to_bool(Config.get_config_value("Webserver", "enable")):
local_web_port = int(Config.get_config_value("Webserver", "port"))
if not utils_web.check_port("127.0.0.1", local_web_port):
log.log_info("Starting the webserver...")
# Importing the module here improve the memory usage
import cr.web
CentralReport.webserver_thread = cr.web.server.WebServer()
else:
log.log_error("Error launching the webserver: port %s is already in use on this host!" % local_web_port)
else:
log.log_info("Webserver is disabled by configuration file!")
if not is_error:
log.log_info("CentralReport started!")
while CentralReport.is_running:
if not Config.CR_CONFIG_ENABLE_DEBUG_MODE:
# If .pid file is not found, we must stop CR (only in production environment)
try:
pf = file(self.pidfile, "r")
pf.close()
except IOError:
log.log_error("Pid file is not found. CentralReport must stop itself.")
CentralReport.is_running = False
self.stop()
time.sleep(1)
else:
log.log_error("Error launching CentralReport!")
standalone.display()
cr.cli.quit()
if __name__ == '__main__':
if os.path.isfile('/usr/local/bin/centralreport') is False:
print 'CentralReport must be installed on this host to run the CLI Manager!'
exit(2)
elif getpass.getuser() != 'root':
print 'You must execute this manager as root to perform administrative operations!'
exit(3)
log.log_info('CLI Manager is starting...')
cr_config = Config()
cr_config.read_config_file()
if len(sys.argv) == 1:
cr.cli.init_screen()
main_screen = MainCli()
main_screen.display()
else:
if sys.argv[1] == 'wizard':
cr.cli.init_screen()
wizard_screen = WizardCli()
wizard_screen.display()
else:
print 'CentralReport CLI Manager - Usage: \n' \
'manager.py [wizard]'
exit(1)
def run(self):
"""
Constructor.
"""
is_error = False # If True, there are one or more errors when CentralReport is trying to start
log.log_info('------------------------------------------------')
log.log_info('CentralReport is starting...')
log.log_info('Current user: '******'Debug', 'log_level')
except:
log_level = 'INFO'
log.change_log_level(log_level)
# Starting the check thread...
if host.get_current_host().os != host.OS_UNKNOWN:
log.log_info('%s detected. Starting ThreadChecks...' %
host.get_current_host().os)
CentralReport.checks_thread = threads.Checks(
) # Launching checks thread
else:
is_error = True
log.log_critical('Sorry, but your OS is not supported yet...')
# Starting the internal webserver...
if not is_error and text.convert_text_to_bool(
Config.get_config_value('Webserver', 'enable')):
local_web_port = int(Config.get_config_value('Webserver', 'port'))
if not utils_web.check_port('127.0.0.1', local_web_port):
log.log_info('Starting the webserver...')
# Importing the module here improve the memory usage
import cr.web
CentralReport.webserver_thread = cr.web.server.WebServer()
else:
log.log_error(
'Error launching the webserver: port %s is already in use on this host!'
% local_web_port)
else:
log.log_info('Webserver is disabled by configuration file!')
if not is_error:
log.log_info('CentralReport started!')
while CentralReport.is_running:
if not Config.CR_CONFIG_ENABLE_DEBUG_MODE:
# If .pid file is not found, we must stop CR (only in production environment)
try:
pf = file(self.pidfile, 'r')
pf.close()
except IOError:
log.log_error(
'Pid file is not found. CentralReport must stop itself.'
)
CentralReport.is_running = False
self.stop()
time.sleep(1)
else:
log.log_error('Error launching CentralReport!')
standalone.display()
cr.cli.quit()
if __name__ == '__main__':
if os.path.isfile('/usr/local/bin/centralreport') is False:
print 'CentralReport must be installed on this host to run the CLI Manager!'
exit(2)
elif getpass.getuser() != 'root':
print 'You must execute this manager as root to perform administrative operations!'
exit(3)
log.log_info('CLI Manager is starting...')
cr_config = Config()
cr_config.read_config_file()
if len(sys.argv) == 1:
cr.cli.init_screen()
main_screen = MainCli()
main_screen.display()
else:
if sys.argv[1] == 'wizard':
cr.cli.init_screen()
wizard_screen = WizardCli()
wizard_screen.display()
else:
print 'CentralReport CLI Manager - Usage: \n' \
'manager.py [wizard]'
exit(1)
print 'Stopping CentralReport...'
time.sleep(1)
daemon = CentralReport(Config.CR_PID_FILE)
if not daemon.status():
print 'CentralReport is not running'
centralReportRunningBefore = False
else:
centralReportRunningBefore = True
try:
daemon.stop()
except:
print 'Error stopping CentralReport daemon...'
config = Config() # Getting the actual config
# Enable or disable internal web server
print '\n\n'
print '-- Internal web server options --'
print 'CentralReport has a small internal web server to display checks datas, with a simple web browser.'
print 'With this web server, you can monitor this host without account on centralreport.net'
validEnableWebServer = False
while (not validEnableWebServer):
resultEnableWebServer = raw_input('Do you want to enable the internal web server? [y/n] ')
if('y' == resultEnableWebServer.lower()[:1]):
validEnableWebServer = True
Config.setConfigValue('Webserver', 'enable', True)
elif 'n' == resultEnableWebServer.lower()[:1]:
def api_full_check(self):
tmpl = self.env.get_template('json/full_check.json')
cherrypy.response.headers['Content-Type'] = 'application/json'
tmpl_vars = dict()
if Checks.last_check_date is None:
tmpl_vars['last_timestamp'] = '0'
tmpl_vars['last_fulldate'] = 'Never'
else:
tmpl_vars['last_timestamp'] = crUtilsDate.datetimeToTimestamp(Checks.last_check_date)
tmpl_vars['last_fulldate'] = Checks.last_check_date.strftime("%Y-%m-%d %H:%M:%S")
tmpl_vars['current_timestamp'] = crUtilsDate.datetimeToTimestamp(datetime.datetime.now())
# CPU Check informations
if Checks.last_check_cpu is None:
tmpl_vars['cpu_check_enabled'] = 'False'
else:
tmpl_vars['cpu_check_enabled'] = 'True'
tmpl_vars['cpu_percent'] = int(Checks.last_check_cpu.user) + int(Checks.last_check_cpu.system)
tmpl_vars['cpu_user'] = Checks.last_check_cpu.user
tmpl_vars['cpu_system'] = Checks.last_check_cpu.system
if int(Config.getConfigValue('Alerts', 'cpu_alert')) <= int(tmpl_vars['cpu_percent']):
tmpl_vars['cpu_state'] = "alert"
elif int(Config.getConfigValue('Alerts', 'cpu_warning')) <= int(tmpl_vars['cpu_percent']):
tmpl_vars['cpu_state'] = "warning"
else:
tmpl_vars['cpu_state'] = 'ok'
# Memory check informations
if Checks.last_check_memory is None:
tmpl_vars['memory_check_enabled'] = 'False'
else:
tmpl_vars['memory_check_enabled'] = "True"
tmpl_vars['memory_percent'] = ((int(Checks.last_check_memory.total) - int(
Checks.last_check_memory.free)) * 100) / int(Checks.last_check_memory.total)
tmpl_vars['memory_free'] = crUtilsText.convertByte(Checks.last_check_memory.free)
tmpl_vars['memory_total'] = crUtilsText.convertByte(Checks.last_check_memory.total)
tmpl_vars['memory_used'] = crUtilsText.convertByte(
float(Checks.last_check_memory.total) - float(Checks.last_check_memory.free))
if int(tmpl_vars['memory_percent']) >= int(Config.getConfigValue('Alerts', 'memory_alert')):
tmpl_vars['memory_state'] = "alert"
elif int(tmpl_vars['memory_percent']) >= int(Config.getConfigValue('Alerts', 'memory_warning')):
tmpl_vars['memory_state'] = "warning"
else:
tmpl_vars['memory_state'] = 'ok'
# Last: swap stats
if 0 != int(Checks.last_check_memory.swapSize):
tmpl_vars['swap_percent'] = int(Checks.last_check_memory.swapUsed) * 100 / int(
Checks.last_check_memory.swapSize)
tmpl_vars['swap_used'] = crUtilsText.convertByte(Checks.last_check_memory.swapUsed)
tmpl_vars['swap_free'] = crUtilsText.convertByte(Checks.last_check_memory.swapFree)
tmpl_vars['swap_size'] = crUtilsText.convertByte(Checks.last_check_memory.swapSize)
# On Mac, the swap is unlimited (only limited by the available hard drive size)
if Checks.last_check_memory.swapSize == Checks.last_check_memory.total:
tmpl_vars['swap_configuration'] = 'unlimited'
else:
tmpl_vars['swap_configuration'] = 'limited'
if isinstance(tmpl_vars['swap_percent'], int):
if int(tmpl_vars['swap_percent']) >= int(Config.getConfigValue('Alerts', 'swap_alert')):
tmpl_vars['swap_state'] = 'alert'
elif int(tmpl_vars['swap_percent']) >= int(Config.getConfigValue('Alerts', 'swap_warning')):
tmpl_vars['swap_state'] = 'warning'
else:
tmpl_vars['swap_state'] = 'ok'
else:
tmpl_vars['swap_state'] = 'ok'
else:
# No swap available on this host
tmpl_vars['swap_configuration'] = 'undefined'
# Load average
if Checks.last_check_loadAverage is None:
tmpl_vars['load_check_enabled'] = 'False'
else:
tmpl_vars['load_check_enabled'] = "True"
tmpl_vars['load_last_one'] = Checks.last_check_loadAverage.last1m
tmpl_vars['load_percent'] = (float(Checks.last_check_loadAverage.last1m) * 100) / int(
Checks.hostEntity.cpuCount)
if int(tmpl_vars['load_percent']) >= int(Config.getConfigValue('Alerts', 'load_alert')):
tmpl_vars['load_state'] = "alert"
elif int(tmpl_vars['load_percent']) >= int(Config.getConfigValue('Alerts', 'load_warning')):
tmpl_vars['load_state'] = "warning"
else:
tmpl_vars['load_state'] = 'ok'
tmpl_vars['uptime_full_text'] = crUtilsText.secondsToPhraseTime(
int(Checks.last_check_loadAverage.uptime))
tmpl_vars['uptime_seconds'] = crUtilsText.numberSeparators(str(Checks.last_check_loadAverage.uptime))
tmpl_vars['start_date'] = datetime.datetime.fromtimestamp(
crUtilsDate.datetimeToTimestamp(Checks.last_check_date) - int(
Checks.last_check_loadAverage.uptime)).strftime("%Y-%m-%d %H:%M:%S")
return tmpl.render(tmpl_vars)
def index(self):
tmpl = self.env.get_template('index.tpl')
tmpl_vars = dict()
# Host informations
tmpl_vars['hostname'] = Checks.hostEntity.hostname
tmpl_vars['os_name'] = Checks.hostEntity.osName
tmpl_vars['os_version'] = Checks.hostEntity.osVersion
if Config.HOST_CURRENT == Config.HOST_MAC:
tmpl_vars['host_os'] = 'MAC'
elif Config.HOST_CURRENT == Config.HOST_UBUNTU:
tmpl_vars['host_os'] = 'UBUNTU'
elif Config.HOST_CURRENT == Config.HOST_DEBIAN:
tmpl_vars['host_os'] = 'DEBIAN'
tmpl_vars['CR_version'] = Config.CR_VERSION
tmpl_vars['CR_version_name'] = Config.CR_VERSION_NAME
if Checks.last_check_date is None:
tmpl_vars['last_check'] = 'Never'
else:
tmpl_vars['last_check'] = Checks.last_check_date.strftime("%Y-%m-%d %H:%M:%S")
# CPU stats
if Checks.last_check_cpu is not None:
tmpl_vars['cpu_percent'] = 100 - int(Checks.last_check_cpu.idle)
tmpl_vars['cpu_user'] = Checks.last_check_cpu.user
tmpl_vars['cpu_system'] = Checks.last_check_cpu.system
tmpl_vars['cpu_count'] = Checks.hostEntity.cpuCount
if int(tmpl_vars['cpu_percent']) >= int(Config.getConfigValue('Alerts', 'cpu_alert')):
tmpl_vars['cpu_alert'] = True
elif int(tmpl_vars['cpu_percent']) >= int(Config.getConfigValue('Alerts', 'cpu_warning')):
tmpl_vars['cpu_warning'] = True
else:
tmpl_vars['cpu_ok'] = True
# Memory and swap stats
if Checks.last_check_memory is not None:
# First: Memory stats
tmpl_vars['memory_percent'] = ((int(Checks.last_check_memory.total) - int(
Checks.last_check_memory.free)) * 100) / int(Checks.last_check_memory.total)
tmpl_vars['memory_free'] = crUtilsText.convertByte(Checks.last_check_memory.free)
tmpl_vars['memory_total'] = crUtilsText.convertByte(Checks.last_check_memory.total)
tmpl_vars['memory_used'] = crUtilsText.convertByte(
float(Checks.last_check_memory.total) - float(Checks.last_check_memory.free))
# Memory status
if int(tmpl_vars['memory_percent']) >= int(Config.getConfigValue('Alerts', 'memory_alert')):
tmpl_vars['memory_alert'] = True
elif int(tmpl_vars['memory_percent']) >= int(Config.getConfigValue('Alerts', 'memory_warning')):
tmpl_vars['memory_warning'] = True
else:
tmpl_vars['memory_ok'] = True
# Last: swap stats
if 0 != int(Checks.last_check_memory.swapSize):
tmpl_vars['swap_percent'] = int(Checks.last_check_memory.swapUsed) * 100 / int(
Checks.last_check_memory.swapSize)
tmpl_vars['swap_used'] = crUtilsText.convertByte(Checks.last_check_memory.swapUsed)
tmpl_vars['swap_free'] = crUtilsText.convertByte(Checks.last_check_memory.swapFree)
tmpl_vars['swap_size'] = crUtilsText.convertByte(Checks.last_check_memory.swapSize)
# On Mac, the swap is unlimited (only limited by the available hard drive size)
if Checks.last_check_memory.swapSize == Checks.last_check_memory.total:
tmpl_vars['swap_configuration'] = 'unlimited'
else:
tmpl_vars['swap_configuration'] = 'limited'
if isinstance(tmpl_vars['swap_percent'], int):
if int(tmpl_vars['swap_percent']) >= int(Config.getConfigValue('Alerts', 'swap_alert')):
tmpl_vars['swap_alert'] = True
elif int(tmpl_vars['swap_percent']) >= int(Config.getConfigValue('Alerts', 'swap_warning')):
tmpl_vars['swap_warning'] = True
else:
tmpl_vars['swap_ok'] = True
else:
tmpl_vars['swap_ok'] = True
else:
# No swap available on this host
tmpl_vars['swap_configuration'] = 'undefined'
# Load average stats
if Checks.last_check_loadAverage is not None:
tmpl_vars['loadaverage'] = Checks.last_check_loadAverage.last1m
tmpl_vars['loadaverage_percent'] = (float(Checks.last_check_loadAverage.last1m) * 100) / int(
Checks.hostEntity.cpuCount)
if int(tmpl_vars['loadaverage_percent']) >= int(Config.getConfigValue('Alerts', 'load_alert')):
tmpl_vars['load_alert'] = True
elif int(tmpl_vars['loadaverage_percent']) >= int(Config.getConfigValue('Alerts', 'load_warning')):
tmpl_vars['load_warning'] = True
else:
tmpl_vars['load_ok'] = True
# Uptime stats (checked in load average collector)
if Checks.last_check_loadAverage is not None:
tmpl_vars['uptime'] = crUtilsText.secondsToPhraseTime(int(Checks.last_check_loadAverage.uptime))
tmpl_vars['uptime_seconds'] = crUtilsText.numberSeparators(str(Checks.last_check_loadAverage.uptime))
tmpl_vars['start_date'] = datetime.datetime.fromtimestamp(
crUtilsDate.datetimeToTimestamp(Checks.last_check_date) - int(
Checks.last_check_loadAverage.uptime)).strftime("%Y-%m-%d %H:%M:%S")
# DIsks stats
if Checks.last_check_disk is not None:
allChecksDisk = []
for disk in Checks.last_check_disk.checks:
checkDisk = {}
# TODO: Find a better solution to decode UTF8
checkDisk['name'] = str.replace(disk.name, '/dev/', '').decode('utf-8')
checkDisk['free'] = crUtilsText.convertByte(disk.free)
checkDisk['total'] = crUtilsText.convertByte(disk.size)
checkDisk['percent'] = int(round(disk.used, 0) * 100 / int(disk.size))
allChecksDisk.append(checkDisk)
tmpl_vars['disks'] = allChecksDisk
return tmpl.render(tmpl_vars)
