class Controller(Thread):
'''The controller is the link between the transport layer and the
resources layer. Basically, its job is to load resources modules and
objects and to call their generic "process" method.
'''
def __init__(self, tq=None, pq=None):
self.logger.debug("Initializing the controller...")
Thread.__init__(self, name="CONTROLLER")
self.tq = tq
self.pq = pq
self.scheduler = SynSched()
self.locator = ResourceLocator(pq)
self.alerter = AlertsController(self.locator, self.scheduler, pq)
self.logger.debug("Controller successfully initialized.")
def start_scheduler(self):
# Start the scheduler thread
self.scheduler.start()
self.alerter.start()
# Prepopulate tasks from config file
if config.monitor['enable_monitoring']:
self._enable_monitoring()
if config.compliance['enable_compliance']:
self._enable_compliance()
def _get_monitor_interval(self, resource):
try:
default_interval = config.monitor['default_interval']
return int(config.monitor.get(resource, default_interval))
except ValueError:
return default_interval
def _get_compliance_interval(self, resource):
try:
default_interval = config.compliance['default_interval']
return int(config.compliance.get(resource, default_interval))
except ValueError:
return default_interval
def _enable_monitoring(self):
resources = self.locator.get_instance()
for resource in resources.values():
if not len(resource.states):
continue
interval = self._get_monitor_interval(resource.__resource__)
self.scheduler.add_job(resource.monitor_states, interval)
def _enable_compliance(self):
resources = self.locator.get_instance()
for resource in resources.values():
if not len(resource.states):
continue
interval = self._get_compliance_interval(resource.__resource__)
self.scheduler.add_job(resource.check_compliance, interval)
def stop_scheduler(self):
# Shutdown the scheduler/monitor
self.logger.debug("Shutting down global scheduler...")
if self.scheduler.isAlive():
self.scheduler.shutdown()
self.scheduler.join()
self.logger.debug("Scheduler stopped.")
def close(self):
# Stop this thread by putting a stop message in the blocking queue get
self.tq.put("stop")
# Close properly each resource
try:
for resource in self.locator.get_instance().itervalues():
resource.close()
except ResourceException, e:
self.logger.debug(str(e))
self.stop_scheduler()
class NagiosPluginsController(ResourcesController):
__resource__ = "nagios"
def __init__(self, module):
super(NagiosPluginsController, self).__init__(module)
self.path = self._configure()
self.plugins = {}
self._load_configs()
self.scheduler = SynSched()
self.scheduler.start()
self._load_jobs()
self.scheduler.add_job(self._reload, 30)
def read(self, res_id=None, attributes=None):
sensors = attributes.keys()
status = {}
for sensor in sensors:
if sensor in self.plugins.keys():
status[sensor] = exec_cmd(self.plugins[sensor]['command'])
return status
def _configure(self):
config_path = os.path.join(config.paths['config_path'], 'nagios.d')
if not os.path.exists(config_path):
os.makedirs(config_path)
return config_path
def _reload(self):
self._load_configs()
self._load_jobs()
def _load_configs(self):
for conf_file in os.listdir(self.path):
if not conf_file.endswith('.conf'):
continue
full_path = os.path.join(self.path, conf_file)
conf = RawConfigParser()
conf.read(full_path)
for section in conf.sections():
if section not in self.plugins:
self.plugins[section] = dict(conf.items(section))
self.plugins[section]['scheduled'] = False
def _load_jobs(self):
for key, value in self.plugins.iteritems():
if value['scheduled']:
continue
try:
interval = int(value['interval'])
command = value['command']
if os.path.exists(command.split()[0]):
self.scheduler.add_job(self._execute,
interval,
actionargs=(key, command))
self.plugins[key]['scheduled'] = True
else:
self.logger.warning("%s doesn't exist" % command)
except ValueError:
self.logger.warning("Interval value for %s must be an int" %
key)
except KeyError as err:
self.logger.warning("Error when parsing %s (%s)" %
(self.path, key))
def _execute(self, name, cmd):
result = exec_cmd(cmd)
if result['returncode'] != 0:
result['name'] = name
msg = OutgoingMessage(collection=self.__resource__, status=result,
msg_type='alert')
self.publish(msg)
def close(self):
super(NagiosPluginsController, self).close()
self.logger.debug("Shutting down nagios scheduler")
self.scheduler.shutdown()
class NagiosPluginsController(ResourcesController):
__resource__ = "nagios"
def __init__(self, module):
super(NagiosPluginsController, self).__init__(module)
self.path = self._configure()
self.plugins = {}
self._load_configs()
self.scheduler = SynSched()
self.scheduler.start()
self._load_jobs()
self.scheduler.add_job(self._reload, 30)
def read(self, res_id=None, attributes=None):
sensors = attributes.keys()
status = {}
for sensor in sensors:
if sensor in self.plugins.keys():
status[sensor] = exec_cmd(self.plugins[sensor]['command'])
return status
def _configure(self):
config_path = os.path.join(config.paths['config_path'], 'nagios.d')
if not os.path.exists(config_path):
os.makedirs(config_path)
return config_path
def _reload(self):
self._load_configs()
self._load_jobs()
def _load_configs(self):
for conf_file in os.listdir(self.path):
if not conf_file.endswith('.conf'):
continue
full_path = os.path.join(self.path, conf_file)
conf = RawConfigParser()
conf.read(full_path)
for section in conf.sections():
if section not in self.plugins:
self.plugins[section] = dict(conf.items(section))
self.plugins[section]['scheduled'] = False
def _load_jobs(self):
for key, value in self.plugins.iteritems():
if value['scheduled']:
continue
try:
interval = int(value['interval'])
command = value['command']
if os.path.exists(command.split()[0]):
self.scheduler.add_job(self._execute,
interval,
actionargs=(key, command))
self.plugins[key]['scheduled'] = True
else:
self.logger.warning("%s doesn't exist" % command)
except ValueError:
self.logger.warning("Interval value for %s must be an int" %
key)
except KeyError as err:
self.logger.warning("Error when parsing %s (%s)" %
(self.path, key))
def _execute(self, name, cmd):
result = exec_cmd(cmd)
if result['returncode'] != 0:
result['name'] = name
msg = OutgoingMessage(collection=self.__resource__,
status=result,
msg_type='alert')
self.publish(msg)
def close(self):
super(NagiosPluginsController, self).close()
self.logger.debug("Shutting down nagios scheduler")
self.scheduler.shutdown()
class Controller(Thread):
'''The controller is the link between the transport layer and the
resources layer. Basically, its job is to load resources modules and
objects and to call their generic "process" method.
'''
def __init__(self, tq=None, pq=None):
self.logger.debug("Initializing the controller...")
Thread.__init__(self, name="CONTROLLER")
self.tq = tq
self.pq = pq
self.scheduler = SynSched()
self.locator = ResourceLocator(pq)
self.alerter = AlertsController(self.locator, self.scheduler, pq)
self.logger.debug("Controller successfully initialized.")
def start_scheduler(self):
# Start the scheduler thread
self.scheduler.start()
self.alerter.start()
# Prepopulate tasks from config file
if config.monitor['enable_monitoring']:
self._enable_monitoring()
if config.compliance['enable_compliance']:
self._enable_compliance()
def _get_monitor_interval(self, resource):
try:
default_interval = config.monitor['default_interval']
return int(config.monitor.get(resource, default_interval))
except ValueError:
return default_interval
def _get_compliance_interval(self, resource):
try:
default_interval = config.compliance['default_interval']
return int(config.compliance.get(resource, default_interval))
except ValueError:
return default_interval
def _enable_monitoring(self):
resources = self.locator.get_instance()
for resource in resources.values():
if not len(resource.states):
continue
interval = self._get_monitor_interval(resource.__resource__)
self.scheduler.add_job(resource.monitor_states, interval)
def _enable_compliance(self):
resources = self.locator.get_instance()
for resource in resources.values():
if not len(resource.states):
continue
interval = self._get_compliance_interval(resource.__resource__)
self.scheduler.add_job(resource.check_compliance, interval)
def stop_scheduler(self):
# Shutdown the scheduler/monitor
self.logger.debug("Shutting down global scheduler...")
if self.scheduler.isAlive():
self.scheduler.shutdown()
self.scheduler.join()
self.logger.debug("Scheduler stopped.")
def close(self):
# Stop this thread by putting a stop message in the blocking queue get
self.tq.put("stop")
# Close properly each resource
try:
for resource in self.locator.get_instance().itervalues():
resource.close()
except ResourceException, e:
self.logger.debug(str(e))
self.stop_scheduler()
