266 lines
No EOL
10 KiB
Python
266 lines
No EOL
10 KiB
Python
from os.path import isfile
|
|
from os.path import join
|
|
import json
|
|
import imp
|
|
from layouts import Layout
|
|
from hostgroups import HostGroup
|
|
from members import Member
|
|
from config import LinspectorConfig
|
|
from periods import CronPeriod, DatePeriod, IntervalPeriod
|
|
|
|
from lib.services.service import Service
|
|
from lib.processors.processor import Processor
|
|
from lib.parsers.parser import Parser
|
|
from lib.tasks.task import Task
|
|
|
|
MOD_SERVICES = "services"
|
|
MOD_PROCESSORS = "processors"
|
|
MOD_PARSERS = "parsers"
|
|
MOD_TASKS = "tasks"
|
|
|
|
KEY_LAYOUTS = "layouts"
|
|
KEY_HOSTGROUPS = "hostgroups"
|
|
KEY_MEMBERS = "members"
|
|
KEY_PERIODS = "periods"
|
|
KEY_CORE = "core"
|
|
|
|
|
|
class ConfigurationException(Exception):
|
|
def __init__(self, msg, log):
|
|
log.e(msg)
|
|
self.msg = msg
|
|
|
|
def __str__(self):
|
|
return repr(self.msg)
|
|
|
|
|
|
class ConfigParser:
|
|
def __init__(self, log):
|
|
"""
|
|
initializes a new ConfigParser Object
|
|
|
|
:param log: pre configured logger Object to post messages while parsing"
|
|
"""
|
|
self.log = log
|
|
self.hostgroups = {}
|
|
self.members = {}
|
|
self.periods = {}
|
|
self.layouts = {}
|
|
self._loadedMods = {MOD_SERVICES: {}, MOD_PROCESSORS: {}, MOD_TASKS: {}, MOD_PARSERS: {}}
|
|
|
|
def _create_new_config_dict(self):
|
|
return {"members": {}, "periods": {}, "hostgroups": {}, "layouts": {}, "core": {}}
|
|
|
|
def create_config(self, config):
|
|
configDict = self._create_new_config_dict()
|
|
for layout in config.get_layouts():
|
|
layout._to_config_dict(configDict)
|
|
|
|
def _read_json_config(self, configFilename):
|
|
"""
|
|
reads the config File and returns a dictionary, while lowering the first keys
|
|
|
|
:param configFilename: the path under which the configuration file should be found
|
|
"""
|
|
if not isfile(configFilename):
|
|
msg = "config file not found at " + str(configFilename)
|
|
raise ConfigurationException(msg, self.log)
|
|
|
|
self.configFilename = configFilename
|
|
|
|
with open(configFilename) as cfgFile:
|
|
config = cfgFile.read()
|
|
|
|
self.log.info("reading Config: " + configFilename)
|
|
return json.loads(config)
|
|
|
|
def _create_raw_Object(self, jsonDict, msgName, creator):
|
|
"""
|
|
creates an Main object from the configuration, but just parses raw data and hands it to the object
|
|
|
|
:param jsonDict: the configuration file part as dict
|
|
:param msgName: name of object for error message
|
|
:param creator: function pointer which is taking two arguments: identifier of the object and arguments.
|
|
:should return an object
|
|
:return: a list of objects returned by creator
|
|
"""
|
|
items = []
|
|
for key, val in jsonDict.items():
|
|
try:
|
|
item = creator(key, val)
|
|
items.append(item)
|
|
except Exception:
|
|
self.log.warning("ignoring " + msgName + ": " + key + "! reason:")
|
|
self.log.warning(str(Exception))
|
|
return items
|
|
|
|
def _load_module(self, clazz, modPart):
|
|
"""
|
|
imports and caches a module.
|
|
|
|
:param clazz: the filename of the module (i.e email, ping...)
|
|
:param modPart: the folder of the module. (i.e services, parsers...)
|
|
:return: the imported/cached module, or throws an error if it couldn't find it
|
|
"""
|
|
mods = self._loadedMods[modPart]
|
|
if clazz in mods:
|
|
return mods[clazz]
|
|
else:
|
|
#mod = __import__(clazz)
|
|
p = join("lib", modPart, clazz + ".py")
|
|
mod = imp.load_source(clazz, p)
|
|
mods[clazz] = mod
|
|
return mod
|
|
|
|
def replace_with_import(self, objList, modPart, items_func, class_check):
|
|
"""
|
|
replaces configuration dicts with their objects by importing and creating it in the first step.
|
|
In the second step the original list of json config dicts gets replaced by the loaded objects
|
|
|
|
:param objList: the list of objects which is iterated on
|
|
:param modPart: the folder from the module (i.e tasks, parsers)
|
|
:param items_func: function to get a pointer on the list of json-config-objects to replace. Takes one argument and
|
|
should return a list of
|
|
:param class_check: currently unsupported
|
|
"""
|
|
for obj in objList:
|
|
repl = []
|
|
items = items_func(obj)
|
|
for clazzItem in items:
|
|
try:
|
|
|
|
clazz = clazzItem["class"]
|
|
mod = self._load_module(clazz, modPart)
|
|
item = mod.create(clazzItem)
|
|
if class_check(item):
|
|
repl.append(item)
|
|
else:
|
|
self.log.warning("Ignoring class " + clazzItem["class"] + "! It does not pass the class check!")
|
|
|
|
except ImportError, err:
|
|
self.log.warning("Could not import " + clazz + ": " + str(clazzItem) + "! reason")
|
|
self.log.warning(str(err))
|
|
except KeyError, k:
|
|
self.log.warning("Key " + str(k) + " not in classItem " + str(clazzItem))
|
|
except Exception, e:
|
|
self.log.warning("Error while replacing class ( " + clazz + " ): " + str(e))
|
|
|
|
del items[:]
|
|
items.extend(repl)
|
|
|
|
def replace_pointer(self, objectList, replObjectList, id_list_func, id_get_func):
|
|
"""
|
|
replaces objects from the config by ids.
|
|
|
|
:param objectList: the list of objects to be iterated on
|
|
:param replObjectList: the list of objects to replace
|
|
:param id_list_func: function taking one argument as object and should return a list of config ids to replace
|
|
:param id_get_func: function taking one config-object as argument and should return the config id to compare
|
|
"""
|
|
for obj in objectList:
|
|
replacements = []
|
|
idList = id_list_func(obj)
|
|
for id in idList:
|
|
repl = [o for o in replObjectList if id == id_get_func(o)]
|
|
if len(repl) == 1:
|
|
replacements.append(repl[0])
|
|
|
|
del idList[:]
|
|
idList.extend(replacements)
|
|
|
|
def parse_config(self, configFilename):
|
|
pass
|
|
|
|
|
|
def parsePeriodList(name, values):
|
|
if "date" in values:
|
|
return DatePeriod(name, **values)
|
|
|
|
comp = ["weeks", "days", "hours", "minutes", "seconds", "start_date"]
|
|
if len([i for i in comp if i in values]) > 0:
|
|
return IntervalPeriod(name, **values)
|
|
|
|
comp = ["year", "month", "day", "week", "day_of_week", "hour", "minute", "second"]
|
|
if len([i for i in comp if i in values]) > 0 :
|
|
return CronPeriod(name, **values)
|
|
else:
|
|
raise ConfigurationException("could not determine correct Period(" + repr(values)+").")
|
|
|
|
|
|
class FullConfigParser(ConfigParser):
|
|
def parse_config(self, configFilename):
|
|
"""
|
|
parses the json configuration and returns a list of layouts,
|
|
which contains all necessary information of the config file.
|
|
parses the full config
|
|
Parsing will be done in 3 steps:
|
|
1. get raw Config Objects by just passing the values defined inside the config
|
|
2. replace references by objects, import services, tasks, parsers and processors
|
|
3. do sanity checks
|
|
|
|
:param configFilename: the configuration file to parse
|
|
"""
|
|
self.jsonDict = self._read_json_config(configFilename)
|
|
|
|
# first step
|
|
creator = lambda name, values: Layout(name,**values)
|
|
layouts = self._create_raw_Object(self.jsonDict[KEY_LAYOUTS], "Layout", creator)
|
|
|
|
creator = lambda name, values: Member(name, **values)
|
|
members = self._create_raw_Object(self.jsonDict[KEY_MEMBERS], "Member", creator)
|
|
|
|
|
|
creator = lambda name, values: HostGroup(name, **values)
|
|
self.hostgroups = self._create_raw_Object(self.jsonDict[KEY_HOSTGROUPS], "Hostgroup", creator)
|
|
|
|
creator = parsePeriodList
|
|
periods = self._create_raw_Object(self.jsonDict[KEY_PERIODS], "Period", creator)
|
|
|
|
#2. import and replace
|
|
items_func = lambda hostgroup: hostgroup.get_services()
|
|
class_check = lambda service: isinstance(service, Service)
|
|
self.replace_with_import(self.hostgroups, MOD_SERVICES, items_func, class_check)
|
|
|
|
items_func = lambda hostgroup: hostgroup.get_processors()
|
|
class_check = lambda processor: isinstance(processor, Processor)
|
|
self.replace_with_import(self.hostgroups, MOD_PROCESSORS, items_func, class_check)
|
|
|
|
items_func = lambda member: member.get_tasks()
|
|
class_check = lambda task: isinstance(task, Task)
|
|
self.replace_with_import(members, MOD_TASKS, items_func, class_check)
|
|
|
|
services = []
|
|
for hg in self.hostgroups:
|
|
services.extend(hg.get_services())
|
|
|
|
items_func = lambda service: service.get_parser()
|
|
class_check = lambda parser: isinstance(parser, Parser)
|
|
self.replace_with_import(services, MOD_PARSERS, items_func, class_check)
|
|
|
|
#replace object pointer
|
|
id_list_func = lambda hostgroup: hostgroup.get_members()
|
|
id_get_func = lambda member: member.get_id()
|
|
self.replace_pointer(self.hostgroups, members, id_list_func, id_get_func)
|
|
|
|
id_list_func = lambda service: service.get_periods()
|
|
id_get_func = lambda period: period.get_name()
|
|
self.replace_pointer(services, periods, id_list_func, id_get_func)
|
|
|
|
id_list_func = lambda layout: layout.get_hostgroups()
|
|
id_get_func = lambda hostgroup: hostgroup.get_name()
|
|
self.replace_pointer(layouts, self.hostgroups, id_list_func, id_get_func)
|
|
|
|
linConf = LinspectorConfig()
|
|
linConf.set_layouts(layouts)
|
|
linConf.set_hostgroups(self.hostgroups)
|
|
linConf.set_members(members)
|
|
linConf.set_periods(periods)
|
|
|
|
for hg in self.hostgroups:
|
|
for service in hg.get_services():
|
|
service.set_hostgroup(hg)
|
|
core = None
|
|
if "core" in self.jsonDict:
|
|
core = self.jsonDict["core"]
|
|
|
|
return linConf, core |