Initial commit

Author: toddrob99

Diff for: .gitignore

@@ -1,3 +1,5 @@
+logs/
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

Diff for: README.md

@@ -1,2 +1,62 @@
-# Webhooks
-Webserver module to listen for webhooks and forward requests to a predefined function.
+# Webhook Listener
+Very basic webserver module to listen for webhooks and forward requests to predefined functions.
+
+Author: Todd Roberts
+
+https://pypi.org/project/webhook_listener/
+
+https://github.com/toddrob99/Webhooks
+
+## Install
+
+Install from PyPI using pip
+
+`pip install webhook_listener`
+
+## Use
+
+* Define a function to process requests
+    * `request` parameter will be a cherrypy request object
+    * `*args` parameter will be a tuple of URL path components
+    * `**kwargs` parameter will be a dictionary of URL parameters
+    * Get the body of a `POST` request from `request.body.read` passing the length of `request.headers['Content-Length']`: `request.body.read(int(request.headers['Content-Length'])) if int(request.headers.get('Content-Length',0)) > 0 else ''`
+
+* Include webhook-listener in your project
+
+* Create an instance of the webhook_listener.Listener class
+    * handlers = Dictionary of functions/callables for each supported HTTP method. (Example: {'POST':process_post_request, 'GET':process_get_request})
+    * port = Port for the web server to listen on (default: 8090)
+    * host = Host for the web server to listen on (default: '0.0.0.0')
+    * threadPool = Number of worker threads for the web server (default: 10)
+    * logScreen = Setting for cherrypy to log to screen (default: False)
+    * autoReload = Setting for cherrypy to auto reload when python files are changed (default: False)
+
+* Start the Listener
+
+* Keep your application running so the Listener can run in a separate thread
+
+## Example
+
+    import time
+    import webhook_listener
+    
+    def process_post_request(request, *args, **kwargs):
+        print('Received request:\n' + 
+                    'Method: {}\n'.format(request.method) +
+                    'Headers: {}\n'.format(request.headers) + 
+                    'Args (url path): {}\n'.format(args) + 
+                    'Keyword Args (url parameters): {}\n'.format(kwargs) + 
+                    'Body: {}'.format(request.body.read(int(request.headers['Content-Length'])) if int(request.headers.get('Content-Length',0)) > 0 else '')
+                )
+        
+        # Process the request!
+        # ...
+        
+        return
+    
+    webhooks = webhook_listener.Listener(handlers={'POST':process_post_request})
+    webhooks.start()
+    
+    while True:
+        print('Still alive...')
+        time.sleep(300)

Diff for: example.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+"""
+Webhook Listener Example
+
+Author: Todd Roberts
+
+https://github.com/toddrob99/Webhooks
+"""
+import sys
+import os
+import logging
+import time
+
+import webhook_listener
+
+import argparse
+
+parser = argparse.ArgumentParser(prog='Webhook Listener', description='Start the webhook listener.')
+parser.add_argument('--verbose', '-v', action='store_true', dest='verbose', help='Enable debug logging.')
+parser.add_argument('--port', '-p', type=int, nargs=1, dest='port', help='Port for the web server to listen on (default: 8090).')
+args = parser.parse_args()
+port = args.port[0] if args.port and args.port[0]>=0 else 8090
+
+rootLogger = logging.getLogger()
+rootLogger.setLevel(logging.DEBUG if args.verbose else logging.INFO)
+
+logger = logging.getLogger('webhooks')
+
+console = logging.StreamHandler(sys.stdout)
+formatter = logging.Formatter('%(asctime)s :: %(levelname)8s :: %(module)s(%(lineno)d) :: %(message)s', datefmt='%Y-%m-%d %I:%M:%S %p')
+console.setFormatter(formatter)
+logger.addHandler(console)
+
+logPath = os.path.join(os.path.dirname(os.path.realpath(__file__)),'logs')
+if not os.path.exists(logPath):
+    os.makedirs(logPath)
+
+file = logging.handlers.TimedRotatingFileHandler(os.path.join(logPath,'webhooks.log'), when='midnight', interval=1, backupCount=7)
+file.setFormatter(formatter)
+logger.addHandler(file)
+logger.debug('Logging started!')
+
+def parse_request(request, *args, **kwargs):
+    logger.debug('Received request:\n' + 
+                    'Method: {}\n'.format(request.method) +
+                    'Headers: {}\n'.format(request.headers) + 
+                    'Args (url path): {}\n'.format(args) + 
+                    'Keyword Args (url parameters): {}\n'.format(kwargs) + 
+                    'Body: {}'.format(request.body.read(int(request.headers['Content-Length'])) if int(request.headers.get('Content-Length',0)) > 0 else '')
+                )
+
+    # Process the request!
+    # ...
+
+    return
+
+webhooks = webhook_listener.Listener(port=port, handlers={'POST':parse_request})
+webhooks.start()
+
+while True:
+    logger.debug('Still alive...')
+    time.sleep(300)

