omdnotificationforwarder 1.0.0.1__tar.gz

omdnotificationforwarder-1.0.0.1/.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.py[cod]
+dist
+sdist
+*.egg

omdnotificationforwarder-1.0.0.1/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: omdnotificationforwarder
+Version: 1.0.0.1
+Summary: A framework for notification scripts for OMD
+Project-URL: Homepage, https://github.com/lausser/noteventificationforhandlerwarder
+Project-URL: Bug Tracker, https://github.com/lausser/noteventificationforhandlerwarder/issues
+Author-email: Gerhard Lausser <lausser@yahoo.com>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Requires-Dist: coshsh
+Requires-Dist: jinja2
+Provides-Extra: test
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: pytest>=2.7.3; extra == 'test'
+Requires-Dist: unittest; extra == 'test'
+Description-Content-Type: text/markdown
+
+# noteventificationforhandlerwarder
+Frickel für Notifications und Eventhandler

omdnotificationforwarder-1.0.0.1/README.md

@@ -0,0 +1,2 @@
+# noteventificationforhandlerwarder
+Frickel für Notifications und Eventhandler

omdnotificationforwarder-1.0.0.1/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["hatchling", "coshsh"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build]
+include = [
+    "src/**/*.py",
+    "/tests",
+]
+exclude = [
+    "__pacache__/",
+    "**/.pyc",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/notificationforwarder"]
+
+[project]
+name = "omdnotificationforwarder"
+version = "1.0.0.1"
+authors = [
+  { name="Gerhard Lausser", email="lausser@yahoo.com" },
+]
+description = "A framework for notification scripts for OMD"
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "coshsh",
+    "jinja2",
+]
+
+[project.optional-dependencies]
+test = [
+    "unittest",
+    "pytest >= 2.7.3",
+    "pytest-cov",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/lausser/noteventificationforhandlerwarder"
+"Bug Tracker" = "https://github.com/lausser/noteventificationforhandlerwarder/issues"
+
+[tool.pytest.ini_options]
+addopts = "-ra -q --import-mode=importlib"
+pythonpath = [
+    "src/"
+]
+testpaths = [
+    "tests",
+]

omdnotificationforwarder-1.0.0.1/src/notificationforwarder/baseclass.py

@@ -0,0 +1,365 @@
+from abc import ABCMeta, abstractmethod
+from importlib import import_module
+import os
+import socket
+import traceback
+import signal
+import functools
+import errno
+import fcntl
+import time
+try:
+    import simplejson as json
+except ImportError:
+    import json
+from importlib import import_module
+from importlib.util import find_spec, module_from_spec
+
+import sqlite3
+import logging
+from coshsh.util import setup_logging
+
+
+MAXAGE = 5
+
+
+logger = None
+
+def new(target_name, tag, verbose, debug, receiveropts):
+
+    if verbose:
+        scrnloglevel = logging.INFO
+    else:
+        scrnloglevel = 100
+    if debug:
+        scrnloglevel = logging.DEBUG
+        txtloglevel = logging.DEBUG
+    else:
+        txtloglevel = logging.INFO
+    if tag:
+        logger_name = "notificationforwarder_"+target_name+"_"+tag
+    else:
+        logger_name = "notificationforwarder_"+target_name
+
+    setup_logging(logdir=os.environ["OMD_ROOT"]+"/var/log", logfile=logger_name+".log", scrnloglevel=scrnloglevel, txtloglevel=txtloglevel, format="%(asctime)s %(process)d - %(levelname)s - %(message)s")
+    logger = logging.getLogger(logger_name)
+    try:
+        if '.' in target_name:
+            module_name, class_name = target_name.rsplit('.', 1)
+        else:
+            module_name = target_name
+            class_name = target_name.capitalize()
+        forwarder_module = import_module('notificationforwarder.'+module_name+'.forwarder', package='notificationforwarder.'+module_name)
+        forwarder_class = getattr(forwarder_module, class_name)
+
+        instance = forwarder_class(receiveropts)
+        instance.__module_file__ = forwarder_module.__file__
+        instance.name = target_name
+        if tag:
+            instance.tag = tag
+        # so we can use logger.info(...) in the single modules
+        forwarder_module.logger = logging.getLogger(logger_name)
+        base_module = import_module('.baseclass', package='notificationforwarder')
+        base_module.logger = logging.getLogger(logger_name)
+
+    except Exception as e:
+        raise ImportError('{} is not part of our forwarder collection!'.format(target_name))
+    else:
+        if not issubclass(forwarder_class, NotificationForwarder):
+            raise ImportError("We currently don't have {}, but you are welcome to send in the request for it!".format(forwarder_class))
+
+    return instance
+
+class ForwarderTimeoutError(Exception):
+    pass
+
+def timeout(seconds, error_message="Timeout"):
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            def handler(signum, frame):
+                raise ForwarderTimeoutError(error_message)
+
+            original_handler = signal.signal(signal.SIGALRM, handler)
+            signal.alarm(seconds)
+            try:
+                result = func(*args, **kwargs)
+            finally:
+                signal.signal(signal.SIGALRM, original_handler)
+                signal.alarm(0)
+            return result
+        return wrapper
+    return decorator
+
+
+class NotificationForwarder(object):
+    """This is the base class where all Forwardes inherit from"""
+    __metaclass__ = ABCMeta # replace with ...BaseClass(metaclass=ABCMeta):
+
+    def __init__(self, opts):
+        self.queued_events = []
+        self.max_queue_length = 10
+        self.sleep_after_flush = 0
+        self.baseclass_logs_summary = True
+        for opt in opts:
+            setattr(self, opt, opts[opt])
+
+    def probe(self):
+        """Checks if a forwarder is principally able to submit an event.
+        It is mostly used to contact an api and confirm that it is alive.
+        After failed attempts, when there are spooled events in the database,
+        a call to probe() can tell the forwarder that the events now can
+        be flushed.
+        """
+        return True
+
+    def init_queue(self, maxlength=10, sleepttime=0):
+        self.max_queue_length = maxlength
+        self.sleep_after_flush = sleepttime
+
+    def flush_queue(self):
+        if not getattr(self, "can_queue", False):
+            logger.critical("forwarder {} can not flush_queue events".format(self.__class__.__name__.lower()))
+            return
+        logger.debug("flush remaining {}".format(len(self.queued_events)))
+        if self.queued_events:
+            formatted_squashed_event = self.squash_queued_events()
+            logger.debug("merge {} queued events and flush".format(len(self.queued_events)))
+            self.forward_formatted(formatted_squashed_event)
+            self.queued_events = []
+            time.sleep(self.sleep_after_flush)
+
+
+    def forward_queued(self, raw_event):
+        if not getattr(self, "can_queue", False):
+            logger.critical("forwarder {} can not queue events".format(self.__class__.__name__.lower()))
+            return
+        try:
+            formatted_event = self.format_event(raw_event)
+            if formatted_event:
+                self.queued_events.append(formatted_event)
+        except Exception as e:
+            logger.critical("formatter error: "+str(e))
+        if len(self.queued_events) >= self.max_queue_length:
+            formatted_squashed_event = self.squash_queued_events()
+            logger.debug("merge {} queued events and flush".format(self.max_queue_length))
+            self.forward_formatted(formatted_squashed_event)
+            self.queued_events = []
+
+    def squash_queued_events(self):
+        instance = self.formatter()
+        return instance.squash_queued_events(self.queued_events)
+        return None
+
+    def forward(self, raw_event):
+        self.initdb()
+        try:
+            if not "omd_site" in raw_event:
+                raw_event["omd_site"] = os.environ.get("OMD_SITE", "get https://omd.consol.de/docs/omd")
+            raw_event["originating_host"] = socket.gethostname()
+            raw_event["originating_fqdn"] = socket.getfqdn()
+            formatted_event = self.format_event(raw_event)
+            if not hasattr(formatted_event, "payload") and not hasattr(formatted_event, "summary"):
+                logger.critical("a formatted event must have the attributes payload and summary")
+                formatted_event = None
+        except Exception as e:
+            logger.critical("formatter error: "+str(e))
+            formatted_event = None
+
+        self.forward_formatted(formatted_event)
+
+    def forward_formatted(self, formatted_event):
+        try:
+            if self.probe():
+                self.flush()
+        except Exception as e:
+            logger.critical("flush probe failed with exception <{}>")
+
+        format_exception_msg = None
+        try:
+            if formatted_event == None:
+                success = True
+            else:
+                success = self.submit(formatted_event)
+        except Exception as e:
+            success = False
+            format_exception_msg = str(e)
+
+        if success:
+            if self.baseclass_logs_summary:
+                logger.info("forwarded {}".format(formatted_event.summary))
+        else:
+            if format_exception_msg:
+                logger.critical("forward failed with exception <{}>, spooled <{}>".format(format_exception_msg, formatted_event.summary))
+            elif self.baseclass_logs_summary:
+                logger.warning("forward failed, spooled {}".format(formatted_event.summary))
+            self.spool(formatted_event)
+
+    def formatter(self):
+        try:
+            module_name = self.__class__.__name__.lower()
+            class_name = self.__class__.__name__+"Formatter"
+            formatter_module = import_module('.formatter', package='notificationforwarder.'+module_name)
+            formatter_module.logger = logger
+            formatter_class = getattr(formatter_module, class_name)
+            instance = formatter_class()
+            instance.__module_file__ = formatter_module.__file__
+            return instance
+        except ImportError:
+            logger.debug("there is no module "+module_name)
+            return None
+        except Exception as e:
+            logger.critical("formatter error: "+str(e))
+            return None
+
+    def format_event(self, raw_event):
+        instance = self.formatter()
+        return instance.format_event(raw_event)
+
+    def connect(self):
+        return True
+
+    def disconnect(self):
+        return True
+
+    def initdb(self):
+        db_file = os.environ["OMD_ROOT"] + '/var/tmp/' + self.name + '-notifications.db'
+        self.table_name = "events_"+self.name
+        sql_create = """CREATE TABLE IF NOT EXISTS """+self.table_name+""" (
+                id INTEGER PRIMARY KEY,
+                payload TEXT NOT NULL,
+                summary TEXT NOT NULL,
+                timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL
+            )"""
+        try:
+            self.dbconn = sqlite3.connect(db_file)
+            self.dbcurs = self.dbconn.cursor()
+            self.dbcurs.execute(sql_create)
+            self.dbconn.commit()
+        except Exception as e:
+            logger.info("error initializing database {}: {}".format(db_file, str(e)))
+
+    def num_spooled_events(self):
+        sql_count = "SELECT COUNT(*) FROM "+self.table_name
+        spooled_events = 999999999
+        try:
+            self.dbcurs.execute(sql_count)
+            spooled_events = self.dbcurs.fetchone()[0]
+        except Exception as e:
+            logger.critical("database error "+str(e))
+        return spooled_events
+
+
+    def spool(self, event):
+        sql_insert = "INSERT INTO "+self.table_name+"(payload, summary) VALUES (?, ?)"
+        try:
+            num_spooled_events = 0
+            if type(event.payload) != list:
+                text = json.dumps(event.payload)
+                summary = event.summary
+                self.dbcurs.execute(sql_insert, (text, summary))
+                self.dbconn.commit()
+                # has already been logged in forward_formatted
+                # logger.warning("spooled "+summary)
+                num_spooled_events += 1
+            else:
+                for subevent in event.payload:
+                    text = json.dumps(subevent)
+                    summary = event.summary.pop(0)
+                    sefl.dbcurs.execute(sql_insert, (text, summary))
+                    self.dbconn.commit()
+                    log.warning("spooled "+summary)
+                    num_spooled_events += 1
+            spooled_events = self.num_spooled_events()
+            logger.warning("spooling queue length is {}".format(spooled_events))
+        except Exception as e:
+            logger.critical("database error "+str(e))
+            logger.info(event.__dict__)
+
+    def flush(self):
+        sql_delete = "DELETE FROM "+self.table_name+" WHERE CAST(STRFTIME('%s', timestamp) AS INTEGER) < ?"
+        sql_count = "SELECT COUNT(*) FROM "+self.table_name
+        sql_select = "SELECT id, payload, summary FROM "+self.table_name+" ORDER BY id LIMIT 10"
+        sql_delete_id = "DELETE FROM "+self.table_name+" WHERE id = ?"
+        with open(os.environ["OMD_ROOT"]+"/tmp/"+self.name+"-flush.lock", "w") as lock_file:
+            try:
+                fcntl.lockf(lock_file, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                logger.debug("flush lock set")
+                locked = True
+            except IOError as e:
+                logger.debug("flush lock failed: "+str(e))
+                locked = False
+            if locked:
+                try:
+                    outdated = int(time.time() - 60*MAXAGE)
+                    self.dbcurs.execute(sql_delete, (outdated,))
+                    dropped = self.dbcurs.rowcount
+                    if dropped:
+                        logger.info("dropped {} outdated events".format(dropped))
+                    last_spooled_events = 0
+                    while True:
+                        self.dbcurs.execute(sql_count)
+                        spooled_events = self.dbcurs.fetchone()[0]
+                        if spooled_events:
+                            logger.info("there are {} spooled events to be re-sent".format(spooled_events))
+                        else:
+                            break
+                        if last_spooled_events == spooled_events:
+                            if spooled_events != 0:
+                                logger.critical("{} spooled events could not be submitted".format(last_spooled_events))
+                            break
+                        else:
+                            self.dbcurs.execute(sql_select)
+                            id_events = self.dbcurs.fetchall()
+                            for id, payload, summary in id_events:
+                                event = FormattedEvent()
+                                event.is_heartbeat = False
+                                event.payload = json.loads(payload)
+                                event.summary = summary
+                                if self.submit(event):
+                                    self.dbcurs.execute(sql_delete_id, (id, ))
+                                    logger.info("delete spooled event {}".format(id))
+                                    self.dbconn.commit()
+                                else:
+                                    logger.critical("event {} spooled again".format(id))
+                            last_spooled_events = spooled_events
+                    self.dbconn.commit()
+                except Exception as e:
+                    logger.critical("database flush failed")
+                    logger.critical(e)
+            else:
+                logger.debug("missed the flush lock")
+
+    def no_more_logging(self):
+        # this is called in the forwarder. If the forwarder already wrote
+        # it's own logs and writing the summary by the baseclass is not
+        # desired.
+        self.baseclass_logs_summary = False
+
+    def __del__(self):
+        try:
+            if self.dbcursor:
+                self.dbcursor.close()
+            if self.dbconn:
+                self.dbconn.commit()
+                self.dbconn.close()
+        except Exception as a:
+            # don't care, we're finished anyway
+            pass
+    
+class NotificationFormatter(metaclass=ABCMeta):
+    @abstractmethod
+    def format_event(self):
+        pass
+
+
+class FormattedEvent(metaclass=ABCMeta):
+    def __init__(self):
+        self.payload = None
+        self.summary = "empty event"
+
+    def set_payload(self, payload):
+        self.payload = payload
+
+    def set_summary(self, summary):
+        self.summary = summary

omdnotificationforwarder-1.0.0.1/src/notificationforwarder/example/formatter.py

@@ -0,0 +1,18 @@
+import time
+import os
+from notificationforwarder.baseclass import NotificationFormatter, FormattedEvent
+
+class ExampleFormatter(NotificationFormatter):
+
+    def format_event(self, raw_event):
+        event = FormattedEvent()
+        json_payload = {
+            'timestamp': time.time(),
+        }
+        json_payload['description'] = raw_event['description']
+        if 'signature' in raw_event:
+            json_payload['signature'] = raw_event['signature']
+        event.set_payload(json_payload)
+        event.set_summary("sum: "+json_payload['description'])
+        return event
+

omdnotificationforwarder-1.0.0.1/src/notificationforwarder/example/forwarder.py

@@ -0,0 +1,36 @@
+import json
+import time
+import logging
+from notificationforwarder.baseclass import NotificationForwarder, NotificationFormatter, timeout
+
+
+class Example(NotificationForwarder):
+    def __init__(self, opts):
+        super(self.__class__, self).__init__(opts)
+        setattr(self, "username", getattr(self, "username", "guest"))
+        setattr(self, "delay", int(getattr(self, "delay", 0)))
+        setattr(self, "fail", getattr(self, "fail", None))
+        setattr(self, "signaturefile", getattr(self, "signaturefile", "/tmp/notificationforwarder_example.txt"))
+        self.parameter = "sample"
+
+    @timeout(2, error_message="submit ran into a timeout")
+    def submit(self, event):
+        time.sleep(self.delay)
+        if True: # for example if self.connect()
+            try:
+                logger.info("{} submits {}".format(self.username, event.__dict__))
+                if self.fail:
+                    logger.critical("sample api does not accept the payload")
+                    return False
+                elif "signature" in event.payload:
+                    with open(self.signaturefile, "a") as f:
+                        print(event.payload["signature"], file=f)
+                    return True
+                else:
+                    return True
+            except Exception as e:
+                logger.critical("sample api post had an exception: {} with payload {}".format(str(e), str(event.payload)))
+                return False
+        else:
+           logger.critical("could not connect to the ticket system")
+           return False

omdnotificationforwarder-1.0.0.1/src/notificationforwarder/rabbitmq/formatter.py

@@ -0,0 +1,29 @@
+import time
+import os
+from notificationforwarder.baseclass import NotificationFormatter, FormattedEvent
+
+class RabbitmqFormatter(NotificationFormatter):
+
+    def format_event(self, raw_event):
+        event = FormattedEvent()
+        print("formatter ", event.__dict__)
+        print("formatter ", self.__dict__)
+        print("formatter ", raw_event)
+        json_payload = {
+            'omd_site': os.environ["OMD_SITE"],
+            'platform': 'Naemon',
+            'host_name': raw_event["HOSTNAME"],
+            'notification_type': raw_event["NOTIFICATIONTYPE"],
+            'timestamp': time.time(),
+        }
+        if "SERVICEDESC" in raw_event:
+            json_payload['service_description'] = raw_event['service_description']
+            json_payload['state'] = raw_event["state"]
+            json_payload['output'] = raw_event["output"]
+        else:
+            json_payload['state'] = raw_event["state"]
+            json_payload['output'] = raw_event["output"]
+        event.set_payload(json_payload)
+        event.set_summary(json_payload)
+        return event
+

omdnotificationforwarder-1.0.0.1/src/notificationforwarder/rabbitmq/forwarder.py

@@ -0,0 +1,58 @@
+import pika
+import json
+import logging
+from notificationforwarder.baseclass import NotificationForwarder, NotificationFormatter, timeout
+
+
+class Rabbitmq(NotificationForwarder):
+    def __init__(self, opts):
+        super(self.__class__, self).__init__(opts)
+        setattr(self, "port", int(getattr(self, "port", 5672)))
+        setattr(self, "server", getattr(self, "server", "localhost"))
+        setattr(self, "vhost", getattr(self, "vhost", "/"))
+        setattr(self, "queue", getattr(self, "queue", "AE"))
+        setattr(self, "username", getattr(self, "username", "guest"))
+        setattr(self, "password", getattr(self, "password", "guest"))
+
+        credentials = pika.PlainCredentials(self.username, self.password)
+        self.connectionparameters = pika.ConnectionParameters(self.server, self.port, self.vhost, credentials)
+
+    def connect(self):
+        try:
+            self.connection = pika.BlockingConnection(self.connectionparameters)
+            self.channel = self.connection.channel()
+            self.channel.queue_declare(queue=self.queue, durable=True)
+            logger.debug('Connected to {}:{}'.format(
+                self.connectionparameters.host,
+                self.connectionparameters.port))
+            return True
+        except Exception as e:
+            logger.critical("connect said: "+ str(e))
+            return False
+
+    def disconnect():
+        try:
+            self.connection.close()
+        except Exception as e:
+            pass
+
+    @timeout(30)
+    def submit(self, payload):
+        if self.connect():
+            try:
+                logger.info("submit "+payload)
+                self.channel = self.connection.channel()
+                self.channel.queue_declare(queue=self.queue, durable=True)
+                for event in payload:
+                    if "service_description" in event:
+                        logger.info("host: {}, service: {}, state: {}, output: {}".format(event["host_name"], event["service_description"], event["state"], event["output"]))
+                    else:
+                        logger.info("host: {}, state: {}, output: {}".format(event["host_name"], event["state"], event["output"]))
+                    logger.debug(json.dumps(event))
+                    self.channel.basic_publish(exchange='', routing_key=MQQUEUE, body=json.dumps(event))
+                return True
+            except Exception as e:
+                logger.critical("rabbitmq post had an exception: {} wit payload {}".format(str(e), str(payload)))
+                return False
+    
+

omdnotificationforwarder-1.0.0.1/src/notificationforwarder/syslog/formatter.py

@@ -0,0 +1,10 @@
+from notificationforwarder.baseclass import NotificationFormatter, FormattedEvent
+
+class SyslogFormatter(NotificationFormatter):
+
+    def format_event(self, raw_event):
+        if "service_description" in raw_event:
+            return("host: {}, service: {}, state: {}, output: {}".format(raw_event["host_name"], raw_event["service_description"], raw_event["state"], raw_event["output"]))
+        else:
+            return("host: {}, state: {}, output: {}".format(raw_event["host_name"], raw_event["state"], raw_event["output"]))
+

omdnotificationforwarder-1.0.0.1/src/notificationforwarder/syslog/forwarder.py

@@ -0,0 +1,42 @@
+import syslog
+import logging
+from notificationforwarder.baseclass import NotificationForwarder, NotificationFormatter, timeout
+
+
+class Syslog(NotificationForwarder):
+    def __init__(self, opts):
+        super(self.__class__, self).__init__(opts)
+        setattr(self, "port", int(getattr(self, "port", 514)))
+        setattr(self, "server", getattr(self, "server", "localhost"))
+        setattr(self, "facility", getattr(self, "facility", "log_local0"))
+        setattr(self, "priority", getattr(self, "priority", "info"))
+        if self.facility in logging.handlers.SysLogHandler.facility_names:
+            self.facility = logging.handlers.SysLogHandler.facility_names[self.facility]
+        elif "log_"+self.facility in known_facilities:
+            self.facility = logging.handlers.SysLogHandler.facility_names["log_"+self.facility]
+        else:
+            self.facility = logging.handlers.SysLogHandler.LOG_DAEMON
+        if self.priority in logging.handlers.SysLogHandler.priority_names:
+            self.priority = logging.handlers.SysLogHandler.priority_names[self.priority]
+        elif "log_"+self.priority in logging.handlers.SysLogHandler.priority_names:
+            self.priority = logging.handlers.SysLogHandler.priority_names["log_"+self.priority]
+        else:
+            self.priority = logging.handlers.SysLogHandler.LOG_INFO
+        self.syslogger = logging.getLogger('Syslogger')
+        # do not suppress anything. (normal logger and syslog have
+        # completely different levels. setLevel(NOTSET) does not work.
+        self.syslogger.setLevel(-1)
+        handler = logging.handlers.SysLogHandler(address=(self.server, self.port), facility=self.facility)
+        self.syslogger.addHandler(handler)
+
+    @timeout(30)
+    def submit(self, payload):
+        try:
+            logger.info("submit "+payload)
+            self.syslogger.log(self.priority, payload)
+            return True
+        except Exception as e:
+            logger.critical("syslog forwarding had an error: {}".format(str(e)))
+            return False
+
+

omdnotificationforwarder-1.0.0.1/tests/pythonpath/lib/python/notificationforwarder/split1/forwarder.py

@@ -0,0 +1,13 @@
+from notificationforwarder.baseclass import NotificationForwarder, NotificationFormatter, timeout
+
+
+class Split1(NotificationForwarder):
+    def __init__(self, opts):
+        super(self.__class__, self).__init__(opts)
+        self.url = "https://split1.com"
+
+    @timeout(30)
+    def submit(self, payload):
+        logger.info("forwarder "+self.__module_file__)
+        return True
+

omdnotificationforwarder-1.0.0.1/tests/pythonpath/lib/python/notificationforwarder/split2/formatter.py

@@ -0,0 +1,14 @@
+from notificationforwarder.baseclass import NotificationFormatter, FormattedEvent
+
+
+class Split2Formatter(NotificationFormatter):
+
+    def __init__(self):
+        pass
+
+    def format_event(self, raw_event):
+        logger.info("formatter "+self.__module_file__)
+        event = FormattedEvent()
+        event.payload = str(raw_event)
+        event.summary = "_".join(["{}={}".format(k, raw_event) for k in raw_event])
+        return event

omdnotificationforwarder-1.0.0.1/tests/pythonpath/lib/python/notificationforwarder/split2/forwarder.py

@@ -0,0 +1,13 @@
+from notificationforwarder.baseclass import NotificationForwarder, NotificationFormatter, timeout
+
+
+class Split2(NotificationForwarder):
+    def __init__(self, opts):
+        super(self.__class__, self).__init__(opts)
+        self.url = "https://split1.com"
+
+    @timeout(30)
+    def submit(self, payload):
+        logger.info("forwarder "+self.__module_file__)
+        return True
+

omdnotificationforwarder-1.0.0.1/tests/pythonpath/lib/python/notificationforwarder/split3/formatter.py

@@ -0,0 +1,14 @@
+from notificationforwarder.baseclass import NotificationFormatter, FormattedEvent
+
+
+class Split3Formatter(NotificationFormatter):
+
+    def __init__(self):
+        pass
+
+    def format_event(self, raw_event):
+        logger.info("formatter "+self.__module_file__)
+        event = FormattedEvent()
+        event.payload = str(raw_event)
+        event.summary = "_".join(["{}={}".format(k, raw_event) for k in raw_event])
+        return event

omdnotificationforwarder-1.0.0.1/tests/pythonpath/lib/python/notificationforwarder/split3/forwarder.py

@@ -0,0 +1,13 @@
+from notificationforwarder.baseclass import NotificationForwarder, NotificationFormatter, timeout
+
+
+class Split3(NotificationForwarder):
+    def __init__(self, opts):
+        super(self.__class__, self).__init__(opts)
+        self.url = "https://split1.com"
+
+    @timeout(30)
+    def submit(self, payload):
+        logger.info("forwarder "+self.__module_file__)
+        return True
+

omdnotificationforwarder-1.0.0.1/tests/pythonpath/local/lib/python/notificationforwarder/split1/formatter.py

@@ -0,0 +1,14 @@
+from notificationforwarder.baseclass import NotificationFormatter, FormattedEvent
+
+
+class Split1Formatter(NotificationFormatter):
+
+    def __init__(self):
+        pass
+
+    def format_event(self, raw_event):
+        logger.info("formatter "+self.__module_file__)
+        event = FormattedEvent()
+        event.payload = str(raw_event)
+        event.summary = "_".join(["{}={}".format(k, raw_event) for k in raw_event])
+        return event

omdnotificationforwarder-1.0.0.1/tests/pythonpath/local/lib/python/notificationforwarder/split2/forwarder.py

@@ -0,0 +1,13 @@
+from notificationforwarder.baseclass import NotificationForwarder, NotificationFormatter, timeout
+
+
+class Split2(NotificationForwarder):
+    def __init__(self, opts):
+        super(self.__class__, self).__init__(opts)
+        self.url = "https://split1.com"
+
+    @timeout(30)
+    def submit(self, payload):
+        logger.info("forwarder "+self.__module_file__)
+        return True
+

omdnotificationforwarder-1.0.0.1/tests/pythonpath/local/lib/python/notificationforwarder/split3/formatter.py

@@ -0,0 +1,14 @@
+from notificationforwarder.baseclass import NotificationFormatter, FormattedEvent
+
+
+class Split3Formatter(NotificationFormatter):
+
+    def __init__(self):
+        pass
+
+    def format_event(self, raw_event):
+        logger.info("formatter "+self.__module_file__)
+        event = FormattedEvent()
+        event.payload = str(raw_event)
+        event.summary = "_".join(["{}={}".format(k, raw_event) for k in raw_event])
+        return event

omdnotificationforwarder-1.0.0.1/tests/pythonpath/local/lib/python/notificationforwarder/split3/forwarder.py

@@ -0,0 +1,13 @@
+from notificationforwarder.baseclass import NotificationForwarder, NotificationFormatter, timeout
+
+
+class Split3(NotificationForwarder):
+    def __init__(self, opts):
+        super(self.__class__, self).__init__(opts)
+        self.url = "https://split1.com"
+
+    @timeout(30)
+    def submit(self, payload):
+        logger.info("forwarder "+self.__module_file__)
+        return True
+

omdnotificationforwarder-1.0.0.1/tests/test_classes.py

@@ -0,0 +1,185 @@
+import pytest
+import os
+import re
+import shutil
+import hashlib, secrets
+import notificationforwarder
+import logging
+
+
+def _setup():
+    omd_root = os.path.dirname(__file__)
+    os.environ["OMD_ROOT"] = omd_root
+    shutil.rmtree(omd_root+"/var", ignore_errors=True)
+    os.makedirs(omd_root+"/var/log", 0o755)
+    shutil.rmtree(omd_root+"/var", ignore_errors=True)
+    os.makedirs(omd_root+"/var/tmp", 0o755)
+    shutil.rmtree(omd_root+"/tmp", ignore_errors=True)
+    os.makedirs(omd_root+"/tmp", 0o755)
+    if os.path.exists("/tmp/notificationforwarder_example.txt"):
+        os.remove("/tmp/notificationforwarder_example.txt")
+
+@pytest.fixture
+def setup():
+    _setup()
+    yield
+
+def get_logfile(forwarder):
+    logger_name = "notificationforwarder_"+forwarder.name
+    logger = logging.getLogger(logger_name)
+    return [h.baseFilename for h in logger.handlers if hasattr(h, "baseFilename")][0]
+
+
+def test_example_forwarder(setup):
+    reveiveropts = {
+        "username": "i_bims",
+        "password": "dem_is_geheim"
+    }
+    example = notificationforwarder.baseclass.new("example", None, True, True,  reveiveropts)
+    assert example.__class__.__name__ == "Example"
+    assert example.password == "dem_is_geheim"
+    assert example.queued_events == []
+
+
+def _test_example_formatter(setup):
+    example = notificationforwarder.baseclass.new("example", None, True, True,  {})
+    fexample = example.formatter()
+    assert fexample.__class__.__name__ == "ExampleFormatter"
+
+
+def test_example_logging(setup):
+    example = notificationforwarder.baseclass.new("example", None, True, True,  {})
+    logger_name = "notificationforwarder_"+example.name
+    logger = logging.getLogger(logger_name)
+    assert logger != None
+    assert logger.name == "notificationforwarder_example"
+    assert len([h for h in logger.handlers]) == 2
+    logfile = [h.baseFilename for h in logger.handlers if hasattr(h, "baseFilename")][0]
+    assert logfile.endswith("notificationforwarder_example.log")
+
+    example = notificationforwarder.baseclass.new("example", "2", True, True,  {})
+    logger_name = "notificationforwarder_"+example.name+"_"+example.tag
+    logger = logging.getLogger(logger_name)
+    assert logger != None
+    assert logger.name == "notificationforwarder_example_2"
+    assert len(logger.handlers) == 2
+    logfile = [h.baseFilename for h in logger.handlers if hasattr(h, "baseFilename")][0]
+    assert logfile.endswith("notificationforwarder_example_2.log")
+    
+
+def _test_example_formatter_format_event(setup):
+    example = notificationforwarder.baseclass.new("example", None, True, True,  {})
+    fexample = example.formatter()
+    raw_event = {
+        "description": "halo i bims 1 alarm vong naemon her",
+    }
+    event = fexample.format_event(raw_event)
+    assert event.summary == "this is an example"
+    assert event.payload["description"] == "halo i bims 1 alarm vong naemon her"
+    assert event.payload["timestamp"] == pytest.approx(time.time(), abs=5)
+
+
+def test_example_forwarder_forward(setup):
+    reveiveropts = {
+        "username": "i_bims",
+        "password": "i_bims_1_i_bims",
+    }
+    eventopts = {
+        "description": "halo i bims 1 alarm vong naemon her",
+    }
+    example = notificationforwarder.baseclass.new("example", None, True, True,  reveiveropts)
+    example.forward(eventopts)
+    log = open(get_logfile(example)).read()
+    assert "INFO - i_bims submits" in log
+    assert "'description': 'halo i bims 1 alarm vong naemon her'" in log
+    # this is the global log, written by the baseclass
+    assert "INFO - forwarded sum: halo i bims 1 alarm vong naemon her" in log
+
+    _setup() # delete logfile
+    # we need to reinitialize, because the logger has the (deleted) file
+    # still open and further writes would end up in nirvana.
+    example = notificationforwarder.baseclass.new("example", None, True, True,  reveiveropts)
+    eventopts = {
+        "description": "halo i bims 1 alarm vong naemon her again",
+    }
+    example.no_more_logging()
+    example.forward(eventopts)
+    log = open(get_logfile(example)).read()
+    # the formatter's logs are still there
+    assert "INFO - i_bims submits" in log
+    assert "'description': 'halo i bims 1 alarm vong naemon her again'" in log
+    # but not the baseclasse's log
+    assert "INFO - forwarded sum: halo i bims 1 alarm vong naemon her" not in log
+
+def test_example_forwarder_forward_success(setup):
+    reveiveropts = {
+        "username": "i_bims",
+        "password": "i_bims_1_i_bims",
+    }
+    signature = hashlib.sha256(secrets.token_bytes(32)).hexdigest()
+    eventopts = {
+        "description": "halo i bims 1 alarm vong naemon her",
+        "signature": signature,
+    }
+    example = notificationforwarder.baseclass.new("example", None, True, True,  reveiveropts)
+    example.forward(eventopts)
+    assert os.path.exists(example.signaturefile)
+    sig = open(example.signaturefile).read().strip()
+    assert sig == signature
+
+def test_example_forwarder_forward_timeout(setup):
+    signatures = [
+        hashlib.sha256(secrets.token_bytes(32)).hexdigest(),
+        hashlib.sha256(secrets.token_bytes(32)).hexdigest(),
+        hashlib.sha256(secrets.token_bytes(32)).hexdigest(),
+    ]
+    reveiveropts = {
+        "username": "i_bims",
+        "password": "i_bims_1_i_bims",
+        "delay": 60,
+    }
+    eventopts = {
+        "description": "halo i bims 1 alarm vong naemon her",
+        "signature": signatures[0],
+    }
+    example = notificationforwarder.baseclass.new("example", None, True, True,  reveiveropts)
+    example.forward(eventopts)
+    log = open(get_logfile(example)).read()
+    # this is the global log, written by the baseclass
+    assert "submit ran into a timeout" in log
+    assert "spooled <sum: halo i bims 1 alarm vong naemon her>" in log
+    assert "WARNING - spooling queue length is 1" in log
+    eventopts = {
+        "description": "halo i bim au 1 alarm vong naemon her",
+        "signature": signatures[1],
+    }
+    example = notificationforwarder.baseclass.new("example", None, True, True,  reveiveropts)
+    example.forward(eventopts)
+    log = open(get_logfile(example)).read()
+    assert "spooled <sum: halo i bim au 1 alarm vong naemon her>" in log
+    assert "WARNING - spooling queue length is 2" in log
+
+    # now the last two events were spooled and are in the database
+    reveiveropts = {
+        "username": "i_bims",
+        "password": "i_bims_1_i_bims",
+        "delay": 0,
+    }
+    eventopts = {
+        "description": "i druecke dem spuelung",
+        "signature": signatures[2],
+    }
+    example = notificationforwarder.baseclass.new("example", None, True, True,  reveiveropts)
+    example.forward(eventopts)
+    log = open(get_logfile(example)).read()
+    assert re.search(r'.*i_bims submits.*i druecke dem spuelung.*', log, re.MULTILINE)
+    assert "forwarded sum: i druecke dem spuelung" in log
+    assert "DEBUG - flush lock set" in log
+    assert "INFO - there are 2 spooled events to be re-sent" in log
+    assert "INFO - delete spooled event 1" in log
+    assert "INFO - delete spooled event 2" in log
+    assert re.search(r'.*i_bims submits.*halo i bims 1 alarm vong naemon her.*', log, re.MULTILINE)
+    assert re.search(r'.*i_bims submits.*halo i bim au 1 alarm vong naemon her.*', log, re.MULTILINE)
+    sigs = [l.strip() for l in open(example.signaturefile).readlines()]
+    # flushing first, then the new event
+    assert sigs == signatures

omdnotificationforwarder-1.0.0.1/tests/test_package.py

@@ -0,0 +1,7 @@
+import pytest
+
+def test_import():
+    import notificationforwarder
+    assert hasattr(notificationforwarder, "baseclass")
+    assert hasattr(notificationforwarder.baseclass, "new")
+

omdnotificationforwarder-1.0.0.1/tests/test_paths.py

@@ -0,0 +1,121 @@
+import pytest
+import inspect
+import sys
+import os
+import re
+import shutil
+import hashlib, secrets
+import logging
+
+omd_root = os.path.dirname(__file__)
+os.environ["OMD_ROOT"] = omd_root
+if not [p for p in sys.path if "pythonpath" in p]:
+    sys.path.append(os.environ["OMD_ROOT"]+"/pythonpath/local/lib/python")
+    sys.path.append(os.environ["OMD_ROOT"]+"/pythonpath/lib/python")
+    print("PYTHONPATH="+":".join(sys.path))
+import notificationforwarder.baseclass
+
+
+def _setup():
+    omd_root = os.path.dirname(__file__)
+    os.environ["OMD_ROOT"] = omd_root
+    shutil.rmtree(omd_root+"/var", ignore_errors=True)
+    os.makedirs(omd_root+"/var/log", 0o755)
+    shutil.rmtree(omd_root+"/var", ignore_errors=True)
+    os.makedirs(omd_root+"/var/tmp", 0o755)
+    shutil.rmtree(omd_root+"/tmp", ignore_errors=True)
+    os.makedirs(omd_root+"/tmp", 0o755)
+    if os.path.exists("/tmp/notificationforwarder_example.txt"):
+        os.remove("/tmp/notificationforwarder_example.txt")
+
+@pytest.fixture
+def setup():
+    _setup()
+    yield
+
+def get_logfile(forwarder):
+    logger_name = "notificationforwarder_"+forwarder.name
+    logger = logging.getLogger(logger_name)
+    return [h.baseFilename for h in logger.handlers if hasattr(h, "baseFilename")][0]
+
+
+def test_split1_forwarder(setup):
+    # lib            local/lib
+    # forwarder      formatter
+    print(sys.path)
+    reveiveropts = {
+        "username": "i_bims",
+        "password": "dem_is_geheim"
+    }
+    eventopts = {
+        "description": "halo i bims 1 alarm vong naemon her",
+    }
+    split1 = notificationforwarder.baseclass.new("split1", None, True, True,  reveiveropts)
+    assert split1.__class__.__name__ == "Split1"
+    assert split1.__module_file__.endswith("pythonpath/lib/python/notificationforwarder/split1/forwarder.py")
+    assert split1.password == "dem_is_geheim"
+    assert split1.queued_events == []
+    fsplit1 = split1.formatter()
+    assert fsplit1.__class__.__name__ == "Split1Formatter"
+    assert fsplit1.__module_file__.endswith("pythonpath/local/lib/python/notificationforwarder/split1/formatter.py")
+    split1.forward(eventopts)
+    log = open(get_logfile(split1)).read()
+    print(log)
+    assert re.search(r'forwarder '+split1.__module_file__, log)
+    assert re.search(r'formatter '+fsplit1.__module_file__, log)
+
+
+def test_split2_forwarder(setup):
+    # lib            local/lib
+    # forwarder      forwarder
+    # formatter
+    print(sys.path)
+    reveiveropts = {
+        "username": "i_bims",
+        "password": "dem_is_geheim"
+    }
+    eventopts = {
+        "description": "halo i bims 1 alarm vong naemon her",
+    }
+    split2 = notificationforwarder.baseclass.new("split2", None, True, True,  reveiveropts)
+    assert split2.__class__.__name__ == "Split2"
+    assert split2.__module_file__.endswith("pythonpath/local/lib/python/notificationforwarder/split2/forwarder.py")
+    assert split2.password == "dem_is_geheim"
+    assert split2.queued_events == []
+    fsplit2 = split2.formatter()
+    assert fsplit2.__class__.__name__ == "Split2Formatter"
+    assert fsplit2.__module_file__.endswith("pythonpath/lib/python/notificationforwarder/split2/formatter.py")
+    split2.forward(eventopts)
+    log = open(get_logfile(split2)).read()
+    print(log)
+    assert re.search(r'forwarder '+split2.__module_file__, log)
+    assert re.search(r'formatter '+fsplit2.__module_file__, log)
+
+
+def test_split3_forwarder(setup):
+    # lib            local/lib
+    # forwarder      forwarder
+    # formatter      formatter
+    print(sys.path)
+    reveiveropts = {
+        "username": "i_bims",
+        "password": "dem_is_geheim"
+    }
+    eventopts = {
+        "description": "halo i bims 1 alarm vong naemon her",
+    }
+    split3 = notificationforwarder.baseclass.new("split3", None, True, True,  reveiveropts)
+    assert split3.__class__.__name__ == "Split3"
+    assert split3.__module_file__.endswith("pythonpath/local/lib/python/notificationforwarder/split3/forwarder.py")
+    assert split3.password == "dem_is_geheim"
+    assert split3.queued_events == []
+    fsplit3 = split3.formatter()
+    assert fsplit3.__class__.__name__ == "Split3Formatter"
+    assert fsplit3.__module_file__.endswith("pythonpath/local/lib/python/notificationforwarder/split3/formatter.py")
+    split3.forward(eventopts)
+    log = open(get_logfile(split3)).read()
+    print(log)
+    assert re.search(r'forwarder '+split3.__module_file__, log)
+    assert re.search(r'formatter '+fsplit3.__module_file__, log)
+
+

omdnotificationforwarder-1.0.0.1/tests/var/log/notificationforwarder_split3.log

@@ -0,0 +1,5 @@
+2023-10-10 18:33:50,168 3511560 - DEBUG - Logger initialized.
+2023-10-10 18:33:50,197 3511560 - INFO - formatter /home/lausser/git/noteventificationforhandlerwarder/notificationforwarder/tests/pythonpath/local/lib/python/notificationforwarder/split3/formatter.py
+2023-10-10 18:33:50,197 3511560 - DEBUG - flush lock set
+2023-10-10 18:33:50,197 3511560 - INFO - forwarder /home/lausser/git/noteventificationforhandlerwarder/notificationforwarder/tests/pythonpath/local/lib/python/notificationforwarder/split3/forwarder.py
+2023-10-10 18:33:50,198 3511560 - INFO - forwarded description={'description': 'halo i bims 1 alarm vong naemon her', 'omd_site': 'my_devel_site', 'originating_host': 'HULSE', 'originating_fqdn': 'HULSE.consol.lan'}_omd_site={'description': 'halo i bims 1 alarm vong naemon her', 'omd_site': 'my_devel_site', 'originating_host': 'HULSE', 'originating_fqdn': 'HULSE.consol.lan'}_originating_host={'description': 'halo i bims 1 alarm vong naemon her', 'omd_site': 'my_devel_site', 'originating_host': 'HULSE', 'originating_fqdn': 'HULSE.consol.lan'}_originating_fqdn={'description': 'halo i bims 1 alarm vong naemon her', 'omd_site': 'my_devel_site', 'originating_host': 'HULSE', 'originating_fqdn': 'HULSE.consol.lan'}