prepared a lot of stuff for new task handling... it was a hell to cleanup unused stuff!!!

bin/linspector

@@ -134,9 +134,7 @@ def main():
                         job = Job(service,
                                   host,
                                   hostgroup.get_members(),
-                                  hostgroup.get_processors(),
                                   core,
-                                  linConf.get_task_list(),
                                   hostgroup)
                         scheduler_job = period.createJob(scheduler, job, handle_job, start_date=new_start_date)
                         if scheduler_job is not None:

examples/dev.json

@@ -8,7 +8,7 @@
                     "type": "error",
                     "args": { "host": "localhost",
                               "port": 25,
-                              "from": "linspector@linspector.org",
+                              "sender": "linspector@linspector.org",
                               "username": "",
                               "password": "",
                               "rcpt": "hanez@linspector.org"
@@ -18,14 +18,15 @@
                     "class": "mail",
                     "type": "warning",
                     "args": { "host": "localhost",
-                              "from": "linspector@linspector.org",
+                              "sender": "linspector@linspector.org",
                               "rcpt": "warning@linspector.org"
                     }
                 },
                 {
                     "class": "mail",
                     "type": "ok",
-                    "args": { "rcpt": "warning@linspector.org" }
+                    "args": { "sender": "linspector@linspector.org",
+                              "rcpt": "warning@linspector.org" }
                 }
             ]
         },
@@ -55,6 +56,30 @@
                     "periods": ["fast"],
                     "threshold": 1,
                     "args": { "sleep": 1, "fail": 1 }
+                },
+                {
+                    "class": "etc/dummy",
+                    "periods": ["fast"],
+                    "threshold": 1,
+                    "args": { "sleep": 10, "fail": 0 }
+                }
+            ]
+        },
+        "b":{
+            "members": ["root", "hannes"],
+            "hosts": [ "b"],
+            "services":[
+                {
+                    "class": "etc/dummy",
+                    "periods": ["fast"],
+                    "threshold": 1,
+                    "args": { "sleep": 1, "fail": 1 }
+                },
+                {
+                    "class": "etc/dummy",
+                    "periods": ["fast"],
+                    "threshold": 1,
+                    "args": { "sleep": 10, "fail": 0 }
                 }
             ]
         }