Diff for: webhook_listener/__init__.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+"""
+Webhook Listener
+
+Author: Todd Roberts
+
+https://github.com/toddrob99/Webhooks
+"""
+import os
+import sys
+import logging, logging.handlers
+import cherrypy
+import json
+import time
+import threading
+
+class Listener(object):
+    def __init__(self, *args, **kwargs):
+        self.logger = logging.getLogger('webhooks')
+        self.logger.debug('Logging started!')
+        self.port = kwargs.get('port', 8090)
+        self.host = kwargs.get('host', '0.0.0.0')
+        self.threadPool = kwargs.get('threadPool', 10)
+        self.logScreen = kwargs.get('logScreen', False)
+        self.autoReload = kwargs.get('autoReload', False)
+        self.handlers = kwargs.get('handlers', {})
+
+    def start(self):
+        self.WEBTHREAD = threading.Thread(target=self._startServer, name='webhooks_websever', daemon=True)
+        self.WEBTHREAD.start()
+
+    def stop(self):
+        cherrypy.engine.stop()
+        self.WEBTHREAD = None
+
+    def _startServer(self):
+        globalConf = {
+            'global' : {
+                'server.socket_host' : self.host,
+                'server.socket_port' : self.port,
+                'server.thread_pool' : self.threadPool,
+                'engine.autoreload.on' : self.autoReload,
+                'log.screen': self.logScreen
+            }
+        }
+        apiConf = {
+            '/': {
+                'request.dispatch': cherrypy.dispatch.Dispatcher(),
+                'tools.response_headers.on': True,
+                'tools.response_headers.headers': [('Content-Type', 'text/plain')]
+            }
+        }
+        cherrypy.config.update(globalConf)
+        cherrypy.tree.mount(WebServer(handlers=self.handlers), '/', config=apiConf)
+        cherrypy.engine.start()
+        self.logger.debug('Started web server on {}{}{}...'.format(self.host, ':', self.port))
+
+class WebServer(object):
+    def __init__(self, *args, **kwargs):
+        self.logger = logging.getLogger('webhooks')
+        self.handlers = {}
+        for m,h in kwargs.get('handlers',{}).items():
+            if callable(h):
+                self.logger.debug('Registered callable object {} for the {} method.'.format(h, m))
+                self.handlers.update({m : h})
+            else:
+                self.logger.error('Object {} is not callable; the {} method will not be supported.'.format(h, m))
+
+    @cherrypy.expose()
+    def default(self, *args, **kwargs):
+        self.logger.debug('Received {} request. args: {}, kwargs: {}'.format(cherrypy.request.method, args, kwargs))
+
+        if cherrypy.request.method not in self.handlers.keys():
+            # Unsupported method
+            self.logger.debug('Ignoring request due to unsupported method.')
+            cherrypy.response.status = 405 # Method Not Allowed
+            return
+        else:
+            if self.handlers.get(cherrypy.request.method):
+                self.logger.debug('Calling {} to process the request...'.format(self.handlers[cherrypy.request.method]))
+                self.handlers[cherrypy.request.method](cherrypy.request, *args, **kwargs)
+            else:
+                self.logger.error('No handler available for method {}. Ignoring request.'.format(cherrypy.request.method))
+                cherrypy.response.status = 500 # Internal Server Error
+                return
+
+        return 'OK'