#!/usr/bin/env python3 # -*- coding: utf-8 -*- # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You under the Apache License, Version 2.0 # (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ This is the main WSGI handler file for Blocky. It compiles a list of valid URLs from the 'pages' library folder, and if a URL matches it runs the specific submodule's run() function. It also handles CGI parsing and exceptions in the applications. """ # Main imports import cgi import re import sys import traceback import yaml import json import plugins.session import plugins.database import plugins.openapi import plugins.worker import atexit import os import time import threading # Hack to start first worker as a background thread ppid = os.getppid() now = time.time() pidfile = "./blocky-bg-%s.pid" % ppid background = False def rmpidfile(): try: print("Removing BG thread pid file...") os.unlink(pidfile) except: pass if not os.path.exists(pidfile) or os.path.getmtime(pidfile) < (now - 60): print("Starting this thread as background worker") open(pidfile, "w").write(str(os.getpid())) atexit.register(rmpidfile) background = True # Compile valid API URLs from the pages library # Allow backwards compatibility by also accepting .lua URLs urls = [] if __name__ != '__main__': import pages for page in pages.handlers: urls.append((r"^(/api/%s)(/.+)?$" % page, pages.handlers[page].run)) # Load Blocky master configuration config = yaml.load(open("yaml/blocky.yaml")) # Instantiate database connections DB = plugins.database.BlockyDatabase(config) # Load Open API specifications BlockyOpenAPI = plugins.openapi.OpenAPI("yaml/openapi.yaml") # Start as background worker? if background: t = threading.Thread(target = plugins.worker.start, args = (DB, config, pidfile)) t.start() class BlockyAPIWrapper: """ Middleware wrapper for exceptions in the application """ def __init__(self, path, func): self.func = func self.API = BlockyOpenAPI self.path = path self.exception = plugins.openapi.BlockyHTTPError def __call__(self, environ, start_response, session): """Run the function, return response OR return stacktrace""" response = None # CORS IGNORE if environ.get('REQUEST_METHOD', 'GET') == 'OPTIONS': start_response('200 Fine, whatever', [ ('Content-Type', 'application/json')]) yield json.dumps({ "code": 200, "reason": "You're probably just being silly..." }) return try: # Read JSON client data if any try: request_size = int(environ.get('CONTENT_LENGTH', 0)) except (ValueError): request_size = 0 requestBody = environ['wsgi.input'].read(request_size) formdata = {} if requestBody and len(requestBody) > 0: try: formdata = json.loads(requestBody.decode('utf-8')) except json.JSONDecodeError as err: start_response('400 Invalid request', [ ('Content-Type', 'application/json')]) yield json.dumps({ "code": 400, "reason": "Invalid JSON: %s" % err }) return else: # Try query string?? xdata = cgi.parse_qs(environ.get('QUERY_STRING')) for k, v in xdata.items(): formdata[k] = v[0] # Validate URL against OpenAPI specs try: self.API.validate(environ['REQUEST_METHOD'], self.path, formdata) except plugins.openapi.OpenAPIException as err: start_response('400 Invalid request', [ ('Content-Type', 'application/json')]) yield json.dumps({ "code": 400, "reason": err.message }) return # Call page with env, SR and form data try: response = self.func(self, environ, formdata, session) if response: for bucket in response: yield bucket except plugins.openapi.BlockyHTTPError as err: errHeaders = { 403: '403 Authentication failed', 404: '404 Resource not found', 500: '500 Internal Server Error', 501: '501 Gateway error' } errHeader = errHeaders[err.code] if err.code in errHeaders else "400 Bad request" start_response(errHeader, [ ('Content-Type', 'application/json')]) yield json.dumps({ "code": err.code, "reason": err.message }, indent = 4) + "\n" return except: err_type, err_value, tb = sys.exc_info() traceback_output = ['API traceback:'] traceback_output += traceback.format_tb(tb) traceback_output.append('%s: %s' % (err_type.__name__, err_value)) # We don't know if response has been given yet, try giving one, fail gracefully. try: start_response('500 Internal Server Error', [ ('Content-Type', 'application/json')]) except: pass yield json.dumps({ "API": "Blocky API 1.0", "code": "500", "reason": '\n'.join(traceback_output) }) def fourohfour(environ, start_response): """A very simple 404 handler""" start_response("404 Not Found", [ ('Content-Type', 'application/json')]) yield json.dumps({ "API": "Blocky API 2.0", "code": 404, "reason": "API endpoint not found" }, indent = 4) + "\n" return def application(environ, start_response): """ This is the main handler. Every API call goes through here. Checks against the pages library, and if submod found, runs it and returns the output. """ path = environ.get('PATH_INFO', '') for regex, function in urls: m = re.match(regex, path) if m: callback = BlockyAPIWrapper(path, function) session = plugins.session.BlockySession(DB, environ, config) a = 0 for bucket in callback(environ, start_response, session): if a == 0: session.headers.append(bucket) try: start_response("200 Okay", session.headers) except: pass a += 1 # WSGI prefers byte strings, so convert if regular py3 string if isinstance(bucket, str): yield bytes(bucket, encoding = 'utf-8') elif isinstance(bucket, bytes): yield bucket return for bucket in fourohfour(environ, start_response): yield bytes(bucket, encoding = 'utf-8') if __name__ == '__main__': BlockyOpenAPI.toHTML()