From 9f824b048eb253b69ae55989166baefcf5e6c85f Mon Sep 17 00:00:00 2001 From: Michael Lavers Date: Sat, 15 Oct 2016 12:59:00 -0700 Subject: [PATCH] Introduce end-of-line normalization --- .gitattributes | 1 + .gitignore | 6 +- requirements.txt | 4 +- sanic/config.py | 48 +-- sanic/log.py | 8 +- sanic/request.py | 286 ++++++++-------- sanic/response.py | 136 ++++---- sanic/router.py | 256 +++++++------- sanic/sanic.py | 382 ++++++++++----------- sanic/server.py | 410 +++++++++++------------ tests/performance/sanic/http_response.py | 66 ++-- tests/performance/sanic/simple_server.py | 38 +-- tests/performance/sanic/varied_server.py | 182 +++++----- 13 files changed, 912 insertions(+), 911 deletions(-) create mode 100644 .gitattributes diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..176a458f --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +* text=auto diff --git a/.gitignore b/.gitignore index df21bc61..4f6666dc 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,4 @@ -settings.py -*.pyc -.idea/* +settings.py +*.pyc +.idea/* .cache/* \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 9b14856d..2e0feec8 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,3 @@ -httptools -ujson +httptools +ujson uvloop \ No newline at end of file diff --git a/sanic/config.py b/sanic/config.py index 3fc174bc..8261c2c0 100644 --- a/sanic/config.py +++ b/sanic/config.py @@ -1,24 +1,24 @@ -class Config: - LOGO = """ - ▄▄▄▄▄ - ▀▀▀██████▄▄▄ _______________ - ▄▄▄▄▄ █████████▄ / \\ - ▀▀▀▀█████▌ ▀▐▄ ▀▐█ | Gotta go fast! | - ▀▀█████▄▄ ▀██████▄██ | _________________/ - ▀▄▄▄▄▄ ▀▀█▄▀█════█▀ |/ - ▀▀▀▄ ▀▀███ ▀ ▄▄ - ▄███▀▀██▄████████▄ ▄▀▀▀▀▀▀█▌ - ██▀▄▄▄██▀▄███▀ ▀▀████ ▄██ -▄▀▀▀▄██▄▀▀▌████▒▒▒▒▒▒███ ▌▄▄▀ -▌ ▐▀████▐███▒▒▒▒▒▐██▌ -▀▄▄▄▄▀ ▀▀████▒▒▒▒▄██▀ - ▀▀█████████▀ - ▄▄██▀██████▀█ - ▄██▀ ▀▀▀ █ - ▄█ ▐▌ - ▄▄▄▄█▌ ▀█▄▄▄▄▀▀▄ -▌ ▐ ▀▀▄▄▄▀ - ▀▀▄▄▀ -""" - REQUEST_MAX_SIZE = 100000000 # 100 megababies - REQUEST_TIMEOUT = 60 # 60 seconds +class Config: + LOGO = """ + ▄▄▄▄▄ + ▀▀▀██████▄▄▄ _______________ + ▄▄▄▄▄ █████████▄ / \\ + ▀▀▀▀█████▌ ▀▐▄ ▀▐█ | Gotta go fast! | + ▀▀█████▄▄ ▀██████▄██ | _________________/ + ▀▄▄▄▄▄ ▀▀█▄▀█════█▀ |/ + ▀▀▀▄ ▀▀███ ▀ ▄▄ + ▄███▀▀██▄████████▄ ▄▀▀▀▀▀▀█▌ + ██▀▄▄▄██▀▄███▀ ▀▀████ ▄██ +▄▀▀▀▄██▄▀▀▌████▒▒▒▒▒▒███ ▌▄▄▀ +▌ ▐▀████▐███▒▒▒▒▒▐██▌ +▀▄▄▄▄▀ ▀▀████▒▒▒▒▄██▀ + ▀▀█████████▀ + ▄▄██▀██████▀█ + ▄██▀ ▀▀▀ █ + ▄█ ▐▌ + ▄▄▄▄█▌ ▀█▄▄▄▄▀▀▄ +▌ ▐ ▀▀▄▄▄▀ + ▀▀▄▄▀ +""" + REQUEST_MAX_SIZE = 100000000 # 100 megababies + REQUEST_TIMEOUT = 60 # 60 seconds diff --git a/sanic/log.py b/sanic/log.py index b7548203..41dd56e4 100644 --- a/sanic/log.py +++ b/sanic/log.py @@ -1,4 +1,4 @@ -import logging - -logging.basicConfig(level=logging.INFO, format="%(asctime)s: %(levelname)s: %(message)s") -log = logging.getLogger(__name__) +import logging + +logging.basicConfig(level=logging.INFO, format="%(asctime)s: %(levelname)s: %(message)s") +log = logging.getLogger(__name__) diff --git a/sanic/request.py b/sanic/request.py index e7f0dc57..ece1ae8f 100644 --- a/sanic/request.py +++ b/sanic/request.py @@ -1,143 +1,143 @@ -from cgi import parse_header -from collections import namedtuple -from httptools import parse_url -from urllib.parse import parse_qs -from ujson import loads as json_loads - -from .log import log - - -class RequestParameters(dict): - """ - Hosts a dict with lists as values where get returns the first - value of the list and getlist returns the whole shebang - """ - - def __init__(self, *args, **kwargs): - self.super = super() - self.super.__init__(*args, **kwargs) - - def get(self, name, default=None): - values = self.super.get(name) - return values[0] if values else default - - def getlist(self, name, default=None): - return self.super.get(name, default) - - -class Request: - __slots__ = ( - 'url', 'headers', 'version', 'method', - 'query_string', 'body', - 'parsed_json', 'parsed_args', 'parsed_form', 'parsed_files', - ) - - def __init__(self, url_bytes, headers, version, method): - # TODO: Content-Encoding detection - url_parsed = parse_url(url_bytes) - self.url = url_parsed.path.decode('utf-8') - self.headers = headers - self.version = version - self.method = method - self.query_string = url_parsed.query.decode('utf-8') if url_parsed.query else None - - # Init but do not inhale - self.body = None - self.parsed_json = None - self.parsed_form = None - self.parsed_files = None - self.parsed_args = None - - @property - def json(self): - if not self.parsed_json: - try: - self.parsed_json = json_loads(self.body) - except: - pass - - return self.parsed_json - - @property - def form(self): - if self.parsed_form is None: - self.parsed_form = {} - self.parsed_files = {} - content_type, parameters = parse_header(self.headers.get('Content-Type')) - try: - if content_type is None or content_type == 'application/x-www-form-urlencoded': - self.parsed_form = RequestParameters(parse_qs(self.body.decode('utf-8'))) - elif content_type == 'multipart/form-data': - # TODO: Stream this instead of reading to/from memory - boundary = parameters['boundary'].encode('utf-8') - self.parsed_form, self.parsed_files = parse_multipart_form(self.body, boundary) - except Exception as e: - log.exception(e) - pass - - return self.parsed_form - - @property - def files(self): - if self.parsed_files is None: - _ = self.form # compute form to get files - - return self.parsed_files - - @property - def args(self): - if self.parsed_args is None: - if self.query_string: - self.parsed_args = RequestParameters(parse_qs(self.query_string)) - else: - self.parsed_args = {} - - return self.parsed_args - - -File = namedtuple('File', ['type', 'body', 'name']) - - -def parse_multipart_form(body, boundary): - """ - Parses a request body and returns fields and files - :param body: Bytes request body - :param boundary: Bytes multipart boundary - :return: fields (dict), files (dict) - """ - files = {} - fields = {} - - form_parts = body.split(boundary) - for form_part in form_parts[1:-1]: - file_name = None - file_type = None - field_name = None - line_index = 2 - line_end_index = 0 - while not line_end_index == -1: - line_end_index = form_part.find(b'\r\n', line_index) - form_line = form_part[line_index:line_end_index].decode('utf-8') - line_index = line_end_index + 2 - - if not form_line: - break - - colon_index = form_line.index(':') - form_header_field = form_line[0:colon_index] - form_header_value, form_parameters = parse_header(form_line[colon_index + 2:]) - - if form_header_field == 'Content-Disposition': - if 'filename' in form_parameters: - file_name = form_parameters['filename'] - field_name = form_parameters.get('name') - elif form_header_field == 'Content-Type': - file_type = form_header_value - - post_data = form_part[line_index:-4] - if file_name or file_type: - files[field_name] = File(type=file_type, name=file_name, body=post_data) - else: - fields[field_name] = post_data.decode('utf-8') - - return fields, files +from cgi import parse_header +from collections import namedtuple +from httptools import parse_url +from urllib.parse import parse_qs +from ujson import loads as json_loads + +from .log import log + + +class RequestParameters(dict): + """ + Hosts a dict with lists as values where get returns the first + value of the list and getlist returns the whole shebang + """ + + def __init__(self, *args, **kwargs): + self.super = super() + self.super.__init__(*args, **kwargs) + + def get(self, name, default=None): + values = self.super.get(name) + return values[0] if values else default + + def getlist(self, name, default=None): + return self.super.get(name, default) + + +class Request: + __slots__ = ( + 'url', 'headers', 'version', 'method', + 'query_string', 'body', + 'parsed_json', 'parsed_args', 'parsed_form', 'parsed_files', + ) + + def __init__(self, url_bytes, headers, version, method): + # TODO: Content-Encoding detection + url_parsed = parse_url(url_bytes) + self.url = url_parsed.path.decode('utf-8') + self.headers = headers + self.version = version + self.method = method + self.query_string = url_parsed.query.decode('utf-8') if url_parsed.query else None + + # Init but do not inhale + self.body = None + self.parsed_json = None + self.parsed_form = None + self.parsed_files = None + self.parsed_args = None + + @property + def json(self): + if not self.parsed_json: + try: + self.parsed_json = json_loads(self.body) + except: + pass + + return self.parsed_json + + @property + def form(self): + if self.parsed_form is None: + self.parsed_form = {} + self.parsed_files = {} + content_type, parameters = parse_header(self.headers.get('Content-Type')) + try: + if content_type is None or content_type == 'application/x-www-form-urlencoded': + self.parsed_form = RequestParameters(parse_qs(self.body.decode('utf-8'))) + elif content_type == 'multipart/form-data': + # TODO: Stream this instead of reading to/from memory + boundary = parameters['boundary'].encode('utf-8') + self.parsed_form, self.parsed_files = parse_multipart_form(self.body, boundary) + except Exception as e: + log.exception(e) + pass + + return self.parsed_form + + @property + def files(self): + if self.parsed_files is None: + _ = self.form # compute form to get files + + return self.parsed_files + + @property + def args(self): + if self.parsed_args is None: + if self.query_string: + self.parsed_args = RequestParameters(parse_qs(self.query_string)) + else: + self.parsed_args = {} + + return self.parsed_args + + +File = namedtuple('File', ['type', 'body', 'name']) + + +def parse_multipart_form(body, boundary): + """ + Parses a request body and returns fields and files + :param body: Bytes request body + :param boundary: Bytes multipart boundary + :return: fields (dict), files (dict) + """ + files = {} + fields = {} + + form_parts = body.split(boundary) + for form_part in form_parts[1:-1]: + file_name = None + file_type = None + field_name = None + line_index = 2 + line_end_index = 0 + while not line_end_index == -1: + line_end_index = form_part.find(b'\r\n', line_index) + form_line = form_part[line_index:line_end_index].decode('utf-8') + line_index = line_end_index + 2 + + if not form_line: + break + + colon_index = form_line.index(':') + form_header_field = form_line[0:colon_index] + form_header_value, form_parameters = parse_header(form_line[colon_index + 2:]) + + if form_header_field == 'Content-Disposition': + if 'filename' in form_parameters: + file_name = form_parameters['filename'] + field_name = form_parameters.get('name') + elif form_header_field == 'Content-Type': + file_type = form_header_value + + post_data = form_part[line_index:-4] + if file_name or file_type: + files[field_name] = File(type=file_type, name=file_name, body=post_data) + else: + fields[field_name] = post_data.decode('utf-8') + + return fields, files diff --git a/sanic/response.py b/sanic/response.py index c1a0569f..6807d04c 100644 --- a/sanic/response.py +++ b/sanic/response.py @@ -1,68 +1,68 @@ -import ujson -import httptools -from ujson import loads as json_loads -from urllib.parse import parse_qs - -STATUS_CODES = { - 200: 'OK', - 400: 'Bad Request', - 401: 'Unauthorized', - 402: 'Payment Required', - 403: 'Forbidden', - 404: 'Not Found', - 405: 'Method Not Allowed', - 500: 'Internal Server Error', - 501: 'Not Implemented', - 502: 'Bad Gateway', - 503: 'Service Unavailable', - 504: 'Gateway Timeout', -} - - -class HTTPResponse: - __slots__ = ('body', 'status', 'content_type', 'headers') - - def __init__(self, body=None, status=200, headers=[], content_type='text/plain', body_bytes=b''): - self.content_type = content_type - - if not body is None: - self.body = body.encode('utf-8') - else: - self.body = body_bytes - - self.status = status - self.headers = headers - - def output(self, version="1.1", keep_alive=False, keep_alive_timeout=None): - # This is all returned in a kind-of funky way - # We tried to make this as fast as possible in pure python - additional_headers = [] - if keep_alive and not keep_alive_timeout is None: - additional_headers = [b'Keep-Alive: timeout=', str(keep_alive_timeout).encode(), b's\r\n'] - if self.headers: - for name, value in self.headers.items(): - additional_headers.append('{}: {}\r\n'.format(name, value).encode('utf-8')) - - return b''.join([ - 'HTTP/{} {} {}\r\n'.format(version, self.status, - STATUS_CODES.get(self.status, 'FAIL')).encode(), - b'Content-Type: ', self.content_type.encode(), b'\r\n', - b'Content-Length: ', str(len(self.body)).encode(), b'\r\n', - b'Connection: ', ('keep-alive' if keep_alive else 'close').encode(), b'\r\n', - ] + additional_headers + [ - b'\r\n', - self.body, - ]) - - -def json(body, status=200, headers=None): - return HTTPResponse(ujson.dumps(body), headers=headers, status=status, - content_type="application/json; charset=utf-8") - - -def text(body, status=200, headers=None): - return HTTPResponse(body, status=status, headers=headers, content_type="text/plain; charset=utf-8") - - -def html(body, status=200, headers=None): - return HTTPResponse(body, status=status, headers=headers, content_type="text/html; charset=utf-8") +import ujson +import httptools +from ujson import loads as json_loads +from urllib.parse import parse_qs + +STATUS_CODES = { + 200: 'OK', + 400: 'Bad Request', + 401: 'Unauthorized', + 402: 'Payment Required', + 403: 'Forbidden', + 404: 'Not Found', + 405: 'Method Not Allowed', + 500: 'Internal Server Error', + 501: 'Not Implemented', + 502: 'Bad Gateway', + 503: 'Service Unavailable', + 504: 'Gateway Timeout', +} + + +class HTTPResponse: + __slots__ = ('body', 'status', 'content_type', 'headers') + + def __init__(self, body=None, status=200, headers=[], content_type='text/plain', body_bytes=b''): + self.content_type = content_type + + if not body is None: + self.body = body.encode('utf-8') + else: + self.body = body_bytes + + self.status = status + self.headers = headers + + def output(self, version="1.1", keep_alive=False, keep_alive_timeout=None): + # This is all returned in a kind-of funky way + # We tried to make this as fast as possible in pure python + additional_headers = [] + if keep_alive and not keep_alive_timeout is None: + additional_headers = [b'Keep-Alive: timeout=', str(keep_alive_timeout).encode(), b's\r\n'] + if self.headers: + for name, value in self.headers.items(): + additional_headers.append('{}: {}\r\n'.format(name, value).encode('utf-8')) + + return b''.join([ + 'HTTP/{} {} {}\r\n'.format(version, self.status, + STATUS_CODES.get(self.status, 'FAIL')).encode(), + b'Content-Type: ', self.content_type.encode(), b'\r\n', + b'Content-Length: ', str(len(self.body)).encode(), b'\r\n', + b'Connection: ', ('keep-alive' if keep_alive else 'close').encode(), b'\r\n', + ] + additional_headers + [ + b'\r\n', + self.body, + ]) + + +def json(body, status=200, headers=None): + return HTTPResponse(ujson.dumps(body), headers=headers, status=status, + content_type="application/json; charset=utf-8") + + +def text(body, status=200, headers=None): + return HTTPResponse(body, status=status, headers=headers, content_type="text/plain; charset=utf-8") + + +def html(body, status=200, headers=None): + return HTTPResponse(body, status=status, headers=headers, content_type="text/html; charset=utf-8") diff --git a/sanic/router.py b/sanic/router.py index 892ba655..ddab5c61 100644 --- a/sanic/router.py +++ b/sanic/router.py @@ -1,128 +1,128 @@ -import re -from collections import namedtuple -from .exceptions import NotFound, InvalidUsage - -Route = namedtuple("Route", ['handler', 'methods', 'pattern', 'parameters']) -Parameter = namedtuple("Parameter", ['name', 'cast']) - - -class Router: - """ - Router supports basic routing with parameters and method checks - Usage: - @sanic.route('/my/url/', methods=['GET', 'POST', ...]) - def my_route(request, my_parameter): - do stuff... - - Parameters will be passed as keyword arguments to the request handling function provided - Parameters can also have a type by appending :type to the . If no type is provided, - a string is expected. A regular expression can also be passed in as the type - - TODO: - This probably needs optimization for larger sets of routes, - since it checks every route until it finds a match which is bad and I should feel bad - """ - routes = None - regex_types = { - "string": (None, "\w+"), - "int": (int, "\d+"), - "number": (float, "[0-9\\.]+"), - "alpha": (None, "[A-Za-z]+"), - } - - def __init__(self): - self.routes = [] - - def add(self, uri, methods, handler): - """ - Adds a handler to the route list - :param uri: Path to match - :param methods: Array of accepted method names. If none are provided, any method is allowed - :param handler: Request handler function. When executed, it should provide a response object. - :return: Nothing - """ - - # Dict for faster lookups of if method allowed - methods_dict = {method: True for method in methods} if methods else None - - parameters = [] - - def add_parameter(match): - # We could receive NAME or NAME:PATTERN - parts = match.group(1).split(':') - if len(parts) == 2: - parameter_name, parameter_pattern = parts - else: - parameter_name = parts[0] - parameter_pattern = 'string' - - # Pull from pre-configured types - parameter_regex = self.regex_types.get(parameter_pattern) - if parameter_regex: - parameter_type, parameter_pattern = parameter_regex - else: - parameter_type = None - - parameter = Parameter(name=parameter_name, cast=parameter_type) - parameters.append(parameter) - - return "({})".format(parameter_pattern) - - pattern_string = re.sub("<(.+?)>", add_parameter, uri) - pattern = re.compile("^{}$".format(pattern_string)) - - route = Route(handler=handler, methods=methods_dict, pattern=pattern, parameters=parameters) - self.routes.append(route) - - def get(self, request): - """ - Gets a request handler based on the URL of the request, or raises an error - :param request: Request object - :return: handler, arguments, keyword arguments - """ - - route = None - args = [] - kwargs = {} - for _route in self.routes: - match = _route.pattern.match(request.url) - if match: - for index, parameter in enumerate(_route.parameters, start=1): - value = match.group(index) - kwargs[parameter.name] = parameter.cast(value) if parameter.cast is not None else value - route = _route - break - - if route: - if route.methods and not request.method in route.methods: - raise InvalidUsage("Method {} not allowed for URL {}".format(request.method, request.url), - status_code=405) - return route.handler, args, kwargs - else: - raise NotFound("Requested URL {} not found".format(request.url)) - - -class SimpleRouter: - """ - Simple router records and reads all routes from a dictionary - It does not support parameters in routes, but is very fast - """ - routes = None - - def __init__(self): - self.routes = {} - - def add(self, uri, methods, handler): - # Dict for faster lookups of method allowed - methods_dict = {method: True for method in methods} if methods else None - self.routes[uri] = Route(handler=handler, methods=methods_dict, pattern=uri, parameters=None) - - def get(self, request): - route = self.routes.get(request.url) - if route: - if route.methods and not request.method in route.methods: - raise InvalidUsage("Method {} not allowed for URL {}".format(request.method, request.url), - status_code=405) - return route.handler, [], {} - else: - raise NotFound("Requested URL {} not found".format(request.url)) +import re +from collections import namedtuple +from .exceptions import NotFound, InvalidUsage + +Route = namedtuple("Route", ['handler', 'methods', 'pattern', 'parameters']) +Parameter = namedtuple("Parameter", ['name', 'cast']) + + +class Router: + """ + Router supports basic routing with parameters and method checks + Usage: + @sanic.route('/my/url/', methods=['GET', 'POST', ...]) + def my_route(request, my_parameter): + do stuff... + + Parameters will be passed as keyword arguments to the request handling function provided + Parameters can also have a type by appending :type to the . If no type is provided, + a string is expected. A regular expression can also be passed in as the type + + TODO: + This probably needs optimization for larger sets of routes, + since it checks every route until it finds a match which is bad and I should feel bad + """ + routes = None + regex_types = { + "string": (None, "\w+"), + "int": (int, "\d+"), + "number": (float, "[0-9\\.]+"), + "alpha": (None, "[A-Za-z]+"), + } + + def __init__(self): + self.routes = [] + + def add(self, uri, methods, handler): + """ + Adds a handler to the route list + :param uri: Path to match + :param methods: Array of accepted method names. If none are provided, any method is allowed + :param handler: Request handler function. When executed, it should provide a response object. + :return: Nothing + """ + + # Dict for faster lookups of if method allowed + methods_dict = {method: True for method in methods} if methods else None + + parameters = [] + + def add_parameter(match): + # We could receive NAME or NAME:PATTERN + parts = match.group(1).split(':') + if len(parts) == 2: + parameter_name, parameter_pattern = parts + else: + parameter_name = parts[0] + parameter_pattern = 'string' + + # Pull from pre-configured types + parameter_regex = self.regex_types.get(parameter_pattern) + if parameter_regex: + parameter_type, parameter_pattern = parameter_regex + else: + parameter_type = None + + parameter = Parameter(name=parameter_name, cast=parameter_type) + parameters.append(parameter) + + return "({})".format(parameter_pattern) + + pattern_string = re.sub("<(.+?)>", add_parameter, uri) + pattern = re.compile("^{}$".format(pattern_string)) + + route = Route(handler=handler, methods=methods_dict, pattern=pattern, parameters=parameters) + self.routes.append(route) + + def get(self, request): + """ + Gets a request handler based on the URL of the request, or raises an error + :param request: Request object + :return: handler, arguments, keyword arguments + """ + + route = None + args = [] + kwargs = {} + for _route in self.routes: + match = _route.pattern.match(request.url) + if match: + for index, parameter in enumerate(_route.parameters, start=1): + value = match.group(index) + kwargs[parameter.name] = parameter.cast(value) if parameter.cast is not None else value + route = _route + break + + if route: + if route.methods and not request.method in route.methods: + raise InvalidUsage("Method {} not allowed for URL {}".format(request.method, request.url), + status_code=405) + return route.handler, args, kwargs + else: + raise NotFound("Requested URL {} not found".format(request.url)) + + +class SimpleRouter: + """ + Simple router records and reads all routes from a dictionary + It does not support parameters in routes, but is very fast + """ + routes = None + + def __init__(self): + self.routes = {} + + def add(self, uri, methods, handler): + # Dict for faster lookups of method allowed + methods_dict = {method: True for method in methods} if methods else None + self.routes[uri] = Route(handler=handler, methods=methods_dict, pattern=uri, parameters=None) + + def get(self, request): + route = self.routes.get(request.url) + if route: + if route.methods and not request.method in route.methods: + raise InvalidUsage("Method {} not allowed for URL {}".format(request.method, request.url), + status_code=405) + return route.handler, [], {} + else: + raise NotFound("Requested URL {} not found".format(request.url)) diff --git a/sanic/sanic.py b/sanic/sanic.py index f17cd4af..8fd1c6b7 100644 --- a/sanic/sanic.py +++ b/sanic/sanic.py @@ -1,191 +1,191 @@ -import asyncio -from inspect import isawaitable -from traceback import format_exc -from types import FunctionType - -from .config import Config -from .exceptions import Handler -from .log import log, logging -from .middleware import Middleware -from .response import HTTPResponse -from .router import Router -from .server import serve -from .exceptions import ServerError - - -class Sanic: - def __init__(self, name, router=None, error_handler=None): - self.name = name - self.router = router or Router() - self.router = router or Router() - self.error_handler = error_handler or Handler(self) - self.config = Config() - self.request_middleware = [] - self.response_middleware = [] - - # -------------------------------------------------------------------- # - # Registration - # -------------------------------------------------------------------- # - - # Decorator - def route(self, uri, methods=None): - """ - Decorates a function to be registered as a route - :param uri: path of the URL - :param methods: list or tuple of methods allowed - :return: decorated function - """ - - def response(handler): - self.router.add(uri=uri, methods=methods, handler=handler) - return handler - - return response - - # Decorator - def exception(self, *exceptions): - """ - Decorates a function to be registered as a route - :param uri: path of the URL - :param methods: list or tuple of methods allowed - :return: decorated function - """ - - def response(handler): - for exception in exceptions: - self.error_handler.add(exception, handler) - return handler - - return response - - # Decorator - def middleware(self, *args, **kwargs): - """ - Decorates and registers middleware to be called before a request - can either be called as @app.middleware or @app.middleware('request') - """ - middleware = None - attach_to = 'request' - - def register_middleware(middleware): - if attach_to == 'request': - self.request_middleware.append(middleware) - if attach_to == 'response': - self.response_middleware.append(middleware) - return middleware - - # Detect which way this was called, @middleware or @middleware('AT') - if len(args) == 1 and len(kwargs) == 0 and callable(args[0]): - return register_middleware(args[0]) - else: - attach_to = args[0] - return register_middleware - - if isinstance(middleware, FunctionType): - middleware = Middleware(process_request=middleware) - - return middleware - - # -------------------------------------------------------------------- # - # Request Handling - # -------------------------------------------------------------------- # - - async def handle_request(self, request, response_callback): - """ - Takes a request from the HTTP Server and returns a response object to be sent back - The HTTP Server only expects a response object, so exception handling must be done here - :param request: HTTP Request object - :param response_callback: Response function to be called with the response as the only argument - :return: Nothing - """ - try: - # Middleware process_request - response = False - # The if improves speed. I don't know why - if self.request_middleware: - for middleware in self.request_middleware: - response = middleware(request) - if isawaitable(response): - response = await response - if response: - break - - # No middleware results - if not response: - # Fetch handler from router - handler, args, kwargs = self.router.get(request) - if handler is None: - raise ServerError("'None' was returned while requesting a handler from the router") - - # Run response handler - response = handler(request, *args, **kwargs) - if isawaitable(response): - response = await response - - # Middleware process_response - if self.response_middleware: - for middleware in self.response_middleware: - _response = middleware(request, response) - if isawaitable(_response): - _response = await _response - if _response: - response = _response - break - - except Exception as e: - try: - response = self.error_handler.response(request, e) - if isawaitable(response): - response = await response - except Exception as e: - if self.debug: - response = HTTPResponse("Error while handling error: {}\nStack: {}".format(e, format_exc())) - else: - response = HTTPResponse("An error occured while handling an error") - - response_callback(response) - - # -------------------------------------------------------------------- # - # Execution - # -------------------------------------------------------------------- # - - def run(self, host="127.0.0.1", port=8000, debug=False, after_start=None, before_stop=None): - """ - Runs the HTTP Server and listens until keyboard interrupt or term signal. - On termination, drains connections before closing. - :param host: Address to host on - :param port: Port to host on - :param debug: Enables debug output (slows server) - :param after_start: Function to be executed after the server starts listening - :param before_stop: Function to be executed when a stop signal is received before it is respected - :return: Nothing - """ - self.error_handler.debug = True - self.debug = debug - - if debug: - log.setLevel(logging.DEBUG) - log.debug(self.config.LOGO) - - # Serve - log.info('Goin\' Fast @ http://{}:{}'.format(host, port)) - - try: - serve( - host=host, - port=port, - debug=debug, - after_start=after_start, - before_stop=before_stop, - request_handler=self.handle_request, - request_timeout=self.config.REQUEST_TIMEOUT, - request_max_size=self.config.REQUEST_MAX_SIZE, - ) - except: - pass - - def stop(self): - """ - This kills the Sanic - """ - asyncio.get_event_loop().stop() +import asyncio +from inspect import isawaitable +from traceback import format_exc +from types import FunctionType + +from .config import Config +from .exceptions import Handler +from .log import log, logging +from .middleware import Middleware +from .response import HTTPResponse +from .router import Router +from .server import serve +from .exceptions import ServerError + + +class Sanic: + def __init__(self, name, router=None, error_handler=None): + self.name = name + self.router = router or Router() + self.router = router or Router() + self.error_handler = error_handler or Handler(self) + self.config = Config() + self.request_middleware = [] + self.response_middleware = [] + + # -------------------------------------------------------------------- # + # Registration + # -------------------------------------------------------------------- # + + # Decorator + def route(self, uri, methods=None): + """ + Decorates a function to be registered as a route + :param uri: path of the URL + :param methods: list or tuple of methods allowed + :return: decorated function + """ + + def response(handler): + self.router.add(uri=uri, methods=methods, handler=handler) + return handler + + return response + + # Decorator + def exception(self, *exceptions): + """ + Decorates a function to be registered as a route + :param uri: path of the URL + :param methods: list or tuple of methods allowed + :return: decorated function + """ + + def response(handler): + for exception in exceptions: + self.error_handler.add(exception, handler) + return handler + + return response + + # Decorator + def middleware(self, *args, **kwargs): + """ + Decorates and registers middleware to be called before a request + can either be called as @app.middleware or @app.middleware('request') + """ + middleware = None + attach_to = 'request' + + def register_middleware(middleware): + if attach_to == 'request': + self.request_middleware.append(middleware) + if attach_to == 'response': + self.response_middleware.append(middleware) + return middleware + + # Detect which way this was called, @middleware or @middleware('AT') + if len(args) == 1 and len(kwargs) == 0 and callable(args[0]): + return register_middleware(args[0]) + else: + attach_to = args[0] + return register_middleware + + if isinstance(middleware, FunctionType): + middleware = Middleware(process_request=middleware) + + return middleware + + # -------------------------------------------------------------------- # + # Request Handling + # -------------------------------------------------------------------- # + + async def handle_request(self, request, response_callback): + """ + Takes a request from the HTTP Server and returns a response object to be sent back + The HTTP Server only expects a response object, so exception handling must be done here + :param request: HTTP Request object + :param response_callback: Response function to be called with the response as the only argument + :return: Nothing + """ + try: + # Middleware process_request + response = False + # The if improves speed. I don't know why + if self.request_middleware: + for middleware in self.request_middleware: + response = middleware(request) + if isawaitable(response): + response = await response + if response: + break + + # No middleware results + if not response: + # Fetch handler from router + handler, args, kwargs = self.router.get(request) + if handler is None: + raise ServerError("'None' was returned while requesting a handler from the router") + + # Run response handler + response = handler(request, *args, **kwargs) + if isawaitable(response): + response = await response + + # Middleware process_response + if self.response_middleware: + for middleware in self.response_middleware: + _response = middleware(request, response) + if isawaitable(_response): + _response = await _response + if _response: + response = _response + break + + except Exception as e: + try: + response = self.error_handler.response(request, e) + if isawaitable(response): + response = await response + except Exception as e: + if self.debug: + response = HTTPResponse("Error while handling error: {}\nStack: {}".format(e, format_exc())) + else: + response = HTTPResponse("An error occured while handling an error") + + response_callback(response) + + # -------------------------------------------------------------------- # + # Execution + # -------------------------------------------------------------------- # + + def run(self, host="127.0.0.1", port=8000, debug=False, after_start=None, before_stop=None): + """ + Runs the HTTP Server and listens until keyboard interrupt or term signal. + On termination, drains connections before closing. + :param host: Address to host on + :param port: Port to host on + :param debug: Enables debug output (slows server) + :param after_start: Function to be executed after the server starts listening + :param before_stop: Function to be executed when a stop signal is received before it is respected + :return: Nothing + """ + self.error_handler.debug = True + self.debug = debug + + if debug: + log.setLevel(logging.DEBUG) + log.debug(self.config.LOGO) + + # Serve + log.info('Goin\' Fast @ http://{}:{}'.format(host, port)) + + try: + serve( + host=host, + port=port, + debug=debug, + after_start=after_start, + before_stop=before_stop, + request_handler=self.handle_request, + request_timeout=self.config.REQUEST_TIMEOUT, + request_max_size=self.config.REQUEST_MAX_SIZE, + ) + except: + pass + + def stop(self): + """ + This kills the Sanic + """ + asyncio.get_event_loop().stop() diff --git a/sanic/server.py b/sanic/server.py index 338435c8..5704bccf 100644 --- a/sanic/server.py +++ b/sanic/server.py @@ -1,205 +1,205 @@ -import asyncio -from inspect import isawaitable -from signal import SIGINT, SIGTERM - -import httptools - -try: - import uvloop as async_loop -except: - async_loop = asyncio - -from .log import log -from .request import Request - - -class Signal: - stopped = False - - -class HttpProtocol(asyncio.Protocol): - __slots__ = ('loop', 'transport', 'connections', 'signal', # event loop, connection - 'parser', 'request', 'url', 'headers', # request params - 'request_handler', 'request_timeout', 'request_max_size', # request config - '_total_request_size', '_timeout_handler') # connection management - - def __init__(self, *, loop, request_handler, signal=Signal(), connections={}, request_timeout=60, - request_max_size=None): - self.loop = loop - self.transport = None - self.request = None - self.parser = None - self.url = None - self.headers = None - self.signal = signal - self.connections = connections - self.request_handler = request_handler - self.request_timeout = request_timeout - self.request_max_size = request_max_size - self._total_request_size = 0 - self._timeout_handler = None - - # -------------------------------------------- # - - # Connection - # -------------------------------------------- # - - def connection_made(self, transport): - self.connections[self] = True - self._timeout_handler = self.loop.call_later(self.request_timeout, self.connection_timeout) - self.transport = transport - - def connection_lost(self, exc): - del self.connections[self] - self._timeout_handler.cancel() - self.cleanup() - - def connection_timeout(self): - self.bail_out("Request timed out, connection closed") - - # -------------------------------------------- # - - # Parsing - # -------------------------------------------- # - - def data_received(self, data): - # Check for the request itself getting too large and exceeding memory limits - self._total_request_size += len(data) - if self._total_request_size > self.request_max_size: - return self.bail_out("Request too large ({}), connection closed".format(self._total_request_size)) - - # Create parser if this is the first time we're receiving data - if self.parser is None: - assert self.request is None - self.headers = [] - self.parser = httptools.HttpRequestParser(self) - - # Parse request chunk or close connection - try: - self.parser.feed_data(data) - except httptools.parser.errors.HttpParserError as e: - self.bail_out("Invalid request data, connection closed ({})".format(e)) - - def on_url(self, url): - self.url = url - - def on_header(self, name, value): - if name == b'Content-Length' and int(value) > self.request_max_size: - return self.bail_out("Request body too large ({}), connection closed".format(value)) - - self.headers.append((name.decode(), value.decode('utf-8'))) - - def on_headers_complete(self): - self.request = Request( - url_bytes=self.url, - headers=dict(self.headers), - version=self.parser.get_http_version(), - method=self.parser.get_method().decode() - ) - - def on_body(self, body): - self.request.body = body - - def on_message_complete(self): - self.loop.create_task(self.request_handler(self.request, self.write_response)) - - # -------------------------------------------- # - # Responding - # -------------------------------------------- # - - def write_response(self, response): - try: - keep_alive = self.parser.should_keep_alive() and not self.signal.stopped - self.transport.write(response.output(self.request.version, keep_alive, self.request_timeout)) - if not keep_alive: - self.transport.close() - else: - self.cleanup() - except Exception as e: - self.bail_out("Writing request failed, connection closed {}".format(e)) - - def bail_out(self, message): - log.error(message) - self.transport.close() - - def cleanup(self): - self.parser = None - self.request = None - self.url = None - self.headers = None - self._total_request_size = 0 - - def close_if_idle(self): - """ - Close the connection if a request is not being sent or received - :return: boolean - True if closed, false if staying open - """ - if not self.parser: - self.transport.close() - return True - return False - - -def serve(host, port, request_handler, after_start=None, before_stop=None, debug=False, request_timeout=60, - request_max_size=None): - # Create Event Loop - loop = async_loop.new_event_loop() - asyncio.set_event_loop(loop) - # I don't think we take advantage of this - # And it slows everything waaayyy down - # loop.set_debug(debug) - - connections = {} - signal = Signal() - server_coroutine = loop.create_server(lambda: HttpProtocol( - loop=loop, - connections=connections, - signal=signal, - request_handler=request_handler, - request_timeout=request_timeout, - request_max_size=request_max_size, - ), host, port) - try: - http_server = loop.run_until_complete(server_coroutine) - except OSError as e: - log.error("Unable to start server: {}".format(e)) - return - except: - log.exception("Unable to start server") - return - - # Run the on_start function if provided - if after_start: - result = after_start(loop) - if isawaitable(result): - loop.run_until_complete(result) - - # Register signals for graceful termination - for _signal in (SIGINT, SIGTERM): - loop.add_signal_handler(_signal, loop.stop) - - try: - loop.run_forever() - finally: - log.info("Stop requested, draining connections...") - - # Run the on_stop function if provided - if before_stop: - result = before_stop(loop) - if isawaitable(result): - loop.run_until_complete(result) - - # Wait for event loop to finish and all connections to drain - http_server.close() - loop.run_until_complete(http_server.wait_closed()) - - # Complete all tasks on the loop - signal.stopped = True - for connection in connections.keys(): - connection.close_if_idle() - - while connections: - loop.run_until_complete(asyncio.sleep(0.1)) - - loop.close() - log.info("Server Stopped") +import asyncio +from inspect import isawaitable +from signal import SIGINT, SIGTERM + +import httptools + +try: + import uvloop as async_loop +except: + async_loop = asyncio + +from .log import log +from .request import Request + + +class Signal: + stopped = False + + +class HttpProtocol(asyncio.Protocol): + __slots__ = ('loop', 'transport', 'connections', 'signal', # event loop, connection + 'parser', 'request', 'url', 'headers', # request params + 'request_handler', 'request_timeout', 'request_max_size', # request config + '_total_request_size', '_timeout_handler') # connection management + + def __init__(self, *, loop, request_handler, signal=Signal(), connections={}, request_timeout=60, + request_max_size=None): + self.loop = loop + self.transport = None + self.request = None + self.parser = None + self.url = None + self.headers = None + self.signal = signal + self.connections = connections + self.request_handler = request_handler + self.request_timeout = request_timeout + self.request_max_size = request_max_size + self._total_request_size = 0 + self._timeout_handler = None + + # -------------------------------------------- # + + # Connection + # -------------------------------------------- # + + def connection_made(self, transport): + self.connections[self] = True + self._timeout_handler = self.loop.call_later(self.request_timeout, self.connection_timeout) + self.transport = transport + + def connection_lost(self, exc): + del self.connections[self] + self._timeout_handler.cancel() + self.cleanup() + + def connection_timeout(self): + self.bail_out("Request timed out, connection closed") + + # -------------------------------------------- # + + # Parsing + # -------------------------------------------- # + + def data_received(self, data): + # Check for the request itself getting too large and exceeding memory limits + self._total_request_size += len(data) + if self._total_request_size > self.request_max_size: + return self.bail_out("Request too large ({}), connection closed".format(self._total_request_size)) + + # Create parser if this is the first time we're receiving data + if self.parser is None: + assert self.request is None + self.headers = [] + self.parser = httptools.HttpRequestParser(self) + + # Parse request chunk or close connection + try: + self.parser.feed_data(data) + except httptools.parser.errors.HttpParserError as e: + self.bail_out("Invalid request data, connection closed ({})".format(e)) + + def on_url(self, url): + self.url = url + + def on_header(self, name, value): + if name == b'Content-Length' and int(value) > self.request_max_size: + return self.bail_out("Request body too large ({}), connection closed".format(value)) + + self.headers.append((name.decode(), value.decode('utf-8'))) + + def on_headers_complete(self): + self.request = Request( + url_bytes=self.url, + headers=dict(self.headers), + version=self.parser.get_http_version(), + method=self.parser.get_method().decode() + ) + + def on_body(self, body): + self.request.body = body + + def on_message_complete(self): + self.loop.create_task(self.request_handler(self.request, self.write_response)) + + # -------------------------------------------- # + # Responding + # -------------------------------------------- # + + def write_response(self, response): + try: + keep_alive = self.parser.should_keep_alive() and not self.signal.stopped + self.transport.write(response.output(self.request.version, keep_alive, self.request_timeout)) + if not keep_alive: + self.transport.close() + else: + self.cleanup() + except Exception as e: + self.bail_out("Writing request failed, connection closed {}".format(e)) + + def bail_out(self, message): + log.error(message) + self.transport.close() + + def cleanup(self): + self.parser = None + self.request = None + self.url = None + self.headers = None + self._total_request_size = 0 + + def close_if_idle(self): + """ + Close the connection if a request is not being sent or received + :return: boolean - True if closed, false if staying open + """ + if not self.parser: + self.transport.close() + return True + return False + + +def serve(host, port, request_handler, after_start=None, before_stop=None, debug=False, request_timeout=60, + request_max_size=None): + # Create Event Loop + loop = async_loop.new_event_loop() + asyncio.set_event_loop(loop) + # I don't think we take advantage of this + # And it slows everything waaayyy down + # loop.set_debug(debug) + + connections = {} + signal = Signal() + server_coroutine = loop.create_server(lambda: HttpProtocol( + loop=loop, + connections=connections, + signal=signal, + request_handler=request_handler, + request_timeout=request_timeout, + request_max_size=request_max_size, + ), host, port) + try: + http_server = loop.run_until_complete(server_coroutine) + except OSError as e: + log.error("Unable to start server: {}".format(e)) + return + except: + log.exception("Unable to start server") + return + + # Run the on_start function if provided + if after_start: + result = after_start(loop) + if isawaitable(result): + loop.run_until_complete(result) + + # Register signals for graceful termination + for _signal in (SIGINT, SIGTERM): + loop.add_signal_handler(_signal, loop.stop) + + try: + loop.run_forever() + finally: + log.info("Stop requested, draining connections...") + + # Run the on_stop function if provided + if before_stop: + result = before_stop(loop) + if isawaitable(result): + loop.run_until_complete(result) + + # Wait for event loop to finish and all connections to drain + http_server.close() + loop.run_until_complete(http_server.wait_closed()) + + # Complete all tasks on the loop + signal.stopped = True + for connection in connections.keys(): + connection.close_if_idle() + + while connections: + loop.run_until_complete(asyncio.sleep(0.1)) + + loop.close() + log.info("Server Stopped") diff --git a/tests/performance/sanic/http_response.py b/tests/performance/sanic/http_response.py index 71b1f755..40557ab7 100644 --- a/tests/performance/sanic/http_response.py +++ b/tests/performance/sanic/http_response.py @@ -1,33 +1,33 @@ -import asyncpg -import sys -import os -import inspect - -currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) -sys.path.insert(0, currentdir + '/../../../') - -import timeit - -from sanic.response import json - -print(json({"test": True}).output()) - -print("Running New 100,000 times") -times = 0 -total_time = 0 -for n in range(6): - time = timeit.timeit('json({ "test":True }).output()', setup='from sanic.response import json', number=100000) - print("Took {} seconds".format(time)) - total_time += time - times += 1 -print("Average: {}".format(total_time / times)) - -print("Running Old 100,000 times") -times = 0 -total_time = 0 -for n in range(6): - time = timeit.timeit('json({ "test":True }).output_old()', setup='from sanic.response import json', number=100000) - print("Took {} seconds".format(time)) - total_time += time - times += 1 -print("Average: {}".format(total_time / times)) +import asyncpg +import sys +import os +import inspect + +currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) +sys.path.insert(0, currentdir + '/../../../') + +import timeit + +from sanic.response import json + +print(json({"test": True}).output()) + +print("Running New 100,000 times") +times = 0 +total_time = 0 +for n in range(6): + time = timeit.timeit('json({ "test":True }).output()', setup='from sanic.response import json', number=100000) + print("Took {} seconds".format(time)) + total_time += time + times += 1 +print("Average: {}".format(total_time / times)) + +print("Running Old 100,000 times") +times = 0 +total_time = 0 +for n in range(6): + time = timeit.timeit('json({ "test":True }).output_old()', setup='from sanic.response import json', number=100000) + print("Took {} seconds".format(time)) + total_time += time + times += 1 +print("Average: {}".format(total_time / times)) diff --git a/tests/performance/sanic/simple_server.py b/tests/performance/sanic/simple_server.py index d19ffa54..823b7b82 100644 --- a/tests/performance/sanic/simple_server.py +++ b/tests/performance/sanic/simple_server.py @@ -1,19 +1,19 @@ -import sys -import os -import inspect - -currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) -sys.path.insert(0, currentdir + '/../../../') - -from sanic import Sanic -from sanic.response import json - -app = Sanic("test") - - -@app.route("/") -async def test(request): - return json({"test": True}) - - -app.run(host="0.0.0.0", port=sys.argv[1]) +import sys +import os +import inspect + +currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) +sys.path.insert(0, currentdir + '/../../../') + +from sanic import Sanic +from sanic.response import json + +app = Sanic("test") + + +@app.route("/") +async def test(request): + return json({"test": True}) + + +app.run(host="0.0.0.0", port=sys.argv[1]) diff --git a/tests/performance/sanic/varied_server.py b/tests/performance/sanic/varied_server.py index 2c788387..a83e3044 100644 --- a/tests/performance/sanic/varied_server.py +++ b/tests/performance/sanic/varied_server.py @@ -1,91 +1,91 @@ -import sys -import os -import inspect - -currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) -sys.path.insert(0, currentdir + '/../../../') - -from sanic import Sanic -from sanic.response import json, text -from sanic.exceptions import ServerError - -app = Sanic("test") - - -@app.route("/") -async def test(request): - return json({"test": True}) - - -@app.route("/sync", methods=['GET', 'POST']) -def test(request): - return json({"test": True}) - - -@app.route("/text//") -def rtext(request, name, butt): - return text("yeehaww {} {}".format(name, butt)) - - -@app.route("/exception") -def exception(request): - raise ServerError("yep") - - -@app.route("/exception/async") -async def test(request): - raise ServerError("asunk") - - -@app.route("/post_json") -def post_json(request): - return json({"received": True, "message": request.json}) - - -@app.route("/query_string") -def query_string(request): - return json({"parsed": True, "args": request.args, "url": request.url, "query_string": request.query_string}) - - -import sys - -app.run(host="0.0.0.0", port=sys.argv[1]) - - - -# import asyncio_redis -# import asyncpg -# async def setup(sanic, loop): -# sanic.conn = [] -# sanic.redis = [] -# for x in range(10): -# sanic.conn.append(await asyncpg.connect(user='postgres', password='zomgdev', database='postgres', host='192.168.99.100')) -# for n in range(30): -# connection = await asyncio_redis.Connection.create(host='192.168.99.100', port=6379) -# sanic.redis.append(connection) - - -# c=0 -# @app.route("/postgres") -# async def postgres(request): -# global c -# values = await app.conn[c].fetch('''SELECT * FROM players''') -# c += 1 -# if c == 10: -# c = 0 -# return text("yep") - -# r=0 -# @app.route("/redis") -# async def redis(request): -# global r -# try: -# values = await app.redis[r].get('my_key') -# except asyncio_redis.exceptions.ConnectionLostError: -# app.redis[r] = await asyncio_redis.Connection.create(host='127.0.0.1', port=6379) -# values = await app.redis[r].get('my_key') - -# r += 1 -# if r == 30: -# r = 0 -# return text(values) +import sys +import os +import inspect + +currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) +sys.path.insert(0, currentdir + '/../../../') + +from sanic import Sanic +from sanic.response import json, text +from sanic.exceptions import ServerError + +app = Sanic("test") + + +@app.route("/") +async def test(request): + return json({"test": True}) + + +@app.route("/sync", methods=['GET', 'POST']) +def test(request): + return json({"test": True}) + + +@app.route("/text//") +def rtext(request, name, butt): + return text("yeehaww {} {}".format(name, butt)) + + +@app.route("/exception") +def exception(request): + raise ServerError("yep") + + +@app.route("/exception/async") +async def test(request): + raise ServerError("asunk") + + +@app.route("/post_json") +def post_json(request): + return json({"received": True, "message": request.json}) + + +@app.route("/query_string") +def query_string(request): + return json({"parsed": True, "args": request.args, "url": request.url, "query_string": request.query_string}) + + +import sys + +app.run(host="0.0.0.0", port=sys.argv[1]) + + + +# import asyncio_redis +# import asyncpg +# async def setup(sanic, loop): +# sanic.conn = [] +# sanic.redis = [] +# for x in range(10): +# sanic.conn.append(await asyncpg.connect(user='postgres', password='zomgdev', database='postgres', host='192.168.99.100')) +# for n in range(30): +# connection = await asyncio_redis.Connection.create(host='192.168.99.100', port=6379) +# sanic.redis.append(connection) + + +# c=0 +# @app.route("/postgres") +# async def postgres(request): +# global c +# values = await app.conn[c].fetch('''SELECT * FROM players''') +# c += 1 +# if c == 10: +# c = 0 +# return text("yep") + +# r=0 +# @app.route("/redis") +# async def redis(request): +# global r +# try: +# values = await app.redis[r].get('my_key') +# except asyncio_redis.exceptions.ConnectionLostError: +# app.redis[r] = await asyncio_redis.Connection.create(host='127.0.0.1', port=6379) +# values = await app.redis[r].get('my_key') + +# r += 1 +# if r == 30: +# r = 0 +# return text(values)