Merge pull request #497 from seemethere/increment_041

Increment version to 0.4.1

.coveragerc

@@ -1,7 +1,7 @@
 [run]
 branch = True
-source = sanic, tests
-omit = site-packages
+source = sanic
+omit = site-packages, sanic/utils.py
 
 [html]
-directory = coverage
+directory = coverage

.gitignore

@@ -1,11 +1,16 @@
 *~
 *.egg-info
 *.egg
+*.eggs
+*.pyc
 .coverage
 .coverage.*
 coverage
 .tox
 settings.py
-*.pyc
 .idea/*
 .cache/*
+.python-version
+docs/_build/
+docs/_api/
+build/*

.travis.yml

@@ -1,18 +1,14 @@
+sudo: false
 language: python
 python:
-  - '3.5'
-install:
-  - pip install -r requirements.txt
-  - pip install -r requirements-dev.txt
-  - python setup.py install
-  - pip install flake8
-  - pip install pytest
-before_script: flake8 sanic
-script: py.test -v tests
+- '3.5'
+- '3.6'
+install: pip install tox-travis
+script: tox
 deploy:
   provider: pypi
   user: channelcat
   password:
-    secure: jH4+Di2/qcBwWVhI5/3NYd/JuDDgf5/cF85h+oQnAjgwP6me3th9RS0PHL2gjKJrmyRgwrW7a3eSAityo5sQSlBloQCNrtCE30rkDiwtgoIxDW72NR/nE8nUkS9Utgy87eS+3B4NrO7ag4GTqO5ET8SQ4/MCiQwyUQATLXj2s2eTpQvqJeZG6YgoeFAOYvlR580yznXoOwldWlkiymJiWSdR/01lthtWCi40sYC/QoU7psODJ/tPcsqgQtQKyUVsci7mKvp3Y8ImkoO/POM01jYNsS9qLh5pKTNCEYxtyzC77whenCNHn7WReVidd56g1ADosbNo4yY/1D3VAvwjUnkQ0SzdBQfT7IIzccEuC0j1NXKPN97OX0a6XzyUMYJ1XiU3juTJOPxdYBPbsDM3imQiwrOh1faIf0HCgNTN+Lxe5l8obCH7kffNcVUhs2zI0+2t4MS5tjb/OVuYD/TFn+bM33DqzLctTOK/pGn6xefzZcdzb191LPo99Lof+4fo6jNUpb0UmcBu5ZJzxh0lGe8FPIK3UAG/hrYDDgjx8s8RtUJjcEUQz0659XffYx7DLlgHO7cWyfjrHD3yrLzDbYr5mAS4FR+4D917V7UL+on4SsKHN00UuMGPguqSYo/xYyPLnJU5XK0du4MIpsNMB8TtrJOIewOOfD32+AisPQ8=
+    secure: OgADRQH3+dTL5swGzXkeRJDNbLpFzwqYnXB4iLD0Npvzj9QnKyQVvkbaeq6VmV9dpEFb5ULaAKYQq19CrXYDm28yanUSn6jdJ4SukaHusi7xt07U6H7pmoX/uZ2WZYqCSLM8cSp8TXY/3oV3rY5Jfj/AibE5XTbim5/lrhsvW6NR+ALzxc0URRPAHDZEPpojTCjSTjpY0aDsaKWg4mXVRMFfY3O68j6KaIoukIZLuoHfePLKrbZxaPG5VxNhMHEaICdxVxE/dO+7pQmQxXuIsEOHK1QiVJ9YrSGcNqgEqhN36kYP8dqMeVB07sv8Xa6o/Uax2/wXS2HEJvuwP1YD6WkoZuo9ZB85bcMdg7BV9jJDbVFVPJwc75BnTLHrMa3Q1KrRlKRDBUXBUsQivPuWhFNwUgvEayq2qSI3aRQR4Z0O+DfboEhXYojSoD64/EWBTZ7vhgbvOTGEdukUQSYrKj9P8jc1s8exomTsAiqdFxTUpzfiammUSL+M93lP4urtahl1jjXFX7gd3DzdEEb0NsGkx5lm/qdsty8/TeAvKUmC+RVU6T856W6MqN0P+yGbpWUARcSE7fwztC3SPxwAuxvIN3BHmRhOUHoORPNG2VpfbnscIzBKJR4v0JKzbpi0IDa66K+tCGsCEvQuL4cxVOtoUySPWNSUAyUWWUrGM2k=
   on:
     tags: true

CHANGELOG.md

@@ -0,0 +1,22 @@
+Version 0.1
+-----------
+ - 0.1.7
+  - Reversed static url and directory arguments to meet spec
+ - 0.1.6
+  - Static files
+  - Lazy Cookie Loading
+ - 0.1.5 
+  - Cookies
+  - Blueprint listeners and ordering
+  - Faster Router
+  - Fix: Incomplete file reads on medium+ sized post requests
+  - Breaking: after_start and before_stop now pass sanic as their first argument
+ - 0.1.4 
+  - Multiprocessing
+ - 0.1.3
+  - Blueprint support
+  - Faster Response processing
+ - 0.1.1 - 0.1.2 
+  - Struggling to update pypi via CI
+ - 0.1.0 
+  - Released to public

CHANGES

@@ -1,7 +0,0 @@
-Version 0.1
------------
- - 0.1.4 - Multiprocessing
- - 0.1.3 - Blueprint support
- - 0.1.1 - 0.1.2 - Struggling to update pypi via CI
-
-Released to public.

README.md

@@ -1,85 +0,0 @@
-# Sanic
-
-[![Build Status](https://travis-ci.org/channelcat/sanic.svg?branch=master)](https://travis-ci.org/channelcat/sanic)
-[![PyPI](https://img.shields.io/pypi/v/sanic.svg)](https://pypi.python.org/pypi/sanic/)
-[![PyPI](https://img.shields.io/pypi/pyversions/sanic.svg)](https://pypi.python.org/pypi/sanic/)
-
-Sanic is a Flask-like Python 3.5+ web server that's written to go fast.  It's based on the work done by the amazing folks at magicstack, and was inspired by this article: https://magic.io/blog/uvloop-blazing-fast-python-networking/.
-
-On top of being Flask-like, Sanic supports async request handlers.  This means you can use the new shiny async/await syntax from Python 3.5, making your code non-blocking and speedy.
-
-## Benchmarks
-
-All tests were run on an AWS medium instance running ubuntu, using 1 process.  Each script delivered a small JSON response and was tested with wrk using 100 connections.  Pypy was tested for Falcon and Flask but did not speed up requests.
-
-
-
-| Server  | Implementation      | Requests/sec | Avg Latency |
-| ------- | ------------------- | ------------:| -----------:|
-| Sanic   | Python 3.5 + uvloop |       30,601 |      3.23ms |
-| Wheezy  | gunicorn + meinheld |       20,244 |      4.94ms |
-| Falcon  | gunicorn + meinheld |       18,972 |      5.27ms |
-| Bottle  | gunicorn + meinheld |       13,596 |      7.36ms |
-| Flask   | gunicorn + meinheld |        4,988 |     20.08ms |
-| Kyoukai | Python 3.5 + uvloop |        3,889 |     27.44ms |
-| Aiohttp | Python 3.5 + uvloop |        2,979 |     33.42ms |
-
-## Hello World
-
-```python
-from sanic import Sanic
-from sanic.response import json
-
-app = Sanic(__name__)
-
-@app.route("/")
-async def test(request):
-    return json({ "hello": "world" })
-
-app.run(host="0.0.0.0", port=8000)
-```
-
-## Installation
- * `python -m pip install sanic`
-
-## Documentation
- * [Getting started](docs/getting_started.md)
- * [Request Data](docs/request_data.md)
- * [Routing](docs/routing.md)
- * [Middleware](docs/middleware.md)
- * [Exceptions](docs/exceptions.md)
- * [Blueprints](docs/blueprints.md)
- * [Deploying](docs/deploying.md)
- * [Contributing](docs/contributing.md)
- * [License](LICENSE)
-
-## TODO:
- * Streamed file processing
- * File output
- * Examples of integrations with 3rd-party modules
- * RESTful router
-
-## Limitations:
- * No wheels for uvloop and httptools on Windows :(
-
-## Final Thoughts:
-
-                     ▄▄▄▄▄
-            ▀▀▀██████▄▄▄       _______________
-          ▄▄▄▄▄  █████████▄  /                 \
-         ▀▀▀▀█████▌ ▀▐▄ ▀▐█ |   Gotta go fast!  | 
-       ▀▀█████▄▄ ▀██████▄██ | _________________/
-       ▀▄▄▄▄▄  ▀▀█▄▀█════█▀ |/
-            ▀▀▀▄  ▀▀███ ▀       ▄▄
-         ▄███▀▀██▄████████▄ ▄▀▀▀▀▀▀█▌
-       ██▀▄▄▄██▀▄███▀ ▀▀████      ▄██
-    ▄▀▀▀▄██▄▀▀▌████▒▒▒▒▒▒███     ▌▄▄▀
-    ▌    ▐▀████▐███▒▒▒▒▒▐██▌
-    ▀▄▄▄▄▀   ▀▀████▒▒▒▒▄██▀
-              ▀▀█████████▀
-            ▄▄██▀██████▀█
-          ▄██▀     ▀▀▀  █
-         ▄█             ▐▌
-     ▄▄▄▄█▌              ▀█▄▄▄▄▀▀▄
-    ▌     ▐                ▀▀▄▄▄▀
-     ▀▀▄▄▀

README.rst

@@ -0,0 +1,109 @@
+Sanic
+=================================
+
+|Join the chat at https://gitter.im/sanic-python/Lobby| |Build Status| |PyPI| |PyPI version|
+
+Sanic is a Flask-like Python 3.5+ web server that's written to go fast.  It's based on the work done by the amazing folks at magicstack, and was inspired by `this article <https://magic.io/blog/uvloop-blazing-fast-python-networking/>`_.
+
+On top of being Flask-like, Sanic supports async request handlers.  This means you can use the new shiny async/await syntax from Python 3.5, making your code non-blocking and speedy.
+
+Sanic is developed `on GitHub <https://github.com/channelcat/sanic/>`_. Contributions are welcome!
+
+Benchmarks
+----------
+
+All tests were run on an AWS medium instance running ubuntu, using 1
+process. Each script delivered a small JSON response and was tested with
+wrk using 100 connections. Pypy was tested for Falcon and Flask but did
+not speed up requests.
+
++-----------+-----------------------+----------------+---------------+
+| Server    | Implementation        | Requests/sec   | Avg Latency   |
++===========+=======================+================+===============+
+| Sanic     | Python 3.5 + uvloop   | 33,342         | 2.96ms        |
++-----------+-----------------------+----------------+---------------+
+| Wheezy    | gunicorn + meinheld   | 20,244         | 4.94ms        |
++-----------+-----------------------+----------------+---------------+
+| Falcon    | gunicorn + meinheld   | 18,972         | 5.27ms        |
++-----------+-----------------------+----------------+---------------+
+| Bottle    | gunicorn + meinheld   | 13,596         | 7.36ms        |
++-----------+-----------------------+----------------+---------------+
+| Flask     | gunicorn + meinheld   | 4,988          | 20.08ms       |
++-----------+-----------------------+----------------+---------------+
+| Kyoukai   | Python 3.5 + uvloop   | 3,889          | 27.44ms       |
++-----------+-----------------------+----------------+---------------+
+| Aiohttp   | Python 3.5 + uvloop   | 2,979          | 33.42ms       |
++-----------+-----------------------+----------------+---------------+
+| Tornado   | Python 3.5            | 2,138          | 46.66ms       |
++-----------+-----------------------+----------------+---------------+
+
+Hello World Example
+-------------------
+
+.. code:: python
+
+    from sanic import Sanic
+    from sanic.response import json
+
+    app = Sanic()
+
+    @app.route("/")
+    async def test(request):
+        return json({"hello": "world"})
+
+    if __name__ == "__main__":
+        app.run(host="0.0.0.0", port=8000)
+
+Installation
+------------
+
+-  ``python -m pip install sanic``
+
+Documentation
+-------------
+
+`Documentation on Readthedocs <http://sanic.readthedocs.io/>`_.
+
+.. |Join the chat at https://gitter.im/sanic-python/Lobby| image:: https://badges.gitter.im/sanic-python/Lobby.svg
+   :target: https://gitter.im/sanic-python/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+.. |Build Status| image:: https://travis-ci.org/channelcat/sanic.svg?branch=master
+   :target: https://travis-ci.org/channelcat/sanic
+.. |Documentation| image:: https://readthedocs.org/projects/sanic/badge/?version=latest
+   :target: http://sanic.readthedocs.io/en/latest/?badge=latest
+.. |PyPI| image:: https://img.shields.io/pypi/v/sanic.svg
+   :target: https://pypi.python.org/pypi/sanic/
+.. |PyPI version| image:: https://img.shields.io/pypi/pyversions/sanic.svg
+   :target: https://pypi.python.org/pypi/sanic/
+
+TODO
+----
+* Streamed file processing
+* http2
+Limitations
+-----------
+* No wheels for uvloop and httptools on Windows :(
+
+Final Thoughts
+--------------
+
+::
+
+                     ▄▄▄▄▄
+            ▀▀▀██████▄▄▄       _______________
+          ▄▄▄▄▄  █████████▄  /                 \
+         ▀▀▀▀█████▌ ▀▐▄ ▀▐█ |   Gotta go fast!  |
+       ▀▀█████▄▄ ▀██████▄██ | _________________/
+       ▀▄▄▄▄▄  ▀▀█▄▀█════█▀ |/
+            ▀▀▀▄  ▀▀███ ▀       ▄▄
+         ▄███▀▀██▄████████▄ ▄▀▀▀▀▀▀█▌
+       ██▀▄▄▄██▀▄███▀ ▀▀████      ▄██
+    ▄▀▀▀▄██▄▀▀▌████▒▒▒▒▒▒███     ▌▄▄▀
+    ▌    ▐▀████▐███▒▒▒▒▒▐██▌
+    ▀▄▄▄▄▀   ▀▀████▒▒▒▒▄██▀
+              ▀▀█████████▀
+            ▄▄██▀██████▀█
+          ▄██▀     ▀▀▀  █
+         ▄█             ▐▌
+     ▄▄▄▄█▌              ▀█▄▄▄▄▀▀▄
+    ▌     ▐                ▀▀▄▄▄▀
+     ▀▀▄▄▀

docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+SPHINXPROJ    = Sanic
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

docs/blueprints.md

@@ -1,82 +0,0 @@
-# Blueprints
-
-Blueprints are objects that can be used for sub-routing within an application.
-Instead of adding routes to the application object, blueprints define similar
-methods for adding routes, which are then registered with the application in a
-flexible and pluggable manner.
-
-## Why?
-
-Blueprints are especially useful for larger applications, where your application
-logic can be broken down into several groups or areas of responsibility.
-
-It is also useful for API versioning, where one blueprint may point at
-`/v1/<routes>`, and another pointing at `/v2/<routes>`.
-
-
-## My First Blueprint
-
-The following shows a very simple blueprint that registers a handler-function at
-the root `/` of your application.
-
-Suppose you save this file as `my_blueprint.py`, this can be imported in your
-main application later.
-
-```python
-from sanic.response import json
-from sanic import Blueprint
-
-bp = Blueprint('my_blueprint')
-
-@bp.route('/')
-async def bp_root():
-    return json({'my': 'blueprint'})
-
-```
-
-## Registering Blueprints
-Blueprints must be registered with the application.
-
-```python
-from sanic import Sanic
-from my_blueprint import bp
-
-app = Sanic(__name__)
-app.register_blueprint(bp)
-
-app.run(host='0.0.0.0', port=8000, debug=True)
-```
-
-This will add the blueprint to the application and register any routes defined
-by that blueprint.
-In this example, the registered routes in the `app.router` will look like:
-
-```python
-[Route(handler=<function bp_root at 0x7f908382f9d8>, methods=None, pattern=re.compile('^/$'), parameters=[])]
-```
-
-## Middleware
-Using blueprints allows you to also register middleware globally.
-
-```python
-@bp.middleware
-async def halt_request(request):
-	print("I am a spy")
-
-@bp.middleware('request')
-async def halt_request(request):
-	return text('I halted the request')
-
-@bp.middleware('response')
-async def halt_response(request, response):
-	return text('I halted the response')
-```
-
-## Exceptions
-Exceptions can also be applied exclusively to blueprints globally.
-
-```python
-@bp.exception(NotFound)
-def ignore_404s(request, exception):
-	return text("Yep, I totally found the page: {}".format(request.url))
-```

docs/conf.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Sanic documentation build configuration file, created by
+# sphinx-quickstart on Sun Dec 25 18:07:21 2016.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+
+import os
+import sys
+
+# Add support for Markdown documentation using Recommonmark
+from recommonmark.parser import CommonMarkParser
+
+# Ensure that sanic is present in the path, to allow sphinx-apidoc to
+# autogenerate documentation from docstrings
+root_directory = os.path.dirname(os.getcwd())
+sys.path.insert(0, root_directory)
+
+import sanic
+
+# -- General configuration ------------------------------------------------
+
+extensions = []
+
+templates_path = ['_templates']
+
+# Enable support for both Restructured Text and Markdown
+source_parsers = {'.md': CommonMarkParser}
+source_suffix = ['.rst', '.md']
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = 'Sanic'
+copyright = '2016, Sanic contributors'
+author = 'Sanic contributors'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = sanic.__version__
+# The full version, including alpha/beta/rc tags.
+release = sanic.__version__
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = 'en'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This patterns also effect to html_static_path and html_extra_path
+#
+# modules.rst is generated by sphinx-apidoc but is unused. This suppresses
+# a warning about it.
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store', 'modules.rst']
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = False
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+html_theme = 'sphinx_rtd_theme'
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+
+# -- Options for HTMLHelp output ------------------------------------------
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'Sanicdoc'
+
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+    # The paper size ('letterpaper' or 'a4paper').
+    #
+    # 'papersize': 'letterpaper',
+
+    # The font size ('10pt', '11pt' or '12pt').
+    #
+    # 'pointsize': '10pt',
+
+    # Additional stuff for the LaTeX preamble.
+    #
+    # 'preamble': '',
+
+    # Latex figure (float) alignment
+    #
+    # 'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+    (master_doc, 'Sanic.tex', 'Sanic Documentation',
+     'Sanic contributors', 'manual'),
+]
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    (master_doc, 'sanic', 'Sanic Documentation',
+     [author], 1)
+]
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (master_doc, 'Sanic', 'Sanic Documentation',
+     author, 'Sanic', 'One line description of project.',
+     'Miscellaneous'),
+]
+
+
+
+# -- Options for Epub output ----------------------------------------------
+
+# Bibliographic Dublin Core info.
+epub_title = project
+epub_author = author
+epub_publisher = author
+epub_copyright = copyright
+
+# A list of files that should not be packed into the epub file.
+epub_exclude_files = ['search.html']
+
+
+
+# -- Custom Settings -------------------------------------------------------
+
+suppress_warnings = ['image.nonlocal_uri']

docs/config.md

@@ -0,0 +1,78 @@
+# Configuration
+
+Any reasonably complex application will need configuration that is not baked into the acutal code. Settings might be different for different environments or installations.
+
+## Basics
+
+Sanic holds the configuration in the `config` attribute of the application object. The configuration object is merely an object that can be modified either using dot-notation or like a dictionary:
+
+```
+app = Sanic('myapp')
+app.config.DB_NAME = 'appdb'
+app.config.DB_USER = 'appuser'
+```
+
+Since the config object actually is a dictionary, you can use its `update` method in order to set several values at once:
+
+```
+db_settings = {
+    'DB_HOST': 'localhost',
+    'DB_NAME': 'appdb',
+    'DB_USER': 'appuser'
+}
+app.config.update(db_settings)
+```
+
+In general the convention is to only have UPPERCASE configuration parameters. The methods described below for loading configuration only look for such uppercase parameters.
+
+## Loading Configuration
+
+There are several ways how to load configuration.
+
+### From an Object
+
+If there are a lot of configuration values and they have sensible defaults it might be helpful to put them into a module:
+
+```
+import myapp.default_settings
+
+app = Sanic('myapp')
+app.config.from_object(myapp.default_settings)
+```
+
+You could use a class or any other object as well.
+
+### From a File
+
+Usually you will want to load configuration from a file that is not part of the distributed application. You can load configuration from a file using `from_file(/path/to/config_file)`. However, that requires the program to know the path to the config file. So instead you can specify the location of the config file in an environment variable and tell Sanic to use that to find the config file:
+
+```
+app = Sanic('myapp')
+app.config.from_envvar('MYAPP_SETTINGS')
+```
+
+Then you can run your application with the `MYAPP_SETTINGS` environment variable set:
+
+```
+$ MYAPP_SETTINGS=/path/to/config_file python3 myapp.py
+INFO: Goin' Fast @ http://0.0.0.0:8000
+```
+
+The config files are regular Python files which are executed in order to load them. This allows you to use arbitrary logic for constructing the right configuration. Only uppercase varibales are added to the configuration. Most commonly the configuration consists of simple key value pairs:
+
+```
+# config_file
+DB_HOST = 'localhost'
+DB_NAME = 'appdb'
+DB_USER = 'appuser'
+```
+
+## Builtin Configuration Values
+
+Out of the box there are just a few predefined values which can be overwritten when creating the application.
+
+| Variable          | Default   | Description                       |
+| ----------------- | --------- | --------------------------------- |
+| REQUEST_MAX_SIZE  | 100000000 | How big a request may be (bytes)  |
+| REQUEST_TIMEOUT   | 60        | How long a request can take (sec) |
+

docs/contributing.md

@@ -1,10 +0,0 @@
-# How to contribute to Sanic
-
-Thank you for your interest!
-
-## Running tests
-* `python -m pip install pytest`
-* `python -m pytest tests`
-
-## Warning
-One of the main goals of Sanic is speed.  Code that lowers the performance of Sanic without significant gains in usability, security, or features may not be merged.

docs/deploying.md

@@ -1,35 +0,0 @@
-# Deploying
-
-When it comes to deploying Sanic, there's not much to it, but there are
-a few things to take note of.
-
-## Workers
-
-By default, Sanic listens in the main process using only 1 CPU core.
-To crank up the juice, just specify the number of workers in the run
-arguments like so:
-
-```python
-app.run(host='0.0.0.0', port=1337, workers=4)
-```
-
-Sanic will automatically spin up multiple processes and route
-traffic between them.  We recommend as many workers as you have
-available cores.
-
-## Running via Command
-
-If you like using command line arguments, you can launch a sanic server
-by executing the module.  For example, if you initialized sanic as
-app in a file named server.py, you could run the server like so:
-
-`python -m sanic server.app --host=0.0.0.0 --port=1337 --workers=4`
-
-With this way of running sanic, it is not necessary to run app.run in
-your python file.  If you do, just make sure you wrap it in name == main
-like so:
-
-```python
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=1337, workers=4)
-```

docs/exceptions.md

@@ -1,28 +0,0 @@
-# Exceptions
-
-Exceptions can be thrown from within request handlers and will automatically be handled by Sanic.  Exceptions take a message as their first argument, and can also take a status_code to be passed back in the HTTP response.  Check sanic.exceptions for the full list of exceptions to throw.
-
-## Throwing an exception
-
-```python
-from sanic import Sanic
-from sanic.exceptions import ServerError
-
-@app.route('/killme')
-def i_am_ready_to_die(request):
-	raise ServerError("Something bad happened")
-```
-
-## Handling Exceptions
-
-Just use the @exception decorator.  The decorator expects a list of exceptions to handle as arguments.  You can pass SanicException to catch them all!  The exception handler must expect a request and exception object as arguments.
-
-```python
-from sanic import Sanic
-from sanic.response import text
-from sanic.exceptions import NotFound
-
-@app.exception(NotFound)
-def ignore_404s(request, exception):
-	return text("Yep, I totally found the page: {}".format(request.url))
-```

docs/getting_started.md

@@ -1,25 +0,0 @@
-# Getting Started
-
-Make sure you have pip and python 3.5 before starting
-
-## Benchmarks
- * Install Sanic
- * `python3 -m pip install sanic`
- * Edit main.py to include:
-```python
-from sanic import Sanic
-from sanic.response import json
-
-app = Sanic(__name__)
-
-@app.route("/")
-async def test(request):
-    return json({ "hello": "world" })
-
-app.run(host="0.0.0.0", port=8000, debug=True)
-```
- * Run `python3 main.py`
-
-You now have a working Sanic server!  To continue on, check out:
- * [Request Data](request_data.md)
- * [Routing](routing.md)

docs/index.rst

@@ -0,0 +1,33 @@
+.. include:: sanic/index.rst
+
+Guides
+======
+
+.. toctree::
+   :maxdepth: 2
+
+   sanic/getting_started
+   sanic/routing
+   sanic/request_data
+   sanic/static_files
+   sanic/exceptions
+   sanic/middleware
+   sanic/blueprints
+   sanic/config
+   sanic/cookies
+   sanic/class_based_views
+   sanic/custom_protocol
+   sanic/ssl
+   sanic/testing
+   sanic/deploying
+   sanic/extensions
+   sanic/contributing
+
+
+Module Documentation
+====================
+
+.. toctree::
+
+* :ref:`genindex`
+* :ref:`search`

docs/make.bat

@@ -0,0 +1,36 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+set SPHINXPROJ=Sanic
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+
+:end
+popd

docs/middleware.md

@@ -1,29 +0,0 @@
-# Middleware
-
-Middleware can be executed before or after requests.  It is executed in the order it was registered.  If middleware returns a response object, the request will stop processing and a response will be returned.
-
-Middleware is registered via the middleware decorator, and can either be added as 'request' or 'response' middleware, based on the argument provided in the decorator.  Response middleware receives both the request and the response as arguments.
-
-## Examples
-
-```python
-app = Sanic(__name__)
-
-@app.middleware
-async def halt_request(request):
-	print("I am a spy")
-
-@app.middleware('request')
-async def halt_request(request):
-	return text('I halted the request')
-
-@app.middleware('response')
-async def halt_response(request, response):
-	return text('I halted the response')
-
-@app.route('/')
-async def handler(request):
-	return text('I would like to speak now please')
-
-app.run(host="0.0.0.0", port=8000)
-```

docs/request_data.md

@@ -1,43 +0,0 @@
-# Request Data
-
-## Properties
-
-The following request variables are accessible as properties:
-
-`request.files` (dictionary of File objects) - List of files that have a name, body, and type  
-`request.json` (any) - JSON body  
-`request.args` (dict) - Query String variables.  Use getlist to get multiple of the same name  
-`request.form` (dict) - Posted form variables.  Use getlist to get multiple of the same name  
-
-See request.py for more information
-
-## Examples
-
-```python
-from sanic import Sanic
-from sanic.response import json
-
-@app.route("/json")
-def post_json(request):
-    return json({ "received": True, "message": request.json })
-
-@app.route("/form")
-def post_json(request):
-    return json({ "received": True, "form_data": request.form, "test": request.form.get('test') })
-
-@app.route("/files")
-def post_json(request):
-	test_file = request.files.get('test')
-
-	file_parameters = {
-		'body': test_file.body,
-		'name': test_file.name,
-		'type': test_file.type,
-	}
-
-    return json({ "received": True, "file_names": request.files.keys(), "test_file_parameters": file_parameters })
-
-@app.route("/query_string")
-def query_string(request):
-    return json({ "parsed": True, "args": request.args, "url": request.url, "query_string": request.query_string })
-```

docs/routing.md

@@ -1,32 +0,0 @@
-# Routing
-
-Sanic comes with a basic router that supports request parameters.  To specify a parameter, surround it with carrots like so: `<PARAM>`.  Request parameters will be passed to the request handler functions as keyword arguments.  To specify a type, add a :type after the parameter name, in the carrots.  If the parameter does not match the type supplied, Sanic will throw a NotFound exception, resulting in a 404 page not found error.
-
-
-## Examples
-
-```python
-from sanic import Sanic
-from sanic.response import text
-
-@app.route('/tag/<tag>')
-async def person_handler(request, tag):
-	return text('Tag - {}'.format(tag))
-
-@app.route('/number/<integer_arg:int>')
-async def person_handler(request, integer_arg):
-	return text('Integer - {}'.format(integer_arg))
-
-@app.route('/number/<number_arg:number>')
-async def person_handler(request, number_arg):
-	return text('Number - {}'.format(number))
-
-@app.route('/person/<name:[A-z]>')
-async def person_handler(request, name):
-	return text('Person - {}'.format(name))
-
-@app.route('/folder/<folder_id:[A-z0-9]{0,4}>')
-async def folder_handler(request, folder_id):
-	return text('Folder - {}'.format(folder_id))
-
-```

docs/sanic/blueprints.md

@@ -0,0 +1,179 @@
+# Blueprints
+
+Blueprints are objects that can be used for sub-routing within an application.
+Instead of adding routes to the application instance, blueprints define similar
+methods for adding routes, which are then registered with the application in a
+flexible and pluggable manner.
+
+Blueprints are especially useful for larger applications, where your
+application logic can be broken down into several groups or areas of
+responsibility.
+
+## My First Blueprint
+
+The following shows a very simple blueprint that registers a handler-function at
+the root `/` of your application.
+
+Suppose you save this file as `my_blueprint.py`, which can be imported into your
+main application later.
+
+```python
+from sanic.response import json
+from sanic import Blueprint
+
+bp = Blueprint('my_blueprint')
+
+@bp.route('/')
+async def bp_root(request):
+    return json({'my': 'blueprint'})
+
+```
+
+## Registering blueprints
+
+Blueprints must be registered with the application.
+
+```python
+from sanic import Sanic
+from my_blueprint import bp
+
+app = Sanic(__name__)
+app.blueprint(bp)
+
+app.run(host='0.0.0.0', port=8000, debug=True)
+```
+
+This will add the blueprint to the application and register any routes defined
+by that blueprint. In this example, the registered routes in the `app.router`
+will look like:
+
+```python
+[Route(handler=<function bp_root at 0x7f908382f9d8>, methods=None, pattern=re.compile('^/$'), parameters=[])]
+```
+
+## Using blueprints
+
+Blueprints have much the same functionality as an application instance.
+
+### Middleware
+
+Using blueprints allows you to also register middleware globally.
+
+```python
+@bp.middleware
+async def halt_request(request):
+	print("I am a spy")
+
+@bp.middleware('request')
+async def halt_request(request):
+	return text('I halted the request')
+
+@bp.middleware('response')
+async def halt_response(request, response):
+	return text('I halted the response')
+```
+
+### Exceptions
+
+Exceptions can be applied exclusively to blueprints globally.
+
+```python
+@bp.exception(NotFound)
+def ignore_404s(request, exception):
+	return text("Yep, I totally found the page: {}".format(request.url))
+```
+
+### Static files
+
+Static files can be served globally, under the blueprint prefix.
+
+```python
+bp.static('/folder/to/serve', '/web/path')
+```
+
+## Start and stop
+
+Blueprints can run functions during the start and stop process of the server.
+If running in multiprocessor mode (more than 1 worker), these are triggered
+after the workers fork.
+
+Available events are:
+
+- `before_server_start`: Executed before the server begins to accept connections
+- `after_server_start`: Executed after the server begins to accept connections
+- `before_server_stop`: Executed before the server stops accepting connections
+- `after_server_stop`: Executed after the server is stopped and all requests are complete
+
+```python
+bp = Blueprint('my_blueprint')
+
+@bp.listener('before_server_start')
+async def setup_connection(app, loop):
+    global database
+    database = mysql.connect(host='127.0.0.1'...)
+    
+@bp.listener('after_server_stop')
+async def close_connection(app, loop):
+    await database.close()
+```
+
+## Use-case: API versioning
+
+Blueprints can be very useful for API versioning, where one blueprint may point
+at `/v1/<routes>`, and another pointing at `/v2/<routes>`.
+
+When a blueprint is initialised, it can take an optional `url_prefix` argument,
+which will be prepended to all routes defined on the blueprint. This feature
+can be used to implement our API versioning scheme.
+
+```python
+# blueprints.py
+from sanic.response import text
+from sanic import Blueprint
+
+blueprint_v1 = Blueprint('v1', url_prefix='/v1')
+blueprint_v2 = Blueprint('v2', url_prefix='/v2')
+
+@blueprint_v1.route('/')
+async def api_v1_root(request):
+    return text('Welcome to version 1 of our documentation')
+    
+@blueprint_v2.route('/')
+async def api_v2_root(request):
+    return text('Welcome to version 2 of our documentation')
+```
+
+When we register our blueprints on the app, the routes `/v1` and `/v2` will now
+point to the individual blueprints, which allows the creation of *sub-sites*
+for each API version.
+
+```python
+# main.py
+from sanic import Sanic
+from blueprints import blueprint_v1, blueprint_v2
+
+app = Sanic(__name__)
+app.blueprint(blueprint_v1, url_prefix='/v1')
+app.blueprint(blueprint_v2, url_prefix='/v2')
+
+app.run(host='0.0.0.0', port=8000, debug=True)
+```
+
+## URL Building with `url_for`
+
+If you wish to generate a URL for a route inside of a blueprint, remember that the endpoint name
+takes the format `<blueprint_name>.<handler_name>`. For example:
+
+```
+@blueprint_v1.route('/')
+async def root(request):
+    url = app.url_for('v1.post_handler', post_id=5) # --> '/v1/post/5'
+    return redirect(url)
+
+
+@blueprint_v1.route('/post/<post_id>')
+async def post_handler(request, post_id):
+    return text('Post {} in Blueprint V1'.format(post_id))
+```
+
+

docs/sanic/class_based_views.md

@@ -0,0 +1,131 @@
+# Class-Based Views
+
+Class-based views are simply classes which implement response behaviour to
+requests. They provide a way to compartmentalise handling of different HTTP
+request types at the same endpoint. Rather than defining and decorating three
+different handler functions, one for each of an endpoint's supported request
+type, the endpoint can be assigned a class-based view.
+
+## Defining views
+
+A class-based view should subclass `HTTPMethodView`. You can then implement
+class methods for every HTTP request type you want to support. If a request is
+received that has no defined method, a `405: Method not allowed` response will
+be generated.
+
+To register a class-based view on an endpoint, the `app.add_route` method is
+used. The first argument should be the defined class with the method `as_view`
+invoked, and the second should be the URL endpoint.
+
+The available methods are `get`, `post`, `put`, `patch`, and `delete`. A class
+using all these methods would look like the following.
+
+```python
+from sanic import Sanic
+from sanic.views import HTTPMethodView
+from sanic.response import text
+
+app = Sanic('some_name')
+
+class SimpleView(HTTPMethodView):
+
+  def get(self, request):
+      return text('I am get method')
+
+  def post(self, request):
+      return text('I am post method')
+
+  def put(self, request):
+      return text('I am put method')
+
+  def patch(self, request):
+      return text('I am patch method')
+
+  def delete(self, request):
+      return text('I am delete method')
+
+app.add_route(SimpleView.as_view(), '/')
+
+```
+
+## URL parameters
+
+If you need any URL parameters, as discussed in the routing guide, include them
+in the method definition.
+
+```python
+class NameView(HTTPMethodView):
+
+  def get(self, request, name):
+    return text('Hello {}'.format(name))
+
+app.add_route(NameView.as_view(), '/<name>')
+```
+
+## Decorators
+
+If you want to add any decorators to the class, you can set the `decorators`
+class variable. These will be applied to the class when `as_view` is called.
+
+```python
+class ViewWithDecorator(HTTPMethodView):
+  decorators = [some_decorator_here]
+
+  def get(self, request, name):
+    return text('Hello I have a decorator')
+
+app.add_route(ViewWithDecorator.as_view(), '/url')
+```
+
+#### URL Building
+
+If you wish to build a URL for an HTTPMethodView, remember that the class name will be the endpoint
+that you will pass into `url_for`. For example:
+
+```python
+@app.route('/')
+def index(request):
+    url = app.url_for('SpecialClassView')
+    return redirect(url)
+
+
+class SpecialClassView(HTTPMethodView):
+    def get(self, request):
+        return text('Hello from the Special Class View!')
+
+
+app.add_route(SpecialClassView.as_view(), '/special_class_view')
+```
+
+
+## Using CompositionView
+
+As an alternative to the `HTTPMethodView`, you can use `CompositionView` to
+move handler functions outside of the view class.
+
+Handler functions for each supported HTTP method are defined elsewhere in the
+source, and then added to the view using the `CompositionView.add` method. The
+first parameter is a list of HTTP methods to handle (e.g. `['GET', 'POST']`),
+and the second is the handler function. The following example shows
+`CompositionView` usage with both an external handler function and an inline
+lambda:
+
+```python
+from sanic import Sanic
+from sanic.views import CompositionView
+from sanic.response import text
+
+app = Sanic(__name__)
+
+def get_handler(request):
+    return text('I am a get method')
+
+view = CompositionView()
+view.add(['GET'], get_handler)
+view.add(['POST', 'PUT'], lambda request: text('I am a post/put method'))
+
+# Use the new view to handle requests to the base URL
+app.add_route(view, '/')
+```
+
+Note: currently you cannot build a URL for a CompositionView using `url_for`. 

docs/sanic/contributing.md

@@ -0,0 +1,33 @@
+# Contributing
+
+Thank you for your interest! Sanic is always looking for contributors. If you
+don't feel comfortable contributing code, adding docstrings to the source files
+is very appreciated.
+
+## Running tests
+
+* `python -m pip install pytest`
+* `python -m pytest tests`
+
+## Documentation
+
+Sanic's documentation is built
+using [sphinx](http://www.sphinx-doc.org/en/1.5.1/). Guides are written in
+Markdown and can be found in the `docs` folder, while the module reference is
+automatically generated using `sphinx-apidoc`.
+
+To generate the documentation from scratch:
+
+```bash
+sphinx-apidoc -fo docs/_api/ sanic
+sphinx-build -b html docs docs/_build
+```
+
+The HTML documentation will be created in the `docs/_build` folder.
+
+## Warning
+
+One of the main goals of Sanic is speed. Code that lowers the performance of
+Sanic without significant gains in usability, security, or features may not be
+merged. Please don't let this intimidate you! If you have any concerns about an
+idea, open an issue for discussion and help.

docs/sanic/cookies.md

@@ -0,0 +1,75 @@
+# Cookies
+
+Cookies are pieces of data which persist inside a user's browser. Sanic can
+both read and write cookies, which are stored as key-value pairs.
+
+## Reading cookies
+
+A user's cookies can be accessed `Request` object's `cookie` dictionary.
+
+```python
+from sanic.response import text
+
+@app.route("/cookie")
+async def test(request):
+    test_cookie = request.cookies.get('test')
+    return text("Test cookie set to: {}".format(test_cookie))
+```
+
+## Writing cookies
+
+When returning a response, cookies can be set on the `Response` object.
+
+```python
+from sanic.response import text
+
+@app.route("/cookie")
+async def test(request):
+    response = text("There's a cookie up in this response")
+    response.cookies['test'] = 'It worked!'
+    response.cookies['test']['domain'] = '.gotta-go-fast.com'
+    response.cookies['test']['httponly'] = True
+    return response
+```
+
+## Deleting cookies
+
+Cookies can be removed semantically or explicitly.
+
+```python
+from sanic.response import text
+
+@app.route("/cookie")
+async def test(request):
+    response = text("Time to eat some cookies muahaha")
+    
+    # This cookie will be set to expire in 0 seconds
+    del response.cookies['kill_me']
+    
+    # This cookie will self destruct in 5 seconds
+    response.cookies['short_life'] = 'Glad to be here'
+    response.cookies['short_life']['max-age'] = 5
+    del response.cookies['favorite_color']
+    
+    # This cookie will remain unchanged
+    response.cookies['favorite_color'] = 'blue'
+    response.cookies['favorite_color'] = 'pink'
+    del response.cookies['favorite_color']
+    
+    return response
+```
+
+Response cookies can be set like dictionary values and have the following
+parameters available:
+
+- `expires` (datetime): The time for the cookie to expire on the
+                        client's browser.
+- `path` (string): The subset of URLs to which this cookie applies.  Defaults to /.
+- `comment` (string): A comment (metadata).
+- `domain` (string): Specifies the domain for which the cookie is valid. An
+           explicitly specified domain must always start with a dot.
+- `max-age` (number): Number of seconds the cookie should live for.
+- `secure` (boolean): Specifies whether the cookie will only be sent via
+                      HTTPS.
+- `httponly` (boolean): Specifies whether the cookie cannot be read by
+                        Javascript.

docs/sanic/custom_protocol.md

@@ -0,0 +1,72 @@
+# Custom Protocols
+
+*Note: this is advanced usage, and most readers will not need such functionality.*
+
+You can change the behavior of Sanic's protocol by specifying a custom
+protocol, which should be a subclass
+of
+[asyncio.protocol](https://docs.python.org/3/library/asyncio-protocol.html#protocol-classes).
+This protocol can then be passed as the keyword argument `protocol` to the `sanic.run` method.
+
+The constructor of the custom protocol class receives the following keyword
+arguments from Sanic.
+
+- `loop`: an `asyncio`-compatible event loop.
+- `connections`: a `set` to store protocol objects. When Sanic receives
+  `SIGINT` or `SIGTERM`, it executes `protocol.close_if_idle` for all protocol
+  objects stored in this set.
+- `signal`: a `sanic.server.Signal` object with the `stopped` attribute. When
+  Sanic receives `SIGINT` or `SIGTERM`, `signal.stopped` is assigned `True`.
+- `request_handler`: a coroutine that takes a `sanic.request.Request` object
+  and a `response` callback as arguments.
+- `error_handler`: a `sanic.exceptions.Handler` which is called when exceptions
+  are raised.
+- `request_timeout`: the number of seconds before a request times out.
+- `request_max_size`: an integer specifying the maximum size of a request, in bytes.
+
+## Example
+
+An error occurs in the default protocol if a handler function does not return
+an `HTTPResponse` object.
+
+By overriding the `write_response` protocol method, if a handler returns a
+string it will be converted to an `HTTPResponse object`.
+
+```python
+from sanic import Sanic
+from sanic.server import HttpProtocol
+from sanic.response import text
+
+app = Sanic(__name__)
+
+
+class CustomHttpProtocol(HttpProtocol):
+
+    def __init__(self, *, loop, request_handler, error_handler,
+                 signal, connections, request_timeout, request_max_size):
+        super().__init__(
+            loop=loop, request_handler=request_handler,
+            error_handler=error_handler, signal=signal,
+            connections=connections, request_timeout=request_timeout,
+            request_max_size=request_max_size)
+
+    def write_response(self, response):
+        if isinstance(response, str):
+            response = text(response)
+        self.transport.write(
+            response.output(self.request.version)
+        )
+        self.transport.close()
+
+
+@app.route('/')
+async def string(request):
+    return 'string'
+
+
+@app.route('/1')
+async def response(request):
+    return text('response')
+
+app.run(host='0.0.0.0', port=8000, protocol=CustomHttpProtocol)
+```

docs/sanic/deploying.md

@@ -0,0 +1,46 @@
+# Deploying
+
+Deploying Sanic is made simple by the inbuilt webserver. After defining an
+instance of `sanic.Sanic`, we can call the `run` method with the following
+keyword arguments:
+
+- `host` *(default `"127.0.0.1"`)*: Address to host the server on.
+- `port` *(default `8000`)*: Port to host the server on.
+- `debug` *(default `False`)*: Enables debug output (slows server).
+- `ssl` *(default `None`)*: `SSLContext` for SSL encryption of worker(s).
+- `sock` *(default `None`)*: Socket for the server to accept connections from.
+- `workers` *(default `1`)*: Number of worker processes to spawn.
+- `loop` *(default `None`)*: An `asyncio`-compatible event loop. If none is
+                             specified, Sanic creates its own event loop.
+- `protocol` *(default `HttpProtocol`)*: Subclass
+  of
+  [asyncio.protocol](https://docs.python.org/3/library/asyncio-protocol.html#protocol-classes).
+
+## Workers
+
+By default, Sanic listens in the main process using only one CPU core. To crank
+up the juice, just specify the number of workers in the `run` arguments.
+
+```python
+app.run(host='0.0.0.0', port=1337, workers=4)
+```
+
+Sanic will automatically spin up multiple processes and route traffic between
+them. We recommend as many workers as you have available cores.
+
+## Running via command
+
+If you like using command line arguments, you can launch a Sanic server by
+executing the module. For example, if you initialized Sanic as `app` in a file
+named `server.py`, you could run the server like so:
+
+`python -m sanic server.app --host=0.0.0.0 --port=1337 --workers=4`
+
+With this way of running sanic, it is not necessary to invoke `app.run` in your
+Python file. If you do, make sure you wrap it so that it only executes when
+directly run by the interpreter.
+
+```python
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=1337, workers=4)
+```

docs/sanic/exceptions.md

@@ -0,0 +1,45 @@
+# Exceptions
+
+Exceptions can be thrown from within request handlers and will automatically be
+handled by Sanic. Exceptions take a message as their first argument, and can
+also take a status code to be passed back in the HTTP response.
+
+## Throwing an exception
+
+To throw an exception, simply `raise` the relevant exception from the
+`sanic.exceptions` module.
+
+```python
+from sanic.exceptions import ServerError
+
+@app.route('/killme')
+def i_am_ready_to_die(request):
+	raise ServerError("Something bad happened", status_code=500)
+```
+
+## Handling exceptions
+
+To override Sanic's default handling of an exception, the `@app.exception`
+decorator is used. The decorator expects a list of exceptions to handle as
+arguments. You can pass `SanicException` to catch them all! The decorated
+exception handler function must take a `Request` and `Exception` object as
+arguments.
+
+```python
+from sanic.response import text
+from sanic.exceptions import NotFound
+
+@app.exception(NotFound)
+def ignore_404s(request, exception):
+	return text("Yep, I totally found the page: {}".format(request.url))
+```
+
+## Useful exceptions
+
+Some of the most useful exceptions are presented below:
+
+- `NotFound`: called when a suitable route for the request isn't found.
+- `ServerError`: called when something goes wrong inside the server. This
+  usually occurs if there is an exception raised in user code.
+
+See the `sanic.exceptions` module for the full list of exceptions to throw.

docs/sanic/extensions.md

@@ -0,0 +1,14 @@
+# Extensions
+
+A list of Sanic extensions created by the community.
+
+- [Sessions](https://github.com/subyraman/sanic_session): Support for sessions.
+  Allows using redis, memcache or an in memory store.
+- [CORS](https://github.com/ashleysommer/sanic-cors): A port of flask-cors.
+- [Compress](https://github.com/subyraman/sanic_compress): Allows you to easily gzip Sanic responses. A port of Flask-Compress.
+- [Jinja2](https://github.com/lixxu/sanic-jinja2): Support for Jinja2 template.
+- [OpenAPI/Swagger](https://github.com/channelcat/sanic-openapi): OpenAPI support, plus a Swagger UI.
+- [Pagination](https://github.com/lixxu/python-paginate): Simple pagination support.
+- [Motor](https://github.com/lixxu/sanic-motor): Simple motor wrapper.
+- [Sanic CRUD](https://github.com/Typhon66/sanic_crud): CRUD REST API generation with peewee models.
+- [UserAgent](https://github.com/lixxu/sanic-useragent): Add `user_agent` to request

docs/sanic/getting_started.md

@@ -0,0 +1,27 @@
+# Getting Started
+
+Make sure you have both [pip](https://pip.pypa.io/en/stable/installing/) and at
+least version 3.5 of Python before starting. Sanic uses the new `async`/`await`
+syntax, so earlier versions of python won't work.
+
+1. Install Sanic: `python3 -m pip install sanic`
+2. Create a file called `main.py` with the following code:
+
+  ```python
+  from sanic import Sanic
+  from sanic.response import text
+
+  app = Sanic(__name__)
+
+  @app.route("/")
+  async def test(request):
+      return text('Hello world!')
+
+  app.run(host="0.0.0.0", port=8000, debug=True)
+  ```
+  
+3. Run the server: `python3 main.py`
+4. Open the address `http://0.0.0.0:8000` in your web browser. You should see
+   the message *Hello world!*.
+
+You now have a working Sanic server!

docs/sanic/index.rst

@@ -0,0 +1,25 @@
+Sanic
+=================================
+
+Sanic is a Flask-like Python 3.5+ web server that's written to go fast.  It's based on the work done by the amazing folks at magicstack, and was inspired by `this article <https://magic.io/blog/uvloop-blazing-fast-python-networking/>`_.
+
+On top of being Flask-like, Sanic supports async request handlers.  This means you can use the new shiny async/await syntax from Python 3.5, making your code non-blocking and speedy.
+
+Sanic is developed `on GitHub <https://github.com/channelcat/sanic/>`_. Contributions are welcome!
+
+Sanic aspires to be simple:
+-------------------
+
+.. code:: python
+
+    from sanic import Sanic
+    from sanic.response import json
+
+    app = Sanic()
+
+    @app.route("/")
+    async def test(request):
+        return json({"hello": "world"})
+
+    if __name__ == "__main__":
+        app.run(host="0.0.0.0", port=8000)

docs/sanic/middleware.md

@@ -0,0 +1,66 @@
+# Middleware
+
+Middleware are functions which are executed before or after requests to the
+server. They can be used to modify the *request to* or *response from*
+user-defined handler functions.
+
+There are two types of middleware: request and response. Both are declared
+using the `@app.middleware` decorator, with the decorator's parameter being a
+string representing its type: `'request'` or `'response'`. Response middleware
+receives both the request and the response as arguments.
+
+
+The simplest middleware doesn't modify the request or response at all:
+
+```python
+@app.middleware('request')
+async def print_on_request(request):
+	print("I print when a request is received by the server")
+
+@app.middleware('response')
+async def print_on_response(request, response):
+	print("I print when a response is returned by the server")
+```
+
+## Modifying the request or response
+
+Middleware can modify the request or response parameter it is given, *as long
+as it does not return it*. The following example shows a practical use-case for
+this.
+
+```python
+app = Sanic(__name__)
+
+@app.middleware('response')
+async def custom_banner(request, response):
+	response.headers["Server"] = "Fake-Server"
+
+@app.middleware('response')
+async def prevent_xss(request, response):
+	response.headers["x-xss-protection"] = "1; mode=block"
+
+app.run(host="0.0.0.0", port=8000)
+```
+
+The above code will apply the two middleware in order. First, the middleware
+**custom_banner** will change the HTTP response header *Server* to
+*Fake-Server*, and the second middleware **prevent_xss** will add the HTTP
+header for preventing Cross-Site-Scripting (XSS) attacks. These two functions
+are invoked *after* a user function returns a response.
+
+## Responding early
+
+If middleware returns a `HTTPResponse` object, the request will stop processing
+and the response will be returned. If this occurs to a request before the
+relevant user route handler is reached, the handler will never be called.
+Returning a response will also prevent any further middleware from running.
+
+```python
+@app.middleware('request')
+async def halt_request(request):
+	return text('I halted the request')
+
+@app.middleware('response')
+async def halt_response(request, response):
+	return text('I halted the response')
+```

docs/sanic/request_data.md

@@ -0,0 +1,108 @@
+# Request Data
+
+When an endpoint receives a HTTP request, the route function is passed a
+`Request` object.
+
+The following variables are accessible as properties on `Request` objects:
+
+- `json` (any) - JSON body
+
+  ```python
+  from sanic.response import json
+  
+  @app.route("/json")
+  def post_json(request):
+      return json({ "received": True, "message": request.json })
+  ```
+  
+- `args` (dict) - Query string variables. A query string is the section of a
+  URL that resembles `?key1=value1&key2=value2`. If that URL were to be parsed,
+  the `args` dictionary would look like `{'key1': 'value1', 'key2': 'value2'}`.
+  The request's `query_string` variable holds the unparsed string value.
+
+  ```python
+  from sanic.response import json
+  
+  @app.route("/query_string")
+  def query_string(request):
+      return json({ "parsed": True, "args": request.args, "url": request.url, "query_string": request.query_string })
+  ```
+
+- `files` (dictionary of `File` objects) - List of files that have a name, body, and type
+
+  ```python
+  from sanic.response import json
+  
+  @app.route("/files")
+  def post_json(request):
+      test_file = request.files.get('test')
+
+      file_parameters = {
+          'body': test_file.body,
+          'name': test_file.name,
+          'type': test_file.type,
+      }
+
+      return json({ "received": True, "file_names": request.files.keys(), "test_file_parameters": file_parameters })
+  ```
+
+- `form` (dict) - Posted form variables.
+
+  ```python
+  from sanic.response import json
+  
+  @app.route("/form")
+  def post_json(request):
+      return json({ "received": True, "form_data": request.form, "test": request.form.get('test') })
+  ```
+
+- `body` (bytes) - Posted raw body. This property allows retrieval of the
+  request's raw data, regardless of content type.
+  
+  ```python
+  from sanic.response import text
+  
+  @app.route("/users", methods=["POST",])
+  def create_user(request):
+      return text("You are trying to create a user with the following POST: %s" % request.body)
+  ```
+  
+- `ip` (str) - IP address of the requester.
+
+- `app` - a reference to the Sanic application object that is handling this request. This is useful when inside blueprints or other handlers in modules that do not have access to the global `app` object.
+
+  ```python
+  from sanic.response import json
+  from sanic import Blueprint
+
+  bp = Blueprint('my_blueprint')
+
+  @bp.route('/')
+  async def bp_root(request):
+      if request.app.config['DEBUG']:
+          return json({'status': 'debug'})
+      else:
+          return json({'status': 'production'})
+
+  ```
+
+## Accessing values using `get` and `getlist`
+
+The request properties which return a dictionary actually return a subclass of
+`dict` called `RequestParameters`. The key difference when using this object is
+the distinction between the `get` and `getlist` methods.
+
+- `get(key, default=None)` operates as normal, except that when the value of
+  the given key is a list, *only the first item is returned*.
+- `getlist(key, default=None)` operates as normal, *returning the entire list*.
+
+```python
+from sanic.request import RequestParameters
+
+args = RequestParameters()
+args['titles'] = ['Post 1', 'Post 2']
+
+args.get('titles') # => 'Post 1'
+
+args.getlist('titles') # => ['Post 1', 'Post 2']
+```

docs/sanic/routing.md

@@ -0,0 +1,183 @@
+# Routing
+
+Routing allows the user to specify handler functions for different URL endpoints.
+
+A basic route looks like the following, where `app` is an instance of the
+`Sanic` class:
+
+```python
+from sanic.response import json
+
+@app.route("/")
+async def test(request):
+    return json({ "hello": "world" })
+```
+
+When the url `http://server.url/` is accessed (the base url of the server), the
+final `/` is matched by the router to the handler function, `test`, which then
+returns a JSON object.
+
+Sanic handler functions must be defined using the `async def` syntax, as they
+are asynchronous functions.
+
+## Request parameters
+
+Sanic comes with a basic router that supports request parameters.
+
+To specify a parameter, surround it with angle quotes like so: `<PARAM>`.
+Request parameters will be passed to the route handler functions as keyword
+arguments.
+
+```python
+from sanic.response import text
+
+@app.route('/tag/<tag>')
+async def tag_handler(request, tag):
+	return text('Tag - {}'.format(tag))
+```
+
+To specify a type for the parameter, add a `:type` after the parameter name,
+inside the quotes. If the parameter does not match the specified type, Sanic
+will throw a `NotFound` exception, resulting in a `404: Page not found` error
+on the URL.
+
+```python
+from sanic.response import text
+
+@app.route('/number/<integer_arg:int>')
+async def integer_handler(request, integer_arg):
+	return text('Integer - {}'.format(integer_arg))
+
+@app.route('/number/<number_arg:number>')
+async def number_handler(request, number_arg):
+	return text('Number - {}'.format(number_arg))
+
+@app.route('/person/<name:[A-z]>')
+async def person_handler(request, name):
+	return text('Person - {}'.format(name))
+
+@app.route('/folder/<folder_id:[A-z0-9]{0,4}>')
+async def folder_handler(request, folder_id):
+	return text('Folder - {}'.format(folder_id))
+
+```
+
+## HTTP request types
+
+By default, a route defined on a URL will be available for only GET requests to that URL.
+However, the `@app.route` decorator accepts an optional parameter, `methods`,
+which allows the handler function to work with any of the HTTP methods in the list.
+
+```python
+from sanic.response import text
+
+@app.route('/post', methods=['POST'])
+async def post_handler(request):
+	return text('POST request - {}'.format(request.json))
+
+@app.route('/get', methods=['GET'])
+async def get_handler(request):
+	return text('GET request - {}'.format(request.args))
+
+```
+
+There is also an optional `host` argument (which can be a list or a string). This restricts a route to the host or hosts provided. If there is a also a route with no host, it will be the default.
+
+```python
+@app.route('/get', methods=['GET'], host='example.com')
+async def get_handler(request):
+	return text('GET request - {}'.format(request.args))
+
+# if the host header doesn't match example.com, this route will be used
+@app.route('/get', methods=['GET'])
+async def get_handler(request):
+	return text('GET request in default - {}'.format(request.args))
+```
+
+There are also shorthand method decorators:
+
+```python
+from sanic.response import text
+
+@app.post('/post')
+async def post_handler(request):
+	return text('POST request - {}'.format(request.json))
+
+@app.get('/get')
+async def get_handler(request):
+	return text('GET request - {}'.format(request.args))
+
+```
+## The `add_route` method
+
+As we have seen, routes are often specified using the `@app.route` decorator.
+However, this decorator is really just a wrapper for the `app.add_route`
+method, which is used as follows:
+
+```python
+from sanic.response import text
+
+# Define the handler functions
+async def handler1(request):
+	return text('OK')
+
+async def handler2(request, name):
+	return text('Folder - {}'.format(name))
+
+async def person_handler2(request, name):
+	return text('Person - {}'.format(name))
+
+# Add each handler function as a route
+app.add_route(handler1, '/test')
+app.add_route(handler2, '/folder/<name>')
+app.add_route(person_handler2, '/person/<name:[A-z]>', methods=['GET'])
+```
+
+## URL building with `url_for`
+
+Sanic provides a `url_for` method, to generate URLs based on the handler method name. This is useful if you want to avoid hardcoding url paths into your app; instead, you can just reference the handler name. For example:
+
+```python
+@app.route('/')
+async def index(request):
+    # generate a URL for the endpoint `post_handler`
+    url = app.url_for('post_handler', post_id=5)
+    # the URL is `/posts/5`, redirect to it
+    return redirect(url)
+
+
+@app.route('/posts/<post_id>')
+async def post_handler(request, post_id):
+    return text('Post - {}'.format(post_id))
+```
+
+Other things to keep in mind when using `url_for`:
+
+- Keyword arguments passed to `url_for` that are not request parameters will be included in the URL's query string. For example:
+```python
+url = app.url_for('post_handler', post_id=5, arg_one='one', arg_two='two')
+# /posts/5?arg_one=one&arg_two=two
+```
+- Multivalue argument can be passed to `url_for`. For example:
+```python
+url = app.url_for('post_handler', post_id=5, arg_one=['one', 'two'])
+# /posts/5?arg_one=one&arg_one=two
+```
+- Also some special arguments (`_anchor`, `_external`, `_scheme`, `_method`, `_server`) passed to `url_for` will have special url building (`_method` is not support now and will be ignored). For example:
+```python
+url = app.url_for('post_handler', post_id=5, arg_one='one', _anchor='anchor')
+# /posts/5?arg_one=one#anchor
+
+url = app.url_for('post_handler', post_id=5, arg_one='one', _external=True)
+# //server/posts/5?arg_one=one
+# _external requires passed argument _server or SERVER_NAME in app.config or url will be same as no _external
+
+url = app.url_for('post_handler', post_id=5, arg_one='one', _scheme='http', _external=True)
+# http://server/posts/5?arg_one=one
+# when specifying _scheme, _external must be True
+
+# you can pass all special arguments one time
+url = app.url_for('post_handler', post_id=5, arg_one=['one', 'two'], arg_two=2, _anchor='anchor', _scheme='http', _external=True, _server='another_server:8888')
+# http://another_server:8888/posts/5?arg_one=one&arg_one=two&arg_two=2#anchor
+```
+- All valid parameters must be passed to `url_for` to build a URL. If a parameter is not supplied, or if a parameter does not match the specified type, a `URLBuildError` will be thrown.

docs/sanic/ssl.rst

@@ -0,0 +1,12 @@
+SSL Example
+-----------
+
+Optionally pass in an SSLContext:
+
+.. code:: python
+
+  import ssl
+  context = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)
+  context.load_cert_chain("/path/to/cert", keyfile="/path/to/keyfile")
+
+  app.run(host="0.0.0.0", port=8443, ssl=context)

docs/sanic/static_files.md

@@ -0,0 +1,21 @@
+# Static Files
+
+Static files and directories, such as an image file, are served by Sanic when
+registered with the `app.static` method. The method takes an endpoint URL and a
+filename. The file specified will then be accessible via the given endpoint.
+
+```python
+from sanic import Sanic
+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('/the_best.png', '/home/ubuntu/test.png')
+
+app.run(host="0.0.0.0", port=8000)
+```
+
+Note: currently you cannot build a URL for a static file using `url_for`. 

docs/sanic/testing.md

@@ -0,0 +1,73 @@
+# Testing
+
+Sanic endpoints can be tested locally using the `test_client` object, which
+depends on the additional [aiohttp](https://aiohttp.readthedocs.io/en/stable/)
+library. 
+
+The `test_client` exposes `get`, `post`, `put`, `delete`, `patch`, `head` and `options` methods
+for you to run against your application. A simple example (using pytest) is like follows:
+
+```python
+# Import the Sanic app, usually created with Sanic(__name__)
+from external_server import app
+
+def test_index_returns_200():
+    request, response = app.test_client.get('/')
+    assert response.status == 200
+
+def test_index_put_not_allowed():
+    request, response = app.test_client.put('/')
+    assert response.status == 405
+```
+
+Internally, each time you call one of the `test_client` methods, the Sanic app is run at `127.0.01:42101` and 
+your test request is executed against your application, using `aiohttp`. 
+
+The `test_client` methods accept the following arguments and keyword arguments:
+
+- `uri` *(default `'/'`)* A string representing the URI to test.
+- `gather_request` *(default `True`)* A boolean which determines whether the
+  original request will be returned by the function. If set to `True`, the
+  return value is a tuple of `(request, response)`, if `False` only the
+  response is returned.
+- `server_kwargs` *(default `{}`) a dict of additional arguments to pass into `app.run` before the test request is run.
+- `debug` *(default `False`)* A boolean which determines whether to run the server in debug mode.
+
+The function further takes the `*request_args` and `**request_kwargs`, which are passed directly to the aiohttp ClientSession request.
+
+For example, to supply data to a GET request, you would do the following:
+
+```python
+def test_get_request_includes_data():
+    params = {'key1': 'value1', 'key2': 'value2'}
+    request, response = app.test_client.get('/', params=params)
+    assert request.args.get('key1') == 'value1'
+```
+
+And to supply data to a JSON POST request:
+
+```python
+def test_post_json_request_includes_data():
+    data = {'key1': 'value1', 'key2': 'value2'}
+    request, response = app.test_client.post('/', data=json.dumps(data))
+    assert request.json.get('key1') == 'value1'
+```
+
+
+More information about
+the available arguments to aiohttp can be found
+[in the documentation for ClientSession](https://aiohttp.readthedocs.io/en/stable/client_reference.html#client-session).
+
+
+### Deprecated: `sanic_endpoint_test`
+
+Prior to version 0.3.2, testing was provided through the `sanic_endpoint_test` method. This method will be deprecated in the next major version after 0.4.0; please use the `test_client` instead.
+
+```
+from sanic.utils import sanic_endpoint_test
+
+def test_index_returns_200():
+    request, response = sanic_endpoint_test(app)
+    assert response.status == 200
+```
+

environment.yml

@@ -0,0 +1,18 @@
+name: py35
+dependencies:
+- openssl=1.0.2g=0
+- pip=8.1.1=py35_0
+- python=3.5.1=0
+- readline=6.2=2
+- setuptools=20.3=py35_0
+- sqlite=3.9.2=0
+- tk=8.5.18=0
+- wheel=0.29.0=py35_0
+- xz=5.0.5=1
+- zlib=1.2.8=0
+- pip:
+  - uvloop>=0.5.3
+  - httptools>=0.0.9
+  - ujson>=1.35
+  - aiofiles>=0.3.0
+  - https://github.com/channelcat/docutils-fork/zipball/master

examples/aiohttp_example.py

@@ -0,0 +1,28 @@
+from sanic import Sanic
+from sanic.response import json
+
+import aiohttp
+
+app = Sanic(__name__)
+
+async def fetch(session, url):
+    """
+    Use session object to perform 'get' request on url
+    """
+    async with session.get(url) as response:
+        return await response.json()
+
+
+@app.route("/")
+async def test(request):
+    """
+    Download and serve example JSON
+    """
+    url = "https://api.github.com/repos/channelcat/sanic"
+
+    async with aiohttp.ClientSession() as session:
+        response = await fetch(session, url)
+        return json(response)
+
+
+app.run(host="0.0.0.0", port=8000, workers=2)

examples/cache_example.py

@@ -0,0 +1,46 @@
+"""
+Example of caching using aiocache package. To run it you will need a Redis
+instance running in localhost:6379. You can also try with SimpleMemoryCache.
+
+Running this example you will see that the first call lasts 3 seconds and
+the rest are instant because the value is retrieved from the Redis.
+
+If you want more info about the package check
+https://github.com/argaen/aiocache
+"""
+
+import asyncio
+import aiocache
+
+from sanic import Sanic
+from sanic.response import json
+from sanic.log import log
+from aiocache import cached
+from aiocache.serializers import JsonSerializer
+
+app = Sanic(__name__)
+
+
+@app.listener('before_server_start')
+def init_cache(sanic, loop):
+    aiocache.settings.set_defaults(
+        class_="aiocache.RedisCache",
+        # class_="aiocache.SimpleMemoryCache",
+        loop=loop
+    )
+
+
+@cached(key="my_custom_key", serializer=JsonSerializer())
+async def expensive_call():
+    log.info("Expensive has been called")
+    await asyncio.sleep(3)
+    return {"test": True}
+
+
+@app.route("/")
+async def test(request):
+    log.info("Received GET /")
+    return json(await expensive_call())
+
+
+app.run(host="0.0.0.0", port=8000)

examples/exception_monitoring.py

@@ -0,0 +1,57 @@
+"""
+Example intercepting uncaught exceptions using Sanic's error handler framework.
+
+This may be useful for developers wishing to use Sentry, Airbrake, etc.
+or a custom system to log and monitor unexpected errors in production.
+
+First we create our own class inheriting from Handler in sanic.exceptions,
+and pass in an instance of it when we create our Sanic instance. Inside this
+class' default handler, we can do anything including sending exceptions to
+an external service.
+"""
+from sanic.exceptions import Handler, SanicException
+"""
+Imports and code relevant for our CustomHandler class
+(Ordinarily this would be in a separate file)
+"""
+
+
+class CustomHandler(Handler):
+
+    def default(self, request, exception):
+        # Here, we have access to the exception object
+        # and can do anything with it (log, send to external service, etc)
+
+        # Some exceptions are trivial and built into Sanic (404s, etc)
+        if not isinstance(exception, SanicException):
+            print(exception)
+
+        # Then, we must finish handling the exception by returning
+        # our response to the client
+        # For this we can just call the super class' default handler
+        return super().default(request, exception)
+
+
+"""
+This is an ordinary Sanic server, with the exception that we set the
+server's error_handler to an instance of our CustomHandler
+"""
+
+from sanic import Sanic
+from sanic.response import json
+
+app = Sanic(__name__)
+
+handler = CustomHandler(sanic=app)
+app.error_handler = handler
+
+
+@app.route("/")
+async def test(request):
+    # Here, something occurs which causes an unexpected exception
+    # This exception will flow to our custom handler.
+    1 / 0
+    return json({"test": True})
+
+
+app.run(host="0.0.0.0", port=8000, debug=True)

examples/jinja_example.py

@@ -0,0 +1,18 @@
+## To use this example:
+# curl -d '{"name": "John Doe"}' localhost:8000
+
+from sanic import Sanic
+from sanic.response import html
+from jinja2 import Template
+
+template = Template('Hello {{ name }}!')
+
+app = Sanic(__name__)
+
+@app.route('/')
+async def test(request):
+    data = request.json
+    return html(template.render(**data))
+
+
+app.run(host="0.0.0.0", port=8000)

examples/limit_concurrency.py

@@ -0,0 +1,37 @@
+from sanic import Sanic
+from sanic.response import json
+
+import asyncio
+import aiohttp
+
+app = Sanic(__name__)
+
+sem = None
+
+@app.listener('before_server_start')
+def init(sanic, loop):
+    global sem
+    CONCURRENCY_PER_WORKER = 4
+    sem = asyncio.Semaphore(CONCURRENCY_PER_WORKER, loop=loop)
+
+async def bounded_fetch(session, url):
+    """
+    Use session object to perform 'get' request on url
+    """
+    async with sem, session.get(url) as response:
+        return await response.json()
+
+
+@app.route("/")
+async def test(request):
+    """
+    Download and serve example JSON
+    """
+    url = "https://api.github.com/repos/channelcat/sanic"
+
+    async with aiohttp.ClientSession() as session:
+        response = await bounded_fetch(session, url)
+        return json(response)
+
+
+app.run(host="0.0.0.0", port=8000, workers=2)

examples/override_logging.py

@@ -0,0 +1,23 @@
+from sanic import Sanic
+from sanic.response import text
+import json
+import logging
+
+logging_format = "[%(asctime)s] %(process)d-%(levelname)s "
+logging_format += "%(module)s::%(funcName)s():l%(lineno)d: "
+logging_format += "%(message)s"
+
+logging.basicConfig(
+    format=logging_format,
+    level=logging.DEBUG
+)
+log = logging.getLogger()
+
+# Set logger to override default basicConfig
+sanic = Sanic()
+@sanic.route("/")
+def test(request):
+    log.info("received request; responding with 'hey'")
+    return text("hey")
+
+sanic.run(host="0.0.0.0", port=8000)

examples/request_timeout.py

@@ -0,0 +1,21 @@
+from sanic import Sanic
+import asyncio
+from sanic.response import text
+from sanic.config import Config
+from sanic.exceptions import RequestTimeout
+
+Config.REQUEST_TIMEOUT = 1
+app = Sanic(__name__)
+
+
+@app.route('/')
+async def test(request):
+    await asyncio.sleep(3)
+    return text('Hello, world!')
+
+
+@app.exception(RequestTimeout)
+def timeout(request, exception):
+    return text('RequestTimeout from error_handler.', 408)
+
+app.run(host='0.0.0.0', port=8000)

examples/run_async.py

@@ -0,0 +1,22 @@
+from sanic import Sanic
+from sanic.response import json
+from multiprocessing import Event
+from signal import signal, SIGINT
+import asyncio
+import uvloop
+
+app = Sanic(__name__)
+
+@app.route("/")
+async def test(request):
+    return json({"answer": "42"})
+
+asyncio.set_event_loop(uvloop.new_event_loop())
+server = app.create_server(host="0.0.0.0", port=8001)
+loop = asyncio.get_event_loop()
+task = asyncio.ensure_future(server)
+signal(SIGINT, lambda s, f: loop.stop())
+try:
+    loop.run_forever()
+except:
+    loop.stop()

examples/sanic_aiopg_example.py

@@ -0,0 +1,65 @@
+""" To run this example you need additional aiopg package
+
+"""
+import os
+import asyncio
+
+import uvloop
+import aiopg
+
+from sanic import Sanic
+from sanic.response import json
+
+database_name = os.environ['DATABASE_NAME']
+database_host = os.environ['DATABASE_HOST']
+database_user = os.environ['DATABASE_USER']
+database_password = os.environ['DATABASE_PASSWORD']
+
+connection = 'postgres://{0}:{1}@{2}/{3}'.format(database_user,
+                                                 database_password,
+                                                 database_host,
+                                                 database_name)
+
+
+async def get_pool():
+    return await aiopg.create_pool(connection)
+
+app = Sanic(name=__name__)
+
+@app.listener('before_server_start')
+async def prepare_db(app, loop):
+    """
+    Let's create some table and add some data
+    """
+    async with aiopg.create_pool(connection) as pool:
+        async with pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                await cur.execute('DROP TABLE IF EXISTS sanic_polls')
+                await cur.execute("""CREATE TABLE sanic_polls (
+                                        id serial primary key,
+                                        question varchar(50),
+                                        pub_date timestamp
+                                    );""")
+                for i in range(0, 100):
+                    await cur.execute("""INSERT INTO sanic_polls
+                                    (id, question, pub_date) VALUES ({}, {}, now())
+                    """.format(i, i))
+
+
+@app.route("/")
+async def handle(request):
+    result = []
+    async def test_select():
+        async with aiopg.create_pool(connection) as pool:
+            async with pool.acquire() as conn:
+                async with conn.cursor() as cur:
+                    await cur.execute("SELECT question, pub_date FROM sanic_polls")
+                    async for row in cur:
+                        result.append({"question": row[0], "pub_date": row[1]})
+    res = await test_select()
+    return json({'polls': result})
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0',
+            port=8000,
+            debug=True)

examples/sanic_aiopg_sqlalchemy_example.py

@@ -0,0 +1,67 @@
+""" To run this example you need additional aiopg package
+
+"""
+import os
+import asyncio
+import datetime
+
+import uvloop
+from aiopg.sa import create_engine
+import sqlalchemy as sa
+
+from sanic import Sanic
+from sanic.response import json
+
+database_name = os.environ['DATABASE_NAME']
+database_host = os.environ['DATABASE_HOST']
+database_user = os.environ['DATABASE_USER']
+database_password = os.environ['DATABASE_PASSWORD']
+
+connection = 'postgres://{0}:{1}@{2}/{3}'.format(database_user,
+                                                 database_password,
+                                                 database_host,
+                                                 database_name)
+
+metadata = sa.MetaData()
+
+polls = sa.Table('sanic_polls', metadata,
+                 sa.Column('id', sa.Integer, primary_key=True),
+                 sa.Column('question', sa.String(50)),
+                 sa.Column("pub_date", sa.DateTime))
+
+
+app = Sanic(name=__name__)
+
+@app.listener('before_server_start')
+async def prepare_db(app, loop):
+    """ Let's add some data
+
+    """
+    async with create_engine(connection) as engine:
+        async with engine.acquire() as conn:
+            await conn.execute('DROP TABLE IF EXISTS sanic_polls')
+            await conn.execute("""CREATE TABLE sanic_polls (
+                                        id serial primary key,
+                                        question varchar(50),
+                                        pub_date timestamp
+                                    );""")
+            for i in range(0, 100):
+                await conn.execute(
+                    polls.insert().values(question=i,
+                                          pub_date=datetime.datetime.now())
+                    )
+
+
+@app.route("/")
+async def handle(request):
+    async with create_engine(connection) as engine:
+        async with engine.acquire() as conn:
+            result = []
+            async for row in conn.execute(polls.select()):
+                result.append({"question": row.question,
+                               "pub_date": row.pub_date})
+            return json({"polls": result})
+
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=8000)

examples/sanic_asyncpg_example.py

@@ -0,0 +1,59 @@
+""" To run this example you need additional asyncpg package
+
+"""
+import os
+import asyncio
+
+import uvloop
+from asyncpg import create_pool
+
+from sanic import Sanic
+from sanic.response import json
+
+DB_CONFIG = {
+    'host': '<host>',
+    'user': '<username>',
+    'password': '<password>',
+    'port': '<port>',
+    'database': '<database>'
+}
+
+def jsonify(records):
+    """
+    Parse asyncpg record response into JSON format
+    """
+    return [{key: value for key, value in
+             zip(r.keys(), r.values())} for r in records]
+
+app = Sanic(__name__)
+
+@app.listener('before_server_start')
+async def create_db(app, loop):
+    """
+    Create some table and add some data
+    """
+    async with create_pool(**DB_CONFIG) as pool:
+        async with pool.acquire() as connection:
+            async with connection.transaction():
+                await connection.execute('DROP TABLE IF EXISTS sanic_post')
+                await connection.execute("""CREATE TABLE sanic_post (
+                                        id serial primary key,
+                                        content varchar(50),
+                                        post_date timestamp
+                                    );""")
+                for i in range(0, 100):
+                    await connection.execute(f"""INSERT INTO sanic_post
+                        (id, content, post_date) VALUES ({i}, {i}, now())""")
+
+
+@app.route("/")
+async def handler(request):
+    async with create_pool(**DB_CONFIG) as pool:
+        async with pool.acquire() as connection:
+            async with connection.transaction():
+                results = await connection.fetch('SELECT * FROM sanic_post')
+                return json({'posts': jsonify(results)})
+
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=8000)

examples/sanic_motor.py

@@ -0,0 +1,41 @@
+""" sanic motor (async driver for mongodb) example
+Required packages:
+pymongo==3.4.0
+motor==1.1
+sanic==0.2.0
+"""
+from sanic import Sanic
+from sanic.response import json
+
+
+app = Sanic('motor_mongodb')
+
+
+def get_db():
+    from motor.motor_asyncio import AsyncIOMotorClient
+    mongo_uri = "mongodb://127.0.0.1:27017/test"
+    client = AsyncIOMotorClient(mongo_uri)
+    return client['test']
+
+
+@app.route('/objects', methods=['GET'])
+async def get(request):
+    db = get_db()
+    docs = await db.test_col.find().to_list(length=100)
+    for doc in docs:
+        doc['id'] = str(doc['_id'])
+        del doc['_id']
+    return json(docs)
+
+
+@app.route('/post', methods=['POST'])
+async def new(request):
+    doc = request.json
+    print(doc)
+    db = get_db()
+    object_id = await db.test_col.save(doc)
+    return json({'object_id': str(object_id)})
+
+
+if __name__ == "__main__":
+    app.run(host='127.0.0.1', port=8000)

examples/sanic_peewee.py

@@ -0,0 +1,79 @@
+## You need the following additional packages for this example
+# aiopg
+# peewee_async
+# peewee
+
+
+## sanic imports
+from sanic import Sanic
+from sanic.response import json
+
+## peewee_async related imports
+import peewee
+from peewee_async import Manager, PostgresqlDatabase
+
+ # we instantiate a custom loop so we can pass it to our db manager
+
+## from peewee_async docs:
+# Also there’s no need to connect and re-connect before executing async queries
+# with manager! It’s all automatic. But you can run Manager.connect() or
+# Manager.close() when you need it.
+
+
+# let's create a simple key value store:
+class KeyValue(peewee.Model):
+    key = peewee.CharField(max_length=40, unique=True)
+    text = peewee.TextField(default='')
+
+    class Meta:
+        database = database
+
+# create table synchronously
+KeyValue.create_table(True)
+
+# OPTIONAL: close synchronous connection
+database.close()
+
+# OPTIONAL: disable any future syncronous calls
+objects.database.allow_sync = False # this will raise AssertionError on ANY sync call
+
+
+app = Sanic('peewee_example')
+
+@app.listener('before_server_start')
+def setup(app, loop):
+    database = PostgresqlDatabase(database='test',
+                                  host='127.0.0.1',
+                                  user='postgres',
+                                  password='mysecretpassword')
+
+    objects = Manager(database, loop=loop)
+
+@app.route('/post/<key>/<value>')
+async def post(request, key, value):
+    """
+    Save get parameters to database
+    """
+    obj = await objects.create(KeyValue, key=key, text=value)
+    return json({'object_id': obj.id})
+
+
+@app.route('/get')
+async def get(request):
+    """
+    Load all objects from database
+    """
+    all_objects = await objects.execute(KeyValue.select())
+    serialized_obj = []
+    for obj in all_objects:
+        serialized_obj.append({
+            'id': obj.id,
+            'key': obj.key,
+            'value': obj.text}
+        )
+
+    return json({'objects': serialized_obj})
+
+
+if __name__ == "__main__":
+    app.run(host='0.0.0.0', port=8000)

examples/try_everything.py

@@ -1,6 +1,8 @@
+import os
+
 from sanic import Sanic
 from sanic.log import log
-from sanic.response import json, text
+from sanic.response import json, text, file
 from sanic.exceptions import ServerError
 
 app = Sanic(__name__)
@@ -31,6 +33,10 @@ async def test_await(request):
     await asyncio.sleep(5)
     return text("I'm feeling sleepy")
 
+@app.route("/file")
+async def test_file(request):
+    return await file(os.path.abspath("setup.py"))
+
 
 # ----------------------------------------------- #
 # Exceptions
@@ -64,12 +70,14 @@ def query_string(request):
 # Run Server
 # ----------------------------------------------- #
 
-def after_start(loop):
+@app.listener('after_server_start')
+def after_start(app, loop):
     log.info("OH OH OH OH OHHHHHHHH")
 
 
-def before_stop(loop):
+@app.listener('before_server_stop')
+def before_stop(app, loop):
     log.info("TRIED EVERYTHING")
 
 
-app.run(host="0.0.0.0", port=8000, debug=True, after_start=after_start, before_stop=before_stop)
+app.run(host="0.0.0.0", port=8000, debug=True)

examples/vhosts.py

@@ -0,0 +1,39 @@
+from sanic.response import text
+from sanic import Sanic
+from sanic.blueprints import Blueprint
+
+# Usage
+# curl -H "Host: example.com" localhost:8000
+# curl -H "Host: sub.example.com" localhost:8000
+# curl -H "Host: bp.example.com" localhost:8000/question
+# curl -H "Host: bp.example.com" localhost:8000/answer
+
+app = Sanic()
+bp = Blueprint("bp", host="bp.example.com")
+
+@app.route('/', host=["example.com",
+                      "somethingelse.com",
+                      "therestofyourdomains.com"])
+async def hello(request):
+    return text("Some defaults")
+
+@app.route('/', host="example.com")
+async def hello(request):
+    return text("Answer")
+
+@app.route('/', host="sub.example.com")
+async def hello(request):
+    return text("42")
+
+@bp.route("/question")
+async def hello(request):
+    return text("What is the meaning of life?")
+
+@bp.route("/answer")
+async def hello(request):
+    return text("42")
+
+app.register_blueprint(bp)
+
+if __name__ == '__main__':
+    app.run(host="0.0.0.0", port=8000)

readthedocs.yml

@@ -0,0 +1,2 @@
+conda:
+    file: environment.yml

requirements-dev.txt

@@ -1,11 +1,18 @@
+aiocache
+aiofiles
+aiohttp
+beautifulsoup4
+bottle
+coverage
+falcon
+gunicorn
 httptools
+kyoukai
+pytest
+recommonmark
+sphinx
+sphinx_rtd_theme
+tornado
+tox
 ujson
 uvloop
-aiohttp
-pytest
-coverage
-tox
-gunicorn
-bottle
-kyoukai
-falcon

requirements.txt

@@ -1,3 +1,4 @@
+aiofiles
 httptools
 ujson
-uvloop
+uvloop

sanic/__init__.py

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

sanic/__main__.py

@@ -1,8 +1,8 @@
 from argparse import ArgumentParser
 from importlib import import_module
 
-from .log import log
-from .sanic import Sanic
+from sanic.log import log
+from sanic.app import Sanic
 
 if __name__ == "__main__":
     parser = ArgumentParser(prog='sanic')
@@ -20,7 +20,7 @@ if __name__ == "__main__":
 
         module = import_module(module_name)
         app = getattr(module, app_name, None)
-        if type(app) is not Sanic:
+        if not isinstance(app, Sanic):
             raise ValueError("Module is not a Sanic app, it is a {}.  "
                              "Perhaps you meant {}.app?"
                              .format(type(app).__name__, args.module))

sanic/app.py

@@ -0,0 +1,591 @@
+import logging
+import re
+import warnings
+from asyncio import get_event_loop
+from collections import deque, defaultdict
+from functools import partial
+from inspect import isawaitable, stack, getmodulename
+from traceback import format_exc
+from urllib.parse import urlencode, urlunparse
+
+from sanic.config import Config
+from sanic.constants import HTTP_METHODS
+from sanic.exceptions import ServerError, URLBuildError, SanicException
+from sanic.handlers import ErrorHandler
+from sanic.log import log
+from sanic.response import HTTPResponse
+from sanic.router import Router
+from sanic.server import serve, serve_multiple, HttpProtocol
+from sanic.static import register as static_register
+from sanic.testing import TestClient
+from sanic.views import CompositionView
+
+
+class Sanic:
+
+    def __init__(self, name=None, router=None, error_handler=None):
+        # Only set up a default log handler if the
+        # end-user application didn't set anything up.
+        if not logging.root.handlers and log.level == logging.NOTSET:
+            formatter = logging.Formatter(
+                "%(asctime)s: %(levelname)s: %(message)s")
+            handler = logging.StreamHandler()
+            handler.setFormatter(formatter)
+            log.addHandler(handler)
+            log.setLevel(logging.INFO)
+
+        # Get name from previous stack frame
+        if name is None:
+            frame_records = stack()[1]
+            name = getmodulename(frame_records[1])
+
+        self.name = name
+        self.router = router or Router()
+        self.error_handler = error_handler or ErrorHandler()
+        self.config = Config()
+        self.request_middleware = deque()
+        self.response_middleware = deque()
+        self.blueprints = {}
+        self._blueprint_order = []
+        self.debug = None
+        self.sock = None
+        self.listeners = defaultdict(list)
+        self.is_running = False
+
+        # Register alternative method names
+        self.go_fast = self.run
+
+    @property
+    def loop(self):
+        """Synonymous with asyncio.get_event_loop().
+
+        Only supported when using the `app.run` method.
+        """
+        if not self.is_running:
+            raise SanicException(
+                'Loop can only be retrieved after the app has started '
+                'running. Not supported with `create_server` function')
+        return get_event_loop()
+
+    # -------------------------------------------------------------------- #
+    # Registration
+    # -------------------------------------------------------------------- #
+
+    def add_task(self, task):
+        """Schedule a task to run later, after the loop has started.
+        Different from asyncio.ensure_future in that it does not
+        also return a future, and the actual ensure_future call
+        is delayed until before server start.
+
+        :param task: future, couroutine or awaitable
+        """
+        @self.listener('before_server_start')
+        def run(app, loop):
+            if callable(task):
+                loop.create_task(task())
+            else:
+                loop.create_task(task)
+
+    # Decorator
+    def listener(self, event):
+        """Create a listener from a decorated function.
+
+        :param event: event to listen to
+        """
+        def decorator(listener):
+            self.listeners[event].append(listener)
+            return listener
+        return decorator
+
+    # Decorator
+    def route(self, uri, methods=frozenset({'GET'}), host=None):
+        """Decorate a function to be registered as a route
+
+        :param uri: path of the URL
+        :param methods: list or tuple of methods allowed
+        :param host:
+        :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,
+                            host=host)
+            return handler
+
+        return response
+
+    # Shorthand method decorators
+    def get(self, uri, host=None):
+        return self.route(uri, methods=frozenset({"GET"}), host=host)
+
+    def post(self, uri, host=None):
+        return self.route(uri, methods=frozenset({"POST"}), host=host)
+
+    def put(self, uri, host=None):
+        return self.route(uri, methods=frozenset({"PUT"}), host=host)
+
+    def head(self, uri, host=None):
+        return self.route(uri, methods=frozenset({"HEAD"}), host=host)
+
+    def options(self, uri, host=None):
+        return self.route(uri, methods=frozenset({"OPTIONS"}), host=host)
+
+    def patch(self, uri, host=None):
+        return self.route(uri, methods=frozenset({"PATCH"}), host=host)
+
+    def delete(self, uri, host=None):
+        return self.route(uri, methods=frozenset({"DELETE"}), host=host)
+
+    def add_route(self, handler, uri, methods=frozenset({'GET'}), host=None):
+        """A helper method to register class instance or
+        functions as a handler to the application url
+        routes.
+
+        :param handler: function or class instance
+        :param uri: path of the URL
+        :param methods: list or tuple of methods allowed, these are overridden
+                        if using a HTTPMethodView
+        :param host:
+        :return: function or class instance
+        """
+        # Handle HTTPMethodView differently
+        if hasattr(handler, 'view_class'):
+            methods = set()
+
+            for method in HTTP_METHODS:
+                if getattr(handler.view_class, method.lower(), None):
+                    methods.add(method)
+
+        # handle composition view differently
+        if isinstance(handler, CompositionView):
+            methods = handler.handlers.keys()
+
+        self.route(uri=uri, methods=methods, host=host)(handler)
+        return handler
+
+    def remove_route(self, uri, clean_cache=True, host=None):
+        self.router.remove(uri, clean_cache, host)
+
+    # Decorator
+    def exception(self, *exceptions):
+        """Decorate a function to be registered as a handler for exceptions
+
+        :param exceptions: exceptions
+        :return: decorated function
+        """
+
+        def response(handler):
+            for exception in exceptions:
+                self.error_handler.add(exception, handler)
+            return handler
+
+        return response
+
+    # Decorator
+    def middleware(self, middleware_or_request):
+        """Decorate and register middleware to be called before a request.
+        Can either be called as @app.middleware or @app.middleware('request')
+        """
+        def register_middleware(middleware, attach_to='request'):
+            if attach_to == 'request':
+                self.request_middleware.append(middleware)
+            if attach_to == 'response':
+                self.response_middleware.appendleft(middleware)
+            return middleware
+
+        # Detect which way this was called, @middleware or @middleware('AT')
+        if callable(middleware_or_request):
+            return register_middleware(middleware_or_request)
+
+        else:
+            return partial(register_middleware,
+                           attach_to=middleware_or_request)
+
+    # Static Files
+    def static(self, uri, file_or_directory, pattern='.+',
+               use_modified_since=True, use_content_range=False):
+        """Register a root to serve files from. The input can either be a
+        file or a directory. See
+        """
+        static_register(self, uri, file_or_directory, pattern,
+                        use_modified_since, use_content_range)
+
+    def blueprint(self, blueprint, **options):
+        """Register a blueprint on the application.
+
+        :param blueprint: Blueprint object
+        :param options: option dictionary with blueprint defaults
+        :return: Nothing
+        """
+        if blueprint.name in self.blueprints:
+            assert self.blueprints[blueprint.name] is blueprint, \
+                'A blueprint with the name "%s" is already registered.  ' \
+                'Blueprint names must be unique.' % \
+                (blueprint.name,)
+        else:
+            self.blueprints[blueprint.name] = blueprint
+            self._blueprint_order.append(blueprint)
+        blueprint.register(self, options)
+
+    def register_blueprint(self, *args, **kwargs):
+        # TODO: deprecate 1.0
+        if self.debug:
+            warnings.simplefilter('default')
+        warnings.warn("Use of register_blueprint will be deprecated in "
+                      "version 1.0.  Please use the blueprint method"
+                      " instead",
+                      DeprecationWarning)
+        return self.blueprint(*args, **kwargs)
+
+    def url_for(self, view_name: str, **kwargs):
+        """Build a URL based on a view name and the values provided.
+
+        In order to build a URL, all request parameters must be supplied as
+        keyword arguments, and each parameter must pass the test for the
+        specified parameter type. If these conditions are not met, a
+        `URLBuildError` will be thrown.
+
+        Keyword arguments that are not request parameters will be included in
+        the output URL's query string.
+
+        :param view_name: string referencing the view name
+        :param **kwargs: keys and values that are used to build request
+            parameters and query string arguments.
+
+        :return: the built URL
+
+        Raises:
+            URLBuildError
+        """
+        # find the route by the supplied view name
+        uri, route = self.router.find_route_by_view_name(view_name)
+
+        if not uri or not route:
+            raise URLBuildError(
+                    'Endpoint with name `{}` was not found'.format(
+                        view_name))
+
+        if uri != '/' and uri.endswith('/'):
+            uri = uri[:-1]
+
+        out = uri
+
+        # find all the parameters we will need to build in the URL
+        matched_params = re.findall(
+            self.router.parameter_pattern, uri)
+
+        # _method is only a placeholder now, don't know how to support it
+        kwargs.pop('_method', None)
+        anchor = kwargs.pop('_anchor', '')
+        # _external need SERVER_NAME in config or pass _server arg
+        external = kwargs.pop('_external', False)
+        scheme = kwargs.pop('_scheme', '')
+        if scheme and not external:
+            raise ValueError('When specifying _scheme, _external must be True')
+
+        netloc = kwargs.pop('_server', None)
+        if netloc is None and external:
+            netloc = self.config.get('SERVER_NAME', '')
+
+        for match in matched_params:
+            name, _type, pattern = self.router.parse_parameter_string(
+                match)
+            # we only want to match against each individual parameter
+            specific_pattern = '^{}$'.format(pattern)
+            supplied_param = None
+
+            if kwargs.get(name):
+                supplied_param = kwargs.get(name)
+                del kwargs[name]
+            else:
+                raise URLBuildError(
+                    'Required parameter `{}` was not passed to url_for'.format(
+                        name))
+
+            supplied_param = str(supplied_param)
+            # determine if the parameter supplied by the caller passes the test
+            # in the URL
+            passes_pattern = re.match(specific_pattern, supplied_param)
+
+            if not passes_pattern:
+                if _type != str:
+                    msg = (
+                        'Value "{}" for parameter `{}` does not '
+                        'match pattern for type `{}`: {}'.format(
+                            supplied_param, name, _type.__name__, pattern))
+                else:
+                    msg = (
+                        'Value "{}" for parameter `{}` '
+                        'does not satisfy pattern {}'.format(
+                            supplied_param, name, pattern))
+                raise URLBuildError(msg)
+
+            # replace the parameter in the URL with the supplied value
+            replacement_regex = '(<{}.*?>)'.format(name)
+
+            out = re.sub(
+                replacement_regex, supplied_param, out)
+
+        # parse the remainder of the keyword arguments into a querystring
+        query_string = urlencode(kwargs, doseq=True) if kwargs else ''
+        # scheme://netloc/path;parameters?query#fragment
+        out = urlunparse((scheme, netloc, out, '', query_string, anchor))
+
+        return out
+
+    # -------------------------------------------------------------------- #
+    # Request Handling
+    # -------------------------------------------------------------------- #
+
+    def converted_response_type(self, response):
+        pass
+
+    async def handle_request(self, request, response_callback):
+        """Take a request from the HTTP Server and return 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:
+            # -------------------------------------------- #
+            # Request Middleware
+            # -------------------------------------------- #
+
+            request.app = self
+
+            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:
+                # -------------------------------------------- #
+                # Execute Handler
+                # -------------------------------------------- #
+
+                # 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
+
+            # -------------------------------------------- #
+            # Response Middleware
+            # -------------------------------------------- #
+
+            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:
+            # -------------------------------------------- #
+            # Response Generation Failed
+            # -------------------------------------------- #
+
+            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 occurred while handling an error")
+
+        response_callback(response)
+
+    # -------------------------------------------------------------------- #
+    # Testing
+    # -------------------------------------------------------------------- #
+
+    @property
+    def test_client(self):
+        return TestClient(self)
+
+    # -------------------------------------------------------------------- #
+    # Execution
+    # -------------------------------------------------------------------- #
+
+    def run(self, host="127.0.0.1", port=8000, debug=False, before_start=None,
+            after_start=None, before_stop=None, after_stop=None, ssl=None,
+            sock=None, workers=1, loop=None, protocol=HttpProtocol,
+            backlog=100, stop_event=None, register_sys_signals=True):
+        """Run the HTTP Server and listen until keyboard interrupt or term
+        signal. On termination, drain connections before closing.
+
+        :param host: Address to host on
+        :param port: Port to host on
+        :param debug: Enables debug output (slows server)
+        :param before_start: Functions to be executed before the server starts
+                             accepting connections
+        :param after_start: Functions to be executed after the server starts
+                            accepting connections
+        :param before_stop: Functions to be executed when a stop signal is
+                            received before it is respected
+        :param after_stop: Functions to be executed when all requests are
+                           complete
+        :param ssl: SSLContext for SSL encryption of worker(s)
+        :param sock: Socket for the server to accept connections from
+        :param workers: Number of processes
+                        received before it is respected
+        :param loop:
+        :param backlog:
+        :param stop_event:
+        :param register_sys_signals:
+        :param protocol: Subclass of asyncio protocol class
+        :return: Nothing
+        """
+        server_settings = self._helper(
+            host=host, port=port, debug=debug, before_start=before_start,
+            after_start=after_start, before_stop=before_stop,
+            after_stop=after_stop, ssl=ssl, sock=sock, workers=workers,
+            loop=loop, protocol=protocol, backlog=backlog,
+            stop_event=stop_event, register_sys_signals=register_sys_signals)
+
+        try:
+            self.is_running = True
+            if workers == 1:
+                serve(**server_settings)
+            else:
+                serve_multiple(server_settings, workers, stop_event)
+        except:
+            log.exception(
+                'Experienced exception while trying to serve')
+        finally:
+            self.is_running = False
+        log.info("Server Stopped")
+
+    def stop(self):
+        """This kills the Sanic"""
+        get_event_loop().stop()
+
+    async def create_server(self, host="127.0.0.1", port=8000, debug=False,
+                            before_start=None, after_start=None,
+                            before_stop=None, after_stop=None, ssl=None,
+                            sock=None, loop=None, protocol=HttpProtocol,
+                            backlog=100, stop_event=None):
+        """Asynchronous version of `run`.
+
+        NOTE: This does not support multiprocessing and is not the preferred
+              way to run a Sanic application.
+        """
+        server_settings = self._helper(
+            host=host, port=port, debug=debug, before_start=before_start,
+            after_start=after_start, before_stop=before_stop,
+            after_stop=after_stop, ssl=ssl, sock=sock,
+            loop=loop or get_event_loop(), protocol=protocol,
+            backlog=backlog, stop_event=stop_event,
+            run_async=True)
+
+        return await serve(**server_settings)
+
+    def _helper(self, host="127.0.0.1", port=8000, debug=False,
+                before_start=None, after_start=None, before_stop=None,
+                after_stop=None, ssl=None, sock=None, workers=1, loop=None,
+                protocol=HttpProtocol, backlog=100, stop_event=None,
+                register_sys_signals=True, run_async=False):
+        """Helper function used by `run` and `create_server`."""
+
+        if loop is not None:
+            if debug:
+                warnings.simplefilter('default')
+            warnings.warn("Passing a loop will be deprecated in version"
+                          " 0.4.0 https://github.com/channelcat/sanic/"
+                          "pull/335 has more information.",
+                          DeprecationWarning)
+
+        # Deprecate this
+        if any(arg is not None for arg in (after_stop, after_start,
+                                           before_start, before_stop)):
+            if debug:
+                warnings.simplefilter('default')
+            warnings.warn("Passing a before_start, before_stop, after_start or"
+                          "after_stop callback will be deprecated in next "
+                          "major version after 0.4.0",
+                          DeprecationWarning)
+
+        self.error_handler.debug = debug
+        self.debug = debug
+
+        server_settings = {
+            'protocol': protocol,
+            'host': host,
+            'port': port,
+            'sock': sock,
+            'ssl': ssl,
+            'debug': debug,
+            'request_handler': self.handle_request,
+            'error_handler': self.error_handler,
+            'request_timeout': self.config.REQUEST_TIMEOUT,
+            'request_max_size': self.config.REQUEST_MAX_SIZE,
+            'loop': loop,
+            'register_sys_signals': register_sys_signals,
+            'backlog': backlog
+        }
+
+        # -------------------------------------------- #
+        # Register start/stop events
+        # -------------------------------------------- #
+
+        for event_name, settings_name, reverse, args in (
+                ("before_server_start", "before_start", False, before_start),
+                ("after_server_start", "after_start", False, after_start),
+                ("before_server_stop", "before_stop", True, before_stop),
+                ("after_server_stop", "after_stop", True, after_stop),
+        ):
+            listeners = self.listeners[event_name].copy()
+            if args:
+                if callable(args):
+                    listeners.append(args)
+                else:
+                    listeners.extend(args)
+            if reverse:
+                listeners.reverse()
+            # Prepend sanic to the arguments when listeners are triggered
+            listeners = [partial(listener, self) for listener in listeners]
+            server_settings[settings_name] = listeners
+
+        if debug:
+            log.setLevel(logging.DEBUG)
+        if self.config.LOGO is not None:
+            log.debug(self.config.LOGO)
+
+        if run_async:
+            server_settings['run_async'] = True
+
+        # Serve
+        proto = "http"
+        if ssl is not None:
+            proto = "https"
+        log.info('Goin\' Fast @ {}://{}:{}'.format(proto, host, port))
+
+        return server_settings

sanic/blueprints.py

@@ -1,97 +1,171 @@
-class BlueprintSetup:
-    """
-    """
+from collections import defaultdict, namedtuple
 
-    def __init__(self, blueprint, app, options):
-        self.app = app
-        self.blueprint = blueprint
-        self.options = options
+from sanic.constants import HTTP_METHODS
+from sanic.views import CompositionView
 
-        url_prefix = self.options.get('url_prefix')
-        if url_prefix is None:
-            url_prefix = self.blueprint.url_prefix
-
-        #: The prefix that should be used for all URLs defined on the
-        #: blueprint.
-        self.url_prefix = url_prefix
-
-    def add_route(self, handler, uri, methods):
-        """
-        A helper method to register a handler to the application url routes.
-        """
-        if self.url_prefix:
-            uri = self.url_prefix + uri
-
-        self.app.router.add(uri, methods, handler)
-
-    def add_exception(self, handler, *args, **kwargs):
-        """
-        Registers exceptions to sanic
-        """
-        self.app.exception(*args, **kwargs)(handler)
-
-    def add_middleware(self, middleware, *args, **kwargs):
-        """
-        Registers middleware to sanic
-        """
-        if args or kwargs:
-            self.app.middleware(*args, **kwargs)(middleware)
-        else:
-            self.app.middleware(middleware)
+FutureRoute = namedtuple('Route', ['handler', 'uri', 'methods', 'host'])
+FutureListener = namedtuple('Listener', ['handler', 'uri', 'methods', 'host'])
+FutureMiddleware = namedtuple('Route', ['middleware', 'args', 'kwargs'])
+FutureException = namedtuple('Route', ['handler', 'args', 'kwargs'])
+FutureStatic = namedtuple('Route',
+                          ['uri', 'file_or_directory', 'args', 'kwargs'])
 
 
 class Blueprint:
-    def __init__(self, name, url_prefix=None):
+    def __init__(self, name, url_prefix=None, host=None):
+        """Create a new blueprint
+
+        :param name: unique name of the blueprint
+        :param url_prefix: URL to be prefixed before all route URLs
+        """
         self.name = name
         self.url_prefix = url_prefix
-        self.deferred_functions = []
+        self.host = host
 
-    def record(self, func):
-        """
-        Registers a callback function that is invoked when the blueprint is
-        registered on the application.
-        """
-        self.deferred_functions.append(func)
-
-    def make_setup_state(self, app, options):
-        """
-        """
-        return BlueprintSetup(self, app, options)
+        self.routes = []
+        self.exceptions = []
+        self.listeners = defaultdict(list)
+        self.middlewares = []
+        self.statics = []
 
     def register(self, app, options):
-        """
-        """
-        state = self.make_setup_state(app, options)
-        for deferred in self.deferred_functions:
-            deferred(state)
+        """Register the blueprint to the sanic app."""
 
-    def route(self, uri, methods=None):
-        """
+        url_prefix = options.get('url_prefix', self.url_prefix)
+
+        # Routes
+        for future in self.routes:
+            # attach the blueprint name to the handler so that it can be
+            # prefixed properly in the router
+            future.handler.__blueprintname__ = self.name
+            # Prepend the blueprint URI prefix if available
+            uri = url_prefix + future.uri if url_prefix else future.uri
+            app.route(
+                uri=uri[1:] if uri.startswith('//') else uri,
+                methods=future.methods,
+                host=future.host or self.host
+                )(future.handler)
+
+        # Middleware
+        for future in self.middlewares:
+            if future.args or future.kwargs:
+                app.middleware(*future.args,
+                               **future.kwargs)(future.middleware)
+            else:
+                app.middleware(future.middleware)
+
+        # Exceptions
+        for future in self.exceptions:
+            app.exception(*future.args, **future.kwargs)(future.handler)
+
+        # Static Files
+        for future in self.statics:
+            # Prepend the blueprint URI prefix if available
+            uri = url_prefix + future.uri if url_prefix else future.uri
+            app.static(uri, future.file_or_directory,
+                       *future.args, **future.kwargs)
+
+        # Event listeners
+        for event, listeners in self.listeners.items():
+            for listener in listeners:
+                app.listener(event)(listener)
+
+    def route(self, uri, methods=frozenset({'GET'}), host=None):
+        """Create a blueprint route from a decorated function.
+
+        :param uri: endpoint at which the route will be accessible.
+        :param methods: list of acceptable HTTP methods.
         """
         def decorator(handler):
-            self.record(lambda s: s.add_route(handler, uri, methods))
+            route = FutureRoute(handler, uri, methods, host)
+            self.routes.append(route)
             return handler
         return decorator
 
+    def add_route(self, handler, uri, methods=frozenset({'GET'}), host=None):
+        """Create a blueprint route from a function.
+
+        :param handler: function for handling uri requests. Accepts function,
+                        or class instance with a view_class method.
+        :param uri: endpoint at which the route will be accessible.
+        :param methods: list of acceptable HTTP methods.
+        :return: function or class instance
+        """
+        # Handle HTTPMethodView differently
+        if hasattr(handler, 'view_class'):
+            methods = set()
+
+            for method in HTTP_METHODS:
+                if getattr(handler.view_class, method.lower(), None):
+                    methods.add(method)
+
+        # handle composition view differently
+        if isinstance(handler, CompositionView):
+            methods = handler.handlers.keys()
+
+        self.route(uri=uri, methods=methods, host=host)(handler)
+        return handler
+
+    def listener(self, event):
+        """Create a listener from a decorated function.
+
+        :param event: Event to listen to.
+        """
+        def decorator(listener):
+            self.listeners[event].append(listener)
+            return listener
+        return decorator
+
     def middleware(self, *args, **kwargs):
-        """
-        """
-        def register_middleware(middleware):
-            self.record(
-                lambda s: s.add_middleware(middleware, *args, **kwargs))
-            return middleware
+        """Create a blueprint middleware from a decorated function."""
+        def register_middleware(_middleware):
+            future_middleware = FutureMiddleware(_middleware, args, kwargs)
+            self.middlewares.append(future_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]):
+            middleware = args[0]
             args = []
-            return register_middleware(args[0])
+            return register_middleware(middleware)
         else:
             return register_middleware
 
     def exception(self, *args, **kwargs):
-        """
-        """
+        """Create a blueprint exception from a decorated function."""
         def decorator(handler):
-            self.record(lambda s: s.add_exception(handler, *args, **kwargs))
+            exception = FutureException(handler, args, kwargs)
+            self.exceptions.append(exception)
             return handler
         return decorator
+
+    def static(self, uri, file_or_directory, *args, **kwargs):
+        """Create a blueprint static route from a decorated function.
+
+        :param uri: endpoint at which the route will be accessible.
+        :param file_or_directory: Static asset.
+        """
+        static = FutureStatic(uri, file_or_directory, args, kwargs)
+        self.statics.append(static)
+
+    # Shorthand method decorators
+    def get(self, uri, host=None):
+        return self.route(uri, methods=["GET"], host=host)
+
+    def post(self, uri, host=None):
+        return self.route(uri, methods=["POST"], host=host)
+
+    def put(self, uri, host=None):
+        return self.route(uri, methods=["PUT"], host=host)
+
+    def head(self, uri, host=None):
+        return self.route(uri, methods=["HEAD"], host=host)
+
+    def options(self, uri, host=None):
+        return self.route(uri, methods=["OPTIONS"], host=host)
+
+    def patch(self, uri, host=None):
+        return self.route(uri, methods=["PATCH"], host=host)
+
+    def delete(self, uri, host=None):
+        return self.route(uri, methods=["DELETE"], host=host)

sanic/config.py

@@ -1,5 +1,11 @@
-class Config:
-    LOGO = """
+import os
+import types
+
+
+class Config(dict):
+    def __init__(self, defaults=None):
+        super().__init__(defaults or {})
+        self.LOGO = """
                  ▄▄▄▄▄
         ▀▀▀██████▄▄▄       _______________
       ▄▄▄▄▄  █████████▄  /                 \\
@@ -20,5 +26,67 @@ class Config:
 ▌     ▐                ▀▀▄▄▄▀
  ▀▀▄▄▀
 """
-    REQUEST_MAX_SIZE = 100000000  # 100 megababies
-    REQUEST_TIMEOUT = 60  # 60 seconds
+        self.REQUEST_MAX_SIZE = 100000000  # 100 megababies
+        self.REQUEST_TIMEOUT = 60  # 60 seconds
+
+    def __getattr__(self, attr):
+        try:
+            return self[attr]
+        except KeyError as ke:
+            raise AttributeError("Config has no '{}'".format(ke.args[0]))
+
+    def __setattr__(self, attr, value):
+        self[attr] = value
+
+    def from_envvar(self, variable_name):
+        """Load a configuration from an environment variable pointing to
+        a configuration file.
+
+        :param variable_name: name of the environment variable
+        :return: bool. ``True`` if able to load config, ``False`` otherwise.
+        """
+        config_file = os.environ.get(variable_name)
+        if not config_file:
+            raise RuntimeError('The environment variable %r is not set and '
+                               'thus configuration could not be loaded.' %
+                               variable_name)
+        return self.from_pyfile(config_file)
+
+    def from_pyfile(self, filename):
+        """Update the values in the config from a Python file.
+        Only the uppercase variables in that module are stored in the config.
+
+        :param filename: an absolute path to the config file
+        """
+        module = types.ModuleType('config')
+        module.__file__ = filename
+        try:
+            with open(filename) as config_file:
+                exec(compile(config_file.read(), filename, 'exec'),
+                     module.__dict__)
+        except IOError as e:
+            e.strerror = 'Unable to load configuration file (%s)' % e.strerror
+            raise
+        self.from_object(module)
+        return True
+
+    def from_object(self, obj):
+        """Update the values from the given object.
+        Objects are usually either modules or classes.
+
+        Just the uppercase variables in that object are stored in the config.
+        Example usage::
+
+            from yourapplication import default_config
+            app.config.from_object(default_config)
+
+        You should not use this function to load the actual configuration but
+        rather configuration defaults. The actual config should be loaded
+        with :meth:`from_pyfile` and ideally from a location not within the
+        package because the package might be installed system wide.
+
+        :param obj: an object holding the configuration
+        """
+        for key in dir(obj):
+            if key.isupper():
+                self[key] = getattr(obj, key)

sanic/constants.py

@@ -0,0 +1 @@
+HTTP_METHODS = ('GET', 'POST', 'PUT', 'HEAD', 'OPTIONS', 'PATCH', 'DELETE')

sanic/cookies.py

@@ -0,0 +1,140 @@
+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['path'] = '/'
+            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):
+        if key not in self.cookie_headers:
+            self[key] = ''
+            self[key]['max-age'] = 0
+        else:
+            cookie_header = self.cookie_headers[key]
+            del self.headers[cookie_header]
+            del self.cookie_headers[key]
+            return super().__delitem__(key)
+
+
+class Cookie(dict):
+    """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':
+                try:
+                    output.append('%s=%d' % (self._keys[key], value))
+                except TypeError:
+                    output.append('%s=%s' % (self._keys[key], value))
+            elif key == 'expires':
+                try:
+                    output.append('%s=%s' % (
+                        self._keys[key],
+                        value.strftime("%a, %d-%b-%Y %T GMT")
+                    ))
+                except AttributeError:
+                    output.append('%s=%s' % (self._keys[key], value))
+            elif key in self._flags:
+                if self[key]:
+                    output.append(self._keys[key])
+            else:
+                output.append('%s=%s' % (self._keys[key], value))
+
+        return "; ".join(output).encode(encoding)
+
+# ------------------------------------------------------------ #
+#  Header Trickery
+# ------------------------------------------------------------ #
+
+
+class MultiHeader:
+    """String-holding object which allow 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

@@ -1,10 +1,106 @@
-from .response import text
-from traceback import format_exc
+TRACEBACK_STYLE = '''
+    <style>
+        body {
+            padding: 20px;
+            font-family: Arial, sans-serif;
+        }
+
+        p {
+            margin: 0;
+        }
+
+        .summary {
+            padding: 10px;
+        }
+
+        h1 {
+            margin-bottom: 0;
+        }
+
+        h3 {
+            margin-top: 10px;
+        }
+
+        h3 code {
+            font-size: 24px;
+        }
+
+        .frame-line > * {
+            padding: 5px 10px;
+        }
+
+        .frame-line {
+            margin-bottom: 5px;
+        }
+
+        .frame-code {
+            font-size: 16px;
+            padding-left: 30px;
+        }
+
+        .tb-wrapper {
+            border: 1px solid #f3f3f3;
+        }
+
+        .tb-header {
+            background-color: #f3f3f3;
+            padding: 5px 10px;
+        }
+
+        .frame-descriptor {
+            background-color: #e2eafb;
+        }
+
+        .frame-descriptor {
+            font-size: 14px;
+        }
+    </style>
+'''
+
+TRACEBACK_WRAPPER_HTML = '''
+    <html>
+        <head>
+            {style}
+        </head>
+        <body>
+            <h1>{exc_name}</h1>
+            <h3><code>{exc_value}</code></h3>
+            <div class="tb-wrapper">
+                <p class="tb-header">Traceback (most recent call last):</p>
+                {frame_html}
+                <p class="summary">
+                <b>{exc_name}: {exc_value}</b>
+                    while handling uri <code>{uri}</code>
+                </p>
+            </div>
+        </body>
+    </html>
+'''
+
+TRACEBACK_LINE_HTML = '''
+    <div class="frame-line">
+        <p class="frame-descriptor">
+            File {0.filename}, line <i>{0.lineno}</i>,
+            in <code><b>{0.name}</b></code>
+        </p>
+        <p class="frame-code"><code>{0.line}</code></p>
+    </div>
+'''
+
+INTERNAL_SERVER_ERROR_HTML = '''
+    <h1>Internal Server Error</h1>
+    <p>
+        The server encountered an internal error and cannot complete
+        your request.
+    </p>
+'''
 
 
 class SanicException(Exception):
+
     def __init__(self, message, status_code=None):
         super().__init__(message)
+
         if status_code is not None:
             self.status_code = status_code
 
@@ -21,36 +117,41 @@ class ServerError(SanicException):
     status_code = 500
 
 
-class Handler:
-    handlers = None
+class URLBuildError(SanicException):
+    status_code = 500
 
-    def __init__(self, sanic):
-        self.handlers = {}
-        self.sanic = sanic
 
-    def add(self, exception, handler):
-        self.handlers[exception] = handler
+class FileNotFound(NotFound):
+    status_code = 404
 
-    def response(self, request, exception):
-        """
-        Fetches and executes an exception handler and returns a response object
-        :param request: Request
-        :param exception: Exception to handle
-        :return: Response object
-        """
-        handler = self.handlers.get(type(exception), self.default)
-        response = handler(request=request, exception=exception)
-        return response
+    def __init__(self, message, path, relative_url):
+        super().__init__(message)
+        self.path = path
+        self.relative_url = relative_url
 
-    def default(self, request, exception):
-        if issubclass(type(exception), SanicException):
-            return text(
-                "Error: {}".format(exception),
-                status=getattr(exception, 'status_code', 500))
-        elif self.sanic.debug:
-            return text(
-                "Error: {}\nException: {}".format(
-                    exception, format_exc()), status=500)
-        else:
-            return text(
-                "An error occurred while generating the request", status=500)
+
+class RequestTimeout(SanicException):
+    status_code = 408
+
+
+class PayloadTooLarge(SanicException):
+    status_code = 413
+
+
+class HeaderNotFound(SanicException):
+    status_code = 400
+
+
+class ContentRangeError(SanicException):
+    status_code = 416
+
+    def __init__(self, message, content_range):
+        super().__init__(message)
+        self.headers = {
+            'Content-Type': 'text/plain',
+            "Content-Range": "bytes */%s" % (content_range.total,)
+        }
+
+
+class InvalidRangeType(ContentRangeError):
+    pass

