Merge pull request #110 from channelcat/cookies-lazy-creation

Lazy cookie creation

CHANGELOG.md

@@ -1,5 +1,7 @@
 Version 0.1
 -----------
+ - 0.1.6 (not released)
+  - Static files
  - 0.1.5 
   - Cookies
   - Blueprint listeners and ordering

README.md

@@ -51,6 +51,7 @@ app.run(host="0.0.0.0", port=8000)
  * [Exceptions](docs/exceptions.md)
  * [Blueprints](docs/blueprints.md)
  * [Cookies](docs/cookies.md)
+ * [Static Files](docs/static_files.md)
  * [Deploying](docs/deploying.md)
  * [Contributing](docs/contributing.md)
  * [License](LICENSE)

docs/blueprints.md

@@ -42,7 +42,7 @@ from sanic import Sanic
 from my_blueprint import bp
 
 app = Sanic(__name__)
-app.register_blueprint(bp)
+app.blueprint(bp)
 
 app.run(host='0.0.0.0', port=8000, debug=True)
 ```
@@ -79,6 +79,12 @@ Exceptions can also be applied exclusively to blueprints globally.
 @bp.exception(NotFound)
 def ignore_404s(request, exception):
 	return text("Yep, I totally found the page: {}".format(request.url))
+
+## Static files
+Static files can also be served globally, under the blueprint prefix.
+
+```python
+bp.static('/folder/to/serve', '/web/path')
 ```
 
 ## Start and Stop

docs/static_files.md

@@ -0,0 +1,18 @@
+# Static Files
+
+Both directories and files can be served by registering with static
+
+## Example
+
+```python
+app = Sanic(__name__)
+
+# Serves files from the static folder to the URL /static
+app.static('./static', '/static')
+
+# Serves the file /home/ubuntu/test.png when the URL /the_best.png
+# is requested
+app.static('/home/ubuntu/test.png', '/the_best.png')
+
+app.run(host="0.0.0.0", port=8000)
+```

sanic/__init__.py

@@ -1,4 +1,6 @@
 from .sanic import Sanic
 from .blueprints import Blueprint
 
+__version__ = '0.1.6'
+
 __all__ = ['Sanic', 'Blueprint']

sanic/blueprints.py

@@ -33,6 +33,15 @@ class BlueprintSetup:
         """
         self.app.exception(*args, **kwargs)(handler)
 
+    def add_static(self, file_or_directory, uri, *args, **kwargs):
+        """
+        Registers static files to sanic
+        """
+        if self.url_prefix:
+            uri = self.url_prefix + uri
+
+        self.app.static(file_or_directory, uri, *args, **kwargs)
+
     def add_middleware(self, middleware, *args, **kwargs):
         """
         Registers middleware to sanic
@@ -112,3 +121,9 @@ class Blueprint:
             self.record(lambda s: s.add_exception(handler, *args, **kwargs))
             return handler
         return decorator
+
+    def static(self, file_or_directory, uri, *args, **kwargs):
+        """
+        """
+        self.record(
+            lambda s: s.add_static(file_or_directory, uri, *args, **kwargs))

sanic/cookies.py

@@ -0,0 +1,129 @@
+from datetime import datetime
+import re
+import string
+
+# ------------------------------------------------------------ #
+#  SimpleCookie
+# ------------------------------------------------------------ #
+
+# Straight up copied this section of dark magic from SimpleCookie
+
+_LegalChars = string.ascii_letters + string.digits + "!#$%&'*+-.^_`|~:"
+_UnescapedChars = _LegalChars + ' ()/<=>?@[]{}'
+
+_Translator = {n: '\\%03o' % n
+               for n in set(range(256)) - set(map(ord, _UnescapedChars))}
+_Translator.update({
+    ord('"'): '\\"',
+    ord('\\'): '\\\\',
+})
+
+
+def _quote(str):
+    r"""Quote a string for use in a cookie header.
+    If the string does not need to be double-quoted, then just return the
+    string.  Otherwise, surround the string in doublequotes and quote
+    (with a \) special characters.
+    """
+    if str is None or _is_legal_key(str):
+        return str
+    else:
+        return '"' + str.translate(_Translator) + '"'
+
+_is_legal_key = re.compile('[%s]+' % re.escape(_LegalChars)).fullmatch
+
+# ------------------------------------------------------------ #
+#  Custom SimpleCookie
+# ------------------------------------------------------------ #
+
+
+class CookieJar(dict):
+    """
+    CookieJar dynamically writes headers as cookies are added and removed
+    It gets around the limitation of one header per name by using the
+    MultiHeader class to provide a unique key that encodes to Set-Cookie
+    """
+    def __init__(self, headers):
+        super().__init__()
+        self.headers = headers
+        self.cookie_headers = {}
+
+    def __setitem__(self, key, value):
+        # If this cookie doesn't exist, add it to the header keys
+        cookie_header = self.cookie_headers.get(key)
+        if not cookie_header:
+            cookie = Cookie(key, value)
+            cookie_header = MultiHeader("Set-Cookie")
+            self.cookie_headers[key] = cookie_header
+            self.headers[cookie_header] = cookie
+            return super().__setitem__(key, cookie)
+        else:
+            self[key].value = value
+
+    def __delitem__(self, key):
+        del self.cookie_headers[key]
+        return super().__delitem__(key)
+
+
+class Cookie(dict):
+    """
+    This is a stripped down version of Morsel from SimpleCookie #gottagofast
+    """
+    _keys = {
+        "expires": "expires",
+        "path": "Path",
+        "comment": "Comment",
+        "domain": "Domain",
+        "max-age": "Max-Age",
+        "secure": "Secure",
+        "httponly": "HttpOnly",
+        "version": "Version",
+    }
+    _flags = {'secure', 'httponly'}
+
+    def __init__(self, key, value):
+        if key in self._keys:
+            raise KeyError("Cookie name is a reserved word")
+        if not _is_legal_key(key):
+            raise KeyError("Cookie key contains illegal characters")
+        self.key = key
+        self.value = value
+        super().__init__()
+
+    def __setitem__(self, key, value):
+        if key not in self._keys:
+            raise KeyError("Unknown cookie property")
+        return super().__setitem__(key, value)
+
+    def encode(self, encoding):
+        output = ['%s=%s' % (self.key, _quote(self.value))]
+        for key, value in self.items():
+            if key == 'max-age' and isinstance(value, int):
+                output.append('%s=%d' % (self._keys[key], value))
+            elif key == 'expires' and isinstance(value, datetime):
+                output.append('%s=%s' % (
+                    self._keys[key],
+                    value.strftime("%a, %d-%b-%Y %T GMT")
+                ))
+            elif key in self._flags:
+                output.append(self._keys[key])
+            else:
+                output.append('%s=%s' % (self._keys[key], value))
+
+        return "; ".join(output).encode(encoding)
+
+# ------------------------------------------------------------ #
+#  Header Trickery
+# ------------------------------------------------------------ #
+
+
+class MultiHeader:
+    """
+    Allows us to set a header within response that has a unique key,
+    but may contain duplicate header names
+    """
+    def __init__(self, name):
+        self.name = name
+
+    def encode(self):
+        return self.name.encode()

