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 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!')
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)