sanic/handlers.py

@@ -0,0 +1,139 @@
+import sys
+from traceback import format_exc, extract_tb
+
+from sanic.exceptions import (
+    ContentRangeError,
+    HeaderNotFound,
+    INTERNAL_SERVER_ERROR_HTML,
+    InvalidRangeType,
+    SanicException,
+    TRACEBACK_LINE_HTML,
+    TRACEBACK_STYLE,
+    TRACEBACK_WRAPPER_HTML)
+from sanic.log import log
+from sanic.response import text, html
+
+
+class ErrorHandler:
+    handlers = None
+
+    def __init__(self):
+        self.handlers = {}
+        self.debug = False
+
+    def _render_traceback_html(self, exception, request):
+        exc_type, exc_value, tb = sys.exc_info()
+        frames = extract_tb(tb)
+
+        frame_html = []
+        for frame in frames:
+            frame_html.append(TRACEBACK_LINE_HTML.format(frame))
+
+        return TRACEBACK_WRAPPER_HTML.format(
+            style=TRACEBACK_STYLE,
+            exc_name=exc_type.__name__,
+            exc_value=exc_value,
+            frame_html=''.join(frame_html),
+            uri=request.url)
+
+    def add(self, exception, handler):
+        self.handlers[exception] = handler
+
+    def response(self, request, exception):
+        """Fetches and executes an exception handler and returns a response
+        object
+
+        :param request: Request
+        :param exception: Exception to handle
+        :return: Response object
+        """
+        handler = self.handlers.get(type(exception), self.default)
+        try:
+            response = handler(request=request, exception=exception)
+        except Exception:
+            self.log(format_exc())
+            if self.debug:
+                url = getattr(request, 'url', 'unknown')
+                response_message = (
+                    'Exception raised in exception handler "{}" '
+                    'for uri: "{}"\n{}').format(
+                        handler.__name__, url, format_exc())
+                log.error(response_message)
+                return text(response_message, 500)
+            else:
+                return text('An error occurred while handling an error', 500)
+        return response
+
+    def log(self, message, level='error'):
+        """
+        Override this method in an ErrorHandler subclass to prevent
+        logging exceptions.
+        """
+        getattr(log, level)(message)
+
+    def default(self, request, exception):
+        self.log(format_exc())
+        if issubclass(type(exception), SanicException):
+            return text(
+                'Error: {}'.format(exception),
+                status=getattr(exception, 'status_code', 500),
+                headers=getattr(exception, 'headers', dict())
+            )
+        elif self.debug:
+            html_output = self._render_traceback_html(exception, request)
+
+            response_message = (
+                'Exception occurred while handling uri: "{}"\n{}'.format(
+                    request.url, format_exc()))
+            log.error(response_message)
+            return html(html_output, status=500)
+        else:
+            return html(INTERNAL_SERVER_ERROR_HTML, status=500)
+
+
+class ContentRangeHandler:
+    """Class responsible for parsing request header"""
+    __slots__ = ('start', 'end', 'size', 'total', 'headers')
+
+    def __init__(self, request, stats):
+        self.total = stats.st_size
+        _range = request.headers.get('Range')
+        if _range is None:
+            raise HeaderNotFound('Range Header Not Found')
+        unit, _, value = tuple(map(str.strip, _range.partition('=')))
+        if unit != 'bytes':
+            raise InvalidRangeType(
+                '%s is not a valid Range Type' % (unit,), self)
+        start_b, _, end_b = tuple(map(str.strip, value.partition('-')))
+        try:
+            self.start = int(start_b) if start_b else None
+        except ValueError:
+            raise ContentRangeError(
+                '\'%s\' is invalid for Content Range' % (start_b,), self)
+        try:
+            self.end = int(end_b) if end_b else None
+        except ValueError:
+            raise ContentRangeError(
+                '\'%s\' is invalid for Content Range' % (end_b,), self)
+        if self.end is None:
+            if self.start is None:
+                raise ContentRangeError(
+                    'Invalid for Content Range parameters', self)
+            else:
+                # this case represents `Content-Range: bytes 5-`
+                self.end = self.total
+        else:
+            if self.start is None:
+                # this case represents `Content-Range: bytes -5`
+                self.start = self.total - self.end
+                self.end = self.total
+        if self.start >= self.end:
+            raise ContentRangeError(
+                'Invalid for Content Range parameters', self)
+        self.size = self.end - self.start
+        self.headers = {
+            'Content-Range': "bytes %s-%s/%s" % (
+                self.start, self.end, self.total)}
+
+    def __bool__(self):
+        return self.size > 0