sanic/exceptions.py

@@ -21,6 +21,15 @@ class ServerError(SanicException):
     status_code = 500
 
 
+class FileNotFound(NotFound):
+    status_code = 404
+
+    def __init__(self, message, path, relative_url):
+        super().__init__(message)
+        self.path = path
+        self.relative_url = relative_url
+
+
 class Handler:
     handlers = None
 

sanic/response.py

@@ -1,6 +1,8 @@
-from datetime import datetime
-from http.cookies import SimpleCookie
-import ujson
+from aiofiles import open as open_async
+from .cookies import CookieJar
+from mimetypes import guess_type
+from os import path
+from ujson import dumps as json_dumps
 
 COMMON_STATUS_CODES = {
     200: b'OK',
@@ -98,12 +100,6 @@ class HTTPResponse:
                 b'%b: %b\r\n' % (name.encode(), value.encode('utf-8'))
                 for name, value in self.headers.items()
             )
-        if self._cookies:
-            for cookie in self._cookies.values():
-                if type(cookie['expires']) is datetime:
-                    cookie['expires'] = \
-                        cookie['expires'].strftime("%a, %d-%b-%Y %T GMT")
-            headers += (str(self._cookies) + "\r\n").encode('utf-8')
 
         # Try to pull from the common codes first
         # Speeds up response rate 6% over pulling from all
@@ -131,12 +127,12 @@ class HTTPResponse:
     @property
     def cookies(self):
         if self._cookies is None:
-            self._cookies = SimpleCookie()
+            self._cookies = CookieJar(self.headers)
         return self._cookies
 
 
 def json(body, status=200, headers=None):
