| """ |
| Copyright (c) 2019, OptoFidelity OY |
| |
| Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: |
| |
| 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. |
| 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. |
| 3. All advertising materials mentioning features or use of this software must display the following acknowledgement: This product includes software developed by the OptoFidelity OY. |
| 4. Neither the name of the OptoFidelity OY nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY |
| EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY |
| DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| """ |
| import cgi |
| import http.server |
| import json |
| import logging |
| import socketserver |
| from urllib.parse import urlparse, parse_qsl, unquote |
| |
| log = logging.getLogger(__name__) |
| |
| from .node import Node, NodeException |
| |
| |
| class RequestHandler(http.server.BaseHTTPRequestHandler): |
| |
| def _to_parts(self, path): |
| if path[0] == "/": |
| path = path[1:] |
| return [unquote(part, "utf-8") for part in path.split("/")] |
| |
| def do_PUT(self): |
| parsed = urlparse(self.path) |
| parts = self._to_parts(parsed.path) |
| self.respond(parts, 'put') |
| |
| def do_POST(self): |
| parsed = urlparse(self.path) |
| parts = self._to_parts(parsed.path) |
| self.respond(parts, 'post') |
| |
| def do_GET(self): |
| parsed = urlparse(self.path) |
| parts = self._to_parts(parsed.path) |
| self.respond(parts, 'get') |
| |
| def do_DELETE(self): |
| parsed = urlparse(self.path) |
| parts = self._to_parts(parsed.path) |
| self.respond(parts, 'delete') |
| |
| def do_OPTIONS(self): |
| parsed = urlparse(self.path) |
| parts = self._to_parts(parsed.path) |
| node, part = self._find_path(parts) |
| part = part[0] |
| allowed_verbs = [] |
| if node is not None: |
| for verb in ["get", "put", "post", "delete"]: |
| try: |
| getattr(node, verb + "_" + part) |
| allowed_verbs.append(verb.upper()) |
| except AttributeError: |
| pass |
| if allowed_verbs: |
| allowed_verbs.append("OPTIONS") |
| self._respond(200, headers={"Access-Control-Allow-Methods": ", ".join(allowed_verbs)}) |
| else: |
| self._respond(404) |
| |
| def _get_raw_content(self): |
| if 'Content-Length' in self.headers: |
| content_length = int(self.headers['Content-Length']) |
| return self.rfile.read(content_length) |
| |
| def _get_content(self): |
| if 'Content-Type' in self.headers and 'Content-Length' in self.headers: |
| content_type, pdict = cgi.parse_header(self.headers['Content-Type']) |
| content_length = int(self.headers['Content-Length']) |
| |
| if content_type == 'multipart/form-data': |
| if 'boundary' in pdict and isinstance(pdict['boundary'], str): |
| pdict['boundary'] = pdict['boundary'].encode() |
| log.debug('Parse multipart/form-data for params %s', pdict) |
| parsed = cgi.parse_multipart(self.rfile, pdict) |
| parsed = self._strip_empty_lists(parsed) |
| parsed = self._extract_json_data(parsed) |
| return parsed |
| elif content_type == 'application/x-www-form-urlencoded': |
| post_data = self.rfile.read(content_length) |
| return parse_qsl(post_data, keep_blank_values=True) |
| elif content_type == 'application/json': |
| post_data = self.rfile.read(content_length) |
| return json.loads(post_data.decode()) |
| elif content_type == "audio/x-wav": |
| post_data = self.rfile.read(content_length) |
| return post_data |
| |
| @staticmethod |
| def _strip_empty_lists(data): |
| def strip_list(value): |
| if isinstance(value, list) and len(value) == 1: |
| return value[0] |
| return value |
| return {k: strip_list(v) for k, v in data.items()} |
| |
| @staticmethod |
| def _extract_json_data(data): |
| # Other params can be embedded as JSON to have typed data: |
| typed_data = {} |
| if 'json_data' in data: |
| typed_data = json.loads(data['json_data'].decode('utf-8')) |
| del data['json_data'] |
| return {**data, **typed_data} |
| |
| def _parse_query_string(self): |
| parsed = urlparse(self.path) |
| query_parts = parse_qsl(parsed.query) |
| params = {} |
| for name, value in query_parts: |
| if value == "true" or value == "True": |
| value = True |
| elif value == "false" or value == "False": |
| value = False |
| else: |
| try: |
| v = float(value) |
| value = v |
| except: |
| pass |
| |
| params[name] = value |
| return params |
| |
| def safe_call(self, instance, handler, *args): |
| try: |
| thread_safe = handler.__thread_safe |
| except: |
| thread_safe = False |
| |
| if thread_safe: |
| v = self.call(handler, *args) |
| else: |
| with instance._api_lock: |
| v = self.call(handler, *args) |
| return v |
| |
| def safe_call_no_response(self, instance, handler, *args): |
| """ |
| Call node method that does not send response (e.g. multipart HTTP request). |
| :param instance: Node object whose method to call. |
| :param handler: Node method that is called. |
| :param args: Arguments to handler. |
| :return: Return value of handler. |
| """ |
| try: |
| thread_safe = handler.__thread_safe |
| except: |
| thread_safe = False |
| |
| if thread_safe: |
| v = handler(*args) |
| else: |
| with instance._api_lock: |
| v = handler(*args) |
| return v |
| |
| def call(self, handler, *args): |
| response_code = 200 |
| response_content_type = None |
| response_data = None |
| response_headers = None |
| |
| request_content = None |
| try: |
| if not hasattr(handler, 'decodes'): |
| request_content = self._get_content() |
| params = self._parse_query_string() |
| if request_content: |
| if not isinstance(request_content, dict): |
| request_content = {"value": request_content} |
| params.update(request_content) |
| out = handler(*args, **params) |
| if not isinstance(out, tuple): |
| raise Exception("Internal callback did not return tuple") |
| else: |
| request_content = self._get_raw_content() |
| out = handler(*args, request_content) |
| |
| if len(out) == 1: |
| response_data = out, |
| elif len(out) == 2: |
| response_content_type, response_data = out |
| elif len(out) == 3: |
| response_content_type, response_data, response_headers = out |
| elif len(out) == 4: |
| response_code, response_content_type, response_data, response_headers = out |
| |
| except NodeException as e: |
| log.exception("Request could not be completed: %s. HTTP payload: %s", e.messages, request_content) |
| response_code = e.http_code |
| response_content_type = "application/json" |
| response_data = json.dumps({"status": "Request processing failed", "message": e.title, |
| "details": e.messages}).encode("utf-8") |
| except TypeError as e: |
| log.exception("Bad request due to TypeError (missing parameters?). HTTP payload: %s", request_content) |
| response_code = 400 |
| response_content_type = "application/json" |
| response_data = json.dumps({"status": "Request processing failed", "message": "Bad request", |
| "details": [str(e)]}).encode("utf-8") |
| except Exception as e: |
| log.exception("Uncaught exception caused internal error). HTTP payload: %s", request_content) |
| response_code = 500 |
| response_content_type = "application/json" |
| response_data = json.dumps({"status": "Request processing failed", "message": "Internal server error", |
| "details": [str(e)]}).encode("utf-8") |
| return response_code, response_content_type, response_data, response_headers |
| |
| def _find_path(self, parts): |
| # |
| # Traverse tree with parts |
| # |
| node = Node.root |
| |
| while len(parts): |
| part = parts[0] |
| if node is None or node.name != part: |
| break |
| parts = parts[1:] |
| if len(parts) == 0: |
| break |
| part = parts[0] |
| try: |
| node = node.find_child_with_path(part) |
| except: |
| break |
| return node, parts |
| |
| def respond(self, parts, scheme): |
| # |
| # Traverse tree with parts |
| # |
| log.debug("Handling HTTP %s for %s", scheme.upper(), "/".join(parts)) |
| |
| node, parts = self._find_path(parts) |
| if node is not None and len(parts) > 0: |
| f = None |
| path_handler = None |
| is_multipart = False |
| |
| try: |
| f = getattr(node, scheme + "_" + parts[0]) |
| is_multipart = getattr(f, "multipart", False) |
| |
| except AttributeError: |
| try: |
| path_handler = getattr(node, "handle_path") |
| except AttributeError: |
| pass |
| |
| if f is not None: |
| log.debug("calling function {} of {}".format(parts[0], node.name)) |
| |
| # Let multipart functions handle their own response |
| if is_multipart: |
| self.safe_call_no_response(node, f, self) |
| return |
| else: |
| response_code, datatype, data, extra_headers = self.safe_call(node, f) |
| |
| elif path_handler is not None: |
| log.debug("path handler {} : {}".format(node.name, ".".join(parts))) |
| response_code, datatype, data, extra_headers = self.safe_call(node, path_handler, scheme, "/".join(parts)) |
| |
| else: |
| response_code = 404 |
| datatype = "text/plain" |
| data = "Not found".encode() |
| extra_headers = None |
| |
| log.warning("found path until {} and remain part {} but did not find goal".format(node.name, ".".join(parts))) |
| |
| self._respond(response_code, datatype, data, extra_headers) |
| return |
| |
| elif node is not None: |
| try: |
| f = getattr(node, scheme + "_self") |
| except: |
| f = None |
| |
| response_code = 200 |
| extra_headers = None |
| if f is not None: |
| response_code, datatype, data, extra_headers = self.safe_call(node, f) |
| else: |
| datatype, data = node.tnt2_info() |
| self._respond(response_code, datatype, data, extra_headers) |
| return |
| |
| self._respond(404) |
| |
| def _respond(self, response_code, content_type=None, data=None, headers=None): |
| self.send_response(response_code) |
| self.send_header("Access-Control-Allow-Credentials", "true") |
| self.send_header("Access-Control-Expose-Headers", "GET, POST, PUT, PATCH, DELETE, OPTIONS") |
| self.send_header("Access-Control-Allow-Origin", "*") |
| if "Access-Control-Request-Headers" in self.headers: |
| self.send_header("Access-Control-Allow-Headers", self.headers["Access-Control-Request-Headers"]) |
| |
| |
| if content_type is not None: |
| self.send_header("Content-Type", content_type) |
| content_length = len(data) if data is not None else 0 |
| self.send_header("Content-Length", content_length) |
| if headers is not None: |
| for header, header_value in headers.items(): |
| self.send_header(header, header_value) |
| self.end_headers() |
| if data is not None: |
| self.wfile.write(data) |
| |
| def log_message(self, format, *args): |
| """Log an arbitrary message. |
| |
| This is used by all other logging functions. Override |
| it if you have specific logging wishes. |
| |
| The first argument, FORMAT, is a format string for the |
| message to be logged. If the format string contains |
| any % escapes requiring parameters, they should be |
| specified as subsequent arguments (it's just like |
| printf!). |
| |
| The client ip and current date/time are prefixed to |
| every message. |
| |
| """ |
| log.debug("%s - %s" % (self.address_string(), format%args)) |
| |
| |
| class DryRunThreadingServer(socketserver.ThreadingMixIn, socketserver.TCPServer): |
| |
| def __init__(self, addr): |
| self.allow_reuse_address = 1 |
| |
| socketserver.ThreadingTCPServer.__init__(self, addr, RequestHandler) |
| |
| |