sanic/log.py

@@ -1,5 +1,3 @@
 import logging
 
-logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s: %(levelname)s: %(message)s")
-log = logging.getLogger(__name__)
+log = logging.getLogger('sanic')

sanic/request.py

@@ -1,79 +1,99 @@
 from cgi import parse_header
 from collections import namedtuple
+from http.cookies import SimpleCookie
 from httptools import parse_url
 from urllib.parse import parse_qs
-from ujson import loads as json_loads
 
-from .log import log
+try:
+    from ujson import loads as json_loads
+except ImportError:
+    from json import loads as json_loads
+
+from sanic.exceptions import InvalidUsage
+from sanic.log import log
+
+
+DEFAULT_HTTP_CONTENT_TYPE = "application/octet-stream"
+# HTTP/1.1: https://www.w3.org/Protocols/rfc2616/rfc2616-sec7.html#sec7.2.1
+# > If the media type remains unknown, the recipient SHOULD treat it
+# > as type "application/octet-stream"
 
 
 class RequestParameters(dict):
-    """
-    Hosts a dict with lists as values where get returns the first
+    """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
+        """Return the first value, either the default or actual"""
+        return super().get(name, [default])[0]
 
     def getlist(self, name, default=None):
-        return self.super.get(name, default)
+        """Return the entire list"""
+        return super().get(name, default)
 
 
-class Request:
-    """
-    Properties of an HTTP request such as URL, headers, etc.
-    """
+class Request(dict):
+    """Properties of an HTTP request such as URL, headers, etc."""
     __slots__ = (
-        'url', 'headers', 'version', 'method',
+        'app', 'url', 'headers', 'version', 'method', '_cookies', 'transport',
         'query_string', 'body',
         'parsed_json', 'parsed_args', 'parsed_form', 'parsed_files',
+        '_ip',
     )
 