-    return HTTPResponse(ujson.dumps(body), headers=headers, status=status,
+    return HTTPResponse(json_dumps(body), headers=headers, status=status,
                         content_type="application/json")
 
 
@@ -148,3 +144,17 @@ def text(body, status=200, headers=None):
 def html(body, status=200, headers=None):
     return HTTPResponse(body, status=status, headers=headers,
                         content_type="text/html; charset=utf-8")
+
+
+async def file(location, mime_type=None, headers=None):
+    filename = path.split(location)[-1]
+
+    async with open_async(location, mode='rb') as _file:
+        out_stream = await _file.read()
+
+    mime_type = mime_type or guess_type(filename)[0] or 'text/plain'
+
+    return HTTPResponse(status=200,
+                        headers=headers,
+                        content_type=mime_type,
+                        body_bytes=out_stream)

sanic/router.py

@@ -82,6 +82,9 @@ class Router:
             # Mark the whole route as unhashable if it has the hash key in it
             if re.search('(^|[^^]){1}/', pattern):
                 properties['unhashable'] = True
+            # Mark the route as unhashable if it matches the hash key
+            elif re.search(pattern, '/'):
+                properties['unhashable'] = True
 
             return '({})'.format(pattern)
 

sanic/sanic.py

@@ -1,4 +1,5 @@
 from asyncio import get_event_loop
+from collections import deque
 from functools import partial
 from inspect import isawaitable
 from multiprocessing import Process, Event
@@ -12,6 +13,7 @@ from .log import log, logging
 from .response import HTTPResponse
 from .router import Router
 from .server import serve
+from .static import register as static_register
 from .exceptions import ServerError
 
 
@@ -21,13 +23,16 @@ class Sanic:
         self.router = router or Router()
         self.error_handler = error_handler or Handler(self)
         self.config = Config()
-        self.request_middleware = []
-        self.response_middleware = []
+        self.request_middleware = deque()
+        self.response_middleware = deque()
         self.blueprints = {}
         self._blueprint_order = []
         self.loop = None
         self.debug = None
 
+        # Register alternative method names
+        self.go_fast = self.run
+
     # -------------------------------------------------------------------- #
     # Registration
     # -------------------------------------------------------------------- #
@@ -41,6 +46,11 @@ class Sanic:
         :return: decorated function
         """
 
+        # Fix case where the user did not prefix the URL with a /
+        # and will probably get confused as to why it's not working
+        if not uri.startswith('/'):
+            uri = '/' + uri
+
         def response(handler):
             self.router.add(uri=uri, methods=methods, handler=handler)
             return handler
@@ -74,7 +84,7 @@ class Sanic:
             if attach_to == 'request':
                 self.request_middleware.append(middleware)
             if attach_to == 'response':
-                self.response_middleware.insert(0, middleware)
+                self.response_middleware.appendleft(middleware)
             return middleware
 
         # Detect which way this was called, @middleware or @middleware('AT')
@@ -84,7 +94,17 @@ class Sanic:
             attach_to = args[0]
             return register_middleware
 
-    def register_blueprint(self, blueprint, **options):
+    # Static Files
+    def static(self, file_or_directory, uri, pattern='.+',
+               use_modified_since=True):
+        """
+        Registers a root to serve files from.  The input can either be a file
+        or a directory.  See
+        """
+        static_register(self, file_or_directory, uri, pattern,
+                        use_modified_since)
+
+    def blueprint(self, blueprint, **options):
         """
         Registers a blueprint on the application.
         :param blueprint: Blueprint object
@@ -101,6 +121,12 @@ class Sanic:
             self._blueprint_order.append(blueprint)
         blueprint.register(self, options)
 
+    def register_blueprint(self, *args, **kwargs):
+        # TODO: deprecate 1.0
+        log.warning("Use of register_blueprint will be deprecated in "
+                    "version 1.0.  Please use the blueprint method instead")
+        return self.blueprint(*args, **kwargs)
+
     # -------------------------------------------------------------------- #
     # Request Handling
     # -------------------------------------------------------------------- #
@@ -296,7 +322,7 @@ class Sanic:
         signal(SIGTERM, lambda s, f: stop_event.set())
 
         processes = []
-        for w in range(workers):
+        for _ in range(workers):
             process = Process(target=serve, kwargs=server_settings)
             process.start()
             processes.append(process)

sanic/server.py

@@ -216,7 +216,7 @@ def serve(host, port, request_handler, before_start=None, after_start=None,
 
     try:
         http_server = loop.run_until_complete(server_coroutine)
-    except Exception as e:
+    except Exception:
         log.exception("Unable to start server")
         return
 

sanic/static.py

@@ -0,0 +1,59 @@
+from aiofiles.os import stat
+from os import path
+from re import sub
+from time import strftime, gmtime
+
+from .exceptions import FileNotFound, InvalidUsage
+from .response import file, HTTPResponse
+
+
+def register(app, file_or_directory, uri, pattern, use_modified_since):
+    # TODO: Though sanic is not a file server, I feel like we should atleast
+    #       make a good effort here.  Modified-since is nice, but we could
+    #       also look into etags, expires, and caching
+    """
+    Registers a static directory handler with Sanic by adding a route to the
+    router and registering a handler.
+    :param app: Sanic
+    :param file_or_directory: File or directory path to serve from
+    :param uri: URL to serve from
+    :param pattern: regular expression used to match files in the URL
+    :param use_modified_since: If true, send file modified time, and return
+                     not modified if the browser's matches the server's
+    """
+
+    # If we're not trying to match a file directly,
+    # serve from the folder
+    if not path.isfile(file_or_directory):
+        uri += '<file_uri:' + pattern + '>'
+
+    async def _handler(request, file_uri=None):
+        # Using this to determine if the URL is trying to break out of the path
+        # served.  os.path.realpath seems to be very slow
+        if file_uri and '../' in file_uri:
+            raise InvalidUsage("Invalid URL")
+
+        # Merge served directory and requested file if provided
+        # Strip all / that in the beginning of the URL to help prevent python
+        # from herping a derp and treating the uri as an absolute path
+        file_path = path.join(file_or_directory, sub('^[/]*', '', file_uri)) \
+            if file_uri else file_or_directory
+        try:
+            headers = {}
+            # Check if the client has been sent this file before
+            # and it has not been modified since
+            if use_modified_since:
+                stats = await stat(file_path)
+                modified_since = strftime('%a, %d %b %Y %H:%M:%S GMT',
+                                          gmtime(stats.st_mtime))
+                if request.headers.get('If-Modified-Since') == modified_since:
+                    return HTTPResponse(status=304)
+                headers['Last-Modified'] = modified_since
+
+            return await file(file_path, headers=headers)
+        except:
+            raise FileNotFound('File not found',
+                               path=file_or_directory,
+                               relative_url=file_uri)
+
+    app.route(uri, methods=['GET'])(_handler)

sanic/utils.py

@@ -11,6 +11,7 @@ async def local_request(method, uri, cookies=None, *args, **kwargs):
     async with aiohttp.ClientSession(cookies=cookies) as session:
         async with getattr(session, method)(url, *args, **kwargs) as response:
             response.text = await response.text()
+            response.body = await response.read()
             return response
 
 

setup.py

@@ -1,11 +1,23 @@
 """
 Sanic
 """
+import codecs
+import os
+import re
 from setuptools import setup
 
+
+with codecs.open(os.path.join(os.path.abspath(os.path.dirname(
+        __file__)), 'sanic', '__init__.py'), 'r', 'latin1') as fp:
+    try:
+        version = re.findall(r"^__version__ = '([^']+)'\r?$",
+                             fp.read(), re.M)[0]
+    except IndexError:
+        raise RuntimeError('Unable to determine version.')
+
 setup(
     name='Sanic',
-    version="0.1.5",
+    version=version,
     url='http://github.com/channelcat/sanic/',
     license='MIT',
     author='Channel Cat',
@@ -17,6 +29,7 @@ setup(
         'uvloop>=0.5.3',
         'httptools>=0.0.9',
         'ujson>=1.35',
+        'aiofiles>=0.3.0',
     ],
     classifiers=[
         'Development Status :: 2 - Pre-Alpha',

tests/test_blueprints.py

@@ -1,3 +1,5 @@
+import inspect
+
 from sanic import Sanic
 from sanic.blueprints import Blueprint
 from sanic.response import json, text
@@ -17,7 +19,7 @@ def test_bp():
     def handler(request):
         return text('Hello')
 
-    app.register_blueprint(bp)
+    app.blueprint(bp)
     request, response = sanic_endpoint_test(app)
 
     assert response.text == 'Hello'
@@ -30,7 +32,7 @@ def test_bp_with_url_prefix():
     def handler(request):
         return text('Hello')
 
-    app.register_blueprint(bp)
+    app.blueprint(bp)
     request, response = sanic_endpoint_test(app, uri='/test1/')
 
     assert response.text == 'Hello'
@@ -49,8 +51,8 @@ def test_several_bp_with_url_prefix():
     def handler2(request):
         return text('Hello2')
 
-    app.register_blueprint(bp)
-    app.register_blueprint(bp2)
+    app.blueprint(bp)
+    app.blueprint(bp2)
     request, response = sanic_endpoint_test(app, uri='/test1/')
     assert response.text == 'Hello'
 
@@ -70,7 +72,7 @@ def test_bp_middleware():
     async def handler(request):
         return text('FAIL')
 
-    app.register_blueprint(blueprint)
+    app.blueprint(blueprint)
 
     request, response = sanic_endpoint_test(app)
 
@@ -97,7 +99,7 @@ def test_bp_exception_handler():
     def handler_exception(request, exception):
         return text("OK")
 
-    app.register_blueprint(blueprint)
+    app.blueprint(blueprint)
 
     request, response = sanic_endpoint_test(app, uri='/1')
     assert response.status == 400
@@ -140,8 +142,24 @@ def test_bp_listeners():
     def handler_6(sanic, loop):
         order.append(6)
 
-    app.register_blueprint(blueprint)
+    app.blueprint(blueprint)
 
     request, response = sanic_endpoint_test(app, uri='/')
 
-    assert order == [1,2,3,4,5,6]
+    assert order == [1,2,3,4,5,6]
+
+def test_bp_static():
+    current_file = inspect.getfile(inspect.currentframe())
+    with open(current_file, 'rb') as file:
+        current_file_contents = file.read()
+
+    app = Sanic('test_static')
+    blueprint = Blueprint('test_static')
+
+    blueprint.static(current_file, '/testing.file')
+
+    app.blueprint(blueprint)
+
+    request, response = sanic_endpoint_test(app, uri='/testing.file')
+    assert response.status == 200
+    assert response.body == current_file_contents

tests/test_middleware.py

@@ -86,3 +86,43 @@ def test_middleware_override_response():
 
     assert response.status == 200
     assert response.text == 'OK'
+
+
+
+def test_middleware_order():
+    app = Sanic('test_middleware_order')
+
+    order = []
+
+    @app.middleware('request')
+    async def request1(request):
+        order.append(1)
+
+    @app.middleware('request')
+    async def request2(request):
+        order.append(2)
+
+    @app.middleware('request')
+    async def request3(request):
+        order.append(3)
+
+    @app.middleware('response')
+    async def response1(request, response):
+        order.append(6)
+
+    @app.middleware('response')
+    async def response2(request, response):
+        order.append(5)
+
+    @app.middleware('response')
+    async def response3(request, response):
+        order.append(4)
+
+    @app.route('/')
+    async def handler(request):
+        return text('OK')
+
+    request, response = sanic_endpoint_test(app)
+
+    assert response.status == 200
+    assert order == [1,2,3,4,5,6]

tests/test_routes.py

@@ -164,3 +164,17 @@ def test_route_duplicate():
         @app.route('/test/<dynamic>/')
         async def handler2(request, dynamic):
             pass
+
+
+def test_method_not_allowed():
+    app = Sanic('test_method_not_allowed')
+
+    @app.route('/test', methods=['GET'])
+    async def handler(request):
+        return text('OK')
+
+    request, response = sanic_endpoint_test(app, uri='/test')
+    assert response.status == 200
+
+    request, response = sanic_endpoint_test(app, method='post', uri='/test')
+    assert response.status == 405

tests/test_static.py

@@ -0,0 +1,30 @@
+import inspect
+import os
+
+from sanic import Sanic
+from sanic.utils import sanic_endpoint_test
+
+def test_static_file():
+    current_file = inspect.getfile(inspect.currentframe())
+    with open(current_file, 'rb') as file:
+        current_file_contents = file.read()
+
+    app = Sanic('test_static')
+    app.static(current_file, '/testing.file')
+
+    request, response = sanic_endpoint_test(app, uri='/testing.file')
+    assert response.status == 200
+    assert response.body == current_file_contents
+
+def test_static_directory():
+    current_file = inspect.getfile(inspect.currentframe())
+    current_directory = os.path.dirname(os.path.abspath(current_file))
+    with open(current_file, 'rb') as file:
+        current_file_contents = file.read()
+
+    app = Sanic('test_static')
+    app.static(current_directory, '/dir')
+
+    request, response = sanic_endpoint_test(app, uri='/dir/test_static.py')
+    assert response.status == 200
+    assert response.body == current_file_contents