@@ -63,6 +88,10 @@
         "main":{
             "hostgroups": [ "a" ],
             "enabled": true
+        },
+        "gooo":{
+            "hostgroups": [ "b" ],
+            "enabled": true
         }
     },
     "core":{

linspector/config/config.py

@@ -1,7 +1,7 @@
 """
 The LinspectorConfig class.
 
-Copyright (c) 2011-2013 "Johannes Findeisen and Rafael Timmerberg"
+Copyright (c) 2011-2013 by Johannes Findeisen and Rafael Timmerberg
 
 This file is part of Linspector (http://linspector.org).
 
@@ -30,7 +30,6 @@ class LinspectorConfig(object):
         self._hostgroups = None
         self._members = None
         self._periods = None
-        self._tasks = None
 
     def set_hostgroups(self, hostgroups):
         self._hostgroups = hostgroups
@@ -75,10 +74,4 @@ class LinspectorConfig(object):
         return self._get_by_name(self.get_members(), name)
 
     def get_period_by_name(self, name):
-        return self._get_by_name(self.get_periods(), name)
+        return self._get_by_name(self.get_periods(), name)
-
-    def set_task_list(self, taskList):
-        self.taskList = taskList
-
-    def get_task_list(self):
-        return self.taskList

linspector/config/hostgroups.py

@@ -116,37 +116,4 @@ class HostGroup(object):
         return self.name
     
     def get_members(self):
-        return self.members 
+        return self.members
-
-
-class HostGroupService:
-    def __init__(self, services, periods):
-        self.services = services
-        self.periods = periods
-
-    def __str__(self):
-        return "HostgroupService { " + str([str(s) for s in self.services]) + ", " + str([p.name for p in self.periods]) + "}"
-
-
-def parseHostGroupList(hostgroups, hosts, members, periods, services):
-    parsedHostGroups = []
-    for hgname, hgValues in hostgroups.items():
-        hostGroup = HostGroup(hgname)
-        hostGroup.members = [m for m in members if m.nameid in hgValues['members']]
-        hostGroup.hosts = [h for h in hosts if h.name in hgValues['hosts']]
-        hostGroup.threshold = hgValues['threshold']
-        if 'parent' in hgValues:
-            hostGroup.parent = hgValues['parent']
-        hostGroup.services = []
-        for serviceName, servicePeriods in hgValues['services'].items():
-            services = []
-            for host in hosts:
-                service = host.getHostServiceByName(serviceName)
-                if service is not None: 
-                    services.append(service)
-                else:
-                    logger.warning("could not find HostService(" + str(serviceName) + ") for host " + host.name)
-            hostGroupPeriods = [p for p in periods if p.name in servicePeriods]
-            hostGroup.services.append(HostGroupService(services, hostGroupPeriods))
-        parsedHostGroups.append(hostGroup)
-    return parsedHostGroups

linspector/config/layouts.py

@@ -61,40 +61,4 @@ class Layout(object):
         ret = "Layout: 'Name:" + str(self.name) + "', 'Enabled: " + str(self.enabled) + " "
         for group in self.hostgroups:
             ret += str(group)
-        return ret
-
-
-class LayoutList:
-    def __init__(self, layouts, hostgroups):
-        self.layouts = []
-        self.dict = layouts
-        self.plugins = []
-        for k, v in layouts.items():
-            if k in ("plugins", "Plugins"):
-                self.plugins = v
-                continue
-            else:
-                l = Layout(k)
-                for k1, v1 in v.items():
-                    if k1 in ("enabled", "Enabled"):
-                        l.enabled = v1
-                    elif k1 in ("hostgroups", "Hostgroups"):
-                        l.hostgroups = []
-                        for group in v1:
-                            h = None
-                            for hostg in hostgroups:
-                                if hostg.name == group:
-                                    h = hostg
-                                    break
-                            if h is not None:
-                                l.hostgroups.append(h)
-                            else:
-                                pass
-                self.layouts.append(l)
-
-    def __str__(self):
-        ret = ""
-        ret += "Plugins: " + str(self.plugins) + "\n"
-        for layout in self.layouts:
-            ret += str(layout) + "\n"
         return ret

linspector/config/members.py

@@ -1,5 +1,5 @@
 """
-Copyright (c) 2011-2013 "Johannes Findeisen and Rafael Timmerberg"
+Copyright (c) 2011-2013 by Johannes Findeisen and Rafael Timmerberg
 
 This file is part of Linspector (http://linspector.org).
 
@@ -24,58 +24,42 @@ from logging import getLogger
 logger = getLogger(__name__)
 
 
+class MemberException(Exception):
+    def __init__(self, msg):
+        self.msg = msg
+
+    def __str__(self):
+        return repr(self.msg)
+
+
+class MemberMissingArgumentException(MemberException):
+    def __init__(self, missingArgument, memberName):
+        super(MemberMissingArgumentException, self).__init__("no " + missingArgument + " defined for member " + memberName)
+
+
 class Member:
-    def __init__(self, id, name="",  comment="", tasks=None):
+    def __init__(self, name="", **kwargs):
-        self.id = id
         self.name = name
-        self.tasks = []
+        tmp = "tasks"
-        self.add_task(tasks)
+        self.__tasks = []
-        self.comment = comment
+        if not tmp in kwargs:
+            raise MemberMissingArgumentException(tmp, name)
+        self.add_tasks(kwargs[tmp])
 
-    def get_id(self):
+    def __add_internal(self, l, item):
-        return self.id
+        if isinstance(item, list):
-
+            l.extend(item)
-    def add_task(self, task):
-        if task is None:
-            return
-        if isinstance(task, list):
-            self.tasks.extend(task)
         else:
-            self.tasks.append(task)
+            l.append(item)
+
+    def add_tasks(self, tasks):
+        self.__add_internal(self.get_tasks(), tasks)
     
     def get_tasks(self):
-        return self.tasks
+        return self.__tasks
 
     def __str__(self):
         ret = "Member Id: " + self.nameid + " Name: " + self.name + " Filters: " + str(self.phone)
         for f in self.filters:
             ret += str(f)
-        return ret
+        return ret
-
-
-class MemberFilter:
-    def __init__(self, filter, Value):
-        self.filter = filter
-        self.value = Value
-
-    def __str__(self):
-        return "Filter:" + str(self.filter) + " Value:" + self.value
-
-
-def parseMemberList(members, filters):
-    parsedMembers = [Member(nameid, **values) for nameid, values in members.items()]
-    for member in parsedMembers:
-        mFilter = []
-        for filtername, replacement in member.filters.items():
-            found = False
-            for filt in filters:
-                if filt.name != filtername:
-                    continue
-                found = True
-                memberFilter = filt.clone()
-                memberFilter.command = re.sub('@member', replacement, filt.command)
-                mFilter.append(memberFilter)
-            if not found:
-                logger.warning("filter: " + filtername + " is not defined in member " + member.name)
-        member.filters = mFilter
-    return parsedMembers

linspector/config/parser.py

@@ -30,7 +30,7 @@ from config import LinspectorConfig
 from periods import CronPeriod, DatePeriod, IntervalPeriod
 
 from linspector.services.service import Service
-from linspector.tasks.task import TaskList
+from linspector.tasks.task import Task
 
 MOD_SERVICES   = "services"
 MOD_TASKS      = "tasks"
@@ -40,7 +40,6 @@ KEY_HOSTGROUPS = "hostgroups"
 KEY_MEMBERS    = "members"
 KEY_PERIODS    = "periods"
 KEY_CORE       = "core"
-KEY_TASKS      = "tasks"
 
 logger = getLogger(__name__)
 
@@ -66,7 +65,7 @@ class ConfigParser:
         self._loadedMods = {MOD_SERVICES: {}, MOD_TASKS: {}}
         
     def _create_new_config_dict(self):
-        return {"members": {}, "periods": {}, "hostgroups": {}, "layouts": {}, "core": {}, "tasks": {}}
+        return {"members": {}, "periods": {}, "hostgroups": {}, "layouts": {}, "core": {}}
         
     def create_config(self, config):
         configDict = self._create_new_config_dict()
@@ -231,59 +230,52 @@ class FullConfigParser(ConfigParser):
 
         #1.
         creator = lambda name, values: Layout(name, **values)
-        layouts = self._create_raw_Object(self.dict[KEY_LAYOUTS], "Layout", creator)
+        self.layouts = self._create_raw_Object(self.dict[KEY_LAYOUTS], "Layout", creator)
 
+        #TODO: self.members is empty after this!!!!!! BUG!!!
         creator = lambda name, values: Member(name, **values)
-        members = self._create_raw_Object(self.dict[KEY_MEMBERS], "Member", creator)
+        self.members = self._create_raw_Object(self.dict[KEY_MEMBERS], "Member", creator)
 
         creator = lambda name, values: HostGroup(name, **values)
         self.hostgroups = self._create_raw_Object(self.dict[KEY_HOSTGROUPS], "Hostgroup", creator)
 
         creator = parsePeriodList
-        periods = self._create_raw_Object(self.dict[KEY_PERIODS], "Period", creator)
+        self.periods = self._create_raw_Object(self.dict[KEY_PERIODS], "Period", creator)
-
-        #1.1 get Tasks
-        creator = lambda name, values: self._load_module(name, MOD_TASKS).create(values).set_task_type(name)
-        tasks = self._create_raw_Object(self.dict[KEY_TASKS], "Task", creator)
-        taskList = TaskList(tasks)
-
 
         #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 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 member: member.get_tasks()
+        class_check = lambda task: isinstance(task, Task)
+        self.replace_with_import(self.members, MOD_TASKS, items_func, class_check)
+        tasks = []
+        for m in self.members:
+            tasks.extend(m.get_tasks())
+
         #replace object pointer
         id_list_func = lambda hostgroup: hostgroup.get_members()
-        id_get_func = lambda member: member.get_id()
+        id_get_func = lambda member: member.get_name()
-        self.replace_pointer(self.hostgroups, members, id_list_func, id_get_func)
+        self.replace_pointer(self.hostgroups, self.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)
+        self.replace_pointer(services, self.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)
+        self.replace_pointer(self.layouts, self.hostgroups, id_list_func, id_get_func)
 
         linConf = LinspectorConfig()
-        linConf.set_layouts(layouts)
+        linConf.set_layouts(self.layouts)
         linConf.set_hostgroups(self.hostgroups)
-        linConf.set_members(members)
+        linConf.set_members(self.members)
-        linConf.set_periods(periods)
+        linConf.set_periods(self.periods)
-        linConf.set_task_list(taskList)
 
-        for hg in self.hostgroups:
-            for service in hg.get_services():
-                service.set_hostgroup(hg)
         core = None
         if "core" in self.dict:
             core = self.dict["core"]

linspector/config/periods.py

@@ -30,8 +30,8 @@ class Period(object):
     def get_name(self):
         return self.name
         
-    def createJob(self, scheduler, jobInfo, func):
+    #def createJob(self, scheduler, jobInfo, func):
-        pass
+    #    pass
         
 
 class IntervalPeriod(Period):

linspector/core/job.py

@@ -28,13 +28,11 @@ logger = getLogger(__name__)
 
 
 class Job:
-    def __init__(self, service, host, members, processors, core, task_list, hostgroup):
+    def __init__(self, service, host, members, core, hostgroup):
         self.service = service
         self.host = host
         self.members = members
-        self.processors = processors
         self.core = core
-        self.task_list = task_list
         self.hostgroup = hostgroup
         self.job_infos = []
         self.job_index = -1
@@ -113,7 +111,10 @@ class Job:
 
     def handle_alarm(self):
         for member in self.members:
-            self.task_list.execute_task_infos(self.status + " " + self.get_message(), member.get_tasks())
+            for task in member.get_tasks():
+                task.execute(str(self.get_message()))
+                #print task
+                logger.info("DO TASK EXECUTION HERE! NOT IMPLEMENTED!")
 
     def handle_call(self):
         logger.debug("handle call")

linspector/services/etc/dummy.py

@@ -63,8 +63,8 @@ class DummyService(Service):
         if "fail" in args:
             self.fail = args["fail"]
 
-    def needs_arguments(self):
+    #def needs_arguments(self):
-        return False
+    #    return False
 
     def execute(self, job):
 

linspector/services/service.py

@@ -19,7 +19,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 
 from logging import getLogger
 
-KEY_PARSER    = "parser"
 KEY_COMMENT   = "comment"
 KEY_THRESHOLD = "threshold"
 KEY_FAILS     = "fails"
@@ -37,10 +36,6 @@ class Service(object):
             self.add_arguments(kwargs[KEY_ARGS])
         elif self.needs_arguments():
             raise Exception("Error: needs arguments but none provided!")
-
-        self._parser = []
-        if KEY_PARSER in kwargs:
-            self.add_parser(kwargs[KEY_PARSER])
         
         self._comment = None
         if KEY_COMMENT in kwargs:
@@ -61,8 +56,9 @@ class Service(object):
     def __str__(self):
         return self.get_name() + " " + repr(self._args)
 
-    def get_type(self):
+    #TODO: not used somewhere
-        return str(self.__class__)
+    #def get_service_type(self):
+    #    return str(self.__class__)
 
     def get_name(self):
         return self.__class__.__name__
@@ -70,10 +66,11 @@ class Service(object):
     def add_arguments(self, args):
         for key, val in args.items():
             self._args[key] = val
-            
+
-    def add_argument(self, key, value):
+    #TODO: not used somewhere
-        self._args[key] = value
+    #def add_argument(self, key, value):
-        
+    #    self._args[key] = value
+
     def get_arguments(self):
         return self._args
 
@@ -136,9 +133,6 @@ class Service(object):
             self._threshold -= 1
             raise e
 
-    ##def execute(self):
-    #    pass
-
     def pre_execute(self, job):
         pass
 

linspector/tasks/mail.py

@@ -35,40 +35,44 @@ logger = getLogger(__name__)
 
 class MailTask(Task):
     def __init__(self, **kwargs):
-        mandatory_args = ["host", "password", "from", "username"]
+        super(MailTask, self).__init__(**kwargs)
-        for arg in mandatory_args:
+
-            if not arg in kwargs:
+        args = self.get_arguments()
-                self.raise_config_exception(kwargs, arg)
+
-        self.host = kwargs["host"]
+        if "sender" in args:
-        self.password = kwargs["password"]
+            self.sender = args["sender"]
-        self.fromName = kwargs["from"]
+        else:
-        self.userName = kwargs["username"]
+            raise Exception("There is no sender set")
+
+        if "rcpt" in args:
+            self.rcpt = args["rcpt"]
+        else:
+            raise Exception("There is no rcpt set")
+
+        self.host = "localhost"
+        if "host" in args:
+            self.host = args["host"]
+
         self.port = 25
-        if "port" in kwargs:
+        if "port" in args:
-            self.port = kwargs["port"]
+            self.port = args["port"]
 
-        #self.set_task_type(kwargs["type"])
+        # ...and so on for all possible args
-        #self.recipient = kwargs["args"]["rcpt"]
-
-    def execute(self, msg, taskArgs):
-        #time.sleep(3)
-        if "rcpt" not in taskArgs:
-            logger.debug("Could not execute Mail Task! No recipient given!")
-            raise "Could not execute Mail Task! No recipient given!"
 
+    def execute(self, msg):
         logger.debug("Eecuting Task!")
 
         message = MIMEText(msg)
         message['Subject'] = msg
         now = datetime.datetime.now()
         message['Date'] = now.strftime("%a, %d %b %Y %H:%M:%S")
-        message['From'] = self.fromName
+        message['From'] = self.sender
-        message['To'] = taskArgs["rcpt"]
+        message['To'] = self.rcpt["rcpt"]
         s = smtplib.SMTP(self.host, self.port)
         #s.login(self.userName, self.password)
-        s.sendmail(self.fromName, taskArgs["rcpt"], message.as_string())
+        s.sendmail(self.sender, self.rcpt["rcpt"], message.as_string())
         s.quit()
 
 
-def create(taskDict):
+def create(kwargs):
-    return MailTask(**taskDict)
+    return MailTask(**kwargs)

linspector/tasks/task.py

@@ -22,25 +22,51 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 from logging import getLogger
 from threading import Event, Thread
 
+KEY_TYPE = "type"
+KEY_ARGS = "args"
 
 logger = getLogger(__name__)
 
 
 class Task:
-    def raise_config_exception(self, typeDict, name):
+    def __init__(self, **kwargs):
-        raise Exception("typeDict " + str(typeDict) + " has no " + str(name) + " argument!")
 
-    def set_task_type(self, taskType):
+        self._args = {}
-        self._taskType = taskType
+
-        return self
+        if KEY_ARGS in kwargs:
+            self.add_arguments(kwargs[KEY_ARGS])
+        elif self.needs_arguments():
+            raise Exception("Error: needs arguments but none provided!")
+
+        self._type = None
+        if KEY_TYPE in kwargs:
+            self._type = kwargs[KEY_TYPE]
 
     def get_task_type(self):
-        return self._taskType
+        return str(self.__class__)
 
-    def execute(self, msg, args):
+    def add_arguments(self, args):
-        pass
+        for key, val in args.items():
+            self._args[key] = val
+
+    def get_arguments(self):
+        return self._args
+
+    def set_member(self, member):
+        self.member = member
+
+    def needs_arguments(self):
+        return False
+
+    def execute(self, job):
+        try:
+            self.execute(job)
+        except Exception, e:
+            logger.debug("Task execute failed!!!")
+            raise e
 
 
+"""
 class TaskList(object):
     def __init__(self, tasks):
         self.tasks = tasks
@@ -74,4 +100,5 @@ class TaskList(object):
 
     def execute_task_infos(self, msg, taskInfos):
         self.taskInfos.append((msg, taskInfos))
-        self.event.set()
+        self.event.set()
+"""