-    def __init__(self, url_bytes, headers, version, method):
+    def __init__(self, url_bytes, headers, version, method, transport):
         # TODO: Content-Encoding detection
         url_parsed = parse_url(url_bytes)
+        self.app = None
         self.url = url_parsed.path.decode('utf-8')
         self.headers = headers
         self.version = version
         self.method = method
+        self.transport = transport
         self.query_string = None
         if url_parsed.query:
             self.query_string = url_parsed.query.decode('utf-8')
 
         # Init but do not inhale
-        self.body = None
+        self.body = []
         self.parsed_json = None
         self.parsed_form = None
         self.parsed_files = None
         self.parsed_args = None
+        self._cookies = None
 
     @property
     def json(self):
-        if not self.parsed_json:
+        if self.parsed_json is None:
             try:
                 self.parsed_json = json_loads(self.body)
             except Exception:
-                pass
+                raise InvalidUsage("Failed when parsing body as json")
 
         return self.parsed_json
 
+    @property
+    def token(self):
+        """Attempt to return the auth header token.
+
+        :return: token related to request
+        """
+        auth_header = self.headers.get('Authorization')
+        if auth_header is not None:
+            return auth_header.split()[1]
+        return auth_header
+
     @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'))
+            self.parsed_form = RequestParameters()
+            self.parsed_files = RequestParameters()
+            content_type = self.headers.get(
+                'Content-Type', DEFAULT_HTTP_CONTENT_TYPE)
+            content_type, parameters = parse_header(content_type)
             try:
-                is_url_encoded = (
-                    content_type == 'application/x-www-form-urlencoded')
-                if content_type is None or is_url_encoded:
+                if content_type == 'application/x-www-form-urlencoded':
                     self.parsed_form = RequestParameters(
                         parse_qs(self.body.decode('utf-8')))
                 elif content_type == 'multipart/form-data':
@@ -81,9 +101,8 @@ class Request:
                     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
+            except Exception:
+                log.exception("Failed when parsing form")
 
         return self.parsed_form
 
@@ -101,23 +120,41 @@ class Request:
                 self.parsed_args = RequestParameters(
                     parse_qs(self.query_string))
             else:
-                self.parsed_args = {}
-
+                self.parsed_args = RequestParameters()
         return self.parsed_args
 
+    @property
+    def cookies(self):
+        if self._cookies is None:
+            cookie = self.headers.get('Cookie') or self.headers.get('cookie')
+            if cookie is not None:
+                cookies = SimpleCookie()
+                cookies.load(cookie)
+                self._cookies = {name: cookie.value
+                                 for name, cookie in cookies.items()}
+            else:
+                self._cookies = {}
+        return self._cookies
+
+    @property
+    def ip(self):
+        if not hasattr(self, '_ip'):
+            self._ip = self.transport.get_extra_info('peername')
+        return self._ip
+
 
 File = namedtuple('File', ['type', 'body', 'name'])
 
 
 def parse_multipart_form(body, boundary):
+    """Parse a request body and returns fields and files
+
+    :param body: bytes request body
+    :param boundary: bytes multipart boundary
+    :return: fields (RequestParameters), files (RequestParameters)
     """
-    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 = {}
+    files = RequestParameters()
+    fields = RequestParameters()
 
     form_parts = body.split(boundary)
     for form_part in form_parts[1:-1]:
@@ -148,9 +185,16 @@ def parse_multipart_form(body, boundary):
 
         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)
+            file = File(type=file_type, name=file_name, body=post_data)
+            if field_name in files:
+                files[field_name].append(file)
+            else:
+                files[field_name] = [file]
         else:
-            fields[field_name] = post_data.decode('utf-8')
+            value = post_data.decode('utf-8')
+            if field_name in fields:
+                fields[field_name].append(value)
+            else:
+                fields[field_name] = [value]
 
     return fields, files

sanic/response.py

@@ -1,77 +1,241 @@
-import ujson
+from mimetypes import guess_type
+from os import path
+from ujson import dumps as json_dumps
 
-STATUS_CODES = {
+from aiofiles import open as open_async
+
+from sanic.cookies import CookieJar
+
+COMMON_STATUS_CODES = {
     200: b'OK',
     400: b'Bad Request',
+    404: b'Not Found',
+    500: b'Internal Server Error',
+}
+ALL_STATUS_CODES = {
+    100: b'Continue',
+    101: b'Switching Protocols',
+    102: b'Processing',
+    200: b'OK',
+    201: b'Created',
+    202: b'Accepted',
+    203: b'Non-Authoritative Information',
+    204: b'No Content',
+    205: b'Reset Content',
+    206: b'Partial Content',
+    207: b'Multi-Status',
+    208: b'Already Reported',
+    226: b'IM Used',
+    300: b'Multiple Choices',
+    301: b'Moved Permanently',
+    302: b'Found',
+    303: b'See Other',
+    304: b'Not Modified',
+    305: b'Use Proxy',
+    307: b'Temporary Redirect',
+    308: b'Permanent Redirect',
+    400: b'Bad Request',
     401: b'Unauthorized',
     402: b'Payment Required',
     403: b'Forbidden',
     404: b'Not Found',
     405: b'Method Not Allowed',
+    406: b'Not Acceptable',
+    407: b'Proxy Authentication Required',
+    408: b'Request Timeout',
+    409: b'Conflict',
+    410: b'Gone',
+    411: b'Length Required',
+    412: b'Precondition Failed',
+    413: b'Request Entity Too Large',
+    414: b'Request-URI Too Long',
+    415: b'Unsupported Media Type',
+    416: b'Requested Range Not Satisfiable',
+    417: b'Expectation Failed',
+    422: b'Unprocessable Entity',
+    423: b'Locked',
+    424: b'Failed Dependency',
+    426: b'Upgrade Required',
+    428: b'Precondition Required',
+    429: b'Too Many Requests',
+    431: b'Request Header Fields Too Large',
     500: b'Internal Server Error',
     501: b'Not Implemented',
     502: b'Bad Gateway',
     503: b'Service Unavailable',
     504: b'Gateway Timeout',
+    505: b'HTTP Version Not Supported',
+    506: b'Variant Also Negotiates',
+    507: b'Insufficient Storage',
+    508: b'Loop Detected',
+    510: b'Not Extended',
+    511: b'Network Authentication Required'
 }
 
 
 class HTTPResponse:
-    __slots__ = ('body', 'status', 'content_type', 'headers')
+    __slots__ = ('body', 'status', 'content_type', 'headers', '_cookies')
 
     def __init__(self, body=None, status=200, headers=None,
                  content_type='text/plain', body_bytes=b''):
         self.content_type = content_type
 
         if body is not None:
-            self.body = body.encode('utf-8')
+            try:
+                # Try to encode it regularly
+                self.body = body.encode()
+            except AttributeError:
+                # Convert it to a str if you can't
+                self.body = str(body).encode()
         else:
             self.body = body_bytes
 
         self.status = status
         self.headers = headers or {}
+        self._cookies = None
 
     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
         timeout_header = b''
-        if keep_alive and keep_alive_timeout:
-            timeout_header = b'Keep-Alive: timeout=%d\r\n' % keep_alive_timeout
-
+        if keep_alive and keep_alive_timeout is not None:
+            timeout_header = b'Keep-Alive: %d\r\n' % keep_alive_timeout
+        self.headers['Content-Length'] = self.headers.get(
+            'Content-Length', len(self.body))
+        self.headers['Content-Type'] = self.headers.get(
+            'Content-Type', self.content_type)
         headers = b''
-        if self.headers:
-            headers = b''.join(
-                b'%b: %b\r\n' % (name.encode(), value.encode('utf-8'))
-                for name, value in self.headers.items()
-            )
+        for name, value in self.headers.items():
+            try:
+                headers += (
+                    b'%b: %b\r\n' % (
+                        name.encode(), value.encode('utf-8')))
+            except AttributeError:
+                headers += (
+                    b'%b: %b\r\n' % (
+                        str(name).encode(), str(value).encode('utf-8')))
+
+        # Try to pull from the common codes first
+        # Speeds up response rate 6% over pulling from all
+        status = COMMON_STATUS_CODES.get(self.status)
+        if not status:
+            status = ALL_STATUS_CODES.get(self.status)
+
         return (b'HTTP/%b %d %b\r\n'
-                b'Content-Type: %b\r\n'
-                b'Content-Length: %d\r\n'
                 b'Connection: %b\r\n'
-                b'%b%b\r\n'
+                b'%b'
+                b'%b\r\n'
                 b'%b') % (
             version.encode(),
             self.status,
-            STATUS_CODES.get(self.status, b'FAIL'),
-            self.content_type.encode(),
-            len(self.body),
+            status,
             b'keep-alive' if keep_alive else b'close',
             timeout_header,
             headers,
             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")
+    @property
+    def cookies(self):
+        if self._cookies is None:
+            self._cookies = CookieJar(self.headers)
+        return self._cookies
 
 
-def text(body, status=200, headers=None):
+def json(body, status=200, headers=None, **kwargs):
+    """
+    Returns response object with body in json format.
+    :param body: Response data to be serialized.
+    :param status: Response code.
+    :param headers: Custom Headers.
+    :param kwargs: Remaining arguments that are passed to the json encoder.
+    """
+    return HTTPResponse(json_dumps(body, **kwargs), headers=headers,
+                        status=status, content_type="application/json")
+
+
+def text(body, status=200, headers=None,
+         content_type="text/plain; charset=utf-8"):
+    """
+    Returns response object with body in text format.
+    :param body: Response data to be encoded.
+    :param status: Response code.
+    :param headers: Custom Headers.
+    :param content_type:
+        the content type (string) of the response
+    """
     return HTTPResponse(body, status=status, headers=headers,
-                        content_type="text/plain; charset=utf-8")
+                        content_type=content_type)
+
+
+def raw(body, status=200, headers=None,
+        content_type="application/octet-stream"):
+    """
+    Returns response object without encoding the body.
+    :param body: Response data.
+    :param status: Response code.
+    :param headers: Custom Headers.
+    :param content_type:
+        the content type (string) of the response
+    """
+    return HTTPResponse(body_bytes=body, status=status, headers=headers,
+                        content_type=content_type)
 
 
 def html(body, status=200, headers=None):
+    """
+    Returns response object with body in html format.
+    :param body: Response data to be encoded.
+    :param status: Response code.
+    :param headers: Custom Headers.
+    """
     return HTTPResponse(body, status=status, headers=headers,
                         content_type="text/html; charset=utf-8")
+
+
+async def file(location, mime_type=None, headers=None, _range=None):
+    """Return a response object with file data.
+
+    :param location: Location of file on system.
+    :param mime_type: Specific mime_type.
+    :param headers: Custom Headers.
+    :param _range:
+    """
+    filename = path.split(location)[-1]
+
+    async with open_async(location, mode='rb') as _file:
+        if _range:
+            await _file.seek(_range.start)
+            out_stream = await _file.read(_range.size)
+            headers['Content-Range'] = 'bytes %s-%s/%s' % (
+                _range.start, _range.end, _range.total)
+        else:
+            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)
+
+
+def redirect(to, headers=None, status=302,
+             content_type="text/html; charset=utf-8"):
+    """Abort execution and cause a 302 redirect (by default).
+
+    :param to: path or fully qualified URL to redirect to
+    :param headers: optional dict of headers to include in the new request
+    :param status: status code (int) of the new request, defaults to 302
+    :param content_type: the content type (string) of the response
+    :returns: the redirecting Response
+    """
+    headers = headers or {}
+
+    # According to RFC 7231, a relative URI is now permitted.
+    headers['Location'] = to
+
+    return HTTPResponse(
+        status=status,
+        headers=headers,
+        content_type=content_type)

sanic/router.py

@@ -1,146 +1,341 @@
 import re
-from collections import namedtuple
-from .exceptions import NotFound, InvalidUsage
+from collections import defaultdict, namedtuple
+from collections.abc import Iterable
+from functools import lru_cache
 
-Route = namedtuple("Route", ['handler', 'methods', 'pattern', 'parameters'])
-Parameter = namedtuple("Parameter", ['name', 'cast'])
+from sanic.exceptions import NotFound, InvalidUsage
+from sanic.views import CompositionView
+
+Route = namedtuple(
+    'Route',
+    ['handler', 'methods', 'pattern', 'parameters', 'name'])
+Parameter = namedtuple('Parameter', ['name', 'cast'])
+
+REGEX_TYPES = {
+    'string': (str, r'[^/]+'),
+    'int': (int, r'\d+'),
+    'number': (float, r'[0-9\\.]+'),
+    'alpha': (str, r'[A-Za-z]+'),
+}
+
+ROUTER_CACHE_SIZE = 1024
+
+
+def url_hash(url):
+    return url.count('/')
+
+
+class RouteExists(Exception):
+    pass
+
+
+class RouteDoesNotExist(Exception):
+    pass
 
 
 class Router:
-    """
-    Router supports basic routing with parameters and method checks
+    """Router supports basic routing with parameters and method checks
+
     Usage:
-        @sanic.route('/my/url/<my_parameter>', methods=['GET', 'POST', ...])
-        def my_route(request, my_parameter):
+
+    .. code-block:: python
+
+        @sanic.route('/my/url/<my_param>', methods=['GET', 'POST', ...])
+        def my_route(request, my_param):
+            do stuff...
+
+    or
+
+    .. code-block:: python
+
+        @sanic.route('/my/url/<my_param:my_type>', methods['GET', 'POST', ...])
+        def my_route_with_type(request, my_param: my_type):
             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 <parameter>.  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
+    function. Provided parameters can also have a type by appending :type to
+    the <parameter>. Given parameter must be able to be type-casted to this.
+    If no type is provided, a string is expected.  A regular expression can
+    also be passed in as the type. The argument given to the function will
+    always be a string, independent of the type.
     """
-    routes = None
-    regex_types = {
-        "string": (None, "[^/]+"),
-        "int": (int, "\d+"),
-        "number": (float, "[0-9\\.]+"),
-        "alpha": (None, "[A-Za-z]+"),
-    }
+    routes_static = None
+    routes_dynamic = None
+    routes_always_check = None
+    parameter_pattern = re.compile(r'<(.+?)>')
 
     def __init__(self):
-        self.routes = []
+        self.routes_all = {}
+        self.routes_static = {}
+        self.routes_dynamic = defaultdict(list)
+        self.routes_always_check = []
+        self.hosts = set()
 
-    def add(self, uri, methods, handler):
+    def parse_parameter_string(self, parameter_string):
+        """Parse a parameter string into its constituent name, type, and
+        pattern
+
+        For example:
+        `parse_parameter_string('<param_one:[A-z]>')` ->
+            ('param_one', str, '[A-z]')
+
+        :param parameter_string: String to parse
+        :return: tuple containing
+            (parameter_name, parameter_type, parameter_pattern)
         """
-        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.
+        # We could receive NAME or NAME:PATTERN
+        name = parameter_string
+        pattern = 'string'
+        if ':' in parameter_string:
+            name, pattern = parameter_string.split(':', 1)
+
+        default = (str, pattern)
+        # Pull from pre-configured types
+        _type, pattern = REGEX_TYPES.get(pattern, default)
+
+        return name, _type, pattern
+
+    def add(self, uri, methods, handler, host=None):
+        # add regular version
+        self._add(uri, methods, handler, host)
+        slash_is_missing = (
+            not uri[-1] == '/'
+            and not self.routes_all.get(uri + '/', False)
+        )
+        without_slash_is_missing = (
+            uri[-1] == '/'
+            and not self.routes_all.get(uri[:-1], False)
+            and not uri == '/'
+        )
+        # add version with trailing slash
+        if slash_is_missing:
+            self._add(uri + '/', methods, handler, host)
+        # add version without trailing slash
+        elif without_slash_is_missing:
+            self._add(uri[:-1], methods, handler, host)
+
+    def _add(self, uri, methods, handler, host=None):
+        """Add a handler to the route list
+
+        :param uri: path to match
+        :param methods: sequence 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
         """
+        if host is not None:
+            if isinstance(host, str):
+                uri = host + uri
+                self.hosts.add(host)
+
+            else:
+                if not isinstance(host, Iterable):
+                    raise ValueError("Expected either string or Iterable of "
+                                     "host strings, not {!r}".format(host))
+
+                for host_ in host:
+                    self.add(uri, methods, handler, host_)
+                return
+        else:
+            # default host
+            self.hosts.add('*')
 
         # Dict for faster lookups of if method allowed
-        methods_dict = None
         if methods:
-            methods_dict = {method: True for method in methods}
+            methods = frozenset(methods)
 
         parameters = []
+        properties = {"unhashable": None}
 
         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'
+            name = match.group(1)
+            name, _type, pattern = self.parse_parameter_string(name)
 
-            # 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)
+            parameter = Parameter(
+                name=name, cast=_type)
             parameters.append(parameter)
 
-            return "({})".format(parameter_pattern)
+            # 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
 
-        pattern_string = re.sub("<(.+?)>", add_parameter, uri)
-        pattern = re.compile("^{}$".format(pattern_string))
+            return '({})'.format(pattern)
 
-        route = Route(
-            handler=handler, methods=methods_dict, pattern=pattern,
-            parameters=parameters)
-        self.routes.append(route)
+        pattern_string = re.sub(self.parameter_pattern, add_parameter, uri)
+        pattern = re.compile(r'^{}$'.format(pattern_string))
+
+        def merge_route(route, methods, handler):
+            # merge to the existing route when possible.
+            if not route.methods or not methods:
+                # method-unspecified routes are not mergeable.
+                raise RouteExists(
+                    "Route already registered: {}".format(uri))
+            elif route.methods.intersection(methods):
+                # already existing method is not overloadable.
+                duplicated = methods.intersection(route.methods)
+                raise RouteExists(
+                    "Route already registered: {} [{}]".format(
+                        uri, ','.join(list(duplicated))))
+            if isinstance(route.handler, CompositionView):
+                view = route.handler
+            else:
+                view = CompositionView()
+                view.add(route.methods, route.handler)
+            view.add(methods, handler)
+            route = route._replace(
+                handler=view, methods=methods.union(route.methods))
+            return route
+
+        if parameters:
+            # TODO: This is too complex, we need to reduce the complexity
+            if properties['unhashable']:
+                routes_to_check = self.routes_always_check
+                ndx, route = self.check_dynamic_route_exists(
+                    pattern, routes_to_check)
+            else:
+                routes_to_check = self.routes_dynamic[url_hash(uri)]
+                ndx, route = self.check_dynamic_route_exists(
+                    pattern, routes_to_check)
+            if ndx != -1:
+                # Pop the ndx of the route, no dups of the same route
+                routes_to_check.pop(ndx)
+        else:
+            route = self.routes_all.get(uri)
+
+        if route:
+            route = merge_route(route, methods, handler)
+        else:
+            # prefix the handler name with the blueprint name
+            # if available
+            if hasattr(handler, '__blueprintname__'):
+                handler_name = '{}.{}'.format(
+                    handler.__blueprintname__, handler.__name__)
+            else:
+                handler_name = getattr(handler, '__name__', None)
+
+            route = Route(
+                handler=handler, methods=methods, pattern=pattern,
+                parameters=parameters, name=handler_name)
+
+        self.routes_all[uri] = route
+        if properties['unhashable']:
+            self.routes_always_check.append(route)
+        elif parameters:
+            self.routes_dynamic[url_hash(uri)].append(route)
+        else:
+            self.routes_static[uri] = route
+
+    @staticmethod
+    def check_dynamic_route_exists(pattern, routes_to_check):
+        for ndx, route in enumerate(routes_to_check):
+            if route.pattern == pattern:
+                return ndx, route
+        else:
+            return -1, None
+
+    def remove(self, uri, clean_cache=True, host=None):
+        if host is not None:
+            uri = host + uri
+        try:
+            route = self.routes_all.pop(uri)
+        except KeyError:
+            raise RouteDoesNotExist("Route was not registered: {}".format(uri))
+
+        if route in self.routes_always_check:
+            self.routes_always_check.remove(route)
+        elif url_hash(uri) in self.routes_dynamic \
+                and route in self.routes_dynamic[url_hash(uri)]:
+            self.routes_dynamic[url_hash(uri)].remove(route)
+        else:
+            self.routes_static.pop(uri)
+
+        if clean_cache:
+            self._get.cache_clear()
+
+    @lru_cache(maxsize=ROUTER_CACHE_SIZE)
+    def find_route_by_view_name(self, view_name):
+        """Find a route in the router based on the specified view name.
+
+        :param view_name: string of view name to search by
+        :return: tuple containing (uri, Route)
+        """
+        if not view_name:
+            return (None, None)
+
+        for uri, route in self.routes_all.items():
+            if route.name == view_name:
+                return uri, route
+
+        return (None, None)
 
     def get(self, request):
-        """
-        Gets a request handler based on the URL of the request, or raises an
+        """Get a request handler based on the URL of the request, or raises an
         error
+
         :param request: Request object
         :return: handler, arguments, keyword arguments
         """
+        # No virtual hosts specified; default behavior
+        if not self.hosts:
+            return self._get(request.url, request.method, '')
+        # virtual hosts specified; try to match route to the host header
+        try:
+            return self._get(request.url, request.method,
+                             request.headers.get("Host", ''))
+        # try default hosts
+        except NotFound:
+            return self._get(request.url, request.method, '')
 
-        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)
-                    if parameter.cast:
-                        kwargs[parameter.name] = parameter.cast(value)
-                    else:
-                        kwargs[parameter.name] = value
-                route = _route
-                break
+    @lru_cache(maxsize=ROUTER_CACHE_SIZE)
+    def _get(self, url, method, host):
+        """Get a request handler based on the URL of the request, or raises an
+        error.  Internal method for caching.
 
+        :param url: request URL
+        :param method: request method
+        :return: handler, arguments, keyword arguments
+        """
+        url = host + url
+        # Check against known static routes
+        route = self.routes_static.get(url)
+        method_not_supported = InvalidUsage(
+            'Method {} not allowed for URL {}'.format(
+                method, url), status_code=405)
         if route:
-            if route.methods and request.method not in route.methods:
-                raise InvalidUsage(
-                    "Method {} not allowed for URL {}".format(
-                        request.method, request.url), status_code=405)
-            return route.handler, args, kwargs
+            if route.methods and method not in route.methods:
+                raise method_not_supported
+            match = route.pattern.match(url)
         else:
-            raise NotFound("Requested URL {} not found".format(request.url))
+            route_found = False
+            # Move on to testing all regex routes
+            for route in self.routes_dynamic[url_hash(url)]:
+                match = route.pattern.match(url)
+                route_found |= match is not None
+                # Do early method checking
+                if match and method in route.methods:
+                    break
+            else:
+                # Lastly, check against all regex routes that cannot be hashed
+                for route in self.routes_always_check:
+                    match = route.pattern.match(url)
+                    route_found |= match is not None
+                    # Do early method checking
+                    if match and method in route.methods:
+                        break
+                else:
+                    # Route was found but the methods didn't match
+                    if route_found:
+                        raise method_not_supported
+                    raise NotFound('Requested URL {} not found'.format(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 = None
-        if methods:
-            methods_dict = {method: True for method in methods}
-        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 request.method not 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))
+        kwargs = {p.name: p.cast(value)
+                  for value, p
+                  in zip(match.groups(1), route.parameters)}
+        route_handler = route.handler
+        if hasattr(route_handler, 'handlers'):
+            route_handler = route_handler.handlers[method]
+        return route_handler, [], kwargs

sanic/sanic.py

@@ -1,267 +0,0 @@
-from asyncio import get_event_loop
-from inspect import isawaitable
-from multiprocessing import Process, Event
-from signal import signal, SIGTERM, SIGINT
-from time import sleep
-from traceback import format_exc
-
-from .config import Config
-from .exceptions import Handler
-from .log import log, logging
-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.error_handler = error_handler or Handler(self)
-        self.config = Config()
-        self.request_middleware = []
-        self.response_middleware = []
-        self.blueprints = {}
-        self._blueprint_order = []
-
-    # -------------------------------------------------------------------- #
-    # 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')
-        """
-        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
-
-    def register_blueprint(self, blueprint, **options):
-        """
-        Registers a blueprint on the application.
-        :param blueprint: Blueprint object
-        :param options: option dictionary with blueprint defaults
-        :return: Nothing
-        """
-        if blueprint.name in self.blueprints:
-            assert self.blueprints[blueprint.name] is blueprint, \
-                'A blueprint with the name "%s" is already registered.  ' \
-                'Blueprint names must be unique.' % \
-                (blueprint.name,)
-        else:
-            self.blueprints[blueprint.name] = blueprint
-            self._blueprint_order.append(blueprint)
-        blueprint.register(self, options)
-
-    # -------------------------------------------------------------------- #
-    # 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, sock=None, workers=1):
-        """
-        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
-        :param sock: Socket for the server to accept connections from
-        :param workers: Number of processes
-        received before it is respected
-        :return: Nothing
-        """
-        self.error_handler.debug = True
-        self.debug = debug
-
-        server_settings = {
-            'host': host,
-            'port': port,
-            'sock': sock,
-            'debug': debug,
-            'request_handler': self.handle_request,
-            'request_timeout': self.config.REQUEST_TIMEOUT,
-            'request_max_size': self.config.REQUEST_MAX_SIZE,
-        }
-
-        if debug:
-            log.setLevel(logging.DEBUG)
-        log.debug(self.config.LOGO)
-
-        # Serve
-        log.info('Goin\' Fast @ http://{}:{}'.format(host, port))
-
-        try:
-            if workers == 1:
-                server_settings['after_start'] = after_start
-                server_settings['before_stop'] = before_stop
-                serve(**server_settings)
-            else:
-                log.info('Spinning up {} workers...'.format(workers))
-
-                self.serve_multiple(server_settings, workers)
-
-        except Exception as e:
-            log.exception(
-                'Experienced exception while trying to serve: {}'.format(e))
-            pass
-
-        log.info("Server Stopped")
-
-    def stop(self):
-        """
-        This kills the Sanic
-        """
-        get_event_loop().stop()
-
-    @staticmethod
-    def serve_multiple(server_settings, workers, stop_event=None):
-        """
-        Starts multiple server processes simultaneously.  Stops on interrupt
-        and terminate signals, and drains connections when complete.
-        :param server_settings: kw arguments to be passed to the serve function
-        :param workers: number of workers to launch
-        :param stop_event: if provided, is used as a stop signal
-        :return:
-        """
-        server_settings['reuse_port'] = True
-
-        # Create a stop event to be triggered by a signal
-        if not stop_event:
-            stop_event = Event()
-        signal(SIGINT, lambda s, f: stop_event.set())
-        signal(SIGTERM, lambda s, f: stop_event.set())
-
-        processes = []
-        for w in range(workers):
-            process = Process(target=serve, kwargs=server_settings)
-            process.start()
-            processes.append(process)
-
-        # Infinitely wait for the stop event
-        try:
-            while not stop_event.is_set():
-                sleep(0.3)
-        except:
-            pass
-
-        log.info('Spinning down workers...')
-        for process in processes:
-            process.terminate()
-        for process in processes:
-            process.join()

sanic/server.py

@@ -1,22 +1,55 @@
 import asyncio
+import os
+import traceback
+import warnings
+from functools import partial
 from inspect import isawaitable
-from signal import SIGINT, SIGTERM
+from multiprocessing import Process, Event
+from os import set_inheritable
+from signal import SIGTERM, SIGINT
+from signal import signal as signal_func
+from socket import socket, SOL_SOCKET, SO_REUSEADDR
+from time import time
 
-import httptools
+from httptools import HttpRequestParser
+from httptools.parser.errors import HttpParserError
 
 try:
     import uvloop as async_loop
 except ImportError:
     async_loop = asyncio
 
-from .log import log
-from .request import Request
+from sanic.log import log
+from sanic.request import Request
+from sanic.exceptions import (
+    RequestTimeout, PayloadTooLarge, InvalidUsage, ServerError)
+
+current_time = None
 
 
 class Signal:
     stopped = False
 
 
+class CIDict(dict):
+    """Case Insensitive dict where all keys are converted to lowercase
+    This does not maintain the inputted case when calling items() or keys()
+    in favor of speed, since headers are case insensitive
+    """
+
+    def get(self, key, default=None):
+        return super().get(key.casefold(), default)
+
+    def __getitem__(self, key):
+        return super().__getitem__(key.casefold())
+
+    def __setitem__(self, key, value):
+        return super().__setitem__(key.casefold(), value)
+
+    def __contains__(self, key):
+        return super().__contains__(key.casefold())
+
+
 class HttpProtocol(asyncio.Protocol):
     __slots__ = (
         # event loop, connection
@@ -26,10 +59,10 @@ class HttpProtocol(asyncio.Protocol):
         # request config
         'request_handler', 'request_timeout', 'request_max_size',
         # connection management
-        '_total_request_size', '_timeout_handler')
+        '_total_request_size', '_timeout_handler', '_last_communication_time')
 
-    def __init__(self, *, loop, request_handler, signal=Signal(),
-                 connections={}, request_timeout=60,
+    def __init__(self, *, loop, request_handler, error_handler,
+                 signal=Signal(), connections=set(), request_timeout=60,
                  request_max_size=None):
         self.loop = loop
         self.transport = None
@@ -40,32 +73,43 @@ class HttpProtocol(asyncio.Protocol):
         self.signal = signal
         self.connections = connections
         self.request_handler = request_handler
+        self.error_handler = error_handler
         self.request_timeout = request_timeout
         self.request_max_size = request_max_size
         self._total_request_size = 0
         self._timeout_handler = None
+        self._last_request_time = None
+        self._request_handler_task = None
 
-        # -------------------------------------------- #
-
+    # -------------------------------------------- #
     # Connection
     # -------------------------------------------- #
 
     def connection_made(self, transport):
-        self.connections[self] = True
+        self.connections.add(self)
         self._timeout_handler = self.loop.call_later(
             self.request_timeout, self.connection_timeout)
         self.transport = transport
+        self._last_request_time = current_time
 
     def connection_lost(self, exc):
-        del self.connections[self]
+        self.connections.discard(self)
         self._timeout_handler.cancel()
-        self.cleanup()
 
     def connection_timeout(self):
-        self.bail_out("Request timed out, connection closed")
-
-        # -------------------------------------------- #
+        # Check if
+        time_elapsed = current_time - self._last_request_time
+        if time_elapsed < self.request_timeout:
+            time_left = self.request_timeout - time_elapsed
+            self._timeout_handler = (
+                self.loop.call_later(time_left, self.connection_timeout))
+        else:
+            if self._request_handler_task:
+                self._request_handler_task.cancel()
+            exception = RequestTimeout('Request Timeout')
+            self.write_error(exception)
 
+    # -------------------------------------------- #
     # Parsing
     # -------------------------------------------- #
 
@@ -74,46 +118,48 @@ class HttpProtocol(asyncio.Protocol):
         # 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))
+            exception = PayloadTooLarge('Payload Too Large')
+            self.write_error(exception)
 
         # 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)
+            self.parser = 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))
+        except HttpParserError:
+            exception = InvalidUsage('Bad Request')
+            self.write_error(exception)
 
     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))
+            exception = PayloadTooLarge('Payload Too Large')
+            self.write_error(exception)
 
-        self.headers.append((name.decode(), value.decode('utf-8')))
+        self.headers.append((name.decode().casefold(), value.decode()))
 
     def on_headers_complete(self):
         self.request = Request(
             url_bytes=self.url,
-            headers=dict(self.headers),
+            headers=CIDict(self.headers),
             version=self.parser.get_http_version(),
-            method=self.parser.get_method().decode()
+            method=self.parser.get_method().decode(),
+            transport=self.transport
         )
 
     def on_body(self, body):
-        self.request.body = body
+        self.request.body.append(body)
 
     def on_message_complete(self):
-        self.loop.create_task(
+        if self.request.body:
+            self.request.body = b''.join(self.request.body)
+        self._request_handler_task = self.loop.create_task(
             self.request_handler(self.request, self.write_response))
 
     # -------------------------------------------- #
@@ -121,34 +167,74 @@ class HttpProtocol(asyncio.Protocol):
     # -------------------------------------------- #
 
     def write_response(self, response):
+        keep_alive = (
+            self.parser.should_keep_alive() and not self.signal.stopped)
         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))
+        except AttributeError:
+            log.error(
+                ('Invalid response object for url {}, '
+                 'Expected Type: HTTPResponse, Actual Type: {}').format(
+                    self.url, type(response)))
+            self.write_error(ServerError('Invalid response type'))
+        except RuntimeError:
+            log.error(
+                'Connection lost before response written @ {}'.format(
+                    self.request.ip))
+        except Exception as e:
+            self.bail_out(
+                "Writing response failed, connection closed {}".format(
+                    repr(e)))
+        finally:
             if not keep_alive:
                 self.transport.close()
             else:
+                # Record that we received data
+                self._last_request_time = current_time
                 self.cleanup()
+
+    def write_error(self, exception):
+        try:
+            response = self.error_handler.response(self.request, exception)
+            version = self.request.version if self.request else '1.1'
+            self.transport.write(response.output(version))
+        except RuntimeError:
+            log.error(
+                'Connection lost before error written @ {}'.format(
+                    self.request.ip if self.request else 'Unknown'))
         except Exception as e:
             self.bail_out(
-                "Writing request failed, connection closed {}".format(e))
+                "Writing error failed, connection closed {}".format(repr(e)),
+                from_error=True)
+        finally:
+            self.transport.close()
 
-    def bail_out(self, message):
-        log.error(message)
-        self.transport.close()
+    def bail_out(self, message, from_error=False):
+        if from_error and self.transport.is_closing():
+            log.error(
+                ("Transport closed @ {} and exception "
+                 "experienced during error handling").format(
+                    self.transport.get_extra_info('peername')))
+            log.debug(
+                'Exception:\n{}'.format(traceback.format_exc()))
+        else:
+            exception = ServerError(message)
+            self.write_error(exception)
+            log.error(message)
 
     def cleanup(self):
         self.parser = None
         self.request = None
         self.url = None
         self.headers = None
+        self._request_handler_task = None
         self._total_request_size = 0
 
     def close_if_idle(self):
-        """
-        Close the connection if a request is not being sent or received
+        """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:
@@ -157,52 +243,124 @@ class HttpProtocol(asyncio.Protocol):
         return False
 
 
-def serve(host, port, request_handler, after_start=None, before_stop=None,
-          debug=False, request_timeout=60, sock=None,
-          request_max_size=None, reuse_port=False):
-    # 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)
+def update_current_time(loop):
+    """Cache the current time, since it is needed at the end of every
+    keep-alive request to update the request timeout time
 
-    connections = {}
+    :param loop:
+    :return:
+    """
+    global current_time
+    current_time = time()
+    loop.call_later(1, partial(update_current_time, loop))
+
+
+def trigger_events(events, loop):
+    """Trigger event callbacks (functions or async)
+
+    :param events: one or more sync or async functions to execute
+    :param loop: event loop
+    """
+    for event in events:
+        result = event(loop)
+        if isawaitable(result):
+            loop.run_until_complete(result)
+
+
+def serve(host, port, request_handler, error_handler, before_start=None,
+          after_start=None, before_stop=None, after_stop=None, debug=False,
+          request_timeout=60, ssl=None, sock=None, request_max_size=None,
+          reuse_port=False, loop=None, protocol=HttpProtocol, backlog=100,
+          register_sys_signals=True, run_async=False):
+    """Start asynchronous HTTP Server on an individual process.
+
+    :param host: Address to host on
+    :param port: Port to host on
+    :param request_handler: Sanic request handler with middleware
+    :param error_handler: Sanic error handler with middleware
+    :param before_start: function to be executed before the server starts
+                         listening. Takes arguments `app` instance and `loop`
+    :param after_start: function to be executed after the server starts
+                        listening. Takes  arguments `app` instance and `loop`
+    :param before_stop: function to be executed when a stop signal is
+                        received before it is respected. Takes arguments
+                        `app` instance and `loop`
+    :param after_stop: function to be executed when a stop signal is
+                       received after it is respected. Takes arguments
+                        `app` instance and `loop`
+    :param debug: enables debug output (slows server)
+    :param request_timeout: time in seconds
+    :param ssl: SSLContext
+    :param sock: Socket for the server to accept connections from
+    :param request_max_size: size in bytes, `None` for no limit
+    :param reuse_port: `True` for multiple workers
+    :param loop: asyncio compatible event loop
+    :param protocol: subclass of asyncio protocol class
+    :return: Nothing
+    """
+    if not run_async:
+        loop = async_loop.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+    if debug:
+        loop.set_debug(debug)
+
+    trigger_events(before_start, loop)
+
+    connections = set()
     signal = Signal()
-    server_coroutine = loop.create_server(lambda: HttpProtocol(
+    server = partial(
+        protocol,
         loop=loop,
         connections=connections,
         signal=signal,
         request_handler=request_handler,
+        error_handler=error_handler,
         request_timeout=request_timeout,
         request_max_size=request_max_size,
-    ), host, port, reuse_port=reuse_port, sock=sock)
+    )
+
+    server_coroutine = loop.create_server(
+        server,
+        host,
+        port,
+        ssl=ssl,
+        reuse_port=reuse_port,
+        sock=sock,
+        backlog=backlog
+    )
+    # Instead of pulling time at the end of every request,
+    # pull it once per minute
+    loop.call_soon(partial(update_current_time, loop))
+
+    if run_async:
+        return server_coroutine
+
     try:
         http_server = loop.run_until_complete(server_coroutine)
-    except Exception as e:
-        log.error("Unable to start server: {}".format(e))
+    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)
+    trigger_events(after_start, loop)
 
     # Register signals for graceful termination
-    for _signal in (SIGINT, SIGTERM):
-        loop.add_signal_handler(_signal, loop.stop)
-
+    if register_sys_signals:
+        for _signal in (SIGINT, SIGTERM):
+            try:
+                loop.add_signal_handler(_signal, loop.stop)
+            except NotImplementedError:
+                log.warn('Sanic tried to use loop.add_signal_handler but it is'
+                         ' not implemented on this platform.')
+    pid = os.getpid()
     try:
+        log.info('Starting worker [{}]'.format(pid))
         loop.run_forever()
     finally:
-        log.info("Stop requested, draining connections...")
+        log.info("Stopping worker [{}]".format(pid))
 
         # Run the on_stop function if provided
-        if before_stop:
-            result = before_stop(loop)
-            if isawaitable(result):
-                loop.run_until_complete(result)
+        trigger_events(before_stop, loop)
 
         # Wait for event loop to finish and all connections to drain
         http_server.close()
@@ -210,10 +368,61 @@ def serve(host, port, request_handler, after_start=None, before_stop=None,
 
         # Complete all tasks on the loop
         signal.stopped = True
-        for connection in connections.keys():
+        for connection in connections:
             connection.close_if_idle()
 
         while connections:
             loop.run_until_complete(asyncio.sleep(0.1))
 
+        trigger_events(after_stop, loop)
+
         loop.close()
+
+
+def serve_multiple(server_settings, workers, stop_event=None):
+    """Start multiple server processes simultaneously.  Stop on interrupt
+    and terminate signals, and drain connections when complete.
+
+    :param server_settings: kw arguments to be passed to the serve function
+    :param workers: number of workers to launch
+    :param stop_event: if provided, is used as a stop signal
+    :return:
+    """
+    if server_settings.get('loop', None) is not None:
+        if server_settings.get('debug', False):
+            warnings.simplefilter('default')
+        warnings.warn("Passing a loop will be deprecated in version 0.4.0"
+                      " https://github.com/channelcat/sanic/pull/335"
+                      " has more information.", DeprecationWarning)
+    server_settings['reuse_port'] = True
+
+    sock = socket()
+    sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+    sock.bind((server_settings['host'], server_settings['port']))
+    set_inheritable(sock.fileno(), True)
+    server_settings['sock'] = sock
+    server_settings['host'] = None
+    server_settings['port'] = None
+
+    if stop_event is None:
+        stop_event = Event()
+
+    signal_func(SIGINT, lambda s, f: stop_event.set())
+    signal_func(SIGTERM, lambda s, f: stop_event.set())
+
+    processes = []
+    for _ in range(workers):
+        process = Process(target=serve, kwargs=server_settings)
+        process.daemon = True
+        process.start()
+        processes.append(process)
+
+    for process in processes:
+        process.join()
+
+    # the above processes will block this until they're stopped
+    for process in processes:
+        process.terminate()
+    sock.close()
+
+    asyncio.get_event_loop().stop()

sanic/static.py

@@ -0,0 +1,100 @@
+from mimetypes import guess_type
+from os import path
+from re import sub
+from time import strftime, gmtime
+from urllib.parse import unquote
+
+from aiofiles.os import stat
+
+from sanic.exceptions import (
+    ContentRangeError,
+    FileNotFound,
+    HeaderNotFound,
+    InvalidUsage,
+)
+from sanic.handlers import ContentRangeHandler
+from sanic.response import file, HTTPResponse
+
+
+def register(app, uri, file_or_directory, pattern,
+             use_modified_since, use_content_range):
+    # TODO: Though sanic is not a file server, I feel like we should at least
+    #       make a good effort here.  Modified-since is nice, but we could
+    #       also look into etags, expires, and caching
+    """
+    Register 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
+    :param use_content_range: If true, process header for range requests
+                              and sends the file part that is requested
+    """
+    # 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 = file_or_directory
+        if file_uri:
+            file_path = path.join(
+                file_or_directory, sub('^[/]*', '', file_uri))
+
+        # URL decode the path sent by the browser otherwise we won't be able to
+        # match filenames which got encoded (filenames with spaces etc)
+        file_path = unquote(file_path)
+        try:
+            headers = {}
+            # Check if the client has been sent this file before
+            # and it has not been modified since
+            stats = None
+            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
+            _range = None
+            if use_content_range:
+                _range = None
+                if not stats:
+                    stats = await stat(file_path)
+                headers['Accept-Ranges'] = 'bytes'
+                headers['Content-Length'] = str(stats.st_size)
+                if request.method != 'HEAD':
+                    try:
+                        _range = ContentRangeHandler(request, stats)
+                    except HeaderNotFound:
+                        pass
+                    else:
+                        del headers['Content-Length']
+                        for key, value in _range.headers.items():
+                            headers[key] = value
+            if request.method == 'HEAD':
+                return HTTPResponse(
+                    headers=headers,
+                    content_type=guess_type(file_path)[0] or 'text/plain')
+            else:
+                return await file(file_path, headers=headers, _range=_range)
+        except ContentRangeError:
+            raise
+        except Exception:
+            raise FileNotFound('File not found',
+                               path=file_or_directory,
+                               relative_url=file_uri)
+
+    app.route(uri, methods=['GET', 'HEAD'])(_handler)

sanic/testing.py

@@ -0,0 +1,91 @@
+from sanic.log import log
+
+HOST = '127.0.0.1'
+PORT = 42101
+
+
+class TestClient:
+    def __init__(self, app):
+        self.app = app
+
+    async def _local_request(self, method, uri, cookies=None, *args, **kwargs):
+        import aiohttp
+        if uri.startswith(('http:', 'https:', 'ftp:', 'ftps://' '//')):
+            url = uri
+        else:
+            url = 'http://{host}:{port}{uri}'.format(
+                host=HOST, port=PORT, uri=uri)
+
+        log.info(url)
+        async with aiohttp.ClientSession(cookies=cookies) as session:
+            async with getattr(
+                    session, method.lower())(url, *args, **kwargs) as response:
+                response.text = await response.text()
+                response.body = await response.read()
+                return response
+
+    def _sanic_endpoint_test(
+            self, method='get', uri='/', gather_request=True,
+            debug=False, server_kwargs={},
+            *request_args, **request_kwargs):
+        results = [None, None]
+        exceptions = []
+
+        if gather_request:
+            def _collect_request(request):
+                if results[0] is None:
+                    results[0] = request
+            self.app.request_middleware.appendleft(_collect_request)
+
+        @self.app.listener('after_server_start')
+        async def _collect_response(sanic, loop):
+            try:
+                response = await self._local_request(
+                    method, uri, *request_args,
+                    **request_kwargs)
+                results[-1] = response
+            except Exception as e:
+                exceptions.append(e)
+            self.app.stop()
+
+        self.app.run(host=HOST, debug=debug, port=PORT, **server_kwargs)
+        self.app.listeners['after_server_start'].pop()
+
+        if exceptions:
+            raise ValueError("Exception during request: {}".format(exceptions))
+
+        if gather_request:
+            try:
+                request, response = results
+                return request, response
+            except:
+                raise ValueError(
+                    "Request and response object expected, got ({})".format(
+                        results))
+        else:
+            try:
+                return results[-1]
+            except:
+                raise ValueError(
+                    "Request object expected, got ({})".format(results))
+
+    def get(self, *args, **kwargs):
+        return self._sanic_endpoint_test('get', *args, **kwargs)
+
+    def post(self, *args, **kwargs):
+        return self._sanic_endpoint_test('post', *args, **kwargs)
+
+    def put(self, *args, **kwargs):
+        return self._sanic_endpoint_test('put', *args, **kwargs)
+
+    def delete(self, *args, **kwargs):
+        return self._sanic_endpoint_test('delete', *args, **kwargs)
+
+    def patch(self, *args, **kwargs):
+        return self._sanic_endpoint_test('patch', *args, **kwargs)
+
+    def options(self, *args, **kwargs):
+        return self._sanic_endpoint_test('options', *args, **kwargs)
+
+    def head(self, *args, **kwargs):
+        return self._sanic_endpoint_test('head', *args, **kwargs)

sanic/utils.py

@@ -1,54 +1,17 @@
-import aiohttp
-from sanic.log import log
+import warnings
 
-HOST = '127.0.0.1'
-PORT = 42101
-
-
-async def local_request(method, uri, *args, **kwargs):
-    url = 'http://{host}:{port}{uri}'.format(host=HOST, port=PORT, uri=uri)
-    log.info(url)
-    async with aiohttp.ClientSession() as session:
-        async with getattr(session, method)(url, *args, **kwargs) as response:
-            response.text = await response.text()
-            return response
+from sanic.testing import TestClient
 
 
 def sanic_endpoint_test(app, method='get', uri='/', gather_request=True,
+                        debug=False, server_kwargs={},
                         *request_args, **request_kwargs):
-    results = []
-    exceptions = []
+    warnings.warn(
+        "Use of sanic_endpoint_test will be deprecated in"
+        "the next major version after 0.4.0.  Please use the `test_client` "
+        "available on the app object.", DeprecationWarning)
 
-    if gather_request:
-        @app.middleware
-        def _collect_request(request):
-            results.append(request)
-
-    async def _collect_response(loop):
-        try:
-            response = await local_request(method, uri, *request_args,
-                                           **request_kwargs)
-            results.append(response)
-        except Exception as e:
-            exceptions.append(e)
-        app.stop()
-
-    app.run(host=HOST, port=42101, after_start=_collect_response)
-
-    if exceptions:
-        raise ValueError("Exception during request: {}".format(exceptions))
-
-    if gather_request:
-        try:
-            request, response = results
-            return request, response
-        except:
-            raise ValueError(
-                "request and response object expected, got ({})".format(
-                    results))
-    else:
-        try:
-            return results[0]
-        except:
-            raise ValueError(
-                "request object expected, got ({})".format(results))
+    test_client = TestClient(app)
+    return test_client._sanic_endpoint_test(
+        method, uri, gather_request, debug, server_kwargs,
+        *request_args, **request_kwargs)

sanic/views.py

@@ -0,0 +1,99 @@
+from sanic.exceptions import InvalidUsage
+from sanic.constants import HTTP_METHODS
+
+
+class HTTPMethodView:
+    """Simple class based implementation of view for the sanic.
+    You should implement methods (get, post, put, patch, delete) for the class
+    to every HTTP method you want to support.
+
+    For example:
+
+    .. code-block:: python
+
+        class DummyView(HTTPMethodView):
+            def get(self, request, *args, **kwargs):
+                return text('I am get method')
+            def put(self, request, *args, **kwargs):
+                return text('I am put method')
+
+    etc.
+
+    If someone tries to use a non-implemented method, there will be a
+    405 response.
+
+    If you need any url params just mention them in method definition:
+
+    .. code-block:: python
+
+        class DummyView(HTTPMethodView):
+            def get(self, request, my_param_here, *args, **kwargs):
+                return text('I am get method with %s' % my_param_here)
+
+    To add the view into the routing you could use
+        1) app.add_route(DummyView.as_view(), '/')
+        2) app.route('/')(DummyView.as_view())
+
+    To add any decorator you could set it into decorators variable
+    """
+
+    decorators = []
+
+    def dispatch_request(self, request, *args, **kwargs):
+        handler = getattr(self, request.method.lower(), None)
+        return handler(request, *args, **kwargs)
+
+    @classmethod
+    def as_view(cls, *class_args, **class_kwargs):
+        """Return view function for use with the routing system, that
+        dispatches request to appropriate handler method.
+        """
+        def view(*args, **kwargs):
+            self = view.view_class(*class_args, **class_kwargs)
+            return self.dispatch_request(*args, **kwargs)
+
+        if cls.decorators:
+            view.__module__ = cls.__module__
+            for decorator in cls.decorators:
+                view = decorator(view)
+
+        view.view_class = cls
+        view.__doc__ = cls.__doc__
+        view.__module__ = cls.__module__
+        view.__name__ = cls.__name__
+        return view
+
+
+class CompositionView:
+    """Simple method-function mapped view for the sanic.
+    You can add handler functions to methods (get, post, put, patch, delete)
+    for every HTTP method you want to support.
+
+    For example:
+        view = CompositionView()
+        view.add(['GET'], lambda request: text('I am get method'))
+        view.add(['POST', 'PUT'], lambda request: text('I am post/put method'))
+
+    etc.
+
+    If someone tries to use a non-implemented method, there will be a
+    405 response.
+    """
+
+    def __init__(self):
+        self.handlers = {}
+
+    def add(self, methods, handler):
+        for method in methods:
+            if method not in HTTP_METHODS:
+                raise InvalidUsage(
+                    '{} is not a valid HTTP method.'.format(method))
+
+            if method in self.handlers:
+                raise InvalidUsage(
+                    'Method {} is already registered.'.format(method))
+            self.handlers[method] = handler
+
+    def __call__(self, request, *args, **kwargs):
+        handler = self.handlers[request.method.upper()]
+        return handler(request, *args, **kwargs)

setup.py

@@ -1,23 +1,41 @@
 """
 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.')
+
+install_requires = [
+    'httptools>=0.0.9',
+    'ujson>=1.35',
+    'aiofiles>=0.3.0',
+]
+
+if os.name != 'nt':
+    install_requires.append('uvloop>=0.5.3')
+
 setup(
-    name='Sanic',
-    version="0.1.4",
+    name='sanic',
+    version=version,
     url='http://github.com/channelcat/sanic/',
     license='MIT',
     author='Channel Cat',
     author_email='channelcat@gmail.com',
-    description='A microframework based on uvloop, httptools, and learnings of flask',
+    description=(
+        'A microframework based on uvloop, httptools, and learnings of flask'),
     packages=['sanic'],
     platforms='any',
-    install_requires=[
-        'uvloop>=0.5.3',
-        'httptools>=0.0.9',
-        'ujson>=1.35',
-    ],
+    install_requires=install_requires,
     classifiers=[
         'Development Status :: 2 - Pre-Alpha',
         'Environment :: Web Environment',

test.py

@@ -1,52 +0,0 @@
-from multiprocessing import Array, Event, Process
-from time import sleep
-from ujson import loads as json_loads
-
-from sanic import Sanic
-from sanic.response import json
-from sanic.utils import local_request, HOST, PORT
-
-
-# ------------------------------------------------------------ #
-#  GET
-# ------------------------------------------------------------ #
-
-def test_json():
-    app = Sanic('test_json')
-
-    response = Array('c', 50)
-    @app.route('/')
-    async def handler(request):
-        return json({"test": True})
-
-    stop_event = Event()
-    async def after_start(*args, **kwargs):
-        http_response = await local_request('get', '/')
-        response.value = http_response.text.encode()
-        stop_event.set()
-
-    def rescue_crew():
-        sleep(5)
-        stop_event.set()
-
-    rescue_process = Process(target=rescue_crew)
-    rescue_process.start()
-
-    app.serve_multiple({
-        'host': HOST,
-        'port': PORT,
-        'after_start': after_start,
-        'request_handler': app.handle_request,
-        'request_max_size': 100000,
-    }, workers=2, stop_event=stop_event)
-
-    rescue_process.terminate()
-
-    try:
-        results = json_loads(response.value)
-    except:
-        raise ValueError("Expected JSON response but got '{}'".format(response))
-
-    assert results.get('test') == True
-
-test_json()

tests/performance/aiohttp/simple_server.py

@@ -15,4 +15,4 @@ async def handle(request):
 app = web.Application(loop=loop)
 app.router.add_route('GET', '/', handle)
 
-web.run_app(app, port=sys.argv[1])
+web.run_app(app, port=sys.argv[1], access_log=None)

tests/performance/golang/golang.http.go

@@ -1,16 +1,30 @@
 package main
 
 import (
-    "fmt"
-    "os"
-    "net/http"
+	"encoding/json"
+	"net/http"
+	"os"
 )
 
+type TestJSONResponse struct {
+	Test bool
+}
+
 func handler(w http.ResponseWriter, r *http.Request) {
-    fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])
+	response := TestJSONResponse{true}
+
+	js, err := json.Marshal(response)
+
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.Write(js)
 }
 
 func main() {
-    http.HandleFunc("/", handler)
-    http.ListenAndServe(":" + os.Args[1], nil)
+	http.HandleFunc("/", handler)
+	http.ListenAndServe(":"+os.Args[1], nil)
 }

tests/performance/tornado/simple_server.py

@@ -0,0 +1,19 @@
+# Run with: python simple_server.py
+import ujson
+from tornado import ioloop, web
+
+
+class MainHandler(web.RequestHandler):
+    def get(self):
+        self.write(ujson.dumps({'test': True}))
+
+
+app = web.Application([
+    (r'/', MainHandler)
+],  debug=False,
+    compress_response=False,
+    static_hash_cache=True
+)
+
+app.listen(8000)
+ioloop.IOLoop.current().start()

tests/static/decode me.txt

@@ -0,0 +1 @@
+I am just a regular static file that needs to have its uri decoded

tests/static/test.file

@@ -0,0 +1 @@
+I am just a regular static file

tests/test_bad_request.py

@@ -0,0 +1,21 @@
+import asyncio
+from sanic import Sanic
+
+
+def test_bad_request_response():
+    app = Sanic('test_bad_request_response')
+    lines = []
+    @app.listener('after_server_start')
+    async def _request(sanic, loop):
+        connect = asyncio.open_connection('127.0.0.1', 42101)
+        reader, writer = await connect
+        writer.write(b'not http')
+        while True:
+            line = await reader.readline()
+            if not line:
+                break
+            lines.append(line)
+        app.stop()
+    app.run(host='127.0.0.1', port=42101, debug=False)
+    assert lines[0] == b'HTTP/1.1 400 Bad Request\r\n'
+    assert lines[-1] == b'Error: Bad Request'

tests/test_blueprints.py

@@ -1,7 +1,8 @@
+import inspect
+
 from sanic import Sanic
 from sanic.blueprints import Blueprint
 from sanic.response import json, text
-from sanic.utils import sanic_endpoint_test
 from sanic.exceptions import NotFound, ServerError, InvalidUsage
 
 
@@ -17,8 +18,8 @@ def test_bp():
     def handler(request):
         return text('Hello')
 
-    app.register_blueprint(bp)
-    request, response = sanic_endpoint_test(app)
+    app.blueprint(bp)
+    request, response = app.test_client.get('/')
 
     assert response.text == 'Hello'
 
@@ -30,8 +31,8 @@ def test_bp_with_url_prefix():
     def handler(request):
         return text('Hello')
 
-    app.register_blueprint(bp)
-    request, response = sanic_endpoint_test(app, uri='/test1/')
+    app.blueprint(bp)
+    request, response = app.test_client.get('/test1/')
 
     assert response.text == 'Hello'
 
@@ -49,14 +50,84 @@ def test_several_bp_with_url_prefix():
     def handler2(request):
         return text('Hello2')
 
-    app.register_blueprint(bp)
-    app.register_blueprint(bp2)
-    request, response = sanic_endpoint_test(app, uri='/test1/')
+    app.blueprint(bp)
+    app.blueprint(bp2)
+    request, response = app.test_client.get('/test1/')
     assert response.text == 'Hello'
 
-    request, response = sanic_endpoint_test(app, uri='/test2/')
+    request, response = app.test_client.get('/test2/')
     assert response.text == 'Hello2'
 
+def test_bp_with_host():
+    app = Sanic('test_bp_host')
+    bp = Blueprint('test_bp_host', url_prefix='/test1', host="example.com")
+
+    @bp.route('/')
+    def handler(request):
+        return text('Hello')
+
+    @bp.route('/', host="sub.example.com")
+    def handler(request):
+        return text('Hello subdomain!')
+
+    app.blueprint(bp)
+    headers = {"Host": "example.com"}
+    request, response = app.test_client.get(
+        '/test1/',
+        headers=headers)
+    assert response.text == 'Hello'
+
+    headers = {"Host": "sub.example.com"}
+    request, response = app.test_client.get(
+        '/test1/',
+        headers=headers)
+
+    assert response.text == 'Hello subdomain!'
+
+
+def test_several_bp_with_host():
+    app = Sanic('test_text')
+    bp = Blueprint('test_text',
+                   url_prefix='/test',
+                   host="example.com")
+    bp2 = Blueprint('test_text2',
+                    url_prefix='/test',
+                    host="sub.example.com")
+
+    @bp.route('/')
+    def handler(request):
+        return text('Hello')
+
+    @bp2.route('/')
+    def handler2(request):
+        return text('Hello2')
+
+    @bp2.route('/other/')
+    def handler2(request):
+        return text('Hello3')
+
+
+    app.blueprint(bp)
+    app.blueprint(bp2)
+
+    assert bp.host == "example.com"
+    headers = {"Host": "example.com"}
+    request, response = app.test_client.get(
+        '/test/',
+        headers=headers)
+    assert response.text == 'Hello'
+
+    assert bp2.host == "sub.example.com"
+    headers = {"Host": "sub.example.com"}
+    request, response = app.test_client.get(
+        '/test/',
+        headers=headers)
+
+    assert response.text == 'Hello2'
+    request, response = app.test_client.get(
+        '/test/other/',
+        headers=headers)
+    assert response.text == 'Hello3'
 
 def test_bp_middleware():
     app = Sanic('test_middleware')
@@ -70,9 +141,9 @@ def test_bp_middleware():
     async def handler(request):
         return text('FAIL')
 
-    app.register_blueprint(blueprint)
+    app.blueprint(blueprint)
 
-    request, response = sanic_endpoint_test(app)
+    request, response = app.test_client.get('/')
 
     assert response.status == 200
     assert response.text == 'OK'
@@ -97,15 +168,143 @@ 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')
+    request, response = app.test_client.get('/1')
     assert response.status == 400
 
 
-    request, response = sanic_endpoint_test(app, uri='/2')
+    request, response = app.test_client.get('/2')
     assert response.status == 200
     assert response.text == 'OK'
 
-    request, response = sanic_endpoint_test(app, uri='/3')
-    assert response.status == 200
+    request, response = app.test_client.get('/3')
+    assert response.status == 200
+
+def test_bp_listeners():
+    app = Sanic('test_middleware')
+    blueprint = Blueprint('test_middleware')
+
+    order = []
+
+    @blueprint.listener('before_server_start')
+    def handler_1(sanic, loop):
+        order.append(1)
+
+    @blueprint.listener('after_server_start')
+    def handler_2(sanic, loop):
+        order.append(2)
+
+    @blueprint.listener('after_server_start')
+    def handler_3(sanic, loop):
+        order.append(3)
+
+    @blueprint.listener('before_server_stop')
+    def handler_4(sanic, loop):
+        order.append(5)
+
+    @blueprint.listener('before_server_stop')
+    def handler_5(sanic, loop):
+        order.append(4)
+
+    @blueprint.listener('after_server_stop')
+    def handler_6(sanic, loop):
+        order.append(6)
+
+    app.blueprint(blueprint)
+
+    request, response = app.test_client.get('/')
+
+    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('/testing.file', current_file)
+
+    app.blueprint(blueprint)
+
+    request, response = app.test_client.get('/testing.file')
+    assert response.status == 200
+    assert response.body == current_file_contents
+
+def test_bp_shorthand():
+    app = Sanic('test_shorhand_routes')
+    blueprint = Blueprint('test_shorhand_routes')
+
+    @blueprint.get('/get')
+    def handler(request):
+        return text('OK')
+
+    @blueprint.put('/put')
+    def handler(request):
+        return text('OK')
+
+    @blueprint.post('/post')
+    def handler(request):
+        return text('OK')
+
+    @blueprint.head('/head')
+    def handler(request):
+        return text('OK')
+
+    @blueprint.options('/options')
+    def handler(request):
+        return text('OK')
+
+    @blueprint.patch('/patch')
+    def handler(request):
+        return text('OK')
+
+    @blueprint.delete('/delete')
+    def handler(request):
+        return text('OK')
+
+    app.blueprint(blueprint)
+
+    request, response = app.test_client.get('/get')
+    assert response.text == 'OK'
+
+    request, response = app.test_client.post('/get')
+    assert response.status == 405
+
+    request, response = app.test_client.put('/put')
+    assert response.text == 'OK'
+
+    request, response = app.test_client.get('/post')
+    assert response.status == 405
+
+    request, response = app.test_client.post('/post')
+    assert response.text == 'OK'
+
+    request, response = app.test_client.get('/post')
+    assert response.status == 405
+
+    request, response = app.test_client.head('/head')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/head')
+    assert response.status == 405
+
+    request, response = app.test_client.options('/options')
+    assert response.text == 'OK'
+
+    request, response = app.test_client.get('/options')
+    assert response.status == 405
+
+    request, response = app.test_client.patch('/patch')
+    assert response.text == 'OK'
+
+    request, response = app.test_client.get('/patch')
+    assert response.status == 405
+
+    request, response = app.test_client.delete('/delete')
+    assert response.text == 'OK'
+
+    request, response = app.test_client.get('/delete')
+    assert response.status == 405

tests/test_config.py

@@ -0,0 +1,76 @@
+from os import environ
+import pytest
+from tempfile import NamedTemporaryFile
+
+from sanic import Sanic
+
+
+def test_load_from_object():
+    app = Sanic('test_load_from_object')
+    class Config:
+        not_for_config = 'should not be used'
+        CONFIG_VALUE = 'should be used'
+
+    app.config.from_object(Config)
+    assert 'CONFIG_VALUE' in app.config
+    assert app.config.CONFIG_VALUE == 'should be used'
+    assert 'not_for_config' not in app.config
+
+
+def test_load_from_file():
+    app = Sanic('test_load_from_file')
+    config = b"""
+VALUE = 'some value'
+condition = 1 == 1
+if condition:
+    CONDITIONAL = 'should be set'
+    """
+    with NamedTemporaryFile() as config_file:
+        config_file.write(config)
+        config_file.seek(0)
+        app.config.from_pyfile(config_file.name)
+        assert 'VALUE' in app.config
+        assert app.config.VALUE == 'some value'
+        assert 'CONDITIONAL' in app.config
+        assert app.config.CONDITIONAL == 'should be set'
+        assert 'condition' not in app.config
+
+
+def test_load_from_missing_file():
+    app = Sanic('test_load_from_missing_file')
+    with pytest.raises(IOError):
+        app.config.from_pyfile('non-existent file')
+
+
+def test_load_from_envvar():
+    app = Sanic('test_load_from_envvar')
+    config = b"VALUE = 'some value'"
+    with NamedTemporaryFile() as config_file:
+        config_file.write(config)
+        config_file.seek(0)
+        environ['APP_CONFIG'] = config_file.name
+        app.config.from_envvar('APP_CONFIG')
+        assert 'VALUE' in app.config
+        assert app.config.VALUE == 'some value'
+
+
+def test_load_from_missing_envvar():
+    app = Sanic('test_load_from_missing_envvar')
+    with pytest.raises(RuntimeError):
+        app.config.from_envvar('non-existent variable')
+
+
+def test_overwrite_exisiting_config():
+    app = Sanic('test_overwrite_exisiting_config')
+    app.config.DEFAULT = 1
+    class Config:
+        DEFAULT = 2
+
+    app.config.from_object(Config)
+    assert app.config.DEFAULT == 2
+
+
+def test_missing_config():
+    app = Sanic('test_missing_config')
+    with pytest.raises(AttributeError):
+        app.config.NON_EXISTENT

tests/test_cookies.py

@@ -0,0 +1,96 @@
+from datetime import datetime, timedelta
+from http.cookies import SimpleCookie
+from sanic import Sanic
+from sanic.response import json, text
+import pytest
+
+
+# ------------------------------------------------------------ #
+#  GET
+# ------------------------------------------------------------ #
+
+def test_cookies():
+    app = Sanic('test_text')
+
+    @app.route('/')
+    def handler(request):
+        response = text('Cookies are: {}'.format(request.cookies['test']))
+        response.cookies['right_back'] = 'at you'
+        return response
+
+    request, response = app.test_client.get('/', cookies={"test": "working!"})
+    response_cookies = SimpleCookie()
+    response_cookies.load(response.headers.get('Set-Cookie', {}))
+
+    assert response.text == 'Cookies are: working!'
+    assert response_cookies['right_back'].value == 'at you'
+
+@pytest.mark.parametrize("httponly,expected", [
+        (False, False),
+        (True, True),
+])
+def test_false_cookies(httponly, expected):
+    app = Sanic('test_text')
+
+    @app.route('/')
+    def handler(request):
+        response = text('Cookies are: {}'.format(request.cookies['test']))
+        response.cookies['right_back'] = 'at you'
+        response.cookies['right_back']['httponly'] = httponly
+        return response
+
+    request, response = app.test_client.get('/')
+    response_cookies = SimpleCookie()
+    response_cookies.load(response.headers.get('Set-Cookie', {}))
+
+    'HttpOnly' in response_cookies == expected
+
+def test_http2_cookies():
+    app = Sanic('test_http2_cookies')
+
+    @app.route('/')
+    async def handler(request):
+        response = text('Cookies are: {}'.format(request.cookies['test']))
+        return response
+
+    headers = {'cookie': 'test=working!'}
+    request, response = app.test_client.get('/', headers=headers)
+
+    assert response.text == 'Cookies are: working!'
+
+def test_cookie_options():
+    app = Sanic('test_text')
+
+    @app.route('/')
+    def handler(request):
+        response = text("OK")
+        response.cookies['test'] = 'at you'
+        response.cookies['test']['httponly'] = True
+        response.cookies['test']['expires'] = datetime.now() + timedelta(seconds=10)
+        return response
+
+    request, response = app.test_client.get('/')
+    response_cookies = SimpleCookie()
+    response_cookies.load(response.headers.get('Set-Cookie', {}))
+
+    assert response_cookies['test'].value == 'at you'
+    assert response_cookies['test']['httponly'] == True
+
+def test_cookie_deletion():
+    app = Sanic('test_text')
+
+    @app.route('/')
+    def handler(request):
+        response = text("OK")
+        del response.cookies['i_want_to_die']
+        response.cookies['i_never_existed'] = 'testing'
+        del response.cookies['i_never_existed']
+        return response
+
+    request, response = app.test_client.get('/')
+    response_cookies = SimpleCookie()
+    response_cookies.load(response.headers.get('Set-Cookie', {}))
+
+    assert int(response_cookies['i_want_to_die']['max-age']) == 0
+    with pytest.raises(KeyError):
+        hold_my_beer = response.cookies['i_never_existed']

tests/test_create_task.py

@@ -0,0 +1,30 @@
+import sanic
+from sanic.utils import sanic_endpoint_test
+from sanic.response import text
+from threading import Event
+import asyncio
+
+def test_create_task():
+    e = Event()
+    async def coro():
+        await asyncio.sleep(0.05)
+        e.set()
+
+    app = sanic.Sanic()
+    app.add_task(coro)
+
+    @app.route('/early')
+    def not_set(request):
+        return text(e.is_set())
+
+    @app.route('/late')
+    async def set(request):
+        await asyncio.sleep(0.1)
+        return text(e.is_set())
+
+
+    request, response = sanic_endpoint_test(app, uri='/early')
+    assert response.body == b'False'
+
+    request, response = sanic_endpoint_test(app, uri='/late')
+    assert response.body == b'True'

tests/test_custom_protocol.py

@@ -0,0 +1,31 @@
+from sanic import Sanic
+from sanic.server import HttpProtocol
+from sanic.response import text
+
+app = Sanic('test_custom_porotocol')
+
+
+class CustomHttpProtocol(HttpProtocol):
+
+    def write_response(self, response):
+        if isinstance(response, str):
+            response = text(response)
+        self.transport.write(
+            response.output(self.request.version)
+        )
+        self.transport.close()
+
+
+@app.route('/1')
+async def handler_1(request):
+    return 'OK'
+
+
+def test_use_custom_protocol():
+    server_kwargs = {
+        'protocol': CustomHttpProtocol
+    }
+    request, response = app.test_client.get(
+        '/1', server_kwargs=server_kwargs)
+    assert response.status == 200
+    assert response.text == 'OK'

tests/test_dynamic_routes.py

@@ -0,0 +1,44 @@
+from sanic import Sanic
+from sanic.response import text
+from sanic.router import RouteExists
+import pytest
+
+
+@pytest.mark.parametrize("method,attr, expected", [
+    ("get", "text", "OK1 test"),
+    ("post", "text", "OK2 test"),
+    ("put", "text", "OK2 test"),
+    ("delete", "status", 405),
+])
+def test_overload_dynamic_routes(method, attr, expected):
+    app = Sanic('test_dynamic_route')
+
+    @app.route('/overload/<param>', methods=['GET'])
+    async def handler1(request, param):
+        return text('OK1 ' + param)
+
+    @app.route('/overload/<param>', methods=['POST', 'PUT'])
+    async def handler2(request, param):
+        return text('OK2 ' + param)
+
+    request, response = getattr(app.test_client, method)('/overload/test')
+    assert getattr(response, attr) == expected
+
+
+def test_overload_dynamic_routes_exist():
+    app = Sanic('test_dynamic_route')
+
+    @app.route('/overload/<param>', methods=['GET'])
+    async def handler1(request, param):
+        return text('OK1 ' + param)
+
+    @app.route('/overload/<param>', methods=['POST', 'PUT'])
+    async def handler2(request, param):
+        return text('OK2 ' + param)
+
+    # if this doesn't raise an error, than at least the below should happen:
+    # assert response.text == 'Duplicated'
+    with pytest.raises(RouteExists):
+        @app.route('/overload/<param>', methods=['PUT', 'DELETE'])
+        async def handler3(request):
+            return text('Duplicated')

tests/test_exceptions.py

@@ -1,51 +1,108 @@
+import pytest
+from bs4 import BeautifulSoup
+
 from sanic import Sanic
 from sanic.response import text
 from sanic.exceptions import InvalidUsage, ServerError, NotFound
-from sanic.utils import sanic_endpoint_test
-
-# ------------------------------------------------------------ #
-#  GET
-# ------------------------------------------------------------ #
-
-exception_app = Sanic('test_exceptions')
 
 
-@exception_app.route('/')
-def handler(request):
-    return text('OK')
+class SanicExceptionTestException(Exception):
+    pass
 
 
-@exception_app.route('/error')
-def handler_error(request):
-    raise ServerError("OK")
+@pytest.fixture(scope='module')
+def exception_app():
+    app = Sanic('test_exceptions')
+
+    @app.route('/')
+    def handler(request):
+        return text('OK')
+
+    @app.route('/error')
+    def handler_error(request):
+        raise ServerError("OK")
+
+    @app.route('/404')
+    def handler_404(request):
+        raise NotFound("OK")
+
+    @app.route('/invalid')
+    def handler_invalid(request):
+        raise InvalidUsage("OK")
+
+    @app.route('/divide_by_zero')
+    def handle_unhandled_exception(request):
+        1 / 0
+
+    @app.route('/error_in_error_handler_handler')
+    def custom_error_handler(request):
+        raise SanicExceptionTestException('Dummy message!')
+
+    @app.exception(SanicExceptionTestException)
+    def error_in_error_handler_handler(request, exception):
+        1 / 0
+
+    return app
 
 
-@exception_app.route('/404')
-def handler_404(request):
-    raise NotFound("OK")
-
-
-@exception_app.route('/invalid')
-def handler_invalid(request):
-    raise InvalidUsage("OK")
-
-
-def test_no_exception():
-    request, response = sanic_endpoint_test(exception_app)
+def test_no_exception(exception_app):
+    """Test that a route works without an exception"""
+    request, response = exception_app.test_client.get('/')
     assert response.status == 200
     assert response.text == 'OK'
 
 
-def test_server_error_exception():
-    request, response = sanic_endpoint_test(exception_app, uri='/error')
+def test_server_error_exception(exception_app):
+    """Test the built-in ServerError exception works"""
+    request, response = exception_app.test_client.get('/error')
     assert response.status == 500
 
 
-def test_invalid_usage_exception():
-    request, response = sanic_endpoint_test(exception_app, uri='/invalid')
+def test_invalid_usage_exception(exception_app):
+    """Test the built-in InvalidUsage exception works"""
+    request, response = exception_app.test_client.get('/invalid')
     assert response.status == 400
 
 
-def test_not_found_exception():
-    request, response = sanic_endpoint_test(exception_app, uri='/404')
+def test_not_found_exception(exception_app):
+    """Test the built-in NotFound exception works"""
+    request, response = exception_app.test_client.get('/404')
     assert response.status == 404
+
+
+def test_handled_unhandled_exception(exception_app):
+    """Test that an exception not built into sanic is handled"""
+    request, response = exception_app.test_client.get('/divide_by_zero')
+    assert response.status == 500
+    soup = BeautifulSoup(response.body, 'html.parser')
+    assert soup.h1.text == 'Internal Server Error'
+
+    message = " ".join(soup.p.text.split())
+    assert message == (
+        "The server encountered an internal error and "
+        "cannot complete your request.")
+
+def test_exception_in_exception_handler(exception_app):
+    """Test that an exception thrown in an error handler is handled"""
+    request, response = exception_app.test_client.get(
+        '/error_in_error_handler_handler')
+    assert response.status == 500
+    assert response.body == b'An error occurred while handling an error'
+
+
+def test_exception_in_exception_handler_debug_off(exception_app):
+    """Test that an exception thrown in an error handler is handled"""
+    request, response = exception_app.test_client.get(
+        '/error_in_error_handler_handler',
+        debug=False)
+    assert response.status == 500
+    assert response.body == b'An error occurred while handling an error'
+
+
+def test_exception_in_exception_handler_debug_off(exception_app):
+    """Test that an exception thrown in an error handler is handled"""
+    request, response = exception_app.test_client.get(
+        '/error_in_error_handler_handler',
+        debug=True)
+    assert response.status == 500
+    assert response.body.startswith(b'Exception raised in exception ')

tests/test_exceptions_handler.py

@@ -1,7 +1,7 @@
 from sanic import Sanic
 from sanic.response import text
 from sanic.exceptions import InvalidUsage, ServerError, NotFound
-from sanic.utils import sanic_endpoint_test
+from bs4 import BeautifulSoup
 
 exception_handler_app = Sanic('test_exception_handler')
 
@@ -21,29 +21,63 @@ def handler_3(request):
     raise NotFound("OK")
 
 
+@exception_handler_app.route('/4')
+def handler_4(request):
+    foo = bar
+    return text(foo)
+
+
+@exception_handler_app.route('/5')
+def handler_5(request):
+    class CustomServerError(ServerError):
+        status_code=200
+    raise CustomServerError('Custom server error')
+
+
 @exception_handler_app.exception(NotFound, ServerError)
 def handler_exception(request, exception):
     return text("OK")
 
 
 def test_invalid_usage_exception_handler():
-    request, response = sanic_endpoint_test(exception_handler_app, uri='/1')
+    request, response = exception_handler_app.test_client.get('/1')
     assert response.status == 400
 
 
 def test_server_error_exception_handler():
-    request, response = sanic_endpoint_test(exception_handler_app, uri='/2')
+    request, response = exception_handler_app.test_client.get('/2')
     assert response.status == 200
     assert response.text == 'OK'
 
 
 def test_not_found_exception_handler():
-    request, response = sanic_endpoint_test(exception_handler_app, uri='/3')
+    request, response = exception_handler_app.test_client.get('/3')
     assert response.status == 200
 
 
 def test_text_exception__handler():
-    request, response = sanic_endpoint_test(
-        exception_handler_app, uri='/random')
+    request, response = exception_handler_app.test_client.get('/random')
     assert response.status == 200
     assert response.text == 'OK'
+
+
+def test_html_traceback_output_in_debug_mode():
+    request, response = exception_handler_app.test_client.get(
+        '/4', debug=True)
+    assert response.status == 500
+    soup = BeautifulSoup(response.body, 'html.parser')
+    html = str(soup)
+
+    assert 'response = handler(request, *args, **kwargs)' in html
+    assert 'handler_4' in html
+    assert 'foo = bar' in html
+
+    summary_text = " ".join(soup.select('.summary')[0].text.split())
+    assert (
+        "NameError: name 'bar' "
+        "is not defined while handling uri /4") == summary_text
+
+
+def test_inherited_exception_handler():
+    request, response = exception_handler_app.test_client.get('/5')
+    assert response.status == 200

tests/test_logging.py

@@ -0,0 +1,36 @@
+import asyncio
+import uuid
+from sanic.response import text
+from sanic import Sanic
+from io import StringIO
+import logging
+
+logging_format = '''module: %(module)s; \
+function: %(funcName)s(); \
+message: %(message)s'''
+
+
+def test_log():
+    log_stream = StringIO()
+    for handler in logging.root.handlers[:]:
+        logging.root.removeHandler(handler)
+    logging.basicConfig(
+        format=logging_format,
+        level=logging.DEBUG,
+        stream=log_stream
+    )
+    log = logging.getLogger()
+    app = Sanic('test_logging')
+    rand_string = str(uuid.uuid4())
+
+    @app.route('/')
+    def handler(request):
+        log.info(rand_string)
+        return text('hello')
+
+    request, response = app.test_client.get('/')
+    log_text = log_stream.getvalue()
+    assert rand_string in log_text
+
+if __name__ == "__main__":
+    test_log()

tests/test_middleware.py

@@ -2,7 +2,6 @@ from json import loads as json_loads, dumps as json_dumps
 from sanic import Sanic
 from sanic.request import Request
 from sanic.response import json, text, HTTPResponse
-from sanic.utils import sanic_endpoint_test
 
 
 # ------------------------------------------------------------ #
@@ -22,7 +21,7 @@ def test_middleware_request():
     async def handler(request):
         return text('OK')
 
-    request, response = sanic_endpoint_test(app)
+    request, response = app.test_client.get('/')
 
     assert response.text == 'OK'
     assert type(results[0]) is Request
@@ -46,12 +45,12 @@ def test_middleware_response():
     async def handler(request):
         return text('OK')
 
-    request, response = sanic_endpoint_test(app)
+    request, response = app.test_client.get('/')
 
     assert response.text == 'OK'
     assert type(results[0]) is Request
     assert type(results[1]) is Request
-    assert issubclass(type(results[2]), HTTPResponse)
+    assert isinstance(results[2], HTTPResponse)
 
 
 def test_middleware_override_request():
@@ -65,7 +64,7 @@ def test_middleware_override_request():
     async def handler(request):
         return text('FAIL')
 
-    response = sanic_endpoint_test(app, gather_request=False)
+    response = app.test_client.get('/', gather_request=False)
 
     assert response.status == 200
     assert response.text == 'OK'
@@ -82,7 +81,47 @@ def test_middleware_override_response():
     async def handler(request):
         return text('FAIL')
 
-    request, response = sanic_endpoint_test(app)
+    request, response = app.test_client.get('/')
 
     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 = app.test_client.get('/')
+
+    assert response.status == 200
+    assert order == [1,2,3,4,5,6]

tests/test_multiprocessing.py

@@ -1,53 +1,26 @@
-from multiprocessing import Array, Event, Process
-from time import sleep
-from ujson import loads as json_loads
+import multiprocessing
+import random
+import signal
 
 from sanic import Sanic
-from sanic.response import json
-from sanic.utils import local_request, HOST, PORT
+from sanic.testing import HOST, PORT
 
 
-# ------------------------------------------------------------ #
-#  GET
-# ------------------------------------------------------------ #
+def test_multiprocessing():
+    """Tests that the number of children we produce is correct"""
+    # Selects a number at random so we can spot check
+    num_workers = random.choice(range(2,  multiprocessing.cpu_count() * 2 + 1))
+    app = Sanic('test_multiprocessing')
+    process_list = set()
 
-# TODO: Figure out why this freezes on pytest but not when
-# executed via interpreter
+    def stop_on_alarm(*args):
+        for process in multiprocessing.active_children():
+            process_list.add(process.pid)
+            process.terminate()
 
-def skip_test_multiprocessing():
-    app = Sanic('test_json')
+    signal.signal(signal.SIGALRM, stop_on_alarm)
+    signal.alarm(1)
+    app.run(HOST, PORT, workers=num_workers)
 
-    response = Array('c', 50)
-    @app.route('/')
-    async def handler(request):
-        return json({"test": True})
+    assert len(process_list) == num_workers
 
-    stop_event = Event()
-    async def after_start(*args, **kwargs):
-        http_response = await local_request('get', '/')
-        response.value = http_response.text.encode()
-        stop_event.set()
-
-    def rescue_crew():
-        sleep(5)
-        stop_event.set()
-
-    rescue_process = Process(target=rescue_crew)
-    rescue_process.start()
-
-    app.serve_multiple({
-        'host': HOST,
-        'port': PORT,
-        'after_start': after_start,
-        'request_handler': app.handle_request,
-        'request_max_size': 100000,
-    }, workers=2, stop_event=stop_event)
-
-    rescue_process.terminate()
-
-    try:
-        results = json_loads(response.value)
-    except:
-        raise ValueError("Expected JSON response but got '{}'".format(response))
-
-    assert results.get('test') == True

tests/test_payload_too_large.py

@@ -0,0 +1,51 @@
+from sanic import Sanic
+from sanic.response import text
+from sanic.exceptions import PayloadTooLarge
+
+data_received_app = Sanic('data_received')
+data_received_app.config.REQUEST_MAX_SIZE = 1
+data_received_default_app = Sanic('data_received_default')
+data_received_default_app.config.REQUEST_MAX_SIZE = 1
+on_header_default_app = Sanic('on_header')
+on_header_default_app.config.REQUEST_MAX_SIZE = 500
+
+
+@data_received_app.route('/1')
+async def handler1(request):
+    return text('OK')
+
+
+@data_received_app.exception(PayloadTooLarge)
+def handler_exception(request, exception):
+    return text('Payload Too Large from error_handler.', 413)
+
+
+def test_payload_too_large_from_error_handler():
+    response = data_received_app.test_client.get('/1', gather_request=False)
+    assert response.status == 413
+    assert response.text == 'Payload Too Large from error_handler.'
+
+
+@data_received_default_app.route('/1')
+async def handler2(request):
+    return text('OK')
+
+
+def test_payload_too_large_at_data_received_default():
+    response = data_received_default_app.test_client.get(
+        '/1', gather_request=False)
+    assert response.status == 413
+    assert response.text == 'Error: Payload Too Large'
+
+
+@on_header_default_app.route('/1')
+async def handler3(request):
+    return text('OK')
+
+
+def test_payload_too_large_at_on_header_default():
+    data = 'a' * 1000
+    response = on_header_default_app.test_client.post(
+        '/1', gather_request=False, data=data)
+    assert response.status == 413
+    assert response.text == 'Error: Payload Too Large'

tests/test_redirect.py

@@ -0,0 +1,91 @@
+import pytest
+
+from sanic import Sanic
+from sanic.response import text, redirect
+
+
+@pytest.fixture
+def redirect_app():
+    app = Sanic('test_redirection')
+
+    @app.route('/redirect_init')
+    async def redirect_init(request):
+        return redirect("/redirect_target")
+
+    @app.route('/redirect_init_with_301')
+    async def redirect_init_with_301(request):
+        return redirect("/redirect_target", status=301)
+
+    @app.route('/redirect_target')
+    async def redirect_target(request):
+        return text('OK')
+
+    @app.route('/1')
+    def handler(request):
+        return redirect('/2')
+
+    @app.route('/2')
+    def handler(request):
+        return redirect('/3')
+
+    @app.route('/3')
+    def handler(request):
+        return text('OK')
+
+    return app
+
+
+def test_redirect_default_302(redirect_app):
+    """
+    We expect a 302 default status code and the headers to be set.
+    """
+    request, response = redirect_app.test_client.get(
+        '/redirect_init',
+        allow_redirects=False)
+
+    assert response.status == 302
+    assert response.headers["Location"] == "/redirect_target"
+    assert response.headers["Content-Type"] == 'text/html; charset=utf-8'
+
+
+def test_redirect_headers_none(redirect_app):
+    request, response = redirect_app.test_client.get(
+        uri="/redirect_init",
+        headers=None,
+        allow_redirects=False)
+
+    assert response.status == 302
+    assert response.headers["Location"] == "/redirect_target"
+
+
+def test_redirect_with_301(redirect_app):
+    """
+    Test redirection with a different status code.
+    """
+    request, response = redirect_app.test_client.get(
+        "/redirect_init_with_301",
+        allow_redirects=False)
+
+    assert response.status == 301
+    assert response.headers["Location"] == "/redirect_target"
+
+
+def test_get_then_redirect_follow_redirect(redirect_app):
+    """
+    With `allow_redirects` we expect a 200.
+    """
+    request, response = redirect_app.test_client.get(
+        "/redirect_init",
+        allow_redirects=True)
+
+    assert response.status == 200
+    assert response.text == 'OK'
+
+
+def test_chained_redirect(redirect_app):
+    """Test test_client is working for redirection"""
+    request, response = redirect_app.test_client.get('/1')
+    assert request.url.endswith('/1')
+    assert response.status == 200
+    assert response.text == 'OK'
+    assert response.url.endswith('/3')

tests/test_request_data.py

@@ -0,0 +1,43 @@
+import random
+
+from sanic import Sanic
+from sanic.response import json
+from ujson import loads
+
+
+def test_storage():
+    app = Sanic('test_text')
+
+    @app.middleware('request')
+    def store(request):
+        request['user'] = 'sanic'
+        request['sidekick'] = 'tails'
+        del request['sidekick']
+
+    @app.route('/')
+    def handler(request):
+        return json({'user': request.get('user'), 'sidekick': request.get('sidekick')})
+
+    request, response = app.test_client.get('/')
+
+    response_json = loads(response.text)
+    assert response_json['user'] == 'sanic'
+    assert response_json.get('sidekick') is None
+
+
+def test_app_injection():
+    app = Sanic('test_app_injection')
+    expected = random.choice(range(0, 100))
+
+    @app.listener('after_server_start')
+    async def inject_data(app, loop):
+        app.injected = expected
+
+    @app.get('/')
+    async def handler(request):
+        return json({'injected': request.app.injected})
+
+    request, response = app.test_client.get('/')
+
+    response_json = loads(response.text)
+    assert response_json['injected'] == expected

tests/test_request_timeout.py

@@ -0,0 +1,38 @@
+from sanic import Sanic
+import asyncio
+from sanic.response import text
+from sanic.exceptions import RequestTimeout
+from sanic.config import Config
+
+Config.REQUEST_TIMEOUT = 1
+request_timeout_app = Sanic('test_request_timeout')
+request_timeout_default_app = Sanic('test_request_timeout_default')
+
+
+@request_timeout_app.route('/1')
+async def handler_1(request):
+    await asyncio.sleep(2)
+    return text('OK')
+
+
+@request_timeout_app.exception(RequestTimeout)
+def handler_exception(request, exception):
+    return text('Request Timeout from error_handler.', 408)
+
+
+def test_server_error_request_timeout():
+    request, response = request_timeout_app.test_client.get('/1')
+    assert response.status == 408
+    assert response.text == 'Request Timeout from error_handler.'
+
+
+@request_timeout_default_app.route('/1')
+async def handler_2(request):
+    await asyncio.sleep(2)
+    return text('OK')
+
+
+def test_default_server_error_request_timeout():
+    request, response = request_timeout_default_app.test_client.get('/1')
+    assert response.status == 408
+    assert response.text == 'Error: Request Timeout'

tests/test_requests.py

@@ -1,7 +1,10 @@
 from json import loads as json_loads, dumps as json_dumps
+
+import pytest
+
 from sanic import Sanic
-from sanic.response import json, text
-from sanic.utils import sanic_endpoint_test
+from sanic.exceptions import ServerError
+from sanic.response import json, text, redirect
 
 
 # ------------------------------------------------------------ #
@@ -15,7 +18,7 @@ def test_sync():
     def handler(request):
         return text('Hello')
 
-    request, response = sanic_endpoint_test(app)
+    request, response = app.test_client.get('/')
 
     assert response.text == 'Hello'
 
@@ -27,11 +30,52 @@ def test_text():
     async def handler(request):
         return text('Hello')
 
-    request, response = sanic_endpoint_test(app)
+    request, response = app.test_client.get('/')
 
     assert response.text == 'Hello'
 
 
+def test_headers():
+    app = Sanic('test_text')
+
+    @app.route('/')
+    async def handler(request):
+        headers = {"spam": "great"}
+        return text('Hello', headers=headers)
+
+    request, response = app.test_client.get('/')
+
+    assert response.headers.get('spam') == 'great'
+
+
+def test_non_str_headers():
+    app = Sanic('test_text')
+
+    @app.route('/')
+    async def handler(request):
+        headers = {"answer": 42}
+        return text('Hello', headers=headers)
+
+    request, response = app.test_client.get('/')
+
+    assert response.headers.get('answer') == '42'
+
+def test_invalid_response():
+    app = Sanic('test_invalid_response')
+
+    @app.exception(ServerError)
+    def handler_exception(request, exception):
+        return text('Internal Server Error.', 500)
+
+    @app.route('/')
+    async def handler(request):
+        return 'This should fail'
+
+    request, response = app.test_client.get('/')
+    assert response.status == 500
+    assert response.text == "Internal Server Error."
+
+
 def test_json():
     app = Sanic('test_json')
 
@@ -39,7 +83,7 @@ def test_json():
     async def handler(request):
         return json({"test": True})
 
-    request, response = sanic_endpoint_test(app)
+    request, response = app.test_client.get('/')
 
     try:
         results = json_loads(response.text)
@@ -49,6 +93,19 @@ def test_json():
     assert results.get('test') == True
 
 
+def test_invalid_json():
+    app = Sanic('test_json')
+
+    @app.route('/')
+    async def handler(request):
+        return json(request.json())
+
+    data = "I am not json"
+    request, response = app.test_client.get('/', data=data)
+
+    assert response.status == 400
+
+
 def test_query_string():
     app = Sanic('test_query_string')
 
@@ -56,12 +113,31 @@ def test_query_string():
     async def handler(request):
         return text('OK')
 
-    request, response = sanic_endpoint_test(app, params=[("test1", 1), ("test2", "false"), ("test2", "true")])
+    request, response = app.test_client.get(
+        '/', params=[("test1", "1"), ("test2", "false"), ("test2", "true")])
 
     assert request.args.get('test1') == '1'
     assert request.args.get('test2') == 'false'
 
 
+def test_token():
+    app = Sanic('test_post_token')
+
+    @app.route('/')
+    async def handler(request):
+        return text('OK')
+
+    # uuid4 generated token.
+    token = 'a1d895e0-553a-421a-8e22-5ff8ecb48cbf'
+    headers = {
+        'content-type': 'application/json',
+        'Authorization': 'Token {}'.format(token)
+    }
+
+    request, response = app.test_client.get('/', headers=headers)
+
+    assert request.token == token
+
 # ------------------------------------------------------------ #
 #  POST
 # ------------------------------------------------------------ #
@@ -69,14 +145,50 @@ def test_query_string():
 def test_post_json():
     app = Sanic('test_post_json')
 
-    @app.route('/')
+    @app.route('/', methods=['POST'])
     async def handler(request):
         return text('OK')
 
     payload = {'test': 'OK'}
     headers = {'content-type': 'application/json'}
 
-    request, response = sanic_endpoint_test(app, data=json_dumps(payload), headers=headers)
+    request, response = app.test_client.post(
+        '/', data=json_dumps(payload), headers=headers)
 
     assert request.json.get('test') == 'OK'
     assert response.text == 'OK'
+
+
+def test_post_form_urlencoded():
+    app = Sanic('test_post_form_urlencoded')
+
+    @app.route('/', methods=['POST'])
+    async def handler(request):
+        return text('OK')
+
+    payload = 'test=OK'
+    headers = {'content-type': 'application/x-www-form-urlencoded'}
+
+    request, response = app.test_client.post('/', data=payload, headers=headers)
+
+    assert request.form.get('test') == 'OK'
+
+
+def test_post_form_multipart_form_data():
+    app = Sanic('test_post_form_multipart_form_data')
+
+    @app.route('/', methods=['POST'])
+    async def handler(request):
+        return text('OK')
+
+    payload = '------sanic\r\n' \
+              'Content-Disposition: form-data; name="test"\r\n' \
+              '\r\n' \
+              'OK\r\n' \
+              '------sanic--\r\n'
+
+    headers = {'content-type': 'multipart/form-data; boundary=----sanic'}
+
+    request, response = app.test_client.post(data=payload, headers=headers)
+
+    assert request.form.get('test') == 'OK'

tests/test_response.py

@@ -0,0 +1,17 @@
+from random import choice
+
+from sanic import Sanic
+from sanic.response import HTTPResponse
+
+
+def test_response_body_not_a_string():
+    """Test when a response body sent from the application is not a string"""
+    app = Sanic('response_body_not_a_string')
+    random_num = choice(range(1000))
+
+    @app.route('/hello')
+    async def hello_route(request):
+        return HTTPResponse(body=random_num)
+
+    request, response = app.test_client.get('/hello')
+    assert response.text == str(random_num)

tests/test_routes.py

@@ -1,13 +1,123 @@
-from json import loads as json_loads, dumps as json_dumps
+import pytest
+
 from sanic import Sanic
-from sanic.response import json, text
-from sanic.utils import sanic_endpoint_test
+from sanic.response import text
+from sanic.router import RouteExists, RouteDoesNotExist
 
 
 # ------------------------------------------------------------ #
 #  UTF-8
 # ------------------------------------------------------------ #
 
+def test_shorthand_routes_get():
+    app = Sanic('test_shorhand_routes_get')
+
+    @app.get('/get')
+    def handler(request):
+        return text('OK')
+
+    request, response = app.test_client.get('/get')
+    assert response.text == 'OK'
+
+    request, response = app.test_client.post('/get')
+    assert response.status == 405
+
+def test_route_optional_slash():
+    app = Sanic('test_route_optional_slash')
+
+    @app.get('/get')
+    def handler(request):
+        return text('OK')
+
+    request, response = app.test_client.get('/get')
+    assert response.text == 'OK'
+
+    request, response = app.test_client.get('/get/')
+    assert response.text == 'OK'
+
+def test_shorthand_routes_post():
+    app = Sanic('test_shorhand_routes_post')
+
+    @app.post('/post')
+    def handler(request):
+        return text('OK')
+
+    request, response = app.test_client.post('/post')
+    assert response.text == 'OK'
+
+    request, response = app.test_client.get('/post')
+    assert response.status == 405
+
+def test_shorthand_routes_put():
+    app = Sanic('test_shorhand_routes_put')
+
+    @app.put('/put')
+    def handler(request):
+        return text('OK')
+
+    request, response = app.test_client.put('/put')
+    assert response.text == 'OK'
+
+    request, response = app.test_client.get('/put')
+    assert response.status == 405
+
+def test_shorthand_routes_patch():
+    app = Sanic('test_shorhand_routes_patch')
+
+    @app.patch('/patch')
+    def handler(request):
+        return text('OK')
+
+    request, response = app.test_client.patch('/patch')
+    assert response.text == 'OK'
+
+    request, response = app.test_client.get('/patch')
+    assert response.status == 405
+
+def test_shorthand_routes_head():
+    app = Sanic('test_shorhand_routes_head')
+
+    @app.head('/head')
+    def handler(request):
+        return text('OK')
+
+    request, response = app.test_client.head('/head')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/head')
+    assert response.status == 405
+
+def test_shorthand_routes_options():
+    app = Sanic('test_shorhand_routes_options')
+
+    @app.options('/options')
+    def handler(request):
+        return text('OK')
+
+    request, response = app.test_client.options('/options')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/options')
+    assert response.status == 405
+
+def test_static_routes():
+    app = Sanic('test_dynamic_route')
+
+    @app.route('/test')
+    async def handler1(request):
+        return text('OK1')
+
+    @app.route('/pizazz')
+    async def handler2(request):
+        return text('OK2')
+
+    request, response = app.test_client.get('/test')
+    assert response.text == 'OK1'
+
+    request, response = app.test_client.get('/pizazz')
+    assert response.text == 'OK2'
+
+
 def test_dynamic_route():
     app = Sanic('test_dynamic_route')
 
@@ -18,7 +128,7 @@ def test_dynamic_route():
         results.append(name)
         return text('OK')
 
-    request, response = sanic_endpoint_test(app, uri='/folder/test123')
+    request, response = app.test_client.get('/folder/test123')
 
     assert response.text == 'OK'
     assert results[0] == 'test123'
@@ -34,12 +144,12 @@ def test_dynamic_route_string():
         results.append(name)
         return text('OK')
 
-    request, response = sanic_endpoint_test(app, uri='/folder/test123')
+    request, response = app.test_client.get('/folder/test123')
 
     assert response.text == 'OK'
     assert results[0] == 'test123'
 
-    request, response = sanic_endpoint_test(app, uri='/folder/favicon.ico')
+    request, response = app.test_client.get('/folder/favicon.ico')
 
     assert response.text == 'OK'
     assert results[1] == 'favicon.ico'
@@ -55,16 +165,16 @@ def test_dynamic_route_int():
         results.append(folder_id)
         return text('OK')
 
-    request, response = sanic_endpoint_test(app, uri='/folder/12345')
+    request, response = app.test_client.get('/folder/12345')
     assert response.text == 'OK'
     assert type(results[0]) is int
 
-    request, response = sanic_endpoint_test(app, uri='/folder/asdf')
+    request, response = app.test_client.get('/folder/asdf')
     assert response.status == 404
 
 
 def test_dynamic_route_number():
-    app = Sanic('test_dynamic_route_int')
+    app = Sanic('test_dynamic_route_number')
 
     results = []
 
@@ -73,32 +183,450 @@ def test_dynamic_route_number():
         results.append(weight)
         return text('OK')
 
-    request, response = sanic_endpoint_test(app, uri='/weight/12345')
+    request, response = app.test_client.get('/weight/12345')
     assert response.text == 'OK'
     assert type(results[0]) is float
 
-    request, response = sanic_endpoint_test(app, uri='/weight/1234.56')
+    request, response = app.test_client.get('/weight/1234.56')
     assert response.status == 200
 
-    request, response = sanic_endpoint_test(app, uri='/weight/1234-56')
+    request, response = app.test_client.get('/weight/1234-56')
     assert response.status == 404
 
 
 def test_dynamic_route_regex():
-    app = Sanic('test_dynamic_route_int')
+    app = Sanic('test_dynamic_route_regex')
 
     @app.route('/folder/<folder_id:[A-Za-z0-9]{0,4}>')
     async def handler(request, folder_id):
         return text('OK')
 
-    request, response = sanic_endpoint_test(app, uri='/folder/test')
+    request, response = app.test_client.get('/folder/test')
     assert response.status == 200
 
-    request, response = sanic_endpoint_test(app, uri='/folder/test1')
+    request, response = app.test_client.get('/folder/test1')
     assert response.status == 404
 
-    request, response = sanic_endpoint_test(app, uri='/folder/test-123')
+    request, response = app.test_client.get('/folder/test-123')
     assert response.status == 404
 
-    request, response = sanic_endpoint_test(app, uri='/folder/')
+    request, response = app.test_client.get('/folder/')
     assert response.status == 200
+
+
+def test_dynamic_route_unhashable():
+    app = Sanic('test_dynamic_route_unhashable')
+
+    @app.route('/folder/<unhashable:[A-Za-z0-9/]+>/end/')
+    async def handler(request, unhashable):
+        return text('OK')
+
+    request, response = app.test_client.get('/folder/test/asdf/end/')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/folder/test///////end/')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/folder/test/end/')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/folder/test/nope/')
+    assert response.status == 404
+
+
+def test_route_duplicate():
+    app = Sanic('test_route_duplicate')
+
+    with pytest.raises(RouteExists):
+        @app.route('/test')
+        async def handler1(request):
+            pass
+
+        @app.route('/test')
+        async def handler2(request):
+            pass
+
+    with pytest.raises(RouteExists):
+        @app.route('/test/<dynamic>/')
+        async def handler1(request, dynamic):
+            pass
+
+        @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 = app.test_client.get('/test')
+    assert response.status == 200
+
+    request, response = app.test_client.post('/test')
+    assert response.status == 405
+
+
+def test_static_add_route():
+    app = Sanic('test_static_add_route')
+
+    async def handler1(request):
+        return text('OK1')
+
+    async def handler2(request):
+        return text('OK2')
+
+    app.add_route(handler1, '/test')
+    app.add_route(handler2, '/test2')
+
+    request, response = app.test_client.get('/test')
+    assert response.text == 'OK1'
+
+    request, response = app.test_client.get('/test2')
+    assert response.text == 'OK2'
+
+
+def test_dynamic_add_route():
+    app = Sanic('test_dynamic_add_route')
+
+    results = []
+
+    async def handler(request, name):
+        results.append(name)
+        return text('OK')
+
+    app.add_route(handler, '/folder/<name>')
+    request, response = app.test_client.get('/folder/test123')
+
+    assert response.text == 'OK'
+    assert results[0] == 'test123'
+
+
+def test_dynamic_add_route_string():
+    app = Sanic('test_dynamic_add_route_string')
+
+    results = []
+
+    async def handler(request, name):
+        results.append(name)
+        return text('OK')
+
+    app.add_route(handler, '/folder/<name:string>')
+    request, response = app.test_client.get('/folder/test123')
+
+    assert response.text == 'OK'
+    assert results[0] == 'test123'
+
+    request, response = app.test_client.get('/folder/favicon.ico')
+
+    assert response.text == 'OK'
+    assert results[1] == 'favicon.ico'
+
+
+def test_dynamic_add_route_int():
+    app = Sanic('test_dynamic_add_route_int')
+
+    results = []
+
+    async def handler(request, folder_id):
+        results.append(folder_id)
+        return text('OK')
+
+    app.add_route(handler, '/folder/<folder_id:int>')
+
+    request, response = app.test_client.get('/folder/12345')
+    assert response.text == 'OK'
+    assert type(results[0]) is int
+
+    request, response = app.test_client.get('/folder/asdf')
+    assert response.status == 404
+
+
+def test_dynamic_add_route_number():
+    app = Sanic('test_dynamic_add_route_number')
+
+    results = []
+
+    async def handler(request, weight):
+        results.append(weight)
+        return text('OK')
+
+    app.add_route(handler, '/weight/<weight:number>')
+
+    request, response = app.test_client.get('/weight/12345')
+    assert response.text == 'OK'
+    assert type(results[0]) is float
+
+    request, response = app.test_client.get('/weight/1234.56')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/weight/1234-56')
+    assert response.status == 404
+
+
+def test_dynamic_add_route_regex():
+    app = Sanic('test_dynamic_route_int')
+
+    async def handler(request, folder_id):
+        return text('OK')
+
+    app.add_route(handler, '/folder/<folder_id:[A-Za-z0-9]{0,4}>')
+
+    request, response = app.test_client.get('/folder/test')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/folder/test1')
+    assert response.status == 404
+
+    request, response = app.test_client.get('/folder/test-123')
+    assert response.status == 404
+
+    request, response = app.test_client.get('/folder/')
+    assert response.status == 200
+
+
+def test_dynamic_add_route_unhashable():
+    app = Sanic('test_dynamic_add_route_unhashable')
+
+    async def handler(request, unhashable):
+        return text('OK')
+
+    app.add_route(handler, '/folder/<unhashable:[A-Za-z0-9/]+>/end/')
+
+    request, response = app.test_client.get('/folder/test/asdf/end/')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/folder/test///////end/')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/folder/test/end/')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/folder/test/nope/')
+    assert response.status == 404
+
+
+def test_add_route_duplicate():
+    app = Sanic('test_add_route_duplicate')
+
+    with pytest.raises(RouteExists):
+        async def handler1(request):
+            pass
+
+        async def handler2(request):
+            pass
+
+        app.add_route(handler1, '/test')
+        app.add_route(handler2, '/test')
+
+    with pytest.raises(RouteExists):
+        async def handler1(request, dynamic):
+            pass
+
+        async def handler2(request, dynamic):
+            pass
+
+        app.add_route(handler1, '/test/<dynamic>/')
+        app.add_route(handler2, '/test/<dynamic>/')
+
+
+def test_add_route_method_not_allowed():
+    app = Sanic('test_add_route_method_not_allowed')
+
+    async def handler(request):
+        return text('OK')
+
+    app.add_route(handler, '/test', methods=['GET'])
+
+    request, response = app.test_client.get('/test')
+    assert response.status == 200
+
+    request, response = app.test_client.post('/test')
+    assert response.status == 405
+
+
+def test_remove_static_route():
+    app = Sanic('test_remove_static_route')
+
+    async def handler1(request):
+        return text('OK1')
+
+    async def handler2(request):
+        return text('OK2')
+
+    app.add_route(handler1, '/test')
+    app.add_route(handler2, '/test2')
+
+    request, response = app.test_client.get('/test')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/test2')
+    assert response.status == 200
+
+    app.remove_route('/test')
+    app.remove_route('/test2')
+
+    request, response = app.test_client.get('/test')
+    assert response.status == 404
+
+    request, response = app.test_client.get('/test2')
+    assert response.status == 404
+
+
+def test_remove_dynamic_route():
+    app = Sanic('test_remove_dynamic_route')
+
+    async def handler(request, name):
+        return text('OK')
+
+    app.add_route(handler, '/folder/<name>')
+
+    request, response = app.test_client.get('/folder/test123')
+    assert response.status == 200
+
+    app.remove_route('/folder/<name>')
+    request, response = app.test_client.get('/folder/test123')
+    assert response.status == 404
+
+
+def test_remove_inexistent_route():
+    app = Sanic('test_remove_inexistent_route')
+
+    with pytest.raises(RouteDoesNotExist):
+        app.remove_route('/test')
+
+def test_removing_slash():
+    app = Sanic(__name__)
+
+    @app.get('/rest/<resource>')
+    def get(_):
+        pass
+
+    @app.post('/rest/<resource>')
+    def post(_):
+        pass
+
+    assert len(app.router.routes_all.keys()) == 2
+
+
+def test_remove_unhashable_route():
+    app = Sanic('test_remove_unhashable_route')
+
+    async def handler(request, unhashable):
+        return text('OK')
+
+    app.add_route(handler, '/folder/<unhashable:[A-Za-z0-9/]+>/end/')
+
+    request, response = app.test_client.get('/folder/test/asdf/end/')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/folder/test///////end/')
+    assert response.status == 200
+
+    request, response = app.test_client.get('/folder/test/end/')
+    assert response.status == 200
+
+    app.remove_route('/folder/<unhashable:[A-Za-z0-9/]+>/end/')
+
+    request, response = app.test_client.get('/folder/test/asdf/end/')
+    assert response.status == 404
+
+    request, response = app.test_client.get('/folder/test///////end/')
+    assert response.status == 404
+
+    request, response = app.test_client.get('/folder/test/end/')
+    assert response.status == 404
+
+
+def test_remove_route_without_clean_cache():
+    app = Sanic('test_remove_static_route')
+
+    async def handler(request):
+        return text('OK')
+
+    app.add_route(handler, '/test')
+
+    request, response = app.test_client.get('/test')
+    assert response.status == 200
+
+    app.remove_route('/test', clean_cache=True)
+
+    request, response = app.test_client.get('/test')
+    assert response.status == 404
+
+    app.add_route(handler, '/test')
+
+    request, response = app.test_client.get('/test')
+    assert response.status == 200
+
+    app.remove_route('/test', clean_cache=False)
+
+    request, response = app.test_client.get('/test')
+    assert response.status == 200
+
+
+def test_overload_routes():
+    app = Sanic('test_dynamic_route')
+
+    @app.route('/overload', methods=['GET'])
+    async def handler1(request):
+        return text('OK1')
+
+    @app.route('/overload', methods=['POST', 'PUT'])
+    async def handler2(request):
+        return text('OK2')
+
+    request, response = app.test_client.get('/overload')
+    assert response.text == 'OK1'
+
+    request, response = app.test_client.post('/overload')
+    assert response.text == 'OK2'
+
+    request, response = app.test_client.put('/overload')
+    assert response.text == 'OK2'
+
+    request, response = app.test_client.delete('/overload')
+    assert response.status == 405
+
+    with pytest.raises(RouteExists):
+        @app.route('/overload', methods=['PUT', 'DELETE'])
+        async def handler3(request):
+            return text('Duplicated')
+
+
+def test_unmergeable_overload_routes():
+    app = Sanic('test_dynamic_route')
+
+    @app.route('/overload_whole', methods=None)
+    async def handler1(request):
+        return text('OK1')
+
+    with pytest.raises(RouteExists):
+        @app.route('/overload_whole', methods=['POST', 'PUT'])
+        async def handler2(request):
+            return text('Duplicated')
+
+    request, response = app.test_client.get('/overload_whole')
+    assert response.text == 'OK1'
+
+    request, response = app.test_client.post('/overload_whole')
+    assert response.text == 'OK1'
+
+
+    @app.route('/overload_part', methods=['GET'])
+    async def handler1(request):
+        return text('OK1')
+
+    with pytest.raises(RouteExists):
+        @app.route('/overload_part')
+        async def handler2(request):
+            return text('Duplicated')
+
+    request, response = app.test_client.get('/overload_part')
+    assert response.text == 'OK1'
+
+    request, response = app.test_client.post('/overload_part')
+    assert response.status